Work towards porting FD1D over to the new build. Also cleaning up the air layer stuff, so that things are more explicit and clear.

LemmaCore/include/LayeredEarth.h

 	// =======================================================================
 	class LayeredEarth : public EarthModel {
 
+        friend class LayeredEarthEM;
+
 		public:
 
 			// ====================    FRIENDS     ===========================

LemmaCore/include/LemmaObject.h

         LemmaObject (const YAML::Node& node);
 
         /** Protected default destructor. This is an abstract class and
-         *  cannot be instantiated.
+         *  cannot be instantiated. Virtual is necessary so that if base class destructor is
+         *  called, we get the right behaviour.
          */
         virtual ~LemmaObject();
 

Modules/FDEM1D/CMakeLists.txt

+include_directories(${CMAKE_INSTALL_PREFIX}/include)
+
+include_directories( "${CMAKE_CURRENT_SOURCE_DIR}/include" )
+add_subdirectory("src")
+
+add_library( fdem1d ${FEM1DSOURCE} )  
+target_link_libraries(fdem1d "lemmacore")
+
+install ( TARGETS fdem1d DESTINATION ${CMAKE_INSTALL_PREFIX}/lib )
+
+if (LEMMA_BUILD_EXAMPLES)
+	add_subdirectory(examples)
+endif()
+	
+if (LEMMA_ENABLE_TESTING)
+	add_subdirectory(testing)
+endif()
+
+install ( TARGETS fdem1d DESTINATION ${CMAKE_INSTALL_PREFIX}/lib )

Modules/FDEM1D/examples/CMakeLists.txt

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

Modules/FDEM1D/examples/LayeredEarthEM.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      07/14/2016 03:14:50 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 "FEM1D"
+
+using namespace Lemma;
+
+int main() {
+
+    auto model = LayeredEarthEM::NewSP();
+        model->SetNumberOfLayers(6);
+        model->SetLayerThickness( (VectorXr(4) << 10,10,10,10).finished() );
+        model->SetLayerConductivity( (VectorXcr(6) << .1, .10,.10,.10,.10,.10).finished() );
+    std::cout << *model << std::endl;
+}
+

Modules/FDEM1D/include/FEM1D

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

Modules/FDEM1D/include/layeredearthem.h → Modules/FDEM1D/include/LayeredEarthEM.h

 #ifndef __LAYEREDEARTHEM_H
 #define __LAYEREDEARTHEM_H
 
-#include "layeredearth.h"
+#include "LayeredEarth.h"
 #include <iomanip>
 
 namespace Lemma {
             // ====================  LIFECYCLE     ===========================
 
             /**
-             *  Public constructor. Creates a new instance of the class and
-             *  assigns a reference to the thrown pointer.
+             *  Factory method for generating concrete class.
+             *  @return a std::shared_ptr of type LayeredEarthEM
              */
-            static LayeredEarthEM* New();
+            static std::shared_ptr<LayeredEarthEM> NewSP();
 
-            /**
-             * @copybrief LemmaObject::Delete()
-             * @copydetails LemmaObject::Delete()
-             */
-            void Delete();
-
-            #ifdef HAVE_YAMLCPP
             /** YAML Serializing method
              */
             YAML::Node Serialize() const;
 
-
-            //static LayeredEarthEM* DeSerialize(const YAML::Node& node);
-            #endif
+            /**
+             *   Constructs an object from a YAML::Node.
+             */
+            static std::shared_ptr< LayeredEarthEM > DeSerialize(const YAML::Node& node);
 
             /** @return a deep copy
              */
-			LayeredEarthEM* Clone();
+			std::shared_ptr<LayeredEarthEM> Clone();
 
             // ====================  OPERATORS     ===========================
 
             // ====================  LIFECYCLE     ===========================
 
             /** Default protected constructor. */
-            LayeredEarthEM (const std::string &name);
+            LayeredEarthEM ( );
 
-            #ifdef HAVE_YAMLCPP
             /** Default protected constructor. */
 			LayeredEarthEM (const YAML::Node& node);
-            #endif
 
             /** Default protected constructor. */
             ~LayeredEarthEM ();
             /** Relaxation breath for each layer */
             VectorXr          LayerBreathPermitivity;
 
+            private:
+
+            /** ASCII string representation of the class name */
+            static constexpr auto CName = "LayeredEarthEM";
+
     }; // -----  end of class  LayeredEarthEM  -----
 
 
 } // namespace Lemma
 
 #endif // __LAYEREDEARTHEM_H
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */

