More cleaning up towards the port to c++-11. Documentation and consistency and better testing.

Modules/LemmaCore/examples/CubicSplineInterpolator.cpp

@@ -17,14 +17,15 @@
  * @copyright Copyright (c) 2016, Trevor Irons & Lemma Software, LLC
  */
 
-#include "CubicSplineInterpolator.h"
-#include "ASCIIParser.h"
+#include "LemmaCore"
 using namespace Lemma;
 
 int main() {
+    auto win = WindowFilter::NewSP();
+        std::cout << *win << std::endl;
     //auto Spline = CubicSplineInterpolator::NewSP();
     //auto Spline2 = CubicSplineInterpolator();
-    auto Parser = ASCIIParser::NewSP();
+    //auto Parser = ASCIIParser::NewSP();
     //ASCIIParser Parser2 = ASCIIParser();
     //    Parser2.SetCommentString( "#");
     //auto Parser3 = ASCIIParser(Parser2);

Modules/LemmaCore/include/ASCIIParser.h

@@ -33,20 +33,34 @@ class ASCIIParser : public LemmaObject {
 
     friend std::ostream &operator<<(std::ostream &stream,
             const ASCIIParser &ob);
-
+    /*
+     *  This key is used to lock the constructors
+     */
     struct ctor_key {};
 
     public:
 
     // ====================  LIFECYCLE     =======================
 
-    /** Default constructor */
+    /** Default constructor
+     * @note This method is locked
+     * @see ASCIIParser::NewSP
+     */
     explicit ASCIIParser ( const ctor_key& );
 
-    /** Constructor using YAML::Node */
+    /**
+     * DeSerializing constructor.
+     * @note This method is locked, and cannot be called directly.
+     *       The reason that the method is public is to enable the use
+     *       of make_shared whilst enforcing the use of shared_ptr,
+     *       in c++-17, this curiosity may be resolved.
+     * @see ASCIIParser::DeSerialize
+     */
     ASCIIParser ( const YAML::Node& node, const ctor_key& );
 
-    /** Default  destructor */
+    /** Default  destructor
+     *  @note This should never be called explicitly, use NewSP
+     */
     virtual ~ASCIIParser ();
 
     /**
@@ -65,7 +79,7 @@ class ASCIIParser : public LemmaObject {
      *  Uses YAML to serialize this object.
      *  @return a YAML::Node
      */
-    YAML::Node Serialize() const;
+    virtual YAML::Node Serialize() const;
 
     // ====================  OPERATORS     =======================
 
@@ -112,7 +126,7 @@ class ASCIIParser : public LemmaObject {
      */
     void SetCommentString( const std::string& key );
 
-    /** Sets the buffer size. This affects the maximum number of column in a line. Defaults
+    /** Sets the buffer size. This affects the maximum number of columns in a line. Defaults
      *  is 255.
      *  @param[in] BufferSize is the size of the buffer to use
      */

Modules/LemmaCore/include/CubicSplineInterpolator.h

@@ -60,7 +60,7 @@ struct SplineSet{
 class CubicSplineInterpolator : public LemmaObject {
 
     friend std::ostream &operator<<(std::ostream &stream,
-            const CubicSplineInterpolator &ob);
+            const CubicSplineInterpolator& ob);
 
     struct ctor_key {};
 
@@ -87,7 +87,7 @@ class CubicSplineInterpolator : public LemmaObject {
      *  Uses YAML to serialize this object.
      *  @return a YAML::Node
      */
-    YAML::Node Serialize() const;
+    virtual YAML::Node Serialize() const;
 
     /**
      *   Constructs an object from a YAML::Node.

Modules/LemmaCore/include/Data.h

@@ -36,12 +36,10 @@ namespace Lemma {
 
             // ====================  LIFECYCLE     =======================
 
-            /** Copies the *structure* of this class to a new object and
-             * returns a pointer to this object. Memory management is
-             * the responsibility of the receiver!. The data values are
-             * not copied.
+            /**
+             * Returns a deep copy
              */
-            virtual Data* Clone()=0;
+            virtual std::shared_ptr<Data> DeepCopy()=0;
 
             // ====================  OPERATORS     =======================
 
@@ -74,8 +72,11 @@ namespace Lemma {
             /** Default protected constructor. */
             Data (  );
 
+            /** Deserializing contructor */
+            Data ( const YAML::Node& node );
+
             /** Default protected constructor. */
-            ~Data ();
+            ~Data ( );
 
             // ====================  DATA MEMBERS  =========================
 
@@ -84,6 +85,8 @@ namespace Lemma {
             /** ASCII string representation of the class name */
             static constexpr auto CName = "Data";
 
+            Data ( const Data& ) = delete;
+
     }; // -----  end of class  Data  -----
 
 }       // -----  end of Lemma  name  -----

Modules/LemmaCore/include/DataReader.h

@@ -40,7 +40,7 @@ class DataReader : public LemmaObject {
         // ====================  OPERATIONS    =======================
 
         // ====================  ACCESS        =======================
-        virtual Data* GetData()=0;
+        virtual std::shared_ptr< Data > GetData()=0;
 
         // ====================  INQUIRY       =======================
         /** Returns the name of the underlying class, similiar to Python's type */
@@ -56,6 +56,9 @@ class DataReader : public LemmaObject {
         DataReader ( );
 
         /// Default protected constructor.
+        DataReader ( const YAML::Node& node );
+
+        /// Default protected constructor.
         ~DataReader ( );
 
         // ====================  DATA MEMBERS  =========================
@@ -65,6 +68,8 @@ class DataReader : public LemmaObject {
         /** ASCII string representation of the class name */
         static constexpr auto CName = "DataReader";
 
+        DataReader( const DataReader& ) = delete;
+
 }; // -----  end of class  DataReader  -----
 
 }       // -----  end of Lemma  name  -----

Modules/LemmaCore/include/EarthModel.h

@@ -20,7 +20,7 @@ namespace Lemma {
 
     // ===================================================================
     //        Class:  EarthModel
-    /// \ingroup LemmaGroup
+    /// \ingroup LemmaCore
     /// \brief abstract class for Earth models
     /// \details
     // ===================================================================
@@ -113,6 +113,8 @@ namespace Lemma {
 
         private:
 
+            EarthModel(const EarthModel& ) = delete;
+
             /** ASCII string representation of the class name */
             static constexpr auto CName = "EarthModel";
 

Modules/LemmaCore/include/Filter.h

@@ -28,14 +28,22 @@ namespace Lemma {
 
     class Filter : public LemmaObject {
 
+        friend std::ostream &operator<<(std::ostream &stream, const Filter& ob);
+
         public:
 
             // ====================  LIFECYCLE     =======================
+            /**
+             *  Uses YAML to serialize this object.
+             *  @return a YAML::Node
+             */
+            virtual YAML::Node Serialize() const;
 
             // ====================  OPERATORS     =======================
 
             // ====================  OPERATIONS    =======================
 
+
             // ====================  ACCESS        =======================
 
             // ====================  INQUIRY       =======================
@@ -53,7 +61,10 @@ namespace Lemma {
             Filter ( );
 
             /// Default protected constructor.
-            ~Filter ();
+            Filter ( const YAML::Node& node );
+
+            /// Default protected constructor.
+            virtual ~Filter ();
 
             // ====================  DATA MEMBERS  =========================
 

Modules/LemmaCore/include/Grid.h

@@ -35,7 +35,7 @@ class Grid : public LemmaObject {
 
         // ====================  LIFECYCLE     ===================================
 
-        YAML::Node Serialize() const;
+        virtual YAML::Node Serialize() const;
 
         // ====================  OPERATORS     ===================================
 
@@ -61,7 +61,7 @@ class Grid : public LemmaObject {
         Grid ( );
 
         /// Default protected constructor.
-        ~Grid ();
+        virtual ~Grid ( );
 
         // ====================  DATA MEMBERS  ===================================
 

Modules/LemmaCore/include/Instrument.h

@@ -33,6 +33,12 @@ namespace Lemma {
 
 			// ====================  LIFECYCLE     ===========================
 
+            /**
+             *  Uses YAML to serialize this object.
+             *  @return a YAML::Node
+             */
+            YAML::Node Serialize() const;
+
 			// ====================  OPERATORS     ===========================
 
 			// ====================  OPERATIONS    ===========================
@@ -53,6 +59,9 @@ namespace Lemma {
 
 			// ====================  LIFECYCLE     ===========================
 
+            /// Default protected constructor.
+			Instrument ( const YAML::Node& node );
+
 			/// Default protected constructor.
 			Instrument ( );
 

Modules/LemmaCore/include/LayeredEarth.h

@@ -86,7 +86,6 @@ namespace Lemma {
             /** YAML Serializing method
              */
             YAML::Node Serialize() const;
-            //static LayeredEarth* DeSerialize(const YAML::Node& node);
 
             /** Returns the name of the underlying class, similiar to Python's type */
             virtual inline std::string GetName() const {
@@ -109,9 +108,13 @@ namespace Lemma {
 			// ====================  DATA MEMBERS  ===========================
 
         private:
+
             /** ASCII string representation of the class name */
             static constexpr auto CName = "LayeredEarth";
 
+            /** no copy */
+            LayeredEarth ( const LayeredEarth& ) = delete;
+
 			/** Number of layers in the model, including the air layer,
 			 * and counting from 0
              */

Modules/LemmaCore/include/LemmaObject.h

@@ -44,28 +44,11 @@ class LemmaObject {
     friend class LemmaObjectDeleter;
 
     public:
-
-        // ====================  LIFECYCLE     ==============================
-
         // Needed because many derived classes have Eigen vectors as members,
         // causing alignment issues when vectorisation is enabled.
         EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
-        // ====================  OPERATORS     ==============================
-
-        // ====================  OPERATIONS    ==============================
-
-        // ====================  ACCESS        ==============================
-
-        // ====================  INQUIRY       ==============================
-
-        /** Returns the name of the underlying class; Run-time type information (RTTI). This approach
-            Was chosen over typeid due to name mangling among various compilers, and the need for consistency
-            in Serialized objects.
-         */
-        virtual inline std::string GetName() const {
-            return this->CName;
-        }
+        // ====================  LIFECYCLE     ==============================
 
         /**
          *  Uses YAML to serialize this object.
@@ -86,6 +69,22 @@ class LemmaObject {
             return node;
         };
 
+        // ====================  OPERATORS     ==============================
+
+        // ====================  OPERATIONS    ==============================
+
+        // ====================  ACCESS        ==============================
+
+        // ====================  INQUIRY       ==============================
+
+        /** Returns the name of the underlying class; Run-time type information (RTTI). This approach
+            Was chosen over typeid due to name mangling among various compilers, and the need for consistency
+            in Serialized objects.
+         */
+        virtual inline std::string GetName() const {
+            return this->CName;
+        }
+
     protected:
 
         // ====================  LIFECYCLE     ==============================

Modules/LemmaCore/include/RectilinearGrid.h

@@ -50,7 +50,7 @@ namespace Lemma {
              *  Uses YAML to serialize this object.
              *  @return a YAML::Node
              */
-            YAML::Node Serialize() const;
+            virtual YAML::Node Serialize() const;
 
             /**
              *   Constructs an object from a YAML::Node.

Modules/LemmaCore/include/WindowFilter.h

@@ -16,12 +16,6 @@
 #include "Filter.h"
 
 namespace Lemma {
-    /** Types of filter window that are supported.
-     */
-    enum WINDOWTYPE { HAMMING, /*!< A hamming window */
-                      HANNING, /*!< A hanning window */
-                      RECTANGULAR /*!< Rectangular window */
-                    };
 
     // ===================================================================
     //  Class:  WindowFilter
@@ -34,14 +28,38 @@ namespace Lemma {
     // ===================================================================
     class WindowFilter : public Filter {
 
+        friend std::ostream &operator<<(std::ostream &stream, const WindowFilter& ob);
+
+        struct ctor_key {};
+
         public:
 
             // ====================  LIFECYCLE     =======================
 
-           /**
-            *  Factory method for generating concrete class.
-            *  @return a std::shared_ptr of type WindowFilter
-            */
+            /** Default constructor, inaccessible use NewSP  */
+            explicit WindowFilter ( const ctor_key& );
+
+            /** DeSerializing constructor, usees factory DeSerialize  method, inaccessible use DeSerialize*/
+            WindowFilter ( const YAML::Node& node, const ctor_key& );
+
+            /** Default constructor. */
+            virtual ~WindowFilter ( );
+
+            /**
+             *  Uses YAML to serialize this object.
+             *  @return a YAML::Node
+             */
+            YAML::Node Serialize() const;
+
+            /**
+             *   Constructs an object from a YAML::Node.
+             */
+            static std::shared_ptr< WindowFilter > DeSerialize(const YAML::Node& node);
+
+            /**
+             *  Factory method for generating concrete class.
+             *  @return a std::shared_ptr of type WindowFilter
+             */
             static std::shared_ptr< WindowFilter > NewSP();
 
             // ====================  OPERATORS     =======================
@@ -86,12 +104,8 @@ namespace Lemma {
 
             // ====================  LIFECYCLE     =======================
 
-            /// Default protected constructor.
-            WindowFilter ( );
-
-            /// Default protected constructor.
-            ~WindowFilter ( );
 
+        private:
             // ====================  DATA MEMBERS  =========================
 
             /// Width of the window
@@ -115,10 +129,10 @@ namespace Lemma {
             /// The type of filter to use
             WINDOWTYPE  Type;
 
-        private:
+            /** ASCII string representation of the class name */
+            static constexpr auto CName = "WindowFilter";
 
-        /** ASCII string representation of the class name */
-        static constexpr auto CName = "WindowFilter";
+            WindowFilter ( const WindowFilter& ) = delete;
 
     }; // -----  end of class  WindowFilter  -----
 

Modules/LemmaCore/include/helper.h

@@ -61,6 +61,8 @@ namespace Lemma {
     std::string enum2String(const HANKELTRANSFORMTYPE& Htype);
     /// convert enums to string saves repeated code useful for YAML serializing
     std::string enum2String(const FIELDCALCULATIONS& Htype);
+    /// convert enums to string saves repeated code useful for YAML serializing
+    std::string enum2String(const WINDOWTYPE& Wtype);
 
     // other way around is a template, where template argument lets us know
     // which specialisation to use.

Modules/LemmaCore/include/lemma.h

@@ -317,6 +317,14 @@
         */
         enum FIELDCALCULATIONS {E, H, BOTH};
 
+        /** Windowing function type
+         */
+        enum WINDOWTYPE { HAMMING, /*!< A hamming window */
+                          HANNING, /*!< A hanning window */
+                          RECTANGULAR /*!< Rectangular window */
+        };
+
+
     }
 
 #endif // __Lemma_H

Modules/LemmaCore/src/CMakeLists.txt

@@ -4,16 +4,16 @@ set (SOURCE
 	${CMAKE_CURRENT_SOURCE_DIR}/LemmaObject.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/ASCIIParser.cpp                # fixed, key 
 	${CMAKE_CURRENT_SOURCE_DIR}/CubicSplineInterpolator.cpp    # fixed, key 
-	${CMAKE_CURRENT_SOURCE_DIR}/Data.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/DataReader.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/EarthModel.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/Instrument.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/LayeredEarth.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/Grid.cpp       
+	${CMAKE_CURRENT_SOURCE_DIR}/Grid.cpp                       # ABC, no key 
 	${CMAKE_CURRENT_SOURCE_DIR}/RectilinearGrid.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/RectilinearGridReader.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/RectilinearGridVTKExporter.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/Filter.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/WindowFilter.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/Filter.cpp                     # ABC, no key
+	${CMAKE_CURRENT_SOURCE_DIR}/WindowFilter.cpp			   # fixed, key
+	${CMAKE_CURRENT_SOURCE_DIR}/EarthModel.cpp                 # ABC, no key
+	${CMAKE_CURRENT_SOURCE_DIR}/LayeredEarth.cpp			   # ABC, no key
+	${CMAKE_CURRENT_SOURCE_DIR}/Data.cpp                       # ABC, no key
+	${CMAKE_CURRENT_SOURCE_DIR}/DataReader.cpp                 # ABC, no key
+	${CMAKE_CURRENT_SOURCE_DIR}/Instrument.cpp                 # ABC, no key
 	PARENT_SCOPE
 )

Modules/LemmaCore/src/CubicSplineInterpolator.cpp

@@ -38,7 +38,7 @@ namespace Lemma {
     //--------------------------------------------------------------------------------------
     //       Class:  CubicSplineInterpolator
     //      Method:  CubicSplineInterpolator
-    // Description:  constructor (protected)
+    // Description:  constructor (locked with ctor_key)
     //--------------------------------------------------------------------------------------
     CubicSplineInterpolator::CubicSplineInterpolator ( const ctor_key& ) : LemmaObject( ) {
 
@@ -47,7 +47,7 @@ namespace Lemma {
     //--------------------------------------------------------------------------------------
     //       Class:  CubicSplineInterpolator
     //      Method:  CubicSplineInterpolator
-    // Description:  DeSerializing constructor (protected)
+    // Description:  DeSerializing constructor (locked with ctor_key)
     //--------------------------------------------------------------------------------------
     CubicSplineInterpolator::CubicSplineInterpolator (const YAML::Node& node, const ctor_key& ) : LemmaObject(node) {
     }  // -----  end of method CubicSplineInterpolator::CubicSplineInterpolator  (constructor)  -----
@@ -58,8 +58,6 @@ namespace Lemma {
     // Description:  public constructor
     //--------------------------------------------------------------------------------------
     std::shared_ptr<CubicSplineInterpolator> CubicSplineInterpolator::NewSP() {
-        //std::shared_ptr<CubicSplineInterpolator> sp(new  CubicSplineInterpolator( CubicSplineInterpolator::ctor_key ), LemmaObjectDeleter() );
-        //return sp;
         return std::make_shared<CubicSplineInterpolator>( ctor_key() );
     }
 
@@ -82,8 +80,6 @@ namespace Lemma {
         if (node.Tag() != "CubicSplineInterpolator") {
             throw  DeSerializeTypeMismatch( "CubicSplineInterpolator", node.Tag());
         }
-        //std::shared_ptr<CubicSplineInterpolator> Object(new  CubicSplineInterpolator(node), LemmaObjectDeleter() );
-        //return Object ;
         return std::make_shared<CubicSplineInterpolator>( node, ctor_key() );
     }
 

Modules/LemmaCore/src/Data.cpp

@@ -23,6 +23,9 @@ namespace Lemma {
 	Data::Data(  ) : LemmaObject( ) {
 	}
 
+    Data::Data( const YAML::Node& node ) : LemmaObject( node ) {
+	}
+
 
 	Data::~Data() {
 	}

Modules/LemmaCore/src/DataReader.cpp

@@ -21,9 +21,15 @@ namespace Lemma {
     }
 
 	DataReader::DataReader( ) : LemmaObject( ) {
+
+	}
+
+    DataReader::DataReader( const YAML::Node& node ) : LemmaObject( node ) {
+
 	}
 
 	DataReader::~DataReader() {
+
 	}
 
 }		// -----  end of Lemma  name  -----

Modules/LemmaCore/src/Filter.cpp

@@ -15,8 +15,41 @@
 
 namespace Lemma {
 
+    std::ostream &operator << (std::ostream &stream, const Filter &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+        return stream;
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  Filter
+    //      Method:  Filter
+    // Description:  constructor (protected)
+    //--------------------------------------------------------------------------------------
     Filter::Filter( ) : LemmaObject( ) { }
 
+    //--------------------------------------------------------------------------------------
+    //       Class:  Filter
+    //      Method:  ~Filter
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
     Filter::~Filter( ) { }
 
+    //--------------------------------------------------------------------------------------
+    //       Class:  Filter
+    //      Method:  Filter
+    // Description:  DeSerializing constructor (protected)
+    //--------------------------------------------------------------------------------------
+    Filter::Filter ( const YAML::Node& node ) : LemmaObject(node) {
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  Filter
+    //      Method:  Serialize
+    //--------------------------------------------------------------------------------------
+    YAML::Node  Filter::Serialize (  ) const {
+        YAML::Node node = LemmaObject::Serialize();;
+        node.SetTag( GetName() );
+        // FILL IN CLASS SPECIFICS HERE
+        return node;
+    }		// -----  end of method Filter::Serialize  -----
 }		// -----  end of Lemma  name  -----

Modules/LemmaCore/src/Grid.cpp

@@ -33,11 +33,9 @@ namespace Lemma {
 	}
 
     YAML::Node Grid::Serialize() const {
-
         YAML::Node node = LemmaObject::Serialize();
         node.SetTag( this->GetName() );
         return node;
-
     }
 
 }

Modules/LemmaCore/src/Instrument.cpp

@@ -23,7 +23,22 @@ namespace Lemma {
 	Instrument::Instrument( ) : LemmaObject() {
 	}
 
+    Instrument::Instrument( const YAML::Node& node ) : LemmaObject( node ) {
+	    // Fill in class specifics
+    }
+
 	Instrument::~Instrument() {
 	}
 
+    //--------------------------------------------------------------------------------------
+    //       Class:  Instrument
+    //      Method:  Serialize
+    //--------------------------------------------------------------------------------------
+    YAML::Node  Instrument::Serialize (  ) const {
+        YAML::Node node = LemmaObject::Serialize();;
+        node.SetTag( GetName() );
+        // Fill in class specifics
+        return node;
+    }		// -----  end of method Instrument::Serialize  -----
+
 }		// -----  end of Lemma  name  -----

Modules/LemmaCore/src/LayeredEarth.cpp

@@ -33,8 +33,7 @@ namespace Lemma {
 	LayeredEarth::~LayeredEarth() {
 	}
 
-    LayeredEarth::LayeredEarth(const YAML::Node& node) : EarthModel(node)
-    {
+    LayeredEarth::LayeredEarth(const YAML::Node& node) : EarthModel(node) {
         NumberOfLayers = node["NumberOfLayers"].as<int>();
         NumberOfInterfaces = node["NumberOfInterfaces"].as<int>();
         LayerThickness = node["LayerThickness"].as<VectorXr>();

Modules/LemmaCore/src/WindowFilter.cpp

@@ -15,20 +15,87 @@
 
 namespace Lemma {
 
-    // ====================  LIFECYCLE     =======================
+    // ====================  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
+        return stream;
+    }
 
-    WindowFilter::WindowFilter( ) : Filter( ),
-        Width(0), SamplingRate(0), Bandwidth(0), Coefficients(),
-        Type(RECTANGULAR) {}
+    // ====================  LIFECYCLE     =======================
 
+    //--------------------------------------------------------------------------------------
+    //       Class:  WindowFilter
+    //      Method:  WindowFilter
+    // Description:  constructor (locked with ctor_key)
+    //--------------------------------------------------------------------------------------
+    WindowFilter::WindowFilter( const ctor_key& ) : Filter( ),
+        Width(0), SamplingRate(0), Bandwidth(0), Coefficients(), Type(RECTANGULAR)
+    {
+    }   // -----  end of method WindowFilter::WindowFilter  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  WindowFilter
+    //      Method:  WindowFilter
+    // Description:  DeSerializing constructor (locked with ctor_key)
+    //--------------------------------------------------------------------------------------
+    WindowFilter::WindowFilter( const YAML::Node& node, const ctor_key& ) : Filter( node ),
+        Width(0), SamplingRate(0), Bandwidth(0), Coefficients(), Type(RECTANGULAR)
+    {
+        Width = node["Width"].as<int>( );
+        Nt = node["Nt"].as<int>( );
+        Nw = node["Nw"].as<int>( );
+        SamplingRate = node["SamplingRate"].as<Real>();
+        Bandwidth = node["Bandwidth"].as<Real>();
+        Coefficients = node["Coefficients"].as<VectorXr>();
+        Type = string2Enum<WINDOWTYPE>( node["WINDOWTYPE"].as<std::string>() );
+    } // -----  end of method WindowFilter::WindowFilter  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  WindowFilter
+    //      Method:  NewSP()
+    // Description:  public constructor
+    //--------------------------------------------------------------------------------------
     std::shared_ptr< WindowFilter > WindowFilter::NewSP() {
-        std::shared_ptr<WindowFilter> sp(new  WindowFilter( ), LemmaObjectDeleter() );
-        return sp;
+        return std::make_shared< WindowFilter >( ctor_key() );
     }
 
+    //--------------------------------------------------------------------------------------
+    //       Class:  WindowFilter
+    //      Method:  ~WindowFilter
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
     WindowFilter::~WindowFilter() {
     }
 
+    //--------------------------------------------------------------------------------------
+    //       Class:  WindowFilter
+    //      Method:  Serialize
+    //--------------------------------------------------------------------------------------
+    YAML::Node  WindowFilter::Serialize (  ) const {
+        YAML::Node node = Filter::Serialize();;
+        node.SetTag( GetName() );
+        // FILL IN CLASS SPECIFICS HERE
+        node["Width"] = Width;
+        node["Nt"] = Nt;
+        node["Nw"] = Nw;
+        node["SamplingRate"] = SamplingRate;
+        node["Bandwidth"] = Bandwidth;
+        node["Coefficients"] = Coefficients;
+        node["WINDOWTYPE"] = enum2String(Type);
+        return node;
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  WindowFilter
+    //      Method:  DeSerialize
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr<WindowFilter> WindowFilter::DeSerialize ( const YAML::Node& node  ) {
+        if (node.Tag() != "WindowFilter") {
+            throw  DeSerializeTypeMismatch( "WindowFilter", node.Tag());
+        }
+        return std::make_shared<WindowFilter>( node, ctor_key() );
+    }
 
     // ====================  OPERATIONS    =======================
 

Modules/LemmaCore/src/helper.cpp

@@ -150,6 +150,20 @@ std::string enum2String(const HANKELTRANSFORMTYPE& Type) {
     return t;
 }
 
+std::string enum2String( const WINDOWTYPE& Type ) {
+    std::string t;
+    switch (Type) {
+        case HAMMING:
+            return std::string("HAMMING");
+        case HANNING:
+            return  std::string("HANNING");
+        case RECTANGULAR:
+            return std::string("RECTANGULAR");
+        default:
+            throw( std::runtime_error( "In enum2String WINDOWTYPE, type not identified" ) );
+    }
+}
+
 template<>
 FREQUENCYUNITS string2Enum<FREQUENCYUNITS>( const std::string& str ) {
     if       (str ==  "HZ") return   HZ;
@@ -197,5 +211,15 @@ FIELDCOMPONENT string2Enum<FIELDCOMPONENT>( const std::string& str) {
     }
 }
 
+template<>
+WINDOWTYPE string2Enum<WINDOWTYPE>( const std::string& str ) {
+    if      (str == "HAMMING")      return HAMMING;
+    if      (str == "HANNING")      return HANNING;
+    if      (str == "RECTANGULAR")  return RECTANGULAR;
+    else {
+        throw std::runtime_error("string not recognized as WindowType");
+    }
+}
+
 }		// -----  end of Lemma  name  -----
 

Modules/LemmaCore/testing/SerializeCheck.h

@@ -26,14 +26,13 @@ class MyTestSuite : public CxxTest::TestSuite
 {
     public:
 
-//     void testASCIIParser( void )
-//     {
-//         auto Obj = ASCIIParser::NewSP();
-//         YAML::Node node = Obj->Serialize();
-//         auto Obj2 = ASCIIParser::DeSerialize(node);
-//         TS_ASSERT_EQUALS( Obj->GetName(), Obj2->GetName() );
-//     }
-
+    void testASCIIParser( void )
+    {
+        auto Obj = ASCIIParser::NewSP();
+        YAML::Node node = Obj->Serialize();
+        auto Obj2 = ASCIIParser::DeSerialize(node);
+        TS_ASSERT_EQUALS( Obj->GetName(), Obj2->GetName() );
+    }
 
     void testCubicSplineInterpolator(void)
     {
@@ -51,6 +50,14 @@ class MyTestSuite : public CxxTest::TestSuite
         TS_ASSERT_EQUALS( Obj->GetName(), Obj2->GetName() );
     }
 
+    void testWindowFilter( void )
+    {
+        auto Obj = WindowFilter::NewSP();
+        YAML::Node node = Obj->Serialize();
+        auto Obj2 = WindowFilter::DeSerialize(node);
+        TS_ASSERT_EQUALS( Obj->GetName(), Obj2->GetName() );
+    }
+
 // /*
 //     void testRectilinearGridReader( void )
 //     {
@@ -64,11 +71,7 @@ class MyTestSuite : public CxxTest::TestSuite
 //         TS_ASSERT_EQUALS( Obj->GetName(), std::string("RectilinearGridVTKExporter") );
 //     }
 //
-//     void testWindowFilter( void )
-//     {
-//         auto Obj = WindowFilter::NewSP();
-//         TS_ASSERT_EQUALS( Obj->GetName(), std::string("WindowFilter") );
-//     }
+
 // */
 
 };

vim/c.vim

@@ -1,21 +1,24 @@
-"===================================================================================
-"
-"         FILE:  c.vim
-"  DESCRIPTION:  syntax file
-"                enable syntax based folding
-"                part of the c-support plugin
-"
-"       AUTHOR:  Trevor Irons
-"        EMAIL:  tirons@mines.edu
-"      COMPANY:  FH Südwestfalen, Iserlohn
-"      VERSION:  1.0
-"      CREATED:  11.03.2006
-"     REVISION:  ---
-"===================================================================================
-"
-" fold C blocks
-"
-syn region cBlock start="{" end="}" transparent fold
-set foldmethod=syntax
-set foldlevel=999
+"highlight cComment ctermfg=Green guifg=Green
+highlight cType ctermfg=Green guifg=Green
+syn keyword cType Real Complex VectorXr VectorXcr Vector3r Vector3Xr VectorXi Vector3cr Vector3Xcr MatrixXr MatrixXi MatrixXcr shared_ptr make_shared
 
+highlight constType ctermfg=Red guifg=Red
+syn keyword constType  PI EPSILON0 MU0 QPI  
+
+highlight eType ctermfg=Magenta guifg=Magenta
+syn keyword eType  MAGUNITS  TEMPUNITS  TIMEUNITS FREQUENCYUNITS FEMCOILORIENTATION ORIENTATION FIELDTYPE FIELDCOMPONENT SPATIALCOORDINANT HANKELTRANSFORMTYPE FIELDCALCULATIONS WINDOWTYPE 
+
+highlight eeType ctermfg=Cyan guifg=Cyan
+syn keyword eeType  TESLA NANOTESLA GAUSS CELCIUS KELVIN SEC MILLISEC MICROSEC NANOSEC PICOSEC HZ KHZ MHZ GHZ COAXIAL COPLANAR HFIELDREAL HFIELDIMAG EFIELDREAL EFIELDIMAG XCOMPONENT YCOMPONENT ZCOMPONENT XCOORD YCOORD ZCOORD X Y Z NX  NY  NZ ANDERSON801 CHAVE FHTKEY201 FHTKEY101 FHTKEY51 QWEKEY E H BOTH HAMMING HANNING RECTANGULAR
+
+" Namespaces
+highlight nspace ctermfg=Red guifg=Red
+syn keyword nspace Lemma YAML Eigen 
+
+" Lemma types
+highlight leType ctermfg=Yellow guifg=Yellow
+syn keyword leType HankelTransform KernelEm1D KernelEM1DManager DipoleSource EarthModel LayeredEarth LayeredEarthEM TEMSurvey TEMSurveyLine TEMSurveyLineRecord TEMInductiveReceiver PolygonalWireAntenna TEMTransmitter TEMReceiver Instrument InstrumentTem LemmaObject ReceiverPoints DCIPElectrode TEMSurveyData TEMSurveyLineData TEMSurveyLineRecordData  ASCIIParser CubicSplineInterpolator RectilinearGrid RectilinearGridReader RectilinearGridVTKExporter Filter WindowFilter DEMParticle DEMGrain Data DataReader
+
+" Deprecated Lemma Types
+highlight dleType ctermfg=Blue guifg=Blue 
+syn keyword dleType  ReferenceCountedObject 

vim/cpp.cpp.template

@@ -129,22 +129,56 @@ class |?CLASSNAME:c| : public |BASECLASS:c| {
 
 	friend std::ostream &operator<<(std::ostream &stream, const |CLASSNAME| &ob);
 
+    /*
+     *  This key is used to lock the constructor.
+     */
+    struct ctor_key {};
+
 	public:
 
 	    // ====================  LIFECYCLE     =======================
 
-        /*
-         *  Factory method for generating concrete class.
-         *  @return a std::shared_ptr of type |CLASSNAME|
+        /**
+         * Default constructor.
+         * @note This method is locked, and cannot be called directly.
+         *       The reason that the method is public is to enable the use
+         *       of make_shared whilst enforcing the use of shared_ptr,
+         *       in c++-17, this curiosity may be resolved.
+         * @see |CLASSNAME|::NewSP
          */
-	    static std::shared_ptr< |CLASSNAME| > NewSP();
+        explicit |CLASSNAME| ( const ctor_key& );
+
+        /**
+         * DeSerializing constructor.
+         * @note This method is locked, and cannot be called directly.
+         *       The reason that the method is public is to enable the use
+         *       of make_shared whilst enforcing the use of shared_ptr,
+         *       in c++-17, this curiosity may be resolved.
+         * @see |CLASSNAME|::DeSerialize
+         */
+        |CLASSNAME| (const YAML::Node& node);
+
+        /**
+         * Default destructor.
+         * @note This method should never be called due to the mandated
+         *       use of smart pointers. It is necessary to keep the method
+         *       public in order to allow for the use of the more efficeint
+         *       make_shared constructor.
+         */
+        virtual ~|CLASSNAME| ();
 
         /**
          *  Uses YAML to serialize this object.
          *  @return a YAML::Node
-         *   @see |CLASSNAME|::DeSerialize
+         *  @see |CLASSNAME|::DeSerialize
+         */
+        virtual YAML::Node Serialize() const;
+
+        /*
+         *  Factory method for generating concrete class.
+         *  @return a std::shared_ptr of type |CLASSNAME|
          */
-        YAML::Node Serialize() const;
+	    static std::shared_ptr< |CLASSNAME| > NewSP();
 
         /**
          *   Constructs an |CLASSNAME| object from a YAML::Node.
@@ -160,31 +194,17 @@ class |?CLASSNAME:c| : public |BASECLASS:c| {
 
         // ====================  INQUIRY       =======================
 
-
-
     protected:
 
         // ====================  LIFECYCLE     =======================
 
-        /**
-         * Default protected constructor, use NewSP methods to construct
-         * @see |CLASSNAME|::NewSP
-         */
-        |CLASSNAME| (const std::string& name);
-
-        /**
-         * Protected DeDerializing constructor, use factory DeSerialize  method.
-         * @see |CLASSNAME|::DeSerialize
-         */
-        |CLASSNAME| (const YAML::Node& node);
-
-        /** Default protected destructor, use smart pointers (std::shared_ptr) */
-        ~|CLASSNAME| ();
-
-	// ====================  DATA MEMBERS  =========================
+    	// ====================  DATA MEMBERS  =========================
 
     private:
 
+        /** ASCII string representation of the class name */
+        static constexpr auto CName = "|CLASSNAME|";
+
 }; // -----  end of class  |CLASSNAME|  -----
 }  // -----  end of namespace Lemma ----