Work towards brining inline with Lemma 0.1.2

CMakeLists.txt

 set(EMSCHUR3D_VERSION "\"${EMSCHUR3D_VERSION_MAJOR}.${EMSCHUR3D_VERSION_MINOR}.${EMSCHUR3D_VERSION_PATCH}\"")
 set(EMSCHUR3D_VERSION_NOQUOTES "${EMSCHUR3D_VERSION_MAJOR}.${EMSCHUR3D_VERSION_MINOR}.${EMSCHUR3D_VERSION_PATCH}")
 
+configure_file (
+	"${CMAKE_CURRENT_SOURCE_DIR}/config/EMSchur3DConfig.h.in"
+	"${PROJECT_BINARY_DIR}/include/EMSchur3DConfig.h"
+)
+install ( FILES  ${PROJECT_BINARY_DIR}/include/EMSchur3DConfig.h   DESTINATION ${CMAKE_INSTALL_PREFIX}/include/Lemma/ )
+
 add_subdirectory("src")
 add_library( emschur3d ${EMSCHUR3DSOURCE} )  
 target_include_directories( emschur3d PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include" )

config/EMSchur3DConfig.h.in

+/* 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      01/08/2018 04:01:30 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     tirons@egi.utah.edu
+ * @copyright Copyright (c) 2018, University of Utah
+ * @copyright Copyright (c) 2018, Lemma Software, LLC
+ */
+
+#define EMSCHUR3D_VERSION_MAJOR @EMSCHUR3D_VERSION_MAJOR@
+#define EMSCHUR3D_VERSION_MINOR @EMSCHUR3D_VERSION_MINOR@
+#define EMSCHUR3D_VERSION_PATCH @EMSCHUR3D_VERSION_PATCH@
+#define EMSCHUR3D_VERSION @EMSCHUR3D_VERSION@
+
+

examples/EMSchur3D.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      01/04/2018 04:34:54 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     tirons@egi.utah.edu
+ * @copyright Copyright (c) 2018, University of Utah
+ * @copyright Copyright (c) 2018, Lemma Software, LLC
+ */
+
+#include <LemmaCore>
+#include "RectilinearGridReader.h"
+//#include "AEMSurveyReader.h"
+#include "EMSchur3D.h"
+//#include "LayeredEarthEMReader.h"
+//#include "CSymSimplicialCholesky.h"
+
+using namespace Lemma;
+
+int main( int argc, char** argv ) {
+
+    // BiCGSTAB Diagonal preconditioner
+    auto EM3D = EMSchur3D< Eigen::BiCGSTAB<Eigen::SparseMatrix<Complex, Eigen::ColMajor> > >::NewSP();
+
+    if (argc < 3) {
+        std::cout << "EMSchur3D  <rgrid>  <1dmod>  <aemsurvey> " << std::endl;
+        exit( EXIT_SUCCESS );
+    }
+
+    ///////////////////////////////////////////////////
+    // Read in Grid
+    auto GridRead = RectilinearGridReader::NewSP();
+        try {
+            GridRead->ReadASCIIGridFile( argv[1] );
+        } catch (std::exception& e) {
+		    std::cout << "Caught an error opening ASCII Grid file: ";
+            std::cout << e.what() << std::endl;
+		    std::cout << "enter filename or 0 to exit programme\n";
+		    std::string inp;
+		    std::cin >> inp;
+		    if (inp != "0")
+                GridRead->ReadASCIIGridFile( inp.c_str() );
+            else exit(EXIT_FAILURE);
+	    }
+
+    //////////////////////////////////////////////////
+    // Read in Layered earth, for backgound model
+    auto LayEarthRead = LayeredEarthEMReader::NewSP();
+        try {
+            LayEarthRead->ReadASCIIInputFile( argv[2] );
+        } catch (std::exception& e) {
+		    std::cout << "Caught an error opening ASCII Layered Earth file: ";
+            std::cout << e.what() << std::endl;
+		    std::cout << "enter filename or 0 to exit programme\n";
+		    std::string inp;
+		    std::cin >> inp;
+		    if (inp != "0")
+                GridRead->ReadASCIIGridFile( inp.c_str() );
+            else exit(EXIT_FAILURE);
+	    }
+
+    /*
+    //////////////////////////////////////////////////
+    // Read in source specification
+    auto AEMRead = AEMSurveyReader::NewSP();
+        try{
+            AEMRead->ReadASCIIAEMFile(argv[4]);
+        } catch (std::exception& e) {
+		    std::cout << "Caught an error opening ASCII AEM file: ";
+            std::cout << e.what() << std::endl;
+		    std::cout << "enter filename or 0 to exit programme\n";
+		    std::string inp;
+		    std::cin >> inp;
+		    if (inp != "0")
+                AEMRead->ReadASCIIAEMFile( inp.c_str() );
+            else exit(EXIT_FAILURE);
+	    }
+    */
+
+    /*
+    //////////////////////////////////////////////////
+    // And solve
+    EM3D->SetRectilinearGrid(GridRead->GetGrid());
+    EM3D->SetLayeredEarthEM( LayEarthRead->GetLayeredEarth() );
+    EM3D->SetAEMSurvey( AEMRead->GetSurvey() );
+    EM3D->LoadMeshToolsConductivityModel( argv[3] );
+    EM3D->SetResFileName(argv[5]);
+    //EM3D->SetCSolver( Lemma::SPARSELU ); // Lemma::BiCGSTAB );
+    EM3D->Solve();
+    */
+    std::cout << *EM3D;
+
+    exit(EXIT_SUCCESS);
+}
+

include/EMSchur3D.h

 #define  EMSCHUR3D_INC
 
 #include "EMSchur3DBase.h"
+#include "bicgstab.h"
 //#include "CSymSimplicialCholesky.h"
 
 namespace Lemma {
     template < class Solver >
     class EMSchur3D : public EMSchur3DBase {
 
+        friend std::ostream &operator << (std::ostream &stream, const EMSchur3D &ob) {
+            stream << ob.Serialize()  << "\n---\n"; // End of doc
+            return stream;
+        }
+
+        struct ctor_key {};
+
         //friend std::ostream &operator<<(std::ostream &stream,
         //        const EMSchur3D &ob);
 
          * @copybrief LemmaObject::New()
          * @copydetails LemmaObject::New()
          */
-        static EMSchur3D* New() {
-            EMSchur3D<Solver>*  Obj = new EMSchur3D<Solver>("EMSchur3D");
-            Obj->AttachTo(Obj);
-            return Obj;
+        static std::shared_ptr< EMSchur3D > NewSP() {
+            return std::make_shared< EMSchur3D<Solver> >( ctor_key() );
+            //return std::make_shared< EMSchur3D< Eigen::BiCGSTAB<Eigen::SparseMatrix<Complex, Eigen::ColMajor> > > >( ctor_key() ) ;
+        }
+
+        /** Default protected constructor, use New */
+        explicit EMSchur3D ( const ctor_key& key ) : EMSchur3DBase( ), CSolver( nullptr ) {
+
+        }
+
+        /** Locked DeDerializing constructor, use factory DeSerialize  method*/
+        EMSchur3D (const YAML::Node& node): EMSchur3DBase(node), CSolver( nullptr ) {
+        }
+
+        /** Default protected destructor, use Delete */
+        virtual ~EMSchur3D () {
+            // TODO delete arrays
         }
 
         /**
-         *  @copybrief   LemmaObject::Delete()
-         *  @copydetails LemmaObject::Delete()
+         *  Uses YAML to serialize this object.
+         *  @return a YAML::Node
          */
-        void Delete() {
-            this->DetachFrom(this);
+        YAML::Node Serialize() const {
+            YAML::Node node = EMSchur3DBase::Serialize();
+            //node["NumberOfLayers"] = NumberOfLayers;
+            node.SetTag( this->GetName() );
+            return node;
         }
 
+        /**
+         *   Constructs an object from a YAML::Node.
+         */
+        static EMSchur3D* DeSerialize(const YAML::Node& node);
+
+
         // ====================  OPERATORS     =======================
 
         // ====================  OPERATIONS    =======================
          *  @param[in] Source is the source term for generating primary fields
          *  @param[in] isource is the source index
          */
-        void SolveSource( DipoleSource* Source , const int& isource);
+        void SolveSource( std::shared_ptr<DipoleSource> Source , const int& isource);
 
         /** Builds the solver for the C matrix */
         void BuildCDirectSolver(  );
 
         // ====================  ACCESS        =======================
 
-        // ====================  INQUIRY       =======================
+        virtual std::string GetName() const {
+            return this->CName;
+        }
 
-#ifdef HAVE_YAMLCPP
-//         /**
-//          *  Uses YAML to serialize this object.
-//          *  @return a YAML::Node
-//          */
-//         YAML::Node Serialize() const;
-//
-//         /**
-//          *   Constructs an object from a YAML::Node.
-//          */
-//         static EMSchur3D* DeSerialize(const YAML::Node& node);
-#endif
+        // ====================  INQUIRY       =======================
 
         protected:
 
         // ====================  LIFECYCLE     =======================
 
-        /** Default protected constructor, use New */
-        EMSchur3D (const std::string& name) : EMSchur3DBase(name), CSolver(NULL) {
-        }
-
-// #ifdef HAVE_YAMLCPP
-//         /** Protected DeDerializing constructor, use factory DeSerialize  method*/
-//         EMSchur3D (const YAML::Node& node): EMSchur3DBase(node), CSolver(NULL) {
-//         }
-// #endif
-
-        /** Default protected destructor, use Delete */
-        ~EMSchur3D () {
-            // TODO delete arrays
-        }
-
-        /**
-         *  @copybrief   LemmaObject::Release()
-         *  @copydetails LemmaObject::Release()
-         */
-        void Release() {
-            delete this;
-        }
-
         private:
 
+        /** Copy constructor */
+        EMSchur3D( const EMSchur3D& ) = delete;
+
         // ====================  DATA MEMBERS  =========================
 
         /** The templated solver for C */
 
         Eigen::SparseMatrix<Complex>  Csym;
 
+        static constexpr auto CName = "EMSchur3D";
+
+
     }; // -----  end of class  EMSchur3D  -----
 
 
     //      Method:  SolveSource
     //--------------------------------------------------------------------------------------
     template < class Solver >
-    void EMSchur3D<Solver>::SolveSource ( DipoleSource* Source, const int& isource ) {
+    void EMSchur3D<Solver>::SolveSource ( std::shared_ptr<DipoleSource> Source, const int& isource ) {
 
         //  figure out which omega we are working with
         int iw = -1;
         //       Alternatively, the bins function of ReceiverPoints could be extended quite easily.
         //       This may be the way to do this.
 
-        Lemma::ReceiverPoints* dpoint = Lemma::ReceiverPoints::New();
+        //Lemma::ReceiverPoints* dpoint = Lemma::ReceiverPoints::New();
+        std::shared_ptr< FieldPoints > dpoint = FieldPoints::NewSP();
 
         FillPoints(dpoint);
         PrimaryField(Source, dpoint);
 
         WriteVTKResults( ResFile+ to_string(isource), A, Se, E0, E , Phi, ADiv, ADiv2, B);
 
-        dpoint->Delete();
+        //dpoint->Delete();
         return ;
 
     }		// -----  end of method EMSchur3D::SolveSource  -----
 //         }
 //     }
 
-    template<>
-    void EMSchur3D< Eigen::CSymSimplicialLLT< Eigen::SparseMatrix<Complex, Eigen::ColMajor>, Eigen::Lower, Eigen::NaturalOrdering<int> > > ::BuildCDirectSolver() {
-        CSolver = new Eigen::CSymSimplicialLLT< Eigen::SparseMatrix<Complex, Eigen::ColMajor>, Eigen::Lower, Eigen::NaturalOrdering<int> > [Omegas.size()];
-        for (int iw=0; iw<Omegas.size(); ++iw) {
-            Csym = Cvec[iw].selfadjointView<Eigen::Lower>();
-            jsw_timer timer;
-            timer.begin();
-            /*  Complex system */
-            std::cout << "CSymSimplicialLLT<NaturalOrdering> pattern analyzing C_" << iw << ",";
-            std::cout.flush();
-            CSolver[iw].analyzePattern( Csym );
-            std::cout << " done in " << timer.end() / 60. << " [m]" << std::endl;
-            /* factorize */
-            timer.begin();
-            std::cout << "CSymSimplicialLLT<NaturalOrdering> factorising C_" << iw << ", ";
-            std::cout.flush();
-            CSolver[iw].factorize( Csym );
-            std::cout << " done in " << timer.end() / 60. << " [m]" << std::endl;
-        }
-    }
-
-    template<>
-    void EMSchur3D< Eigen::CSymSimplicialLLT< Eigen::SparseMatrix<Complex, Eigen::ColMajor>, Eigen::Lower, Eigen::AMDOrdering<int> > > ::BuildCDirectSolver() {
-        CSolver = new Eigen::CSymSimplicialLLT< Eigen::SparseMatrix<Complex, Eigen::ColMajor>, Eigen::Lower, Eigen::AMDOrdering<int> > [Omegas.size()];
-        for (int iw=0; iw<Omegas.size(); ++iw) {
-            //Csym = Cvec[iw].selfadjointView<Eigen::Lower>();
-            jsw_timer timer;
-            timer.begin();
-            /*  Complex system */
-            std::cout << "CSymSimplicialLLT<AMDOrdering> pattern analyzing C_" << iw << ",";
-            std::cout.flush();
-            CSolver[iw].analyzePattern( Cvec[iw] );
-            std::cout << " done in " << timer.end() / 60. << " [m]" << std::endl;
-            /* factorize */
-            timer.begin();
-            std::cout << "CSymSimplicialLLT<AMDOrdering> factorising C_" << iw << ", ";
-            std::cout.flush();
-            CSolver[iw].factorize( Cvec[iw] );
-            std::cout << " done in " << timer.end() / 60. << " [m]" << std::endl;
-        }
-    }
+//     template<>
+//     void EMSchur3D< Eigen::CSymSimplicialLLT< Eigen::SparseMatrix<Complex, Eigen::ColMajor>, Eigen::Lower, Eigen::NaturalOrdering<int> > > ::BuildCDirectSolver() {
+//         CSolver = new Eigen::CSymSimplicialLLT< Eigen::SparseMatrix<Complex, Eigen::ColMajor>, Eigen::Lower, Eigen::NaturalOrdering<int> > [Omegas.size()];
+//         for (int iw=0; iw<Omegas.size(); ++iw) {
+//             Csym = Cvec[iw].selfadjointView<Eigen::Lower>();
+//             jsw_timer timer;
+//             timer.begin();
+//             /*  Complex system */
+//             std::cout << "CSymSimplicialLLT<NaturalOrdering> pattern analyzing C_" << iw << ",";
+//             std::cout.flush();
+//             CSolver[iw].analyzePattern( Csym );
+//             std::cout << " done in " << timer.end() / 60. << " [m]" << std::endl;
+//             /* factorize */
+//             timer.begin();
+//             std::cout << "CSymSimplicialLLT<NaturalOrdering> factorising C_" << iw << ", ";
+//             std::cout.flush();
+//             CSolver[iw].factorize( Csym );
+//             std::cout << " done in " << timer.end() / 60. << " [m]" << std::endl;
+//         }
+//     }
+//
+//     template<>
+//     void EMSchur3D< Eigen::CSymSimplicialLLT< Eigen::SparseMatrix<Complex, Eigen::ColMajor>, Eigen::Lower, Eigen::AMDOrdering<int> > > ::BuildCDirectSolver() {
+//         CSolver = new Eigen::CSymSimplicialLLT< Eigen::SparseMatrix<Complex, Eigen::ColMajor>, Eigen::Lower, Eigen::AMDOrdering<int> > [Omegas.size()];
+//         for (int iw=0; iw<Omegas.size(); ++iw) {
+//             //Csym = Cvec[iw].selfadjointView<Eigen::Lower>();
+//             jsw_timer timer;
+//             timer.begin();
+//             /*  Complex system */
+//             std::cout << "CSymSimplicialLLT<AMDOrdering> pattern analyzing C_" << iw << ",";
+//             std::cout.flush();
+//             CSolver[iw].analyzePattern( Cvec[iw] );
+//             std::cout << " done in " << timer.end() / 60. << " [m]" << std::endl;
+//             /* factorize */
+//             timer.begin();
+//             std::cout << "CSymSimplicialLLT<AMDOrdering> factorising C_" << iw << ", ";
+//             std::cout.flush();
+//             CSolver[iw].factorize( Cvec[iw] );
+//             std::cout << " done in " << timer.end() / 60. << " [m]" << std::endl;
+//         }
+//     }
+//
+//     template<>
+//     void EMSchur3D< Eigen::CSymSimplicialLDLT< Eigen::SparseMatrix<Complex, Eigen::ColMajor>, Eigen::Lower, Eigen::AMDOrdering<int> > > ::BuildCDirectSolver() {
+//         CSolver = new Eigen::CSymSimplicialLDLT< Eigen::SparseMatrix<Complex, Eigen::ColMajor>, Eigen::Lower, Eigen::AMDOrdering<int> > [Omegas.size()];
+//         for (int iw=0; iw<Omegas.size(); ++iw) {
+//             Csym = Cvec[iw].selfadjointView<Eigen::Lower>();
+//             jsw_timer timer;
+//             timer.begin();
+//             /*  Complex system */
+//             std::cout << "CSymSimplicialLDLT<AMDOrdering> pattern analyzing C_" << iw << ",";
+//             std::cout.flush();
+//             CSolver[iw].analyzePattern( Csym );
+//             std::cout << " done in " << timer.end() / 60. << " [m]" << std::endl;
+//             /* factorize */
+//             timer.begin();
+//             std::cout << "CSymSimplicialLDLT<AMDOrdering> factorising C_" << iw << ", ";
+//             std::cout.flush();
+//             CSolver[iw].factorize( Csym );
+//             std::cout << " done in " << timer.end() / 60. << " [m]" << std::endl;
+//         }
+//     }
 
-    template<>
-    void EMSchur3D< Eigen::CSymSimplicialLDLT< Eigen::SparseMatrix<Complex, Eigen::ColMajor>, Eigen::Lower, Eigen::AMDOrdering<int> > > ::BuildCDirectSolver() {
-        CSolver = new Eigen::CSymSimplicialLDLT< Eigen::SparseMatrix<Complex, Eigen::ColMajor>, Eigen::Lower, Eigen::AMDOrdering<int> > [Omegas.size()];
-        for (int iw=0; iw<Omegas.size(); ++iw) {
-            Csym = Cvec[iw].selfadjointView<Eigen::Lower>();
-            jsw_timer timer;
-            timer.begin();
-            /*  Complex system */
-            std::cout << "CSymSimplicialLDLT<AMDOrdering> pattern analyzing C_" << iw << ",";
-            std::cout.flush();
-            CSolver[iw].analyzePattern( Csym );
-            std::cout << " done in " << timer.end() / 60. << " [m]" << std::endl;
-            /* factorize */
-            timer.begin();
-            std::cout << "CSymSimplicialLDLT<AMDOrdering> factorising C_" << iw << ", ";
-            std::cout.flush();
-            CSolver[iw].factorize( Csym );
-            std::cout << " done in " << timer.end() / 60. << " [m]" << std::endl;
-        }
-    }
 
     template<>
     void EMSchur3D< Eigen::BiCGSTAB<Eigen::SparseMatrix<Complex, Eigen::ColMajor>, Eigen::IncompleteLUT<Complex> > > ::BuildCDirectSolver() {

include/EMSchur3DBase.h

   @date     09/20/2013
   @version  $Id$
  **/
-
+#pragma once
 
 #ifndef  EMSCHUR3DBASE_INC
 #define  EMSCHUR3DBASE_INC
 
 #include <LemmaCore>
+#include "EMSchur3DConfig.h"
 #include <FDEM1D>
 
+
 //#include "LemmaObject.h"
 //#include "rectilineargrid.h"
 //#include "RectilinearGridVTKExporter.h"
 
 #include "timer.h"
 #include <Eigen/Sparse>
-#include "bicgstab.h"
+//#include "bicgstab.h"
 
 // Solvers
 #ifdef HAVE_PASTIX
             const EMSchur3DBase &ob);
 
     protected:
-    struct ctor_key {};
+
+    // since this is a ABC, key is not necessary...still would be nice to find a
+    // mechanism for specifying where keys may be passed down from...
+    //struct ctor_key {};
+    //template<typename U>
+    //friend class EMSchur3D;
 
     public:
 
     // ====================  LIFECYCLE     =======================
 
     /** Default protected constructor, use New */
-    explicit EMSchur3DBase ( const ctor_key& );
+    explicit EMSchur3DBase (  );
 
     /** Default protected constructor, use New */
-    explicit EMSchur3DBase ( const YAML::Node& node, const ctor_key& );
+    explicit EMSchur3DBase ( const YAML::Node& node );
 
     /** Default protected destructor, use Delete */
-    virtual ~EMSchur3DBase ();
+    virtual ~EMSchur3DBase ( );
 
     /**
      * Initialises antenna to contain no points, with no current
      */
     static std::shared_ptr<EMSchur3DBase> NewSP();
 
-    /**
+    /*
      * Provides deep copy
      */
-    virtual std::shared_ptr<EMSchur3DBase> Clone() const ;
+    //virtual std::shared_ptr<EMSchur3DBase> Clone() const ;
 
     /**
      *  Uses YAML to serialize this object.
     // ====================  INQUIRY       =======================
 
     /** Returns the name of the underlying class, similiar to Python's type */
-    virtual std::string GetName() const;
+    virtual std::string GetName() const {
+        return this->CName;
+    }
 
     protected:
 
      *  @param[in] Source is the source term for generating primary fields
      *  @param[in] isource is the source index
      */
-    virtual void SolveSource( DipoleSource* Source , const int& isource)=0;
+    virtual void SolveSource( std::shared_ptr< DipoleSource > Source , const int& isource)=0;
 
     /** Computes the primary field
      */

include/bicgstab.h

 //  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
 // ===========================================================================
+#pragma once
+
+#ifndef  BICGSTAB_INC
+#define  BICGSTAB_INC
 
 #include <Eigen/Core>
 #include <Eigen/Sparse>
 #include <string>
 #include <complex>
 #include <fstream>
-#include "lemma.h"
+#include <LemmaCore>
 #include "timer.h"
 
 using namespace Eigen;
 // On Output
 // X real solution vector
 // errorn = Real error norm
-int implicitbicgstab(const SparseMat& D,
+int implicitbicgstabnt(const SparseMat& D,
                      const SparseMat& C,
                      const VectorXcr& ioms,
                      const SparseMat& MC,
     return (0);
 }
 
+#endif   // ----- #ifndef BICGSTAB_INC  -----
 
 //int bicgstab(const SparseMat &A, Eigen::SparseLU< Eigen::SparseMatrix<Complex, RowMajor> ,
 

src/EMSchur3DBase.cpp

 
 #include "EMSchur3DBase.h"
 
-typedef Eigen::Triplet<Complex> Tc;
-typedef Eigen::Triplet<Real> Tr;
+typedef Eigen::Triplet<Lemma::Complex> Tc;
+typedef Eigen::Triplet<Lemma::Real> Tr;
 
 #define UPPER 0
 #define LOWER 1 // 1=true, 0=false
     //      Method:  EMSchur3DBase
     // Description:  constructor (protected)
     //--------------------------------------------------------------------------------------
-    EMSchur3DBase::EMSchur3DBase ( const ctor_key& key ) : LemmaObject( ),
+    EMSchur3DBase::EMSchur3DBase ( ) : LemmaObject( ),
         Grid(nullptr),
         //Survey(nullptr),
         LayModel(nullptr), Cvec(nullptr),
     //      Method:  EMSchur3DBase
     // Description:  constructor (protected)
     //--------------------------------------------------------------------------------------
-    EMSchur3DBase::EMSchur3DBase ( const YAML::Node& node, const ctor_key& key ) : LemmaObject(),
+    EMSchur3DBase::EMSchur3DBase ( const YAML::Node& node ) : LemmaObject(),
         Grid(nullptr),
         //Survey(nullptr),
         LayModel(nullptr), Cvec(nullptr),
     YAML::Node EMSchur3DBase::Serialize (  ) const {
         YAML::Node node = LemmaObject::Serialize();
         node.SetTag( this->GetName() );
+        node["EMSchur3D_VERSION"] = EMSCHUR3D_VERSION;
         return node;
     }		// -----  end of method EMSchur3D::Serialize  -----
 
         EImag->SetNumberOfComponents(3);
 
         // Interpolate
-        VectorXcd  Ax(nx*ny*nz);       // A
-        VectorXcd  Ay(nx*ny*nz);
-        VectorXcd  Az(nx*ny*nz);
-        VectorXcd  Bx(nx*ny*nz);       // B
-        VectorXcd  By(nx*ny*nz);
-        VectorXcd  Bz(nx*ny*nz);
-        VectorXcd  Sex(nx*ny*nz);      // Se
-        VectorXcd  Sey(nx*ny*nz);
-        VectorXcd  Sez(nx*ny*nz);
-        VectorXcd  E0x(nx*ny*nz);      // E0
-        VectorXcd  E0y(nx*ny*nz);
-        VectorXcd  E0z(nx*ny*nz);
-        VectorXcd  Ex(nx*ny*nz);       // E
-        VectorXcd  Ey(nx*ny*nz);
-        VectorXcd  Ez(nx*ny*nz);
-
+        Eigen::VectorXcd  Ax(nx*ny*nz);       // A
+        Eigen::VectorXcd  Ay(nx*ny*nz);
+        Eigen::VectorXcd  Az(nx*ny*nz);
+        Eigen::VectorXcd  Bx(nx*ny*nz);       // B
+        Eigen::VectorXcd  By(nx*ny*nz);
+        Eigen::VectorXcd  Bz(nx*ny*nz);
+        Eigen::VectorXcd  Sex(nx*ny*nz);      // Se
+        Eigen::VectorXcd  Sey(nx*ny*nz);
+        Eigen::VectorXcd  Sez(nx*ny*nz);
+        Eigen::VectorXcd  E0x(nx*ny*nz);      // E0
+        Eigen::VectorXcd  E0y(nx*ny*nz);
+        Eigen::VectorXcd  E0z(nx*ny*nz);
+        Eigen::VectorXcd  Ex(nx*ny*nz);       // E
+        Eigen::VectorXcd  Ey(nx*ny*nz);
+        Eigen::VectorXcd  Ez(nx*ny*nz);
 
         ////////////////////////////////
         // X component
             ADiv2ImagArray->InsertTuple1(i, std::imag(ADiv2(i)));
 
             // vectors
-            AReal->InsertTuple3(i, real(Ax(i)), real(Ay(i)), real(Az(i)));
-            AImag->InsertTuple3(i, imag(Ax(i)), imag(Ay(i)), imag(Az(i)));
-            BReal->InsertTuple3(i, real(Bx(i)), real(By(i)), real(Bz(i)));
-            BImag->InsertTuple3(i, imag(Bx(i)), imag(By(i)), imag(Bz(i)));
-            SeReal->InsertTuple3(i, real(Sex(i)), real(Sey(i)), real(Sez(i)));
-            SeImag->InsertTuple3(i, imag(Sex(i)), imag(Sey(i)), imag(Sez(i)));
-            E0Real->InsertTuple3(i, real(E0x(i)), real(E0y(i)), real(E0z(i)));
-            E0Imag->InsertTuple3(i, imag(E0x(i)), imag(E0y(i)), imag(E0z(i)));
-            EReal-> InsertTuple3(i, real(Ex(i)), real(Ey(i)), real(Ez(i)));
-            EImag-> InsertTuple3(i, imag(Ex(i)), imag(Ey(i)), imag(Ez(i)));
+            AReal->InsertTuple3(i, std::real(Ax(i)), std::real(Ay(i)), std::real(Az(i)));
+            AImag->InsertTuple3(i, std::imag(Ax(i)), std::imag(Ay(i)), std::imag(Az(i)));
+            BReal->InsertTuple3(i, std::real(Bx(i)), std::real(By(i)), std::real(Bz(i)));
+            BImag->InsertTuple3(i, std::imag(Bx(i)), std::imag(By(i)), std::imag(Bz(i)));
+            SeReal->InsertTuple3(i, std::real(Sex(i)), std::real(Sey(i)), std::real(Sez(i)));
+            SeImag->InsertTuple3(i, std::imag(Sex(i)), std::imag(Sey(i)), std::imag(Sez(i)));
+            E0Real->InsertTuple3(i, std::real(E0x(i)), std::real(E0y(i)), std::real(E0z(i)));
+            E0Imag->InsertTuple3(i, std::imag(E0x(i)), std::imag(E0y(i)), std::imag(E0z(i)));
+            EReal-> InsertTuple3(i, std::real(Ex(i)), std::real(Ey(i)), std::real(Ez(i)));
+            EImag-> InsertTuple3(i, std::imag(Ex(i)), std::imag(Ey(i)), std::imag(Ez(i)));
 
             ++i;
         }