Modules/FDEM1D/src/CMakeLists.txt

+set (FEM1DSOURCE
+	${FEM1DSOURCE}
+	${CMAKE_CURRENT_SOURCE_DIR}/LayeredEarthEM.cpp
+	#${CMAKE_CURRENT_SOURCE_DIR}/UngroundedElectricDipole.cpp
+	PARENT_SCOPE
+)

Modules/FDEM1D/src/layeredearthem.cpp → Modules/FDEM1D/src/LayeredEarthEM.cpp

   @version  $Id: layeredearthem.cpp 216 2015-03-09 02:26:49Z tirons $
  **/
 
-#include "layeredearthem.h"
+#include "LayeredEarthEM.h"
 
 namespace Lemma {
 
-#ifdef HAVE_YAMLCPP
     std::ostream &operator << (std::ostream &stream, const LayeredEarthEM &ob) {
         stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
         return stream;
     }
-#else
-    std::ostream &operator<<(std::ostream &stream,
-                const LayeredEarthEM &ob) {
-        stream << *(LayeredEarth*)(&ob);
-        //stream << "Class Name : "<< ob.Name  << "\n";
-        stream << std::setw(15) << "LayerNumber"         << "\t"
-               << std::setw(15) << "Thickness"           << "\t"
-               << std::setw(15) << "BottomInterface"     << "\t"
-               << std::setw(15) << "Conductivity"        << "\t"
-               << std::setw(15) << "Susceptibility"      << "\t"
-               << std::setw(15) << "Permitivity"         << "\n";
-        stream << std::setw(15) << " "                   << "\t"
-               << std::setw(15) << "[m]"                 << "\t"
-               << std::setw(15) << "[m]"                 << "\t"
-               << std::setw(15) << "[Sm^-1]"             << "\t"
-               << std::setw(15) << "[]"                  << "\t"
-               << std::setw(15) << "[F/m]"               << "\n";
-        for (int i=0; i< ob.NumberOfLayers; ++i) {
-            stream << std::setw(15) <<  i << "\t"
-                   << std::setw(15) << ((LayeredEarth*)(&ob))->GetLayerThickness(i) << "\t"
-                   << std::setw(15) << ((LayeredEarth*)(&ob))->GetLayerDepth(i) << "\t"
-                   << std::setw(15) << ob.LayerConductivity(i)     << "\t"
-                   << std::setw(15) << ob.LayerSusceptibility(i)   << "\t"
-                   << std::setw(15) << ob.LayerPermitivity(i)      << "\n";
-        }
-
-        return stream;
-    }
-#endif
 
     // ====================  LIFECYCLE     ===================================
 
-    LayeredEarthEM::LayeredEarthEM(const std::string &name) :
-        LayeredEarth(name) {
+    LayeredEarthEM::LayeredEarthEM( ) : LayeredEarth() {
     }
 
     LayeredEarthEM::~LayeredEarthEM() {
-        if (NumberOfReferences != 0) {
-            throw DeleteObjectWithReferences(this);
-        }
-    }
-
-    LayeredEarthEM* LayeredEarthEM::New() {
-        LayeredEarthEM* Obj = new LayeredEarthEM("LayeredEarthEM");
-        Obj->AttachTo(Obj);
-        return Obj;
     }
 
-    void LayeredEarthEM::Delete() {
-        this->DetachFrom(this);
+    std::shared_ptr<LayeredEarthEM> LayeredEarthEM::NewSP() {
+        std::shared_ptr<LayeredEarthEM> sp(new  LayeredEarthEM( ), LemmaObjectDeleter() );
+        return sp;
     }
 
-    void LayeredEarthEM::Release() {
-        delete this;
-    }
-
-    #ifdef HAVE_YAMLCPP
     YAML::Node LayeredEarthEM::Serialize() const {
         YAML::Node node = LayeredEarth::Serialize();
-        node.SetTag( this->Name );
+        node.SetTag( GetName() );
         node["LayerConductivity"] = LayerConductivity;
         node["LayerSusceptibility"] = LayerSusceptibility;
         node["LayerLowFreqSusceptibility"] = LayerLowFreqSusceptibility;
         node["LayerBreathPermitivity"] = LayerBreathPermitivity;
         return node;
     }
-    #endif
 
     // ====================  OPERATIONS    ===================================
     void LayeredEarthEM::EvaluateColeColeModel(const Real& omega) {
 
-        for (int ilay=0; ilay<NumberOfLayers; ++ilay) {
+        for (int ilay=0; ilay<GetNumberOfLayers(); ++ilay) {
             if ( LayerTauSusceptibility(ilay) > 1e-10) {
                 LayerSusceptibility(ilay) = LayerHighFreqSusceptibility(ilay) + (LayerLowFreqSusceptibility(ilay) -
                      LayerHighFreqSusceptibility(ilay)) /
         }
     }
 
-	LayeredEarthEM* LayeredEarthEM::Clone() {
-		LayeredEarthEM* copy = LayeredEarthEM::New();
-
+	std::shared_ptr<LayeredEarthEM> LayeredEarthEM::Clone() {
+		auto copy = LayeredEarthEM::NewSP();
 		copy->LayerConductivity = this->LayerConductivity;
 		copy->LayerSusceptibility = this->LayerSusceptibility;
 		copy->LayerLowFreqSusceptibility = this->LayerLowFreqSusceptibility;
 		copy->LayerHighFreqPermitivity = this->LayerHighFreqPermitivity;
 		copy->LayerTauPermitivity = this->LayerTauPermitivity;
 		copy->LayerBreathPermitivity = this->LayerBreathPermitivity;
-		copy->NumberOfLayers = this->NumberOfLayers;
+		copy->SetNumberOfLayers( this->GetNumberOfLayers() );
 		copy->NumberOfInterfaces = this->NumberOfInterfaces;
 		copy->LayerThickness = this->LayerThickness;
-
 		return copy;
-
 	}
 
     // ====================  ACCESS        ==================================
 
     void LayeredEarthEM::SetLayerConductivity(const VectorXcr &sig) {
-        if (sig.size() != this->NumberOfLayers )
+        if (sig.size() != this->GetNumberOfLayers() )
             throw EarthModelParametersDoNotMatchNumberOfLayers( );
         LayerConductivity = sig;
     }
 
     void LayeredEarthEM::SetLayerConductivity(const int& ilay, const Complex &sig) {
-        if (ilay > this->NumberOfLayers || ilay < 1 )
+        if (ilay > this->GetNumberOfLayers() || ilay < 1 )
             throw EarthModelParametersDoNotMatchNumberOfLayers( );
         LayerConductivity[ilay] = sig;
     }
 */
 
     void LayeredEarthEM::SetLayerHighFreqSusceptibility(const VectorXr &sus) {
-        if (sus.size() != this->NumberOfLayers )
+        if (sus.size() != this->GetNumberOfLayers() )
             throw EarthModelParametersDoNotMatchNumberOfLayers( );
         LayerHighFreqSusceptibility = sus;
     }
 
     void LayeredEarthEM::SetLayerLowFreqSusceptibility(const VectorXr &sus) {
-        if (sus.size() != this->NumberOfLayers )
+        if (sus.size() != this->GetNumberOfLayers() )
             throw EarthModelParametersDoNotMatchNumberOfLayers( );
         LayerLowFreqSusceptibility = sus;
     }
 
     void LayeredEarthEM::SetLayerBreathSusceptibility(const VectorXr &sus) {
-        if (sus.size() != this->NumberOfLayers )
+        if (sus.size() != this->GetNumberOfLayers() )
             throw EarthModelParametersDoNotMatchNumberOfLayers( );
         LayerBreathSusceptibility = sus;
     }
 
     void LayeredEarthEM::SetLayerTauSusceptibility(const VectorXr &sus) {
-        if (sus.size() != this->NumberOfLayers )
+        if (sus.size() != this->GetNumberOfLayers() )
             throw EarthModelParametersDoNotMatchNumberOfLayers( );
         LayerTauSusceptibility = sus;
     }
 
     void LayeredEarthEM::SetLayerHighFreqPermitivity(const VectorXr &per) {
-        if (per.size() != this->NumberOfLayers )
+        if (per.size() != this->GetNumberOfLayers() )
             throw EarthModelParametersDoNotMatchNumberOfLayers( );
         LayerHighFreqPermitivity = per;
     }
 
     void LayeredEarthEM::SetLayerLowFreqPermitivity(const VectorXr &per) {
-        if (per.size() != this->NumberOfLayers )
+        if (per.size() != this->GetNumberOfLayers() )
             throw EarthModelParametersDoNotMatchNumberOfLayers( );
         LayerLowFreqPermitivity = per;
     }
 
     void LayeredEarthEM::SetLayerBreathPermitivity(const VectorXr &per) {
-        if (per.size() != this->NumberOfLayers )
+        if (per.size() != this->GetNumberOfLayers() )
             throw EarthModelParametersDoNotMatchNumberOfLayers( );
         LayerBreathPermitivity = per;
     }
 
     void LayeredEarthEM::SetLayerTauPermitivity(const VectorXr &per) {
-        if (per.size() != this->NumberOfLayers )
+        if (per.size() != this->GetNumberOfLayers() )
             throw EarthModelParametersDoNotMatchNumberOfLayers( );
         LayerTauPermitivity = per;
     }
 
     void LayeredEarthEM::SetLayerThickness(const VectorXr &thick) {
-        if (thick.size() != this->NumberOfLayers - 2)
+        if (thick.size() != this->GetNumberOfLayers() - 2)
             throw EarthModelParametersDoNotMatchNumberOfLayers( );
         LayerThickness = thick;
     }
 
         // Otherwise
         this->NumberOfLayers = nlay;
-
+        this->NumberOfInterfaces = nlay-1;
 
         // Resize all layers
 
         // Conducitivy set to zero
         LayerConductivity = VectorXcr::Zero(NumberOfLayers);
 
-
         ////////////////////////////////////
         // Susceptibility set to One (free space)
         LayerSusceptibility = VectorXcr::Ones(NumberOfLayers);
         return this->LayerBreathPermitivity;
     }
 }
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */

Modules/FDEM1D/testing/CMakeLists.txt

+
+CXXTEST_ADD_TEST(unittestFEM1D_GetNameCheck GetNameCheck.cc ${CMAKE_CURRENT_SOURCE_DIR}/GetNameCheck.h)
+target_link_libraries(unittestFEM1D_GetNameCheck "lemmacore" "fdem1d")

Modules/FDEM1D/testing/GetNameCheck.h

+/* 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      06/23/2016 01:26:46 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 <cxxtest/TestSuite.h>
+#include <LemmaCore>
+#include <FEM1D>
+
+using namespace Lemma;
+
+class MyTestSuite : public CxxTest::TestSuite
+{
+    public:
+
+    void testLayeredEarthEM( void )
+    {
+        auto Obj = LayeredEarthEM::NewSP();
+        TS_ASSERT_EQUALS( Obj->GetName(), std::string("LayeredEarthEM") );
+    }
+
+};
+