Work towards port to C++-11. Still not functioning, but a snapshot.

Modules/FDEM1D/include/DipoleSource.h

 #ifndef __DIPOLESOURCE_H
 #define __DIPOLESOURCE_H
 
-#include "LemmaObject.h"
 #include "LayeredEarthEM.h"
+#include "FieldPoints.h"
 
-#include "receiverpoints.h"
-#include "emearth1d.h"
+//#include "emearth1d.h"
 
 #ifdef LEMMAUSEVTK
 #include "vtkActor.h"
 
 namespace Lemma {
 
+    // Forward declarations
     class KernelEM1DManager;
-    class ReceiverPoints;
     class HankelTransform;
 
     // ==========================================================================
     // ==========================================================================
     class DipoleSource : public LemmaObject {
 
-        public:
+        // ====================    FRIENDS     ======================
 
-            // ====================    FRIENDS     ======================
+        friend std::ostream &operator<<(std::ostream &stream, const DipoleSource &ob);
 
-            friend std::ostream &operator<<(std::ostream &stream,
-                        const DipoleSource &ob);
+        struct ctor_key{};
 
+        public:
 
             // ====================  LIFECYCLE     ======================
 
+            /** Default locked constructor. */
+            explicit DipoleSource ( const ctor_key& );
+
+            /** Locked deserializing constructor */
+            DipoleSource ( const YAML::Node& node, const ctor_key& );
+
+            /** Default locked constructor. */
+            ~DipoleSource ();
+
             /**
-             *  Returns pointer to new DipoleSource. Location is
+             *  Returns shared_ptr  to new DipoleSource. Location is
              *  initialized to (0,0,0) type and polarization are
              *  initialized  to nonworking values that will throw
              *  exceptions if used.
              */
-            static DipoleSource* New();
+            static std::shared_ptr< DipoleSource > NewSP();
 
-
-            /** Returns a deep copy of the dipole. Used to make thread safe methods. Does not
-                copy attachments.
+            /**
+             *   YAML Serializing method
              */
-            DipoleSource* Clone();
+            YAML::Node Serialize() const;
 
             /**
-             * @copybrief LemmaObject::Delete()
-             * @copydetails LemmaObject::Delete()
+             *   Constructs an object from a YAML::Node.
              */
-            void Delete();
+            static std::shared_ptr< DipoleSource > DeSerialize(const YAML::Node& node);
+
+
+            /** Returns a deep copy of the dipole. Used to make thread safe methods. Does not
+                copy attachments.
+             */
+            std::shared_ptr< DipoleSource > Clone();
 
             // ====================  OPERATORS     ======================
 
 
             /** Determines if kernels have been loaded already, and if so if they can be reused
              */
-            void SetKernels(const int& ifreq,  const FIELDCALCULATIONS&  Fields, ReceiverPoints* Receivers, const int& irec,
-                    LayeredEarthEM* Earth );
+            void SetKernels(const int& ifreq,  const FIELDCALCULATIONS&  Fields, std::shared_ptr<FieldPoints> Receivers, const int& irec,
+                    std::shared_ptr<LayeredEarthEM> Earth );
 
             /** resets the kernels if they cannot be reused */
-            virtual void ReSetKernels(const int& ifreq,  const FIELDCALCULATIONS&  Fields, ReceiverPoints* Receivers, const int& irec,
-                    LayeredEarthEM* Earth );
+            virtual void ReSetKernels(const int& ifreq,  const FIELDCALCULATIONS&  Fields, std::shared_ptr<FieldPoints> Receivers,
+                    const int& irec, std::shared_ptr<LayeredEarthEM> Earth );
 
             /** Updates the receiver fields */
-            virtual void UpdateFields(const int& ifreq, HankelTransform* Hankel, const Real& wavef);
+            virtual void UpdateFields(const int& ifreq, std::shared_ptr<HankelTransform> Hankel, const Real& wavef);
 
             // ====================  ACCESS        ======================
 
             DipoleSourceType GetType();
 
             /// Returns pointer to KernelEM1DManager
-            KernelEM1DManager*  GetKernelManager();
+            std::shared_ptr<KernelEM1DManager>  GetKernelManager();
 
             // Returns enumerated DipoleSourcePolarization
             //DipoleSourcePolarisation GetDipoleSourcePolarisation();
             vtkActor* GetVtkActor();
             #endif
 
-        protected:
+            /** Returns the name of the underlying class, similiar to Python's type */
+            virtual inline std::string GetName() const {
+                return CName;
+            }
 
-            // ====================  LIFECYCLE     ======================
-
-            /// Default protected constructor.
-            DipoleSource (const std::string &name);
-
-            /// Default protected constructor.
-            ~DipoleSource ();
-
-            /**
-             * @copybrief LemmaObject::Release()
-             * @copydetails LemmaObject::Release()
-             */
-            void Release();
+        private:
 
             // ====================  DATA MEMBERS  ======================
 
             VectorXr                     Freqs;
 
             /// Storage of the EM1D kernels used by this dipole
-            KernelEM1DManager*          KernelManager;
+            std::shared_ptr<KernelEM1DManager>          KernelManager;
 
             /// Receiver points, keep track if these have changed
-            ReceiverPoints*             Receivers;
+            std::shared_ptr<FieldPoints>                Receivers;
 
             /// Layered Earth used by Kernels
-            LayeredEarthEM*             Earth;
+            std::shared_ptr<LayeredEarthEM>             Earth;
+
+            /** ASCII string representation of the class name */
+            static constexpr auto CName = "DipoleSource";
 
     }; // -----  end of class  DipoleSource  -----
 

Modules/FDEM1D/include/FieldPoints.h

 #endif
 
 #include "LemmaObject.h"
-//#include "dipolesource.h"
+//#include "DipoleSource.h"
 
 namespace Lemma {
 
     // Forward Declarations
-    class DipoleSource;
+    //class DipoleSource;
 
     // =======================================================================
     //        Class:  FieldPoints
     // =======================================================================
     class FieldPoints : public LemmaObject {
 
+        friend class EMEarth1D;
+        friend class DipoleSource;
+
         /**
          *  Stream operator printing out information about this class.
          */
 
             // ====================    FRIENDS     ===========================
 
-            //friend class EMEarth1D;
-            //friend class DipoleSource;
+
 
             // ====================  LIFECYCLE     ===========================
 

Modules/FDEM1D/include/kernelem1dmanager.h → Modules/FDEM1D/include/KernelEM1DManager.h

 //#include "dipolesource.h"
 //#include "kernelem1dreflbase.h"
 #include "kernelem1dbase.h"
-#include "kernelem1dspec.h"
+#include "KernelEM1DSpec.h"
 
 namespace Lemma {
 
     // ===================================================================
     class KernelEM1DManager : public LemmaObject {
 
-        public:
+        struct ctor_key {};
+
+        friend std::ostream &operator<<(std::ostream &stream, const KernelEM1DManager &ob);
 
-            friend std::ostream &operator<<(std::ostream &stream,
-                        const KernelEM1DManager &ob);
+        public:
 
             // ====================  LIFECYCLE     =======================
 
+            /** Default protected constructor. */
+            KernelEM1DManager (const std::string& name);
+
+            /** Default protected constructor. */
+            ~KernelEM1DManager ();
+
             /** Returns a pointer to a new object of type KernelEM1DManager.
              * It allocates all necessary memory.
              */
-            static KernelEM1DManager* New();
-
-            /** Deletes this object. Delete also disconnects any
-             * attachments to this object.
-             */
-            void Delete();
+            static std::shared_ptr<KernelEM1DManager> NewSP();
 
             // ====================  OPERATORS     =======================
 
             /*
             {
 
-                KernelEm1DSpec<Mode, Ikernel, Isource, Irecv>* NewKern =
-                    KernelEm1DSpec<Mode, Ikernel, Isource, Irecv>::New();
+                KernelEM1DSpec<Mode, Ikernel, Isource, Irecv>* NewKern =
+                    KernelEM1DSpec<Mode, Ikernel, Isource, Irecv>::New();
                 KernelVec.push_back( NewKern );
                 NewKern->managerIdx = KernelVec.size()-1;
                 switch (Mode) {
 
             /** Clears the vector of kernels */
             void ClearVec() {
-                for (unsigned int ik=0; ik<this->KernelVec.size(); ++ik) {
-                    this->KernelVec[ik]->Delete();
-                }
                 KernelVec.clear();
             }
 
 
             /** Sets the LayeredEarthEM class that will be used by the kernels.
              */
-            void SetEarth( LayeredEarthEM*   Earth);
+            void SetEarth( std::shared_ptr<LayeredEarthEM>   Earth);
 
             /** Sets the source of the kernels */
-            void SetDipoleSource( DipoleSource*   Dipole, const int& ifreq, const Real& rx_zin);
+            void SetDipoleSource( std::shared_ptr<DipoleSource> Dipole, const int& ifreq, const Real& rx_zin);
 
             /** Returns pointer to specified kernel indice. Indices are assigned in the same
                 order as they are created by AddKernel.
              */
-            KernelEm1DBase*    GetKernel(const unsigned int& ik);
+            std::shared_ptr<KernelEm1DBase>    GetKernel(const unsigned int& ik);
 
             /** Returns pointer to connected dipole.
              */
-            DipoleSource*    GetDipole( );
+            std::shared_ptr<DipoleSource>    GetDipole( );
 
-            inline std::vector<KernelEm1DBase*>  GetSTLVector() {
+            inline std::vector< std::shared_ptr<KernelEm1DBase> >  GetSTLVector() {
                 return KernelVec;
             }
 
             // ====================  INQUIRY       =======================
 
+            /** Returns the name of the underlying class, similiar to Python's type */
+            virtual inline std::string GetName() const {
+                return CName;
+            }
+
         protected:
 
             // ====================  LIFECYCLE     =======================
 
-            /** Default protected constructor. */
-            KernelEM1DManager (const std::string& name);
-
-            /** Default protected constructor. */
-            ~KernelEM1DManager ();
-
-            /**
-             * @copybrief LemmaObject::Release()
-             * @copydetails LemmaObject::Release()
-             */
-            void Release();
-
             // ====================  DATA MEMBERS  =========================
 
             /** List of KernelEm1D instances */
-            std::vector<KernelEm1DBase*>           KernelVec;
+            std::vector< std::shared_ptr<KernelEm1DBase> >  KernelVec;
 
             /** Reflection base used for TE mode */
-            KernelEM1DReflBase*                    TEReflBase;
+            std::shared_ptr<KernelEM1DReflBase>        TEReflBase;
 
             /** Reflection base used for TM mode */
-            KernelEM1DReflBase*                    TMReflBase;
+            std::shared_ptr<KernelEM1DReflBase>        TMReflBase;
 
             /** EmEarth Class */
-            LayeredEarthEM*                        Earth;
+            std::shared_ptr<LayeredEarthEM>            Earth;
 
             /** EM dipole souce */
-            DipoleSource*                          Dipole;
+            std::shared_ptr<DipoleSource>              Dipole;
 
             /** Frequency index for the sources */
-            int                                    ifreq;
+            int                                        ifreq;
 
             /** Receiver height */
-            Real                                   rx_z;
+            Real                                       rx_z;
 
         private:
 
+            static constexpr auto CName = "KernelEM1DManager";
+
     }; // -----  end of class  KernelEM1DManager  -----
 
     // template methods
     template<EMMODE Mode, int Ikernel, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
     int KernelEM1DManager::AddKernel( ) {
 
-        KernelEm1DSpec<Mode, Ikernel, Isource, Irecv>* NewKern =
-                    KernelEm1DSpec<Mode, Ikernel, Isource, Irecv>::New();
+        auto NewKern = KernelEM1DSpec<Mode, Ikernel, Isource, Irecv>::NewSP();
         KernelVec.push_back( NewKern );
         NewKern->managerIdx = KernelVec.size()-1;
         switch (Mode) {
             case TE:
-                if (TEReflBase == NULL) {
-                    TEReflBase = KernelEM1DReflSpec<TE, Isource, Irecv>::New();
+                if (TEReflBase == nullptr) {
+                    TEReflBase = KernelEM1DReflSpec<TE, Isource, Irecv>::NewSP();
                     TEReflBase->Initialise(Earth);
                     TEReflBase->SetUpSource(Dipole, ifreq);
                     TEReflBase->SetUpReceiver( rx_z );
                 NewKern->SetReflBase(TEReflBase);
                 break;
             case TM:
-                if (TMReflBase == NULL) {
-                    TMReflBase = KernelEM1DReflSpec<TM, Isource, Irecv>::New();
+                if (TMReflBase == nullptr) {
+                    TMReflBase = KernelEM1DReflSpec<TM, Isource, Irecv>::NewSP();
                     TMReflBase->Initialise(Earth);
                     TMReflBase->SetUpSource(Dipole, ifreq);
                     TMReflBase->SetUpReceiver( rx_z );

Modules/FDEM1D/include/kernelem1dreflspec.h → Modules/FDEM1D/include/KernelEM1DReflSpec.h

 #ifndef  KERNELEM1DREFLSPEC_INC
 #define  KERNELEM1DREFLSPEC_INC
 
-#include "dipolesource.h"
-#include "kernelem1dreflbase.h"
-#include "layeredearthem.h"
+#include "DipoleSource.h"
+#include "LayeredEarthEM.h"
 
-// #include<unordered_map> // for caching results
+#include "kernelem1dreflbase.h"
 
 namespace Lemma {
 
-    // forward declare
-    //struct cache;
-    // Simple container to hold reflection results
-    struct  cache {
-        Real                       rho0;
-        Real                       lambda[805];
-        Real                       rams[805];
-        Complex                    uk[805];
-        Complex                    um[805];
-        Real                       zh0i[805];
-        VectorXcr                  Rtd[805];
-        VectorXcr                  Rtu[805];
-        VectorXcr                  u[805];
-        VectorXcr                  cf[805];
-        VectorXcr                  kk[805];
-        const Real                 epsilon;
-        //bool                       nc;
-        cache( ) : epsilon (std::numeric_limits<Real>::epsilon() ) { // TODO reset to precision of Real
-            //Rtd = VectorXcr::Zero(805);
-            //Rtu = VectorXcr::Zero(805);
-        }
-    };
-
     // forward declaration for friend
     template<EMMODE Mode, int Ikernel, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
-    class KernelEm1DSpec;
+    class KernelEM1DSpec;
 
     // ===================================================================
     //  Class:  KernelEM1DReflSpec
       @class
       \brief   Specialized version of KernelEM1DReflBase
       \details Through use of template specialisations, this KernelEm1D
-               class delivers much better performance.
+               class delivers much better performance. This class is internal
+               to Lemma, you should never need to instantiate it. The constructors
+               are public to allow make_shared. Additonally, this class is not
+               serializable.
      */
     // ===================================================================
     template<EMMODE Mode, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
     class KernelEM1DReflSpec : public KernelEM1DReflBase {
 
+        // TODO can we use the manager's key instead to lock for that?
+        struct ctor_key{};
+
         public:
 
+            // what do these template parameters do -TI
             template<EMMODE Mode2, int Ikernel2, DIPOLE_LOCATION Isource2, DIPOLE_LOCATION Irecv2>
-            friend class KernelEm1DSpec;
+            friend class KernelEM1DSpec;
             friend class KernelEM1DManager;
 
             // ====================  LIFECYCLE     =======================
 
-            static KernelEM1DReflSpec* New() {
-                KernelEM1DReflSpec<Mode, Isource, Irecv>*  Obj =
-                    new KernelEM1DReflSpec<Mode, Isource, Irecv>("KernelEM1DReflSpec<>");
-                Obj->AttachTo(Obj);
-                return Obj;
+            /// Default locked constructor.
+            explicit KernelEM1DReflSpec ( const ctor_key& ) : KernelEM1DReflBase( ) {
             }
 
-            void Delete() {
-                this->DetachFrom(this);
+            /// Default protected constructor.
+            ~KernelEM1DReflSpec () {
+            }
+
+            static std::shared_ptr<KernelEM1DReflSpec<Mode, Isource, Irecv> > NewSP() {
+                return std::make_shared<KernelEM1DReflSpec<Mode, Isource, Irecv> >( ctor_key() );
             }
 
             // ====================  OPERATORS     =======================
             // ====================  INQUIRY       =======================
 
         protected:
+        private:
 
             // ====================  LIFECYCLE     =======================
 
-            /// Default protected constructor.
-            KernelEM1DReflSpec (const std::string& name) : KernelEM1DReflBase(name)
-            {
-            }
-
-            /// Default protected constructor.
-            ~KernelEM1DReflSpec () {
-                if (this->NumberOfReferences > 0)
-                    throw DeleteObjectWithReferences( this );
-            }
-
-            void Release() {
-                delete this;
-            }
-
             // ====================  OPERATIONS    =======================
 
             /** Computes reflection coefficients. Depending on the
 
             // ====================  DATA MEMBERS  =========================
 
-        private:
-
-            //** Storage container for reused results */
-            //static std::unordered_map<Real, cache> CACHE;
-
-            //** Currenly used cache */
-            //cache* tcache;
-            //#pragma omp threadprivate(tcache)
-
     }; // -----  end of class  KernelEM1DReflSpec  -----
 
     //template<EMMODE Mode, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
 
     ///////////////////////////////////////////////
     // Default mode definitions
-
-/*
-    template<EMMODE Mode, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
-    void KernelEM1DReflSpec<Mode, Isource, Irecv>::SetTCache(const Real& rho0) {
-       #ifdef LEMMAUSEOMP
-        #pragma omp critical
-        #endif
-        {
-        this->tcache = &this->CACHE[rho0];
-        }
-    }
-*/
-
-/*
-    template<EMMODE Mode, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
-    void KernelEM1DReflSpec<Mode, Isource, Irecv>::ComputeReflectionCoeffs(const Real& lambda, const int& idx) {
-
-        if ( (std::abs(this->tcache->lambda[idx]-lambda) <= this->tcache->epsilon) &&
-            this->tcache->u[idx].size() > 0  && std::abs(this->kk(0) - this->tcache->kk[idx](0)) <= this->tcache->epsilon ) {
-            //std::cout << "USING CACHED RESULTS !!!!!!" << std::endl;
-            // load all the values we need
-            this->u   = this->tcache->u[idx];
-            this->rams = this->tcache->rams[idx];
-            this->cf = this->tcache->cf[idx];
-            //this->kk = this->tcache->kk[idx];
-            this->uk = this->tcache->uk[idx];
-            this->um = this->tcache->um[idx];
-            this->rtd = this->tcache->Rtd[idx];
-            this->rtu = this->tcache->Rtu[idx];
-
-        } else { // else do the work
-        }
-
-        ComputeReflectionCoeffs(lambda);
-
-        //#pragma omp critical
-        //{
-        //std::cout << idx << "\t" << lambda << "\t" << rtd.transpose() << std::endl;
-        //}
-        // store the results
-        this->tcache->u[idx]      = this->u;
-        this->tcache->cf[idx]     = this->cf;
-        this->tcache->kk[idx]     = this->kk;
-        this->tcache->uk[idx]     = this->uk;
-        this->tcache->um[idx]     = this->um;
-        this->tcache->Rtd[idx]    = this->rtd;
-        this->tcache->Rtu[idx]    = this->rtu;
-        this->tcache->zh0i[idx]    = std::imag(this->zh[0]);
-        this->tcache->lambda[idx] = lambda;
-        this->tcache->rams[idx]   = rams;
-
-        }
-
-        return;
-    }
-*/
-
     template<EMMODE Mode, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
     void KernelEM1DReflSpec<Mode, Isource, Irecv>::ComputeReflectionCoeffs(const Real& lambda) {
         static bool called = false;

Modules/FDEM1D/include/LayeredEarthEM.h

 #define __LAYEREDEARTHEM_H
 
 #include "LayeredEarth.h"
-#include <iomanip>
 
 namespace Lemma {
 

Modules/FDEM1D/include/PolygonalWireAntenna.h

   @date     05/18/2010
   @version  $Id: PolygonalWireAntenna.h 211 2015-02-27 05:43:26Z tirons $
  **/
-
-#include "WireAntenna.h"
-
 #ifndef  POLYGONALWIREANTENNA_INC
 #define  POLYGONALWIREANTENNA_INC
 
+#include "DipoleSource.h"
+#include "WireAntenna.h"
+
 namespace Lemma {
 
     // ===================================================================
     // ===================================================================
     class PolygonalWireAntenna : public WireAntenna {
 
-        friend std::ostream &operator<<(std::ostream &stream,
-                const PolygonalWireAntenna &ob);
+        friend std::ostream &operator<<(std::ostream &stream, const PolygonalWireAntenna &ob);
+
+        struct ctor_key {};
 
         public:
 
             // ====================  LIFECYCLE     =======================
 
+            /// Default protected constructor.
+            explicit PolygonalWireAntenna ( const ctor_key& );
+
+            /// Default protected constructor.
+            PolygonalWireAntenna (const YAML::Node& node, const ctor_key& );
+
+            /// Default protected constructor.
+            virtual ~PolygonalWireAntenna ();
+
             /**
              * Declares all memory and returns a new instance.
              */
-            static PolygonalWireAntenna* New();
+            static std::shared_ptr<PolygonalWireAntenna> NewSP();
+
+            /// Makes a deep copy of this antenna with all connections except
+            /// the dipole approximation.
+            std::shared_ptr<PolygonalWireAntenna> Clone();
 
             /**
-             * @copybrief LemmaObject::Delete()
-             * @copydetails LemmaObject::Delete()
+             *  Uses YAML to serialize this object.
+             *  @return a YAML::Node
              */
-            void Delete();
+            YAML::Node Serialize() const;
 
-            /// Makes a deep copy of this antenna with all connections except
-            /// the dipole approximation.
-            PolygonalWireAntenna* Clone();
+            /**
+             *   Constructs an object from a YAML::Node.
+             */
+            static std::shared_ptr<PolygonalWireAntenna> DeSerialize(const YAML::Node& node);
 
             // ====================  OPERATORS     =======================
 
 
             // ====================  INQUIRY       =======================
 
-            #ifdef HAVE_YAMLCPP
-            /**
-             *  Uses YAML to serialize this object.
-             *  @return a YAML::Node
-             */
-            YAML::Node Serialize() const;
-
-            /**
-             *   Constructs an object from a YAML::Node.
-             */
-            static PolygonalWireAntenna* DeSerialize(const YAML::Node& node);
-            #endif
+            /** Returns the name of the underlying class, similiar to Python's type */
+            virtual inline std::string GetName() const {
+                return CName;
+            }
 
         protected:
 
-            // ====================  LIFECYCLE     =======================
-
-            /// Default protected constructor.
-            PolygonalWireAntenna (const std::string& name);
-
-#ifdef HAVE_YAMLCPP
-            /// Default protected constructor.
-            PolygonalWireAntenna (const YAML::Node& node);
-#endif
-
-            /// Default protected constructor.
-            ~PolygonalWireAntenna ();
-
-            /**
-             * @copybrief LemmaObject::Release()
-             * @copydetails LemmaObject::Release()
-             */
-            void Release();
-
             // ====================  DATA MEMBERS  =======================
 
             /// minimum ratio of dipole moment to distance to receiver point
             Real maxDipoleMoment;
 
             /// appends
-            void PushXYZDipoles(const Vector3r &step, const Vector3r &cp,
+            void PushXYZDipoles( const Vector3r &step, const Vector3r &cp,
                             const Vector3r &dir,
-                            std::vector<DipoleSource*> &Dipoles) ;
+                            std::vector< std::shared_ptr<DipoleSource> > &Dipoles) ;
 
             /// corrects for overstep
-            void CorrectOverstepXYZDipoles(const Vector3r &step,
+            void CorrectOverstepXYZDipoles( const Vector3r &step,
                             const Vector3r &cp,
                             const Vector3r &dir,
-                            std::vector<DipoleSource*> &Dipoles );
+                            std::vector< std::shared_ptr<DipoleSource> > &Dipoles );
 
             // ====================  OPERATIONS    =======================
 
 
             Vector3r                               rRepeat;
 
+            static constexpr auto CName = "PolygonalWireAntenna";
+
     }; // -----  end of class  PolygonalWireAntenna  -----
 
 }       // -----  end of Lemma  name  -----

Modules/FDEM1D/include/WireAntenna.h

 #ifndef __WIREANTENNA_H
 #define __WIREANTENNA_H
 
-#include "LemmaObject.h"
-#include "dipolesource.h"
+#include "DipoleSource.h"
 
 #ifdef LEMMAUSEVTK
 #include "vtkActor.h"
     // ===================================================================
     class WireAntenna : public LemmaObject {
 
-        friend std::ostream &operator<<(std::ostream &stream,
-            const WireAntenna &ob);
+        friend std::ostream &operator<<(std::ostream &stream, const WireAntenna &ob);
+
+        struct ctor_key {};
 
         public:
 
             // ====================  LIFECYCLE     =======================
 
+            /** Locked default constructor */
+            explicit WireAntenna ( const ctor_key& );
+
+            /** Locked deserializing constructor */
+            WireAntenna ( const YAML::Node& node, const ctor_key& );
+
+            /** Destructor */
+            virtual ~WireAntenna();
+
             /**
              * Initialises antenna to contain no points, with no current
              * and no frequency. NumberOfTurns set to 1
              */
-            static WireAntenna* New();
+            static std::shared_ptr<WireAntenna> NewSP();
 
             /**
              * Provides deep copy
              */
-            virtual WireAntenna* Clone();
+            virtual std::shared_ptr<WireAntenna> Clone();
 
             /**
-             * @copybrief LemmaObject::Delete()
-             * @copydetails LemmaObject::Delete()
+             *  Uses YAML to serialize this object.
+             *  @return a YAML::Node
              */
-            void Delete();
+            YAML::Node Serialize() const;
+
+            /**
+             *   Constructs an object from a YAML::Node.
+             */
+            static std::shared_ptr<WireAntenna> DeSerialize( const YAML::Node& node );
 
             // ====================  OPERATORS     =======================
 
 
             // ====================  INQUIRY       =======================
 
-            #ifdef HAVE_YAMLCPP
-            /**
-             *  Uses YAML to serialize this object.
-             *  @return a YAML::Node
-             */
-            YAML::Node Serialize() const;
-
-            /**
-             *   Constructs an object from a YAML::Node.
-             */
-            static WireAntenna* DeSerialize(const YAML::Node& node);
-            #endif
-
 			/**
               * Returns the number of turns
               * @return the number of turns of the loop.
 			/**
               * Returns pointer to a dipole source
 			  */
-            DipoleSource* GetDipoleSource(const int &dip);
+            std::shared_ptr<DipoleSource> GetDipoleSource(const int &dip);
 
 			/**
               * returns number of dipoles used to approximate this
              */
             bool IsHorizontallyPlanar();
 
-        protected:
-
-            // ====================  LIFECYCLE     =======================
-
-			/**
-              * Default protected constructor.
-			  */
-            WireAntenna (const std::string &name);
-
-#ifdef HAVE_YAMLCPP
-        /** Protected DeDerializing constructor, use factory DeSerialize  method*/
-            WireAntenna (const YAML::Node& node);
-#endif
-
-			/**
-              * Default protected destructor.
-			  */
-            ~WireAntenna ();
+            /** Returns the name of the underlying class, similiar to Python's type */
+            virtual inline std::string GetName() const {
+                return CName;
+            }
 
-            /**
-             * @copybrief LemmaObject::Release()
-             * @copydetails LemmaObject::Release()
-             */
-            void Release();
+        protected:
 
             // ====================  DATA MEMBERS  =======================
 
 			/**
               * List of the dipoles
 			  */
-            std::vector<DipoleSource*>           Dipoles;
+            std::vector< std::shared_ptr<DipoleSource> > Dipoles;
 
 			/**
               * Points that define this loop
 
         private:
 
+            static constexpr auto CName = "WireAntenna";
+
     }; // -----  end of class  WireAntenna  -----
 
 }

Modules/FDEM1D/include/emearth1d.h

 #ifndef __EMEARTH1D_H
 #define __EMEARTH1D_H
 
-#include "dipolesource.h"
-#include "layeredearthem.h"
-#include "receiverpoints.h"
-#include "WireAntenna.h"
-#include "PolygonalWireAntenna.h"
-#include "kernelem1dspec.h"
-#include "kernelem1dmanager.h"
+
+
+// forward declare these due to include cycle
+//#include "LayeredEarthEM.h"
+//#include "DipoleSource.h"
+//#include "FieldPoints.h"
+//#include "WireAntenna.h"
+//#include "PolygonalWireAntenna.h"
+//#include "KernelEM1DManager.h"
+
+#include "KernelEM1DSpec.h"
 #include "hankeltransformgaussianquadrature.h"
 #include "hankeltransformhankel2.h"
 #include "FHTKey.h"
 
 namespace Lemma {
 
+    class WireAntenna;
+    class PolygonalWireAntenna;
+    class FieldPoints;
+    class DipoleSource;
+    class LayeredEarthEM;
+
     // =======================================================================
     //        Class:  EmEarth1D
     /// \brief  Implimentation of 1D EM solution.
 		friend std::ostream &operator<<(std::ostream &stream,
 			const EMEarth1D &ob);
 
+        struct ctor_key{};
+
         public:
 
             //friend class KernelEm1D;
 
             // ====================  LIFECYCLE     ===========================
 
+            /** Default protected constructor. */
+            EMEarth1D ( const ctor_key& );
+
+            /** Default protected constructor. */
+			EMEarth1D ( const YAML::Node& node, const ctor_key& );
+
+            /** Default protected constructor. */
+            ~EMEarth1D ();
+
             /**
              *  Returns pointer to new EMEarth1D. Location is
              *  initialized to (0,0,0) type and polarization are
              *  initialized  to nonworking values that will throw
              *  exceptions if used.
              */
-            static EMEarth1D* New();
-
-            /**
-             * @copybrief LemmaObject::Delete()
-             * @copydetails LemmaObject::Delete()
-             */
-            void Delete();
+            static std::shared_ptr<EMEarth1D> NewSP();
 
             /** stream debugging info to std::out
              */
             void Query();
 
-            #ifdef HAVE_YAMLCPP
             /** YAML Serializing method
              */
             YAML::Node Serialize() const;
 
             //static EMEarth1D* DeSerialize(const YAML::Node& node);
-            #endif
 
             // ====================  OPERATORS     ===========================
 
             void AttachWireAntenna(WireAntenna *antennae);
 
             /** Attaches a dipole for calculation */
-            void AttachDipoleSource(DipoleSource *dipole);
+            void AttachDipoleSource( std::shared_ptr<DipoleSource> dipole);
 
             /** Attaches a layered earth model for calculation */
-            void AttachLayeredEarthEM(LayeredEarthEM *Earth);
+            void AttachLayeredEarthEM( std::shared_ptr<LayeredEarthEM> Earth);
 
             /** Attaches a set of receiver points for calculation */
-            void AttachReceiverPoints(ReceiverPoints *Receivers);
+            void AttachFieldPoints( std::shared_ptr<FieldPoints> Receivers);
 
             /** Sets the fields that are calcultated, E,H or BOTH */
             void SetFieldsToCalculate(const FIELDCALCULATIONS &calc);
 
         protected:
 
-            // ====================  LIFECYCLE     ===========================
-
-            /** Default protected constructor. */
-            EMEarth1D (const std::string& name);
-
-            #ifdef HAVE_YAMLCPP
-            /** Default protected constructor. */
-			EMEarth1D (const YAML::Node& node);
-            #endif
-
-            /** Default protected constructor. */
-            ~EMEarth1D ();
-
-            /**
-             * @copybrief LemmaObject::Release()
-             * @copydetails LemmaObject::Release()
-             */
-            void Release();
-
             // ====================  OPERATIONS    ===========================
 
             /** Used internally, this is the innermost loop of the MakeCalc3,
              *  and CalculateWireAntennaField routines.
              */
             void SolveSingleTxRxPair(const int &irec,
-                    HankelTransform *Hankel,
+                    std::shared_ptr<HankelTransform> Hankel,
                     const Real &wavef, const int &ifreq,
-                    DipoleSource *tDipole);
+                    std::shared_ptr<DipoleSource> tDipole);
 
             /** Used internally, this is the innermost loop of the MakeCalc3,
              *  and CalculateWireAntennaField routines.
              */
-            void SolveLaggedTxRxPair(const int &irec, Hankel2* Hankel,
+            void SolveLaggedTxRxPair(const int &irec, std::shared_ptr<Hankel2> Hankel,
                     const Real &wavef, const int &ifreq,
-                    PolygonalWireAntenna* antenna);
+                    std::shared_ptr<PolygonalWireAntenna> antenna);
 
             /** Removes all connections */
             void DetachAll();
             // ====================  DATA MEMBERS  ===========================
 
             /** Computes field due to dipole */
-            DipoleSource*        Dipole;
+            std::shared_ptr<DipoleSource>        Dipole;
 
             /** Earth model (Cole-cole) */
-            LayeredEarthEM*      Earth;
+            std::shared_ptr<LayeredEarthEM>      Earth;
 
             /** Receiver points */
-            ReceiverPoints*      Receivers;
+            std::shared_ptr<FieldPoints>         Receivers;
 
             /** Wire antennae tx */
-            WireAntenna*         Antenna;
+            std::shared_ptr<WireAntenna>         Antenna;
 
             /** What fields are wanted */
             FIELDCALCULATIONS    FieldsToCalculate;

Modules/FDEM1D/include/hankeltransform.h

 #ifndef __hankeltransform_h
 #define __hankeltransform_h
 
-#include "LemmaObject.h"
-#include "kernelem1dbase.h"
-#include "kernelem1dspec.h"
-#include "kernelem1dmanager.h"
+//#include "kernelem1dbase.h"
+#include "KernelEM1DSpec.h"
+#include "KernelEM1DManager.h"
 
 namespace Lemma {
 
+
+        class KernelEM1DBase;
+
         // ===================================================================
         //        Class:  HankelTransform
         /// \brief  Pure abstract class for hankel transforms
                 /// = omega * sqrt( EP*AMU )  amu = 4 pi e-7  ep = 8.85e-12
                 virtual Complex Zgauss(const int &ikk, const EMMODE &imode,
                             const int &itype, const Real &rho,
-                            const Real &wavef, KernelEm1DBase *Kernel)=0;
+                            const Real &wavef, std::shared_ptr<KernelEm1DBase> Kernel)=0;
 
                 /// Computes related kernels, if applicable, otherwise this is
                 /// just a dummy function.
                 virtual void ComputeRelated(const Real& rho, KernelEm1DBase* Kernel);
 
-                virtual void ComputeRelated(const Real& rho, std::vector< KernelEm1DBase* > KernelVec);
+                virtual void ComputeRelated(const Real& rho, std::vector< std::shared_ptr<KernelEM1DBase> > KernelVec);
 
-                virtual void ComputeRelated(const Real& rho, KernelEM1DManager* KernelManager);
+                virtual void ComputeRelated(const Real& rho, std::shared_ptr<KernelEM1DManager> KernelManager);
 
                 // ====================  ACCESS        =======================
 

Modules/FDEM1D/include/hankeltransformhankel2.h

 
 #include "hankeltransform.h"
 #include "kernelem1dbase.h"
-#include "kernelem1dspec.h"
+#include "KernelEM1DSpec.h"
 #include "CubicSplineInterpolator.h"
 
 namespace Lemma {

Modules/FDEM1D/include/kernelem1dbase.h

 
             // ====================  LIFECYCLE     =======================
 
+            /// Default protected constructor.
+            KernelEm1DBase ( ) : LemmaObject( ) {
+
+            }
+
+            /// Default protected constructor.
+            ~KernelEm1DBase () {
+            }
+
             // ====================  OPERATORS     =======================
 
             // ====================  OPERATIONS    =======================
 
         protected:
 
-            // ====================  LIFECYCLE     =======================
-
-            /// Default protected constructor.
-            KernelEm1DBase (const std::string& name) : LemmaObject(name)
-            {
-            }
-
-            /// Default protected constructor.
-            ~KernelEm1DBase () {
-                if (this->NumberOfReferences > 0)
-                    throw DeleteObjectWithReferences( this );
-            }
-
-            void Release() {
-                delete this;
-            }
-
-            // ====================  OPERATIONS    =======================
-
-
             // ====================  DATA MEMBERS  =========================
 
             /** Where does this kernel live on the vector managed by the manager */
 
         private:
 
+            /** ASCII string representation of the class name */
+            static constexpr auto CName = "KernelEM1DBase";
+
     }; // -----  end of class  KernelEm1DBase  -----
 
 } // namespace Lemma

Modules/FDEM1D/include/kernelem1dreflbase.h

 #ifndef  KERNELEM1DREFLBASE_INC
 #define  KERNELEM1DREFLBASE_INC
 
-#include "dipolesource.h"
-#include "kernelem1dbase.h"
-#include "layeredearthem.h"
-//#include "kernelem1dspec.h"
+#include "KernelEM1DSpec.h"
+//#include "kernelem1dbase.h"
+#include "DipoleSource.h"
+#include "LayeredEarthEM.h"
 
 namespace Lemma {
 
-    //class DipoleSource;
-
     enum DIPOLE_LOCATION { INAIR, INGROUND };
 
     // forward declaration for friend
-    template<EMMODE Mode, int Ikernel, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
-    class KernelEm1DSpec;
+    //template<EMMODE Mode, int Ikernel, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
+    //class KernelEM1DSpec;
 
 
     // ===================================================================
     // ===================================================================
     class KernelEM1DReflBase : public LemmaObject {
 
-        template<EMMODE Mode, int Ikernel, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
-        friend class KernelEm1DSpec;
-        friend class KernelEM1DManager;
+        //template<EMMODE Mode, int Ikernel, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
+        friend class KernelEM1DSpec;
+        //friend class KernelEM1DManager;
+        //friend class DipoleSource;
 
         public:
 
 
             // ====================  OPERATIONS    =======================
 
-            void Initialise(LayeredEarthEM* EarthIn) {
+            void Initialise( std::shared_ptr<LayeredEarthEM> EarthIn) {
 
                 nlay = EarthIn->GetNumberOfLayers();
                 zh = VectorXcr::Zero(nlay);
 
             }
 
-            void SetUpSource(DipoleSource *Dipole, const int &ifreq) {
+            void SetUpSource( std::shared_ptr<DipoleSource> Dipole, const int &ifreq ) {
 
                 zh(0) = Complex(0, Dipole->GetAngularFrequency(ifreq)*MU0);
                 yh(0) = Complex(0, Dipole->GetAngularFrequency(ifreq)*EPSILON0);
             // ====================  LIFECYCLE     =======================
 
             /// Default protected constructor.
-            KernelEM1DReflBase (const std::string& name) : LemmaObject(name)
+            KernelEM1DReflBase ( ) : LemmaObject( )
             {
             }
 
             /// Default protected constructor.
             ~KernelEM1DReflBase () {
-                if (this->NumberOfReferences > 0)
-                    throw DeleteObjectWithReferences( this );
-            }
-
-            void Release() {
-                delete this;
             }
 
             // ====================  OPERATIONS    =======================
 			EMMODE mode;
 
             /// Pointer to layered earth
-            LayeredEarthEM *Earth;
+            std::shared_ptr<LayeredEarthEM> Earth;
 
 			Complex       uk;
 			Complex       um;

Modules/FDEM1D/src/CMakeLists.txt

 	#${CMAKE_CURRENT_SOURCE_DIR}/AEMSurvey.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/LayeredEarthEM.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/FieldPoints.cpp
-	#${CMAKE_CURRENT_SOURCE_DIR}/DipoleSource.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/WireAntenna.cpp
+#	${CMAKE_CURRENT_SOURCE_DIR}/DipoleSource.cpp
 	#${CMAKE_CURRENT_SOURCE_DIR}/UngroundedElectricDipole.cpp
 	PARENT_SCOPE
 )

Modules/FDEM1D/src/DipoleSource.cpp

   @version  $Id: dipolesource.cpp 203 2015-01-09 21:19:04Z tirons $
  **/
 
-#include "dipolesource.h"
-#include "kernelem1dmanager.h"
+#include "DipoleSource.h"
+#include "KernelEM1DManager.h"
+#include "FieldPoints.h"
+
+//#include "GroundedElectricDipole.h"
+//#include "UngroundedElectricDipole.h"
+//#include "MagneticDipole.h"
 
-#include "GroundedElectricDipole.h"
-#include "UngroundedElectricDipole.h"
-#include "MagneticDipole.h"
-#include "receiverpoints.h"
 #include "hankeltransform.h"
 
 namespace Lemma {
 
 
     // ====================    FRIENDS     ======================
-    std::ostream &operator<<(std::ostream &stream,
-                const DipoleSource &ob) {
-
-        stream << *(LemmaObject*)(&ob);
-        switch (ob.Type) {
-            case (NOSOURCETYPE):
-                stream << "\tType=" << ob.Type << " (Uninitialized dipole)"
-                << "\n";
-                break;
-            case (GROUNDEDELECTRICDIPOLE):
-                stream << "\tType=" << ob.Type << " (Grounded Electric dipole)"
-                << "\n";
-                break;
-            case (UNGROUNDEDELECTRICDIPOLE):
-                stream << "\tType=" << ob.Type << " (Ungrounded Electric dipole)"
-                << "\n";
-                break;
-            case (MAGNETICDIPOLE):
-                stream << "\tType=" << ob.Type << " (Magnetic dipole)"
-                << "\n";
-                break;
-            default:
-                throw NonValidDipoleType( );
-        }
-
-        /*
-        switch (ob.Polarisation) {
-
-            case(NOPOLARISATION):
-                stream << "Polarisation=" << ob.Polarisation <<
-                        " (Unset polarisation)" << "\n";
-                break;
-
-            case(XPOLARISATION):
-                stream << "Polarisation=" << ob.Polarisation <<
-                        " (X polarised)" << "\n";
-                break;
-
-            case(YPOLARISATION):
-                stream << "Polarisation=" << ob.Polarisation <<
-                        " (Y polarised)" << "\n";
-                break;
-
-            case(ZPOLARISATION):
-                stream << "Polarisation=" << ob.Polarisation <<
-                        " (Z polarised)" << "\n";
-                break;
-        }
-        */
-        stream << "\tPolarisation " << ob.Phat.transpose() << "\n";
-        stream << "\tLocation= " << ob.Location.transpose()
-                << " [metres] \n";
-        stream << "\tFrequencies= " << ob.Freqs.transpose() << " [Hz] \n";
-        stream << "\tPhase= " << ob.Phase << "\n";
-        stream << "\tMoment= " << ob.Moment << "\n";
+    std::ostream &operator<<(std::ostream &stream, const DipoleSource &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
         return stream;
     }
 
 
     // ====================  LIFECYCLE     ======================
 
-    DipoleSource::DipoleSource(const std::string &name) :
-                    LemmaObject(name),
+    DipoleSource::DipoleSource( const ctor_key& ) : LemmaObject( ),
                     Type(NOSOURCETYPE),
                     Phase(0),
                     Moment(1),
-                    KernelManager(NULL),
-                    Receivers(NULL),
-                    Earth(NULL)
+                    KernelManager(nullptr),
+                    Receivers(nullptr),
+                    Earth(nullptr)
     {
         this->Location.setZero();
         this->Phat.setZero();
     }
 
     DipoleSource::~DipoleSource() {
-        if (this->NumberOfReferences != 0)
-            throw DeleteObjectWithReferences(this);
-        /* These are not attched as they are connected for such a short time that the reference counting
-           was getting tricked and calling delete
-        if (Receivers != NULL) {
-            Receivers->DetachFrom(this);
-        }
-
-        if (Earth != NULL) {
-            Earth->DetachFrom(this);
-        }
-        */
-        if (KernelManager != NULL) {
-            KernelManager->Delete();
-        }
-
     }
 
-    DipoleSource* DipoleSource::New() {
-        DipoleSource* Obj = new DipoleSource("DipoleSource");
-        Obj->AttachTo(Obj);
-        return Obj;
+    std::shared_ptr<DipoleSource> DipoleSource::NewSP() {
+        return std::make_shared<DipoleSource> ( ctor_key() );
     }
 
-    DipoleSource* DipoleSource::Clone() {
 
-        DipoleSource* Obj = new DipoleSource("DipoleSource");
-        Obj->AttachTo(Obj);
+    std::shared_ptr<DipoleSource> DipoleSource::Clone() {
+
+        auto Obj = DipoleSource::NewSP();
 
         // copy
         Obj->Type = Type;
         return Obj;
     }
 
-    void DipoleSource::Delete() {
-        this->DetachFrom(this);
-    }
-
-    void DipoleSource::Release() {
-        delete this;
-    }
-
     // ====================  ACCESS        ======================
     void DipoleSource::SetLocation(const Vector3r &posin) {
         this->Location = posin;
 
     // ====================  OPERATIONS     =====================
 
-    void DipoleSource::SetKernels(const int& ifreq, const FIELDCALCULATIONS&  Fields , ReceiverPoints* ReceiversIn, const int& irecin,
-            LayeredEarthEM* EarthIn  ) {
+    void DipoleSource::SetKernels(const int& ifreq, const FIELDCALCULATIONS&  Fields , std::shared_ptr<FieldPoints> ReceiversIn, const int& irecin,
+            std::shared_ptr<LayeredEarthEM> EarthIn  ) {
 
-        // These are not properly attached because in tight parallel loops reference counting is unreliable. This is safe as this
-        // method is not exposed to the public API and we know what we are doing here -TI
         if (Receivers != ReceiversIn) {
-            //if (Receivers != NULL) Receivers->DetachFrom(this);
             Receivers = ReceiversIn;
-            //ReceiversIn->AttachTo(this);
         }
 
         if (Earth != EarthIn) {
-            //if (Earth != NULL) Earth->DetachFrom(this);
             Earth = EarthIn;
-            //EarthIn->AttachTo(this);
         }
 
         if (irecin != irec) {
         lays = Earth->GetLayerAtThisDepth(Location[2]);
         layr = Earth->GetLayerAtThisDepth(Receivers->GetLocation(irec)[2]);
 
-        if (KernelManager != NULL) KernelManager->Delete();
-        KernelManager = KernelEM1DManager::New();
+        KernelManager = KernelEM1DManager::NewSP();
             KernelManager->SetEarth(Earth);
-            KernelManager->SetDipoleSource(this, ifreq, Receivers->GetLocation(irec)[2]);
+            KernelManager->SetDipoleSource(shared_from_this(), ifreq, Receivers->GetLocation(irec)[2]);
         kernelFreq = Freqs(ifreq); // this is never used
         ReSetKernels( ifreq, Fields, Receivers, irec, Earth );
 
 
     // TODO we could make the dipoles template specializations avoiding this rats nest of switch statements. Probably
     //      not the most critical piece though
-    void DipoleSource::ReSetKernels(const int& ifreq, const FIELDCALCULATIONS&  Fields , ReceiverPoints* Receivers, const int& irec,
-            LayeredEarthEM* Earth  ) {
+    void DipoleSource::ReSetKernels(const int& ifreq, const FIELDCALCULATIONS&  Fields , std::shared_ptr<FieldPoints> Receivers, const int& irec,
+            std::shared_ptr<LayeredEarthEM> Earth  ) {
 
         Vector3r Pol = Phat;
 
 
     }
 
-    void DipoleSource::UpdateFields( const int& ifreq, HankelTransform* Hankel, const Real& wavef) {
+    void DipoleSource::UpdateFields( const int& ifreq, std::shared_ptr<HankelTransform> Hankel, const Real& wavef) {
 
         Vector3r Pol = Phat;
 
 
     // ====================  INQUIRY       ======================
 
-    KernelEM1DManager*  DipoleSource::GetKernelManager() {
+    std::shared_ptr<KernelEM1DManager>  DipoleSource::GetKernelManager() {
         return KernelManager;
     }
 

Modules/FDEM1D/src/WireAntenna.cpp

 
 namespace Lemma {
 
-    #ifdef HAVE_YAMLCPP
     std::ostream &operator << (std::ostream &stream, const WireAntenna &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
         return stream;
     }
-    #else
-    std::ostream &operator<<(std::ostream &stream,
-                const WireAntenna &ob) {
-
-        stream << *(LemmaObject*)(&ob);
-        stream << "Current: " << ob.Current << " [A]\n";
-        stream << "Frequencies: " << ob.Freqs.transpose() << " [Hz]\n";
-        stream << "Number of points " << ob.NumberOfPoints << "\n";
-        stream << "Number of turns " << ob.NumberOfTurns << "\n";
-
-        if (ob.NumberOfPoints) {
-            stream << "Points:\n" << ob.Points.transpose() << "\n";
-            //stream << "Dipoles used to approximate " << ob.Dipoles.size() << "\n";
-        }
-        return stream;
-    }
-    #endif
+
     // ====================  LIFECYCLE     =======================
 
-    WireAntenna::WireAntenna(const std::string &name) :
-        LemmaObject(name),
+    WireAntenna::WireAntenna( const ctor_key& ) : LemmaObject( ),
         NumberOfPoints(0), Current(1), NumberOfTurns(1) {
     }
 
-#ifdef HAVE_YAMLCPP
-    WireAntenna::WireAntenna(const YAML::Node &node) :
-        LemmaObject(node) {
+    WireAntenna::WireAntenna( const YAML::Node& node, const ctor_key& ) : LemmaObject( node ) {
         Points =  node["Points"].as<Vector3Xr>();
         Freqs = node["Freqs"].as<VectorXr>();
         NumberOfPoints = node["NumberOfPoints"].as<int>();
         NumberOfTurns = node["NumberOfTurns"].as<int>();
         Current = node["Current"].as<Real>();
     }
-#endif
 
     WireAntenna::~WireAntenna() {
-        for (unsigned int id=0; id<Dipoles.size(); ++id) {
-            Dipoles[id]->Delete();
-        }
-        Dipoles.clear();
-        if (this->NumberOfReferences != 0) {
-            throw DeleteObjectWithReferences(this);
-        }
     }
 
-    WireAntenna* WireAntenna::New() {
-        WireAntenna* Obj = new WireAntenna("WireAntenna");
-        Obj->AttachTo(Obj);
-        return Obj;
+    std::shared_ptr<WireAntenna> WireAntenna::NewSP() {
+        return std::make_shared<WireAntenna>( ctor_key() );
     }
 
-    WireAntenna* WireAntenna::Clone() {
-        WireAntenna* copy = WireAntenna::New();
-		//copy->AttachTo(copy); // NO! Attached above!
+    std::shared_ptr<WireAntenna> WireAntenna::Clone() {
+        auto copy = WireAntenna::NewSP();
+
 		copy->NumberOfPoints = this->NumberOfPoints;
 		copy->Freqs = this->Freqs;
 		copy->Current = this->Current;
 		return copy;
     }
 
-    void WireAntenna::Delete() {
-        this->DetachFrom(this);
-    }
+    //--------------------------------------------------------------------------------------
+    //       Class:  WireAntenna
+    //      Method:  Serialize
+    //--------------------------------------------------------------------------------------
+    YAML::Node WireAntenna::Serialize (  ) const {
+        YAML::Node node = LemmaObject::Serialize();
+        node.SetTag( GetName() );
+        node["NumberOfPoints"] = NumberOfPoints;
+        node["NumberOfTurns"] = NumberOfTurns;
+        node["Current"] = Current;
+        node["Points"] = Points;
+        node["Freqs"] = Freqs;
+        return node;
+    }		// -----  end of method WireAntenna::Serialize  -----
 
-    void WireAntenna::Release() {
-        delete this;
-    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  WireAntenna
+    //      Method:  DeSerialize
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr<WireAntenna> WireAntenna::DeSerialize ( const YAML::Node& node ) {
+        if (node.Tag() != "WireAntenna") {
+            throw  DeSerializeTypeMismatch( "WireAntenna", node.Tag());
+        }
+        return std::make_shared<WireAntenna> ( node, ctor_key() );
+    }		// -----  end of method WireAntenna::DeSerialize  -----
 
 
     // ====================  ACCESS        =======================
     void WireAntenna::ApproximateWithElectricDipoles(const Real &deltai) {
 
         // Get rid of any dipoles
-        for (unsigned int id=0; id<Dipoles.size(); ++id) {
-            Dipoles[id]->Delete();
-        }
         Dipoles.clear();
 
         Real Dist(0);
 
                 // X dipoles
                 if (std::abs(r[0]) > 1e-6) {
-                    DipoleSource *tx = DipoleSource::New();
+                    auto tx = DipoleSource::NewSP();
                     tx->SetLocation(p);
                     tx->SetType(GROUNDEDELECTRICDIPOLE);
                     tx->SetPolarisation(XPOLARISATION);
 
                 // Y dipoles
                 if (std::abs(r[1]) > 1e-6) {
-                    DipoleSource *ty = DipoleSource::New();
+                    auto ty = DipoleSource::NewSP();
                     ty->SetLocation(p);
                     ty->SetType(GROUNDEDELECTRICDIPOLE);
                     ty->SetPolarisation(YPOLARISATION);
 
                 // Z dipoles
                 if (std::abs(r[2]) > 1e-6) {
-                    DipoleSource *tz = DipoleSource::New();
+                    auto tz = DipoleSource::NewSP();
                     tz->SetLocation(p);
                     tz->SetType(GROUNDEDELECTRICDIPOLE);
                     tz->SetPolarisation(ZPOLARISATION);
         return Dipoles.size();
     }
 
-    DipoleSource* WireAntenna::GetDipoleSource(const int &dip) {
+    std::shared_ptr<DipoleSource> WireAntenna::GetDipoleSource(const int &dip) {
         return this->Dipoles[dip];
     }
 
     }
     #endif
 
-    #ifdef HAVE_YAMLCPP
-    //--------------------------------------------------------------------------------------
-    //       Class:  WireAntenna
-    //      Method:  Serialize
-    //--------------------------------------------------------------------------------------
-    YAML::Node WireAntenna::Serialize (  ) const {
-        YAML::Node node = LemmaObject::Serialize();
-        node.SetTag( this->Name );
-        node["NumberOfPoints"] = NumberOfPoints;
-        node["NumberOfTurns"] = NumberOfTurns;
-        node["Current"] = Current;
-        node["Points"] = Points;
-        node["Freqs"] = Freqs;
-        return node;
-    }		// -----  end of method WireAntenna::Serialize  -----
-
-
-    //--------------------------------------------------------------------------------------
-    //       Class:  WireAntenna
-    //      Method:  DeSerialize
-    //--------------------------------------------------------------------------------------
-    WireAntenna* WireAntenna::DeSerialize ( const YAML::Node& node ) {
-        WireAntenna* Object = new WireAntenna(node);
-        Object->AttachTo(Object);
-        DESERIALIZECHECK( node, Object )
-        return Object ;
-    }		// -----  end of method WireAntenna::DeSerialize  -----
-
-    #endif
-
-
     //--------------------------------------------------------------------------------------
     //       Class:  WireAntenna
     //      Method:  IsPlanar

Modules/LemmaCore/include/LemmaObject.h

   *           standard. All Lemma objects should be created as C++-11 Smart pointers, using
   *           the supplied New method. Calls to Delete are no longer necessary or available.
   */
-class LemmaObject {
+class LemmaObject : public std::enable_shared_from_this<LemmaObject> {
 
     /**
      *  Streams class information as YAML::Node