Lemma V 0.2.0, ctor_key now only at root level

CMakeLists.txt

 endif()
 
 set(LEMMA_VERSION_MAJOR "0")
-set(LEMMA_VERSION_MINOR "1")
-set(LEMMA_VERSION_PATCH "2")
+set(LEMMA_VERSION_MINOR "2")
+set(LEMMA_VERSION_PATCH "0")
 set(LEMMA_VERSION "\"${LEMMA_VERSION_MAJOR}.${LEMMA_VERSION_MINOR}.${LEMMA_VERSION_PATCH}\"")
 set(LEMMA_VERSION_NOQUOTES "${LEMMA_VERSION_MAJOR}.${LEMMA_VERSION_MINOR}.${LEMMA_VERSION_PATCH}")
 

Modules/FDEM1D/include/DipoleSource.h

 
         friend std::ostream &operator<<(std::ostream &stream, const DipoleSource &ob);
 
-        struct ctor_key{};
-
         public:
 
             // ====================  LIFECYCLE     ======================

Modules/FDEM1D/include/EMEarth1D.h

 		friend std::ostream &operator<<(std::ostream &stream,
 			const EMEarth1D &ob);
 
-        struct ctor_key{};
-
         public:
 
             //friend class KernelEm1D;

Modules/FDEM1D/include/FHTAnderson801.h

 
     friend std::ostream &operator<<(std::ostream &stream, const FHTAnderson801 &ob);
 
-    struct ctor_key {};
-
     public:
 
         // ====================  LIFECYCLE     ==============================

Modules/FDEM1D/include/FHTKey101.h

 
         friend std::ostream &operator<<(std::ostream &stream, const FHTKey101 &ob);
 
-        struct ctor_key {};
-
         public:
 
         // ====================  LIFECYCLE     =======================

