Work towards port of FDEM code to C++-11 and improved unit testing.

CMakeLists.txt

 set(LEMMA_VERSION_MAJOR "0")
 set(LEMMA_VERSION_MINOR "1")
 set(LEMMA_VERSION_PATCH "1")
-set(LEMMA_VERSION "${LEMMA_VERSION_MAJOR}.${LEMMA_VERSION_MINOR}.${LEMMA_VERSION_PATCH}")
+set(LEMMA_VERSION "\"${LEMMA_VERSION_MAJOR}.${LEMMA_VERSION_MINOR}.${LEMMA_VERSION_PATCH}\"")
 
 configure_file (
 	"${PROJECT_SOURCE_DIR}/config/LemmaConfig.h.in"

Modules/FDEM1D/examples/CMakeLists.txt

 add_executable( LayeredEarthEM LayeredEarthEM.cpp  )
 target_link_libraries(  LayeredEarthEM  "lemmacore" "fdem1d")
 
+add_executable( FieldPoints FieldPoints.cpp  )
+target_link_libraries(  FieldPoints  "lemmacore" "fdem1d")
+
 INSTALL_TARGETS( "/share/FEM1D/"
 	LayeredEarthEM 
+	FieldPoints
 )

Modules/FDEM1D/examples/FieldPoints.cpp

+/* This file is part of Lemma, a geophysical modelling and inversion API.
+ * More information is available at http://lemmasoftware.org
+ */
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+/**
+ * @file
+ * @date      11/01/2016 02:24:11 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     tirons@egi.utah.edu
+ * @copyright Copyright (c) 2016, University of Utah
+ * @copyright Copyright (c) 2016, Lemma Software, LLC
+ */
+#include<random>
+#include<FDEM1D>
+using namespace Lemma;
+
+int main()
+{
+
+    std::random_device rd;
+    std::mt19937 gen(rd());
+
+    // up to 11 layers
+    std::discrete_distribution<> d({0,0,0,10,10,10,10,10,10,10,10,10,10});
+    int np = d(gen);
+
+    auto Obj = FieldPoints::NewSP();
+    // fill with details
+        Obj->SetNumberOfPoints(np);
+        //void SetLocation(const int& nrec, const Real& xp, const Real& yp,
+        //                 const Real& zp);
+
+    YAML::Node node = Obj->Serialize();
+    std::cout << node << std::endl;
+    auto Obj2 = FieldPoints::DeSerialize(node);
+    //std::cout << Obj2->GetNumberOfPoints() << std::endl;
+    //std::cout << Obj->GetNumberOfPoints() << std::endl;
+}
+

Modules/FDEM1D/examples/LayeredEarthEM.cpp

 
     std::uniform_real_distribution<> dis(0, 1);
     VectorXcr con = VectorXcr(nl);
+    VectorXr thick = VectorXr(nl-2);
     con(0) = 0;
     for ( int i=1; i<nl; ++i ) {
         con(i) = Complex(dis(gen), dis(gen));
     }
-    std::cout << con << std::endl;
+    for ( int i=0; i<nl-2; ++i ) {
+        thick(i) = dis(gen);
+    }
+    auto Obj = LayeredEarthEM::NewSP();
+         Obj->SetNumberOfLayers(nl);
+         Obj->SetLayerConductivity(con);
+         Obj->SetLayerThickness(thick);
 
-    auto model = LayeredEarthEM::NewSP();
-        model->SetNumberOfLayers(nl);
-        //model->SetLayerThickness( (VectorXr(4) << 10,10,10,10).finished() );
-        //model->SetLayerConductivity( (VectorXcr(6) << .1, .10,.10,.10,.10,.10).finished() );
-    auto model2 = LayeredEarthEM::DeSerialize(model->Serialize());
+    auto model2 = LayeredEarthEM::DeSerialize(Obj->Serialize());
 
-    std::cout << model->GetNumberOfLayers() << std::endl;
-    std::cout << model2->GetNumberOfLayers() << std::endl;
+    std::cout << *Obj << std::endl;
+    //std::cout << model->GetNumberOfLayers() << std::endl;
+    //std::cout << model2->GetNumberOfLayers() << std::endl;
 
 }
 

Modules/FDEM1D/include/FDEM1D

 #include "LayeredEarthEM.h"
+#include "FieldPoints.h"
 
 /* vim: set tabstop=4 expandtab: */
 /* vim: set filetype=cpp: */

Modules/FDEM1D/include/FieldPoints.h

 #endif
 
 #include "LemmaObject.h"
-#include "dipolesource.h"
-
-#ifdef HAVE_YAMLCPP
-#include "yaml-cpp/yaml.h"
-#endif
+//#include "dipolesource.h"
 
 namespace Lemma {
 
+    // Forward Declarations
+    class DipoleSource;
+
     // =======================================================================
     //        Class:  FieldPoints
     /**
      *  \brief  Points in the subsurface where 1D EM calculations are made
-     */ \details
+     *  \details These are the points where Hankel transform calculations are
+     *           made.
+     *  \note In previous versions of Lemma, this class was called ReceiverPoints,
+     *        the functionality remains roughly the same, but the name is more
+     *        appropriate.
+     */
     // =======================================================================
     class FieldPoints : public LemmaObject {
 
+        /**
+         *  Stream operator printing out information about this class.
+         */
+        friend std::ostream &operator<<(std::ostream &stream, const FieldPoints &ob);
+
+        struct ctor_key {};
+
         public:
 
             // ====================    FRIENDS     ===========================
 
-            /**
-             *  Stream operator printing out information about this class.
-             */
-            friend std::ostream &operator<<(std::ostream &stream,
-                        const FieldPoints &ob);
-
-            friend class EMEarth1D;
-            friend class DipoleSource;
+            //friend class EMEarth1D;
+            //friend class DipoleSource;
 
             // ====================  LIFECYCLE     ===========================
 
+            /** Default locked constructor. */
+            explicit FieldPoints ( const ctor_key& );
+
+            /** Locked deserializing constructor. */
+            FieldPoints (const YAML::Node& node, const ctor_key&);
+
+            /** Default destructor. */
+            ~FieldPoints ();
+
             /**
              *  Factory method for generating concrete class.
              *  @return a std::shared_ptr of type FieldPoints
              */
-            static std::shared_ptr<FieldPoints*> NewSP();
+            static std::shared_ptr<FieldPoints> NewSP();
 
         	/**
              *  Uses YAML to serialize this object.
+             *  @note The actual calculation results are not serialized, currently.
              *  @return a YAML::Node
              */
             YAML::Node Serialize() const;
              *   @param[in] node is a YAML node containing the serialized class information
              *   @return a std::shared_ptr object of FieldPoints
              */
-            static std::shared_ptr< FieldPoints* > DeSerialize(const YAML::Node& node);
+            static std::shared_ptr<FieldPoints> DeSerialize(const YAML::Node& node);
 
             // ====================  OPERATORS     ===========================
 
             // ====================  ACCESS        ===========================
 
             /** Sets the number of receivers */
-            virtual void SetNumberOfReceivers(const int &nrec);
+            virtual void SetNumberOfPoints(const int &nrec);
 
             /** Returns the location of a single receiver as an Eigen Vector */
             void SetLocation(const int& nrec, const Vector3r& loc);
 
             // ====================  INQUIRY       ===========================
 
+            /** Returns the name of the underlying class, similiar to Python's type */
+            virtual inline std::string GetName() const {
+                return CName;
+            }
+
             /// Returns the number of receiverpoints.
-            int GetNumberOfReceivers();
+            int GetNumberOfPoints();
 
             /// Returns all the receiver locations as a 3 X matrix
             Vector3Xr GetLocations();
             /// Returns the mask for this point
             int GetMask(const int& i);
 
-
         protected:
 
-            // ====================  LIFECYCLE     ===========================
-
-            /** Default protected constructor. */
-            FieldPoints ( );
-
-            #ifdef HAVE_YAMLCPP
-            /** Default protected constructor. */
-            FieldPoints (const YAML::Node& node);
-            #endif
-
-            /** Default protected constructor. */
-            ~FieldPoints ();
-
-            /**
-             * @copybrief LemmaObject::Release()
-             * @copydetails LemmaObject::Release()
-             */
-            void Release();
-
             // ====================  OPERATIONS    ===========================
 
             /// Sets the number of H bins. These bins are often frequencies.
 
             // ====================  DATA MEMBERS  ===========================
 
+        private:
+
             /// Number of receivers
-            int                         NumberOfReceivers;
+            int                         NumberOfPoints;
 
             /// Number of fields
             int                         NumberOfBinsE;
             /// Locations of receivers
             Vector3Xr                   Locations;
 
-        private:
-
             // NOTE, these are not serialized in output!
-
             /// Electric field at receiver locations
             std::vector<Vector3Xcr>     Efield;
 
             /// H field at receiver locations
             std::vector<Vector3Xcr>     Hfield;
 
-
             /** ASCII string representation of the class name */
             static constexpr auto CName = "FieldPoints";
 

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     ===========================
 
-            /** Default protected constructor. */
+            /** Default locked constructor. */
             explicit LayeredEarthEM ( const ctor_key& );
 
-            /** Default protected constructor. */
+            /** Locked deserializing constructor. */
 			LayeredEarthEM ( const YAML::Node& node, const ctor_key& );
 
-            /** Default protected constructor. */
+            /** Default destructor */
             virtual ~LayeredEarthEM ();
 
             /**

Modules/FDEM1D/src/CMakeLists.txt

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

Modules/FDEM1D/src/FieldPoints.cpp

   @version  $Id: receiverpoints.cpp 203 2015-01-09 21:19:04Z tirons $
  **/
 
-#include "receiverpoints.h"
+#include "FieldPoints.h"
 
 namespace Lemma {
 
     // ====================    FRIENDS     ======================
 
-#ifdef HAVE_YAMLCPP
-    std::ostream &operator << (std::ostream &stream, const ReceiverPoints &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
+    std::ostream &operator << (std::ostream &stream, const FieldPoints &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
         return stream;
     }
-#else
-    std::ostream &operator<<(std::ostream &stream,
-                const ReceiverPoints &ob) {
-
-        stream << *(LemmaObject*)(&ob);
-        stream << "Number of Receivers "<< ob.NumberOfReceivers  << "\n";
-        return stream;
-    }
-#endif
 
     // ====================  LIFECYCLE     ===================================
 
-    ReceiverPoints::ReceiverPoints(const std::string& name) :
-        LemmaObject(name),
-        NumberOfReceivers(0), NumberOfBinsE(0), NumberOfBinsH(0) {
+    FieldPoints::FieldPoints( const ctor_key& ) : LemmaObject( ),
+        NumberOfPoints(0), NumberOfBinsE(0), NumberOfBinsH(0) {
     }
 
-#ifdef HAVE_YAMLCPP
     //--------------------------------------------------------------------------------------
-    //       Class:  ReceiverPoints
-    //      Method:  ReceiverPoints
+    //       Class:  FieldPoints
+    //      Method:  FieldPoints
     // Description:  constructor (protected)
     //--------------------------------------------------------------------------------------
-    ReceiverPoints::ReceiverPoints (const YAML::Node& node) : LemmaObject(node) {
-
+    FieldPoints::FieldPoints (const YAML::Node& node, const ctor_key&) : LemmaObject(node) {
         //DeSerialize
-        NumberOfReceivers = node["NumberOfReceivers"].as<int>();
+        NumberOfPoints = node["NumberOfPoints"].as<int>();
         NumberOfBinsE = node["NumberOfBinsE"].as<int>();
         NumberOfBinsH = node["NumberOfBinsH"].as<int>();
         Mask = node["Mask"].as<VectorXi>();
         Locations = node["Locations"].as<Vector3Xr>();
+    }  // -----  end of method FieldPoints::FieldPoints  (constructor)  -----
 
-    }  // -----  end of method ReceiverPoints::ReceiverPoints  (constructor)  -----
-#endif
-
-    ReceiverPoints::~ReceiverPoints() {
-        if (this->NumberOfReferences != 0)
-            throw DeleteObjectWithReferences( this );
+    FieldPoints::~FieldPoints() {
     }
 
-    ReceiverPoints* ReceiverPoints::New() {
-        ReceiverPoints* Obj = new ReceiverPoints("ReceiverPoints");
-        Obj->AttachTo(Obj);
-        return Obj;
+    std::shared_ptr<FieldPoints> FieldPoints::NewSP() {
+        return std::make_shared<FieldPoints> ( ctor_key() );
     }
 
-    void ReceiverPoints::Delete() {
-        this->DetachFrom(this);
-    }
+    //--------------------------------------------------------------------------------------
+    //       Class:  FieldPoints
+    //      Method:  Serialize
+    //--------------------------------------------------------------------------------------
+    YAML::Node  FieldPoints::Serialize (  ) const {
+        YAML::Node node = LemmaObject::Serialize();
+        node.SetTag( GetName() );
 
-    void ReceiverPoints::Release() {
-        delete this;
-    }
+        // update here
+        node["NumberOfPoints"] = NumberOfPoints;
+        node["NumberOfBinsE"] = NumberOfBinsE;
+        node["NumberOfBinsH"] = NumberOfBinsH;
+        node["Mask"] = Mask;
+        node["Locations"] = Locations;// Can be huge
+        //std::cout << "Locations.data" << Locations.data()[0] << std::endl;
+        return node;
+    }		// -----  end of method FieldPoints::Serialize  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  FieldPoints
+    //      Method:  DeSerialize
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr<FieldPoints> FieldPoints::DeSerialize ( const YAML::Node& node  ) {
+        if (node.Tag() != "FieldPoints") {
+            throw  DeSerializeTypeMismatch( "FieldPoints", node.Tag());
+        }
+        return std::make_shared<FieldPoints> ( node, ctor_key() );
+    }		// -----  end of method FieldPoints::DeSerialize  -----
 
     // ====================  ACCESS        ===================================
 
-    void ReceiverPoints::SetNumberOfReceivers(const int &nrec) {
+    void FieldPoints::SetNumberOfPoints(const int &nrec) {
 
         if (nrec > 0)
-            this->NumberOfReceivers = nrec;
+            this->NumberOfPoints = nrec;
         else
             throw std::runtime_error("NUMBER RECEIVERS LESS THAN 1");
 
         ResizeHField();
     }
 
-    void ReceiverPoints::ResizeEField() {
+    void FieldPoints::ResizeEField() {
         Efield.clear();
         for (int i=0; i<NumberOfBinsE; ++i) {
             Eigen::Matrix<Complex, 3, Eigen::Dynamic> tempe;
             this->Efield.push_back(tempe);
-            this->Efield[i].resize(Eigen::NoChange, NumberOfReceivers);
+            this->Efield[i].resize(Eigen::NoChange, NumberOfPoints);
             this->Efield[i].setZero();
         }
     }
 
-    void ReceiverPoints::ResizeHField() {
+    void FieldPoints::ResizeHField() {
         Hfield.clear();
         for (int i=0; i<NumberOfBinsH; ++i) {
             Eigen::Matrix<Complex, 3, Eigen::Dynamic> temph;
             this->Hfield.push_back(temph);
-            this->Hfield[i].resize(Eigen::NoChange, NumberOfReceivers);
+            this->Hfield[i].resize(Eigen::NoChange, NumberOfPoints);
             this->Hfield[i].setZero();
         }
     }
 
-    void ReceiverPoints::SetNumberOfBinsE(const int& nbins) {
+    void FieldPoints::SetNumberOfBinsE(const int& nbins) {
         NumberOfBinsE = nbins;
         ResizeEField();
     }
 
-    void ReceiverPoints::SetNumberOfBinsH(const int& nbins) {
+    void FieldPoints::SetNumberOfBinsH(const int& nbins) {
         NumberOfBinsH = nbins;
         ResizeHField();
     }
 
-    void ReceiverPoints::SetLocation(const int&nrec,const  Vector3r& loc) {
+    void FieldPoints::SetLocation(const int&nrec,const  Vector3r& loc) {
         this->Locations.col(nrec) = loc;
     }
 
-    void ReceiverPoints::SetLocation(const int&nrec,const  Real& xp,
+    void FieldPoints::SetLocation(const int&nrec,const  Real& xp,
                     const Real& yp, const Real& zp) {
         this->Locations.col(nrec) << xp, yp, zp;
     }
 
-    void ReceiverPoints::SetEfield(const int& nbin,
+    void FieldPoints::SetEfield(const int& nbin,
                     const int& loc, const Complex &ex,
                     const Complex &ey, const Complex &ez) {
         this->Efield[nbin].col(loc) << ex, ey, ez;
     }
 
-    void ReceiverPoints::AppendEfield(const int&nbin, const int& loc,
+    void FieldPoints::AppendEfield(const int&nbin, const int& loc,
                     const Complex &ex,
                     const Complex &ey, const Complex &ez) {
         #ifdef LEMMAUSEOMP
         this->Efield[nbin].col(loc) += Vector3cr(ex, ey, ez); //temp;
     }
 
-    void ReceiverPoints::SetHfield(const int &nbin, const int& loc,
+    void FieldPoints::SetHfield(const int &nbin, const int& loc,
                     const Complex &hx, const Complex &hy,
                     const Complex &hz) {
         this->Hfield[nbin].col(loc) << hx, hy, hz;
     }
 
-    void ReceiverPoints::AppendHfield(const int &nbin, const int& loc,
+    void FieldPoints::AppendHfield(const int &nbin, const int& loc,
                     const Complex &hx, const Complex &hy,
                     const Complex &hz) {
 //      #ifdef LEMMAUSEOMP
 
 
     // ====================  INQUIRY       ===================================
-    Vector3Xr ReceiverPoints::GetLocations() {
+    Vector3Xr FieldPoints::GetLocations() {
         return this->Locations;
     }
 
-    MatrixXr ReceiverPoints::GetLocationsMat() {
+    MatrixXr FieldPoints::GetLocationsMat() {
         return MatrixXr(this->Locations);
     }
 
-    Vector3r ReceiverPoints::GetLocation(const int &nrec) {
+    Vector3r FieldPoints::GetLocation(const int &nrec) {
         return this->Locations.col(nrec);
     }
 
-    Real ReceiverPoints::GetLocationX(const int &nrec) {
+    Real FieldPoints::GetLocationX(const int &nrec) {
         return this->Locations.col(nrec)[0];
     }
 
-    Real ReceiverPoints::GetLocationY(const int &nrec) {
+    Real FieldPoints::GetLocationY(const int &nrec) {
         return this->Locations.col(nrec)[1];
     }
 
-    Real ReceiverPoints::GetLocationZ(const int &nrec) {
+    Real FieldPoints::GetLocationZ(const int &nrec) {
         return this->Locations.col(nrec)[2];
     }
 
-    Vector3cr ReceiverPoints::GetEfield(const int &nfreq, const int&nrec) {
+    Vector3cr FieldPoints::GetEfield(const int &nfreq, const int&nrec) {
         return this->Efield[nfreq].col(nrec);
     }
 
-    Vector3cr ReceiverPoints::GetHfield(const int &nfreq, const int&nrec) {
+    Vector3cr FieldPoints::GetHfield(const int &nfreq, const int&nrec) {
         return this->Hfield[nfreq].col(nrec);
     }
 
-    std::vector<Vector3Xcr> ReceiverPoints::GetHfield( ) {
+    std::vector<Vector3Xcr> FieldPoints::GetHfield( ) {
         return this->Hfield;
     }
 
-    std::vector<Vector3Xcr> ReceiverPoints::GetEfield( ) {
+    std::vector<Vector3Xcr> FieldPoints::GetEfield( ) {
         return this->Efield;
     }
 
-    Vector3Xcr ReceiverPoints::GetEfield (const int &nfreq) {
+    Vector3Xcr FieldPoints::GetEfield (const int &nfreq) {
         return this->Efield[nfreq];
     }
 
-    MatrixXcr ReceiverPoints::GetEfieldMat (const int &nfreq) {
+    MatrixXcr FieldPoints::GetEfieldMat (const int &nfreq) {
         return MatrixXcr(this->Efield[nfreq]);
     }
 
-    MatrixXcr ReceiverPoints::GetHfieldMat (const int &nfreq) {
+    MatrixXcr FieldPoints::GetHfieldMat (const int &nfreq) {
         return MatrixXcr(this->Hfield[nfreq]);
     }
 
-    Vector3Xcr ReceiverPoints::GetHfield (const int &nfreq) {
+    Vector3Xcr FieldPoints::GetHfield (const int &nfreq) {
         return this->Hfield[nfreq];
     }
 
-    void ReceiverPoints::MaskPoint(const int& imask) {
+    void FieldPoints::MaskPoint(const int& imask) {
         Mask(imask) = true;
     }
 
-    void ReceiverPoints::UnMaskPoint(const int& imask) {
+    void FieldPoints::UnMaskPoint(const int& imask) {
         Mask(imask) = false;
     }
 
-    void ReceiverPoints::UnMaskAllPoints() {
+    void FieldPoints::UnMaskAllPoints() {
         Mask.setZero();
     }
 
-    int ReceiverPoints::GetMask(const int& i) {
+    int FieldPoints::GetMask(const int& i) {
         return Mask(i);
     }
 
-    int ReceiverPoints::GetNumberOfReceivers() {
-        return this->NumberOfReceivers;
+    int FieldPoints::GetNumberOfPoints() {
+        return this->NumberOfPoints;
     }
 
-    void ReceiverPoints::ClearFields() {
+    void FieldPoints::ClearFields() {
         for (int i=0; i<NumberOfBinsE; ++i) {
             this->Efield[i].setZero();
         }
         }
     }
 
-
-#ifdef HAVE_YAMLCPP
-    //--------------------------------------------------------------------------------------
-    //       Class:  ReceiverPoints
-    //      Method:  Serialize
-    //--------------------------------------------------------------------------------------
-    YAML::Node  ReceiverPoints::Serialize (  ) const {
-        YAML::Node node = LemmaObject::Serialize(); //static_cast<const LemmaObject*>(this)->Serialize();
-        node.SetTag( this->Name ); // Set Tag after doing parents
-
-        // update here
-        node["NumberOfReceivers"] = NumberOfReceivers;
-        node["NumberOfBinsE"] = NumberOfBinsE;
-        node["NumberOfBinsH"] = NumberOfBinsH;
-        //node["Mask"] = Mask;
-        //std::cout << "Locations.data" << Locations.data()[0] << std::endl;
-        // node["Locations"] = Locations.data(); // HUGE
-        return node;
-    }		// -----  end of method ReceiverPoints::Serialize  -----
-
-
-    //--------------------------------------------------------------------------------------
-    //       Class:  ReceiverPoints
-    //      Method:  DeSerialize
-    //--------------------------------------------------------------------------------------
-    ReceiverPoints* ReceiverPoints::DeSerialize ( const YAML::Node& node  ) {
-        ReceiverPoints* Object = new ReceiverPoints(node);
-        Object->AttachTo(Object);
-        DESERIALIZECHECK( node, Object )
-        return Object ;
-    }		// -----  end of method ReceiverPoints::DeSerialize  -----
-#endif
-
-
     #ifdef LEMMAUSEVTK
-    vtkActor* ReceiverPoints::GetVtkGlyphActor(const FIELDTYPE &ftype,
+    vtkActor* FieldPoints::GetVtkGlyphActor(const FIELDTYPE &ftype,
                     const Real &clip, const Real &scale,
                     const int &nfreq) {
 
         vVects->SetNumberOfComponents(3);
 
         // Make PointData
-        for (int ic=0; ic<NumberOfReceivers; ++ic) {
+        for (int ic=0; ic<NumberOfPoints; ++ic) {
 
             Vector3r loc = this->GetLocation(ic);
 
         return vActor;
     }
 
-    vtkDataObject* ReceiverPoints::GetVtkDataObject(const FIELDTYPE &ftype,
+    vtkDataObject* FieldPoints::GetVtkDataObject(const FIELDTYPE &ftype,
                     const int& nbin,
                     const int& start, const int& end,
                     const FIELDCOMPONENT& fcomp,
                     const SPATIALCOORDINANT &scord) {
 
         if (start < 0) throw 77;
-        if (end > NumberOfReceivers) throw 78;
+        if (end > NumberOfPoints) throw 78;
         if (start > end) throw 79;
 
         int ifc(-1);
         return _dataObject;
     }
 
-    vtkDataObject* ReceiverPoints::GetVtkDataObjectFreq(const FIELDTYPE &ftype,
+    vtkDataObject* FieldPoints::GetVtkDataObjectFreq(const FIELDTYPE &ftype,
                     const int& nrec,
                     const int& fstart, const int& fend,
                     const FIELDCOMPONENT& fcomp,

Modules/FDEM1D/testing/GetNameCheck.h

         TS_ASSERT_EQUALS( Obj->GetName(), std::string("LayeredEarthEM") );
     }
 
+    void testFieldPoints( void )
+    {
+        auto Obj = FieldPoints::NewSP();
+        TS_ASSERT_EQUALS( Obj->GetName(), std::string("FieldPoints") );
+    }
+
 };
 

Modules/FDEM1D/testing/SerializeCheck.h

 #include <cxxtest/TestSuite.h>
 #include <FDEM1D>
 #include <random>
-
+#define EPSILON 1e-10
 using namespace Lemma;
 
 class MyTestSuite : public CxxTest::TestSuite
         std::mt19937 gen(rd());
 
         // up to 11 layers
-        std::discrete_distribution<> d({0,0,0,10,10,10,10,10,10,10,10,10,10});
+        std::discrete_distribution<> d({0,0,0,0,10,10,10,10,10,10,10,10,10,10});
         int nl = d(gen);
 
         // for Reals
-        std::uniform_real_distribution<> dis(1e-2, 1);
+        std::uniform_real_distribution<> dis(1e-1, 1);
 
         // conductivity
         VectorXcr con = VectorXcr(nl);
 
         TS_ASSERT_EQUALS( Obj->GetName(), Obj2->GetName() );
         TS_ASSERT_EQUALS( Obj->GetNumberOfLayers(), Obj2->GetNumberOfLayers() );
-        TS_ASSERT_LESS_THAN( std::abs((Obj->GetLayerConductivity() - Obj2->GetLayerConductivity()).array().sum()), 1e-16 );
-        TS_ASSERT_LESS_THAN( std::abs((Obj->GetLayerThickness() - Obj2->GetLayerThickness()).array().sum()), 1e-16 );
+        for (int ilay=0; ilay<nl; ++ilay) {
+            TS_ASSERT_DELTA( std::real(Obj->GetLayerConductivity(ilay)), std::real(Obj2->GetLayerConductivity(ilay)), EPSILON );
+        }
+        for (int ilay=1; ilay<nl-1; ++ilay) {
+            TS_ASSERT_DELTA( Obj->GetLayerThickness(ilay), Obj2->GetLayerThickness(ilay), EPSILON );
+        }
     }
 
+    void testFieldPoints(void)
+    {
+        std::random_device rd;
+        std::mt19937 gen(rd());
+
+        // up to 11 layers
+        std::discrete_distribution<> d({0,0,0,10,10,10,10,10,10,10,10,10,10});
+        std::uniform_real_distribution<> dis(1e-1, 10);
+
+        int np = d(gen);
+        auto Obj = FieldPoints::NewSP();
+            Obj->SetNumberOfPoints(np);
+
+            for (int ip=0; ip<np; ++ip) {
+                Obj->SetLocation( ip, dis(gen), dis(gen), dis(gen) );
+            }
+
+        YAML::Node node = Obj->Serialize();
+        auto Obj2 = FieldPoints::DeSerialize(node);
+        TS_ASSERT_EQUALS( Obj->GetName(), Obj2->GetName() );
+        for (int ip=0; ip<np; ++ip) {
+            TS_ASSERT_DELTA( Obj->GetLocationX(ip), Obj2->GetLocationX(ip), EPSILON );
+            TS_ASSERT_DELTA( Obj->GetLocationY(ip), Obj2->GetLocationY(ip), EPSILON );
+            TS_ASSERT_DELTA( Obj->GetLocationZ(ip), Obj2->GetLocationZ(ip), EPSILON );
+            TS_ASSERT_EQUALS( Obj->GetLocationX(ip), Obj->GetLocation(ip)(0) );
+            TS_ASSERT_EQUALS( Obj->GetLocationY(ip), Obj->GetLocation(ip)(1) );
+            TS_ASSERT_EQUALS( Obj->GetLocationZ(ip), Obj->GetLocation(ip)(2) );
+        }
+    }
 };
 

Modules/LemmaCore/include/LemmaObject.h

          *        all external classes that might need to be serialized.
          */
         virtual YAML::Node Serialize() const {
+            std::cout.precision( 21 );
             YAML::Node node = YAML::Node();
             node.SetTag( GetName() );
             std::time_t now = std::chrono::system_clock::to_time_t( std::chrono::system_clock::now() );
             node["Serialized"] = std::ctime(&now);
+            node["Lemma_VERSION"] = LEMMA_VERSION;
             return node;
         };
 

Modules/LemmaCore/include/lemma.h

 #ifndef __LEMMA_H
 #define __LEMMA_H
 
+    #include <LemmaConfig.h>
+
     // Include some basic stuff that will always be needed
     #include <iostream>
     #include <iomanip>

config/LemmaConfig.h.in

 #define LEMMA_VERSION_MAJOR @LEMMA_VERSION_MAJOR@
 #define LEMMA_VERSION_MINOR @LEMMA_VERSION_MINOR@
 #define LEMMA_VERSION_PATCH @LEMMA_VERSION_PATCH@
-//#define LEMMA_VERSION @LEMMA_VERSION@
+#define LEMMA_VERSION @LEMMA_VERSION@

vim/c.vim

 
 " 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 GridReader RectilinearGridReader RectilinearGridVTKExporter Filter WindowFilter DEMParticle DEMGrain Data DataReader
+syn keyword leType HankelTransform KernelEm1D KernelEM1DManager DipoleSource EarthModel LayeredEarth LayeredEarthEM TEMSurvey TEMSurveyLine TEMSurveyLineRecord TEMInductiveReceiver PolygonalWireAntenna TEMTransmitter TEMReceiver Instrument InstrumentTem LemmaObject FieldPoints DCIPElectrode TEMSurveyData TEMSurveyLineData TEMSurveyLineRecordData  ASCIIParser CubicSplineInterpolator RectilinearGrid GridReader RectilinearGridReader RectilinearGridVTKExporter Filter WindowFilter DEMParticle DEMGrain Data DataReader 
 
 " Deprecated Lemma Types
 highlight dleType ctermfg=Blue guifg=Blue