Modules/FDEM1D/include/FHTKey201.h

     class FHTKey201 : public HankelTransform {
 
         friend std::ostream &operator<<(std::ostream &stream, const FHTKey201 &ob);
-
-        struct ctor_key {};
+        // ====================  LIFECYCLE     =======================
 
         public:
 
-        // ====================  LIFECYCLE     =======================
-
         /** Default locked constructor, use NewSP */
         FHTKey201 ( const ctor_key& );
 

Modules/FDEM1D/include/FHTKey51.h

 
         friend std::ostream &operator<<(std::ostream &stream, const FHTKey51 &ob);
 
-        struct ctor_key {};
-
         public:
 
         // ====================  LIFECYCLE     =======================

Modules/FDEM1D/include/FieldPoints.h

          */
         friend std::ostream &operator<<(std::ostream &stream, const FieldPoints &ob);
 
-        struct ctor_key {};
-
         public:
 
             // ====================    FRIENDS     ===========================
 
-
-
             // ====================  LIFECYCLE     ===========================
 
             /** Default locked constructor. */

Modules/FDEM1D/include/GQChave.h

 	class GQChave : public HankelTransform {
 
 		friend std::ostream &operator<<(std::ostream &stream, const GQChave &ob);
-
-        struct ctor_key{};
-
 		public:
 
 			// ====================  LIFECYCLE     ===========================

Modules/FDEM1D/include/HankelTransform.h

                 // ====================  LIFECYCLE     =======================
 
                 /// Default protected constructor.
-                HankelTransform ( );
+                HankelTransform ( const ctor_key& );
 
                 /// Default protected constructor.
-                HankelTransform ( const YAML::Node& node );
+                HankelTransform ( const YAML::Node& node, const ctor_key& );
 
                 /// Default protected constructor.
                 ~HankelTransform ( );

Modules/FDEM1D/include/KernelEM1DBase.h

             // ====================  LIFECYCLE     =======================
 
             /// Default protected constructor.
-            KernelEM1DBase ( ) : LemmaObject( ) {
+            KernelEM1DBase ( const ctor_key& key ) : LemmaObject( key ) {
 
             }
 

Modules/FDEM1D/include/KernelEM1DManager.h

     // ===================================================================
     class KernelEM1DManager : public LemmaObject {
 
-        struct ctor_key {};
-
         /** Recursively streams information about this class */
         friend std::ostream &operator<<(std::ostream &stream, const KernelEM1DManager &ob);
 

Modules/FDEM1D/include/KernelEM1DReflBase.h

             // ====================  LIFECYCLE     =======================
 
             /// Default protected constructor.
-            KernelEM1DReflBase ( ) : LemmaObject( )
+            KernelEM1DReflBase ( const ctor_key& key ) : LemmaObject( key )
             {
             }
 

Modules/FDEM1D/include/KernelEM1DReflSpec.h

     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:
 
             //template<EMMODE Mode2, int Ikernel2, DIPOLE_LOCATION Isource2, DIPOLE_LOCATION Irecv2>
             // ====================  LIFECYCLE     =======================
 
             /// Default locked constructor.
-            explicit KernelEM1DReflSpec ( const ctor_key& ) : KernelEM1DReflBase( ) {
+            explicit KernelEM1DReflSpec ( const ctor_key& key ) : KernelEM1DReflBase( key ) {
             }
 
             /// Default protected constructor.
 
             virtual std::string GetName() {
                 return CName;
-            } 
+            }
 
         protected:
         private:

Modules/FDEM1D/include/KernelEM1DSpec.h

     template<EMMODE Mode, int Ikernel, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
     class KernelEM1DSpec : public KernelEM1DBase {
 
-        struct ctor_key {};
-
         public:
 
             // ====================  LIFECYCLE     =======================
 
             /// Default locked constructor.
-            explicit KernelEM1DSpec (const ctor_key& ) : KernelEM1DBase( ), ReflCalc(nullptr) {
+            explicit KernelEM1DSpec (const ctor_key& key ) : KernelEM1DBase( key ), ReflCalc(nullptr) {
             }
 
             /// Default destructor.
             }
 
             static std::shared_ptr<KernelEM1DSpec> NewSP(LayeredEarthEM* Earth, std::shared_ptr<DipoleSource> Dipole,
-                                                                                        const int& ifreq, const Real& rz) {
+                                                         const int& ifreq, const Real& rz) {
                 auto Obj = std::make_shared< KernelEM1DSpec > ( ctor_key() );
 
                 // under this scenario KernelEM1DSpec manages its own Refl Base

Modules/FDEM1D/include/LayeredEarthEM.h

         /** Recursively streams information about this class */
         friend std::ostream &operator<<(std::ostream &stream, const LayeredEarthEM &ob);
 
-        struct ctor_key {};
-
         public:
 
             // ====================  LIFECYCLE     ===========================

Modules/FDEM1D/include/PolygonalWireAntenna.h

 
         friend std::ostream &operator<<(std::ostream &stream, const PolygonalWireAntenna &ob);
 
-        struct ctor_key {};
-
         public:
 
             // ====================  LIFECYCLE     =======================

Modules/FDEM1D/include/QWEKey.h

 
         friend std::ostream &operator<<(std::ostream &stream, const QWEKey &ob);
 
-        struct ctor_key {};
-
         public:
 
         // ====================  LIFECYCLE     =======================

Modules/FDEM1D/include/WireAntenna.h

 
         friend std::ostream &operator<<(std::ostream &stream, const WireAntenna &ob);
 
-        protected:
-        struct ctor_key {};
-
         public:
 
             // ====================  LIFECYCLE     =======================

Modules/FDEM1D/src/DipoleSource.cpp

 
     // ====================    FRIENDS     ======================
     std::ostream &operator<<(std::ostream &stream, const DipoleSource &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
 
 
     // ====================  LIFECYCLE     ======================
 
-    DipoleSource::DipoleSource( const ctor_key& ) : LemmaObject( ),
+    DipoleSource::DipoleSource( const ctor_key& key ) : LemmaObject( key ),
                     Type(NOSOURCETYPE),
                     irec(-1),
                     Phase(0),

Modules/FDEM1D/src/EMEarth1D.cpp

 namespace Lemma {
 
     std::ostream &operator << (std::ostream &stream, const EMEarth1D &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
 
     // ====================  LIFECYCLE     ===================================
 
     // TODO init large arrays here.
-    EMEarth1D::EMEarth1D( const ctor_key& ) : LemmaObject( ),
+    EMEarth1D::EMEarth1D( const ctor_key& key ) : LemmaObject( key ),
             Dipole(nullptr), Earth(nullptr), Receivers(nullptr), Antenna(nullptr),
             FieldsToCalculate(BOTH), HankelType(ANDERSON801), icalcinner(0), icalc(0)
         //#ifdef HAVEBOOSTPROGRESS

Modules/FDEM1D/src/FHTAnderson801.cpp

 namespace Lemma {
 
     std::ostream &operator << (std::ostream &stream, const FHTAnderson801 &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
 
 	const Real FHTAnderson801::ABSER = 0.904837418035959573;      // 1/exp(.1)
 
 	// ====================  LIFECYCLE     ==============================
-	FHTAnderson801::FHTAnderson801(const ctor_key& ) : HankelTransform( ),
+	FHTAnderson801::FHTAnderson801(const ctor_key& key ) : HankelTransform( key ),
 			             Lambda(0), NumFun(0),
 						 NumConv(0), NumRel(0),
 						 BesselOrder(-1),  Manager(nullptr) {
 	}
 
-    FHTAnderson801::FHTAnderson801( const YAML::Node& node, const ctor_key& ) : HankelTransform( ) {
+    FHTAnderson801::FHTAnderson801( const YAML::Node& node, const ctor_key& key ) : HankelTransform( key ) {
         Lambda = node["Lambda"].as<Real>();
         NumFun = node["NumFun"].as<int>();
 		NumConv = node["NumConv"].as<int>();

Modules/FDEM1D/src/FHTKey101.cpp

     // ====================  FRIEND METHODS  =====================
 
     std::ostream &operator<<(std::ostream &stream, const FHTKey101 &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
 
     //      Method:  FHTKey101
     // Description:  constructor (locked)
     //--------------------------------------------------------------------------------------
-    FHTKey101::FHTKey101 ( const ctor_key& ) : HankelTransform( ) {
+    FHTKey101::FHTKey101 ( const ctor_key& key ) : HankelTransform( key ) {
 
     }  // -----  end of method FHTKey101::FHTKey101  (constructor)  -----
 
     //      Method:  FHTKey101
     // Description:  constructor (protected)
     //--------------------------------------------------------------------------------------
-    FHTKey101::FHTKey101( const YAML::Node& node, const ctor_key& ) : HankelTransform(node) {
+    FHTKey101::FHTKey101( const YAML::Node& node, const ctor_key& key ) : HankelTransform(node, key) {
 
     }
 

Modules/FDEM1D/src/FHTKey201.cpp

     // ====================  FRIEND METHODS  =====================
 
     std::ostream &operator<<(std::ostream &stream, const FHTKey201 &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
 
     //      Method:  FHTKey201
     // Description:  constructor (locked)
     //--------------------------------------------------------------------------------------
-    FHTKey201::FHTKey201 (const ctor_key& ) : HankelTransform( ) {
+    FHTKey201::FHTKey201 (const ctor_key& key ) : HankelTransform( key ) {
 
     }  // -----  end of method FHTKey201::FHTKey201  (constructor)  -----
 
     //      Method:  FHTKey201
     // Description:  constructor (locked)
     //--------------------------------------------------------------------------------------
-    FHTKey201::FHTKey201( const YAML::Node& node, const ctor_key& ) : HankelTransform(node) {
+    FHTKey201::FHTKey201( const YAML::Node& node, const ctor_key& key) : HankelTransform(node, key) {
 
     }
 

Modules/FDEM1D/src/FHTKey51.cpp

     // ====================  FRIEND METHODS  =====================
 
     std::ostream &operator<<(std::ostream &stream, const FHTKey51 &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        stream << ob.Serialize()  << "\n"; // End of doc ---
         return stream;
     }
 
     //      Method:  FHTKey51
     // Description:  constructor (locked)
     //--------------------------------------------------------------------------------------
-    FHTKey51::FHTKey51 (const ctor_key& ) : HankelTransform( ) {
+    FHTKey51::FHTKey51 (const ctor_key& key ) : HankelTransform( key ) {
 
     }  // -----  end of method FHTKey51::FHTKey51  (constructor)  -----
 
     //      Method:  FHTKey51
     // Description:  constructor (protected)
     //--------------------------------------------------------------------------------------
-    FHTKey51::FHTKey51( const YAML::Node& node, const ctor_key& ) : HankelTransform(node) {
+    FHTKey51::FHTKey51( const YAML::Node& node, const ctor_key& key ) : HankelTransform(node, key) {
 
     }
 

Modules/FDEM1D/src/FieldPoints.cpp

     // ====================    FRIENDS     ======================
 
     std::ostream &operator << (std::ostream &stream, const FieldPoints &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
 
     // ====================  LIFECYCLE     ===================================
 
-    FieldPoints::FieldPoints( const ctor_key& ) : LemmaObject( ),
+    FieldPoints::FieldPoints( const ctor_key& key ) : LemmaObject( key ),
         NumberOfPoints(0), NumberOfBinsE(0), NumberOfBinsH(0) {
     }
 
     //      Method:  FieldPoints
     // Description:  constructor (protected)
     //--------------------------------------------------------------------------------------
-    FieldPoints::FieldPoints (const YAML::Node& node, const ctor_key&) : LemmaObject(node) {
+    FieldPoints::FieldPoints (const YAML::Node& node, const ctor_key& key) : LemmaObject(node, key) {
         //DeSerialize
         NumberOfPoints = node["NumberOfPoints"].as<int>();
         NumberOfBinsE = node["NumberOfBinsE"].as<int>();

Modules/FDEM1D/src/GQChave.cpp

 namespace Lemma{
 
     std::ostream &operator<<(std::ostream &stream, const GQChave &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
 
     const Real J1_X12 = -0.5382308663841630e-15;
 */
 
-    GQChave::GQChave( const ctor_key& ) : HankelTransform( ) {
+    GQChave::GQChave( const ctor_key& key ) : HankelTransform( key ) {
         karg.resize(255, 100);
         kern.resize(510, 100);
     }
 
-    GQChave::GQChave( const YAML::Node& node, const ctor_key& ) : HankelTransform(node) {
+    GQChave::GQChave( const YAML::Node& node, const ctor_key& key ) : HankelTransform(node, key) {
 
     }
 

Modules/FDEM1D/src/HankelTransform.cpp

 namespace Lemma {
 
     std::ostream &operator << (std::ostream &stream, const HankelTransform &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
 
-	HankelTransform::HankelTransform( ) : LemmaObject( )	{
+	HankelTransform::HankelTransform( const ctor_key& key ) : LemmaObject( key )	{
 	}
 
-    HankelTransform::HankelTransform( const YAML::Node& node ) : LemmaObject( node )	{
+    HankelTransform::HankelTransform( const YAML::Node& node, const ctor_key& key  ) : LemmaObject( node, key )	{
 	}
 
 	HankelTransform::~HankelTransform( ) {

Modules/FDEM1D/src/KernelEM1DManager.cpp

 namespace Lemma {
 
     std::ostream &operator<<(std::ostream &stream, const KernelEM1DManager &ob) {
-        stream << ob.Serialize() << "\n---\n";
+        stream << ob.Serialize() << "\n";
         return stream;
     }
 
     // ====================  LIFECYCLE     =======================
 
-    KernelEM1DManager::KernelEM1DManager( const ctor_key& ) : LemmaObject( ), TEReflBase(nullptr),
+    KernelEM1DManager::KernelEM1DManager( const ctor_key& key ) : LemmaObject( key ), TEReflBase(nullptr),
         TMReflBase(nullptr), Earth(nullptr), Dipole(nullptr) {
     }
 

Modules/FDEM1D/src/LayeredEarthEM.cpp

 namespace Lemma {
 
     std::ostream &operator << (std::ostream &stream, const LayeredEarthEM &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
 
     // ====================  LIFECYCLE     ===================================
 
-    LayeredEarthEM::LayeredEarthEM( const ctor_key& key ) : LayeredEarth( LayeredEarth::ctor_key() ) {
+    LayeredEarthEM::LayeredEarthEM( const ctor_key& key ) : LayeredEarth( key ) {
     }
 
-    LayeredEarthEM::LayeredEarthEM( const YAML::Node& node, const ctor_key& ) : LayeredEarth(node) {
+    LayeredEarthEM::LayeredEarthEM( const YAML::Node& node, const ctor_key& key ) : LayeredEarth(node, key) {
         SetNumberOfLayers(NumberOfLayers);
         LayerThickness = node["LayerThickness"].as<VectorXr>();
         if (node["LayerConductivity"]) {

Modules/FDEM1D/src/PolygonalWireAntenna.cpp

 namespace Lemma {
 
     std::ostream &operator << (std::ostream &stream, const PolygonalWireAntenna &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
 
 	// ====================  LIFECYCLE     =======================
 
-	PolygonalWireAntenna::PolygonalWireAntenna( const ctor_key& key ) : WireAntenna( WireAntenna::ctor_key() ), minDipoleRatio(.15),
+	PolygonalWireAntenna::PolygonalWireAntenna( const ctor_key& key ) :
+            WireAntenna( key ), minDipoleRatio(.15),
    		minDipoleMoment(1e-6), maxDipoleMoment(1e1), rRepeat(1e10,1e10,1e10) {
 		Points.setZero();
         //rRepeat.setOnes();
 	}
 
-    PolygonalWireAntenna::PolygonalWireAntenna( const YAML::Node& node, const ctor_key& ) : WireAntenna(node, WireAntenna::ctor_key() ) {
+    PolygonalWireAntenna::PolygonalWireAntenna( const YAML::Node& node, const ctor_key& key) : WireAntenna(node, key ) {
         minDipoleRatio   = node["minDipoleRatio"].as<Real>();
         maxDipoleMoment  = node["maxDipoleMoment"].as<Real>();
         minDipoleMoment  = node["minDipoleMoment"].as<Real>();

Modules/FDEM1D/src/QWEKey.cpp

     // Description:  constructor (protected)
     //--------------------------------------------------------------------------------------
     //
-    QWEKey::QWEKey (const ctor_key& ) : HankelTransform( ), RelTol(1e-12), AbsTol(1e-32), nQuad(61), nDelay(1),
+    QWEKey::QWEKey (const ctor_key& key) : HankelTransform( key ), RelTol(1e-12), AbsTol(1e-32), nQuad(61), nDelay(1),
     //QWEKey::QWEKey (const std::string& name) : HankelTransform(name), RelTol(1e-38), AbsTol(1e-48), nQuad(39), nDelay(5),
         nIntervalsMax(40) {
         BesselWeights( J0 ); // TODO experiment with zero weight (J0, J1) options, should be static one time method
     //      Method:  QWEKey
     // Description:  constructor (locked)
     //--------------------------------------------------------------------------------------
-    QWEKey::QWEKey( const YAML::Node& node, const ctor_key& ) : HankelTransform(node) {
+    QWEKey::QWEKey( const YAML::Node& node, const ctor_key& key ) : HankelTransform(node, key) {
 
     }
 

Modules/FDEM1D/src/WireAntenna.cpp

 namespace Lemma {
 
     std::ostream &operator << (std::ostream &stream, const WireAntenna &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
 
     // ====================  LIFECYCLE     =======================
 
-    WireAntenna::WireAntenna( const ctor_key& ) : LemmaObject( ),
+    WireAntenna::WireAntenna( const ctor_key& key ) : LemmaObject( key ),
         NumberOfPoints(0), Current(1), NumberOfTurns(1) {
     }
 
-    WireAntenna::WireAntenna( const YAML::Node& node, const ctor_key& ) : LemmaObject( node ) {
+    WireAntenna::WireAntenna( const YAML::Node& node, const ctor_key& key ) : LemmaObject( node, key ) {
         Points =  node["Points"].as<Vector3Xr>();
         Freqs = node["Freqs"].as<VectorXr>();
         NumberOfPoints = node["NumberOfPoints"].as<int>();

Modules/LemmaCore/include/CubicSplineInterpolator.h

  * @date      09/25/2013 08:20:14 AM
  * @version   $Id$
  * @author    Trevor Irons (ti)
- * @email     Trevor.Irons@xri-geo.com
- * @copyright Copyright (c) 2013, XRI Geophysics, LLC
- * @copyright Copyright (c) 2013, Trevor Irons
+ * @email     Trevor.Irons@lemmasoftware.org
+ * @copyright Copyright (c) 2013,2018 Trevor Irons
  */
 
 #ifndef  CUBICSPLINEINTERPOLATOR_INC
     friend std::ostream &operator<<(std::ostream &stream,
             const CubicSplineInterpolator& ob);
 
-    struct ctor_key {};
+    //struct ctor_key {};
 
     public:
 

Modules/LemmaCore/include/Data.h

             // ====================  LIFECYCLE     =======================
 
             /** Default protected constructor. */
-            Data (  );
+            Data ( const ctor_key& key  );
 
             /** Deserializing contructor */
-            Data ( const YAML::Node& node );
+            Data ( const YAML::Node& node, const ctor_key& key );
 
             /** Default protected constructor. */
             ~Data ( );

Modules/LemmaCore/include/DataReader.h

         // ====================  LIFECYCLE     =======================
 
         /// Default protected constructor.
-        DataReader ( );
+        DataReader ( const ctor_key& key );
 
         /// Default protected constructor.
-        DataReader ( const YAML::Node& node );
+        DataReader ( const YAML::Node& node, const ctor_key& key );
 
         /// Default protected constructor.
         ~DataReader ( );

Modules/LemmaCore/include/EarthModel.h

             // ====================  LIFECYCLE     =======================
 
             /// Default protected constructor.
-            EarthModel ( );
+            EarthModel ( const ctor_key& );
 
             /** Deserialize constructor */
-            EarthModel (const YAML::Node& node);
+            EarthModel (const YAML::Node& node, const ctor_key&);
 
             /// Default protected constructor.
             ~EarthModel ();

Modules/LemmaCore/include/Filter.h

             // ====================  LIFECYCLE     =======================
 
             /// Default protected constructor.
-            Filter ( );
+            Filter ( const ctor_key&  );
 
             /// Default protected constructor.
-            Filter ( const YAML::Node& node );
+            Filter ( const YAML::Node& node, const ctor_key& );
 
             /// Default protected constructor.
             virtual ~Filter ();

Modules/LemmaCore/include/Grid.h

         // ====================  LIFECYCLE     ===================================
 
         /** Protected DeDerializing constructor, use factory DeSerialize  method on non abstract classes*/
-        Grid (const YAML::Node& node);
+        Grid (const YAML::Node& node, const ctor_key& );
 
         /// Default protected constructor.
-        Grid ( );
+        Grid ( const ctor_key& );
 
         /// Default protected constructor.
         virtual ~Grid ( );

Modules/LemmaCore/include/GridReader.h

             // ====================  LIFECYCLE     =======================
 
             /** Default protected constructor, use New */
-            GridReader ( ) : LemmaObject( ) {
+            GridReader ( const ctor_key& key ) : LemmaObject( key ) {
             }
 
             /** Default protected constructor, use New */
-            GridReader ( const YAML::Node& node ) : LemmaObject( node ) {
+            GridReader ( const YAML::Node& node, const ctor_key& key ) : LemmaObject( node, key ) {
             }
 
             /** Default protected constructor, use Delete */

Modules/LemmaCore/include/LayeredEarth.h

         friend class LayeredEarthEM;
         friend class LayeredEarthMR;
 
-        struct ctor_key{};
-
 		public:
 
 			// ====================    FRIENDS     ===========================
 			LayeredEarth ( const ctor_key& );
 
             /** Default protected constructor. */
-			LayeredEarth (const YAML::Node& node);
+			LayeredEarth (const YAML::Node& node, const ctor_key& key);
 
 			/** Default protected constructor. */
 			~LayeredEarth ();

Modules/LemmaCore/include/RectilinearGrid.h

         /*
          *  This key is used to lock the constructors
          */
-        struct ctor_key {};
+        //struct ctor_key {};
 
         public:
 

Modules/LemmaCore/include/RectilinearGridReader.h

         /*
          *  This key is used to lock the constructors
          */
-        struct ctor_key {};
+        //struct ctor_key {};
 
         public:
 

Modules/LemmaCore/include/RectilinearGridVTKExporter.h

     friend std::ostream &operator<<(std::ostream &stream,
             const RectilinearGridVTKExporter &ob);
 
-    struct ctor_key {};
+    //struct ctor_key {};
 
     public:
 

Modules/LemmaCore/include/WindowFilter.h

 
         friend std::ostream &operator<<(std::ostream &stream, const WindowFilter& ob);
 
-        struct ctor_key {};
+        //struct ctor_key {};
 
         public:
 

Modules/LemmaCore/src/CubicSplineInterpolator.cpp

  * @date      02/07/2014 12:50:52 PM
  * @version   $Id$
  * @author    Trevor Irons (ti)
- * @email     Trevor.Irons@xri-geo.com
- * @copyright Copyright (c) 2014, Trevor Irons
+ * @email     Trevor.Irons@lemmasoftware.org
+ * @copyright Copyright (c) 2014,2018 Trevor Irons
  */
 
 #include "CubicSplineInterpolator.h"
     //      Method:  CubicSplineInterpolator
     // Description:  constructor (locked with ctor_key)
     //--------------------------------------------------------------------------------------
-    CubicSplineInterpolator::CubicSplineInterpolator ( const ctor_key& ) : LemmaObject( ) {
+    CubicSplineInterpolator::CubicSplineInterpolator ( const ctor_key& key ) : LemmaObject( key ) {
 
     }  // -----  end of method CubicSplineInterpolator::CubicSplineInterpolator  (constructor)  -----
 
     //      Method:  CubicSplineInterpolator
     // Description:  DeSerializing constructor (locked with ctor_key)
     //--------------------------------------------------------------------------------------
-    CubicSplineInterpolator::CubicSplineInterpolator (const YAML::Node& node, const ctor_key& ) : LemmaObject(node) {
+    CubicSplineInterpolator::CubicSplineInterpolator (const YAML::Node& node, const ctor_key& key ) : LemmaObject(node, key) {
     }  // -----  end of method CubicSplineInterpolator::CubicSplineInterpolator  (constructor)  -----
 
     //--------------------------------------------------------------------------------------

Modules/LemmaCore/src/Data.cpp

 namespace Lemma {
 
     std::ostream &operator << (std::ostream &stream, const Data &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
 
-	Data::Data(  ) : LemmaObject( ) {
+	Data::Data( const ctor_key& key  ) : LemmaObject( key ) {
 	}
 
-    Data::Data( const YAML::Node& node ) : LemmaObject( node ) {
+    Data::Data( const YAML::Node& node, const ctor_key& key ) : LemmaObject( node, key ) {
 	}
 
 

Modules/LemmaCore/src/DataReader.cpp

 namespace Lemma {
 
     std::ostream &operator << (std::ostream &stream, const DataReader &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
 
-	DataReader::DataReader( ) : LemmaObject( ) {
+	DataReader::DataReader( const ctor_key& key ) : LemmaObject( key ) {
 
 	}
 
-    DataReader::DataReader( const YAML::Node& node ) : LemmaObject( node ) {
+    DataReader::DataReader( const YAML::Node& node, const ctor_key& key ) : LemmaObject( node, key ) {
 
 	}
 

Modules/LemmaCore/src/EarthModel.cpp

 namespace Lemma {
 
     std::ostream &operator << (std::ostream &stream, const EarthModel &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
 
 	// ====================  LIFECYCLE     =======================
 
-	EarthModel::EarthModel() : LemmaObject( ),
+	EarthModel::EarthModel( const ctor_key& key ) : LemmaObject( key ),
         BField(0,0,0), BFieldUnit(0,0,0), BInc(0), BDec(0), BMag(0) {
 	}
 
-    EarthModel::EarthModel(const YAML::Node& node) : LemmaObject(node) {
+    EarthModel::EarthModel(const YAML::Node& node, const ctor_key& key) : LemmaObject(node, key) {
         BInc = node["BInc"].as<double>();
         BDec = node["BDec"].as<double>();
         BMag = node["BMag"].as<double>();

Modules/LemmaCore/src/Filter.cpp

     //      Method:  Filter
     // Description:  constructor (protected)
     //--------------------------------------------------------------------------------------
-    Filter::Filter( ) : LemmaObject( ) { }
+    Filter::Filter( const ctor_key& key ) : LemmaObject( key ) { }
 
     //--------------------------------------------------------------------------------------
     //       Class:  Filter
     //      Method:  Filter
     // Description:  DeSerializing constructor (protected)
     //--------------------------------------------------------------------------------------
-    Filter::Filter ( const YAML::Node& node ) : LemmaObject(node) {
+    Filter::Filter ( const YAML::Node& node, const ctor_key& key ) : LemmaObject(node, key) {
     }
 
     //--------------------------------------------------------------------------------------

Modules/LemmaCore/src/Grid.cpp

 
     // ====================  LIFECYCLE     ===================================
 
-	Grid::Grid( ) : LemmaObject( ) {
+	Grid::Grid( const ctor_key& key ) : LemmaObject( key ) {
 	}
 
-    Grid::Grid( const YAML::Node& node ) : LemmaObject(node) {
+    Grid::Grid( const YAML::Node& node, const ctor_key& key ) : LemmaObject(node, key) {
 
     }
 

Modules/LemmaCore/src/LayeredEarth.cpp

 	// ====================    FRIENDS     ======================
 
     std::ostream &operator << (std::ostream &stream, const LayeredEarth &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
 
 	// ====================  LIFECYCLE     ===================================
 
-	LayeredEarth::LayeredEarth( const ctor_key& key ) : EarthModel( ),
+	LayeredEarth::LayeredEarth( const ctor_key& key ) : EarthModel( key ),
 		NumberOfLayers(0), 	NumberOfInterfaces(0) {
 	}
 
 	LayeredEarth::~LayeredEarth() {
 	}
 
-    LayeredEarth::LayeredEarth(const YAML::Node& node) : EarthModel(node) {
+    LayeredEarth::LayeredEarth(const YAML::Node& node, const ctor_key& key) : EarthModel(node, key) {
         NumberOfLayers = node["NumberOfLayers"].as<int>();
         NumberOfInterfaces = node["NumberOfInterfaces"].as<int>();
         LayerThickness = node["LayerThickness"].as<VectorXr>();

Modules/LemmaCore/src/RectilinearGrid.cpp

 
     // ====================  LIFECYCLE     =======================
 
-    RectilinearGrid::RectilinearGrid( const ctor_key& ) : Grid( ), nx(0), ny(0), nz(0) {
+    RectilinearGrid::RectilinearGrid( const ctor_key& key ) : Grid( key ), nx(0), ny(0), nz(0) {
 
     }
 
-    RectilinearGrid::RectilinearGrid( const YAML::Node& node, const ctor_key& ) : Grid(node) {
+    RectilinearGrid::RectilinearGrid( const YAML::Node& node, const ctor_key& key ) : Grid(node, key) {
 
         nx = node["nx"].as<int>( );
         ny = node["ny"].as<int>( );

Modules/LemmaCore/src/RectilinearGridReader.cpp

     //      Method:  RectilinearGridReader
     // Description:  constructor (locked)
     //--------------------------------------------------------------------------------------
-    RectilinearGridReader::RectilinearGridReader ( const ctor_key& ) : GridReader( ),
+    RectilinearGridReader::RectilinearGridReader ( const ctor_key& key ) : GridReader( key ),
         rGrid( nullptr ), Parser( nullptr ) {
 
     }  // -----  end of method RectilinearGridReader::RectilinearGridReader  (constructor)  -----
     //      Method:  RectilinearGridReader
     // Description:  DeSerializing constructor (protected)
     //--------------------------------------------------------------------------------------
-    RectilinearGridReader::RectilinearGridReader (const YAML::Node& node, const ctor_key&  key) : GridReader(node) {
+    RectilinearGridReader::RectilinearGridReader (const YAML::Node& node, const ctor_key&  key) : GridReader(node, key) {
     }  // -----  end of method RectilinearGridReader::RectilinearGridReader  (constructor)  -----
 
     //--------------------------------------------------------------------------------------

Modules/LemmaCore/src/RectilinearGridVTKExporter.cpp

 //      Method:  RectilinearGridVTKExporter
 // Description:  constructor (protected)
 //--------------------------------------------------------------------------------------
-RectilinearGridVTKExporter::RectilinearGridVTKExporter ( const ctor_key& ) : LemmaObject( ), Grid(nullptr), VTKGrid(nullptr) {
+RectilinearGridVTKExporter::RectilinearGridVTKExporter ( const ctor_key& key ) : LemmaObject( key ), Grid(nullptr), VTKGrid(nullptr) {
 
 }  // -----  end of method RectilinearGridVTKExporter::RectilinearGridVTKExporter  (constructor)  -----
 
 //      Method:  RectilinearGridVTKExporter
 // Description:  DeSerializing constructor (protected)
 //--------------------------------------------------------------------------------------
-RectilinearGridVTKExporter::RectilinearGridVTKExporter (const YAML::Node& node, const ctor_key&  key) : LemmaObject(node) {
+RectilinearGridVTKExporter::RectilinearGridVTKExporter (const YAML::Node& node, const ctor_key&  key) : LemmaObject(node, key) {
     if (node["Grid"]) {
         this->Grid = RectilinearGrid::DeSerialize( node["Grid"] );
     }

Modules/LemmaCore/src/WindowFilter.cpp

     // ====================  FRIEND METHODS  =====================
 
     std::ostream &operator << (std::ostream &stream, const WindowFilter &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
 
     //      Method:  WindowFilter
     // Description:  constructor (locked with ctor_key)
     //--------------------------------------------------------------------------------------
-    WindowFilter::WindowFilter( const ctor_key& ) : Filter( ),
+    WindowFilter::WindowFilter( const ctor_key& key ) : Filter( key ),
         Width(0), SamplingRate(0), Bandwidth(0), Coefficients(), Type(RECTANGULAR)
     {
     }   // -----  end of method WindowFilter::WindowFilter  (constructor)  -----
     //      Method:  WindowFilter
     // Description:  DeSerializing constructor (locked with ctor_key)
     //--------------------------------------------------------------------------------------
-    WindowFilter::WindowFilter( const YAML::Node& node, const ctor_key& ) : Filter( node ),
+    WindowFilter::WindowFilter( const YAML::Node& node, const ctor_key& key) : Filter( node, key ),
         Width(0), SamplingRate(0), Bandwidth(0), Coefficients(), Type(RECTANGULAR)
     {
         Width = node["Width"].as<int>( );