Work on TEM module

Modules/TEM1D/CMakeLists.txt

+add_subdirectory("src")
+add_library( tem1d ${TEM1DSOURCE} )  
+target_include_directories( tem1d PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include" )
+
+set_target_properties(tem1d PROPERTIES 
+	VERSION  "${LEMMA_VERSION_NOQUOTES}"
+	SOVERSION "${LEMMA_VERSION_MAJOR}.${LEMMA_VERSION_MINOR}"
+	PROJECT_LABEL "TEM1D ${LABEL_SUFFIX}"
+    CXX_STANDARD 14
+    CXX_STANDARD_REQUIRED ON
+)
+
+# Linking
+target_link_libraries(tem1d "lemmacore")
+target_link_libraries(tem1d "fdem1d")
+
+# Testing
+if (LEMMA_ENABLE_TESTING)
+	add_subdirectory(testing)
+endif()
+
+# Install
+install ( TARGETS tem1d DESTINATION ${CMAKE_INSTALL_PREFIX}/lib )
+install ( FILES include/TEM1D  DESTINATION ${CMAKE_INSTALL_PREFIX}/include/Lemma ) 
+install ( DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_PREFIX}/include/Lemma  FILES_MATCHING PATTERN "*.h")
+
+#install ( DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_PREFIX}/include/Lemma/  FILES_MATCHING PATTERN "FDEM1D")
+#install ( DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_PREFIX}/include/Lemma/FDEM1D  FILES_MATCHING PATTERN "*.h")
+
+# Examples
+if (LEMMA_BUILD_EXAMPLES)
+	add_subdirectory(examples)
+endif()

Modules/TEM1D/include/TEMReceiver.h

 /**
  * @file
  * @date      10/08/2014 02:36:47 PM
- * @version   $Id$
  * @author    Trevor Irons (ti)
- * @email     Trevor.Irons@xri-geo.com
- * @copyright Copyright (c) 2014, XRI Geophysics, LLC
+ * @email     Trevor.Irons@Utah.edu
  * @copyright Copyright (c) 2014, Trevor Irons
  */
+#pragma once
 
 #ifndef  TEMRECEIVER_INC
 #define  TEMRECEIVER_INC
 
-#include "receiverpoints.h"
+#include <random>
+//#include "yaml-cpp/yaml.h"
+#include <LemmaCore>
+#include <FDEM1D>
 
 //#include <boost/random.hpp>
 //#include <boost/random/normal_distribution.hpp>
-#include <random>
 
 namespace Lemma {
 
-#ifdef HAVE_YAMLCPP
-#include "yaml-cpp/yaml.h"
-#endif
-
-
 /**
   \brief
   \details
  */
-class TEMReceiver : public ReceiverPoints {
+class TEMReceiver : public FieldPoints {
 
-    friend std::ostream &operator<<(std::ostream &stream,
-            const TEMReceiver &ob);
+    friend std::ostream &operator<<(std::ostream &stream, const TEMReceiver &ob);
 
     public:
 
     // ====================  LIFECYCLE     =======================
 
+    /** Default locked constructor. */
+    explicit TEMReceiver ( const ctor_key& );
+
+    /** Locked deserializing constructor. */
+    TEMReceiver (const YAML::Node& node, const ctor_key&);
+
+    /** Default destructor. */
+    ~TEMReceiver ();
+
     /**
-     * @copybrief LemmaObject::New()
-     * @copydetails LemmaObject::New()
+     *  Factory method for generating concrete class.
+     *  @return a std::shared_ptr of type TEMReceiver
      */
-    static TEMReceiver* New();
+    static std::shared_ptr<TEMReceiver> NewSP();
 
     /**
-     *   @return a deep copy of this
+     *  Uses YAML to serialize this object.
+     *  @note The actual calculation results are not serialized, currently.
+     *  @return a YAML::Node
      */
-    TEMReceiver* Clone();
+    YAML::Node Serialize() const;
 
     /**
-     *  @copybrief   LemmaObject::Delete()
-     *  @copydetails LemmaObject::Delete()
+     *   Constructs an object from a YAML::Node.
+     *   @param[in] node is a YAML node containing the serialized class information
+     *   @return a std::shared_ptr object of TEMReceiver
      */
-    void Delete();
+    static std::shared_ptr<TEMReceiver> DeSerialize(const YAML::Node& node);
+
 
     // ====================  OPERATORS     =======================
 
      *  @return the reference time
      */
     Real    GetReferenceTime();
+
     protected:
 
     // ====================  LIFECYCLE     =======================
 
-    /** Default protected constructor, use New */
-    TEMReceiver (const std::string& name);
-
-     #ifdef HAVE_YAMLCPP
-    /** Default protected de-serializing constructor, use factory DeSerialize */
-    TEMReceiver (const YAML::Node& node);
-    #endif
-
-    /** Default protected destructor, use Delete */
-    ~TEMReceiver ();
-
     /**
      *  @copybrief   LemmaObject::Release()
      *  @copydetails LemmaObject::Release()

Modules/TEM1D/src/CMakeLists.txt

+set (TEM1DSOURCE
+	${TEM1DSOURCE}
+
+
+	${CMAKE_CURRENT_SOURCE_DIR}/TEMReceiver.cpp
+#	${CMAKE_CURRENT_SOURCE_DIR}/LayeredEarthEMReader.cpp
+	
+	# Calculation points
+#	${CMAKE_CURRENT_SOURCE_DIR}/FieldPoints.cpp
+
+	# Sources	
+#	${CMAKE_CURRENT_SOURCE_DIR}/CompactSupportEMSource.cpp
+#	${CMAKE_CURRENT_SOURCE_DIR}/CircularLoop.cpp
+
+#	${CMAKE_CURRENT_SOURCE_DIR}/DipoleSource.cpp
+#	${CMAKE_CURRENT_SOURCE_DIR}/WireAntenna.cpp
+#	${CMAKE_CURRENT_SOURCE_DIR}/PolygonalWireAntenna.cpp
+
+	# Kernel management	
+#	${CMAKE_CURRENT_SOURCE_DIR}/KernelEM1DManager.cpp
+#	${CMAKE_CURRENT_SOURCE_DIR}/KernelEM1DSpec.cpp
+#	${CMAKE_CURRENT_SOURCE_DIR}/KernelEM1DReflSpec.cpp
+
+	#####################
+	# Hankel transforms #
+	#####################
+	# FHT
+#	${CMAKE_CURRENT_SOURCE_DIR}/HankelTransform.cpp
+#	${CMAKE_CURRENT_SOURCE_DIR}/FHTAnderson801.cpp
+#	${CMAKE_CURRENT_SOURCE_DIR}/FHTKey201.cpp
+#	${CMAKE_CURRENT_SOURCE_DIR}/FHTKey101.cpp
+#	${CMAKE_CURRENT_SOURCE_DIR}/FHTKey51.cpp
+
+	# Templated FHT
+#	${CMAKE_CURRENT_SOURCE_DIR}/FHT.cpp
+
+	# Gaussian Quadrature
+#	${CMAKE_CURRENT_SOURCE_DIR}/GQChave.cpp
+#	${CMAKE_CURRENT_SOURCE_DIR}/QWEKey.cpp
+	
+	# Calculation
+#	${CMAKE_CURRENT_SOURCE_DIR}/EMEarth1D.cpp
+
+	# AEM 
+#	${CMAKE_CURRENT_SOURCE_DIR}/AEMSurvey.cpp
+#	${CMAKE_CURRENT_SOURCE_DIR}/AEMSurveyReader.cpp
+	
+	#${CMAKE_CURRENT_SOURCE_DIR}/UngroundedElectricDipole.cpp
+	PARENT_SCOPE
+)

Modules/TEM1D/src/TEMReceiver.cpp

 /**
  * @file
  * @date      10/08/2014 03:04:56 PM
- * @version   $Id$
  * @author    Trevor Irons (ti)
- * @email     Trevor.Irons@xri-geo.com
- * @copyright Copyright (c) 2014, XRI Geophysics, LLC
- * @copyright Copyright (c) 2014, Trevor Irons
+ * @email     Trevor.Irons@utah.edu
+ * @copyright Copyright (c) 2014, 2018 Trevor Irons
  */
 
 #include "TEMReceiver.h"
 
 
     // ====================  FRIEND METHODS  =====================
-#ifdef HAVE_YAMLCPP
+
     std::ostream &operator << (std::ostream &stream, const TEMReceiver &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 TEMReceiver& ob) {
-        stream << *(ReceiverPoints*)(&ob);
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
-#endif
 
     // ====================  LIFECYCLE     =======================
 
     //--------------------------------------------------------------------------------------
     //       Class:  TEMReceiver
     //      Method:  TEMReceiver
-    // Description:  constructor (protected)
+    // Description:  constructor (locked)
     //--------------------------------------------------------------------------------------
-    TEMReceiver::TEMReceiver (const std::string& name) : ReceiverPoints(name), moment(1), referenceTime(0) {
+    TEMReceiver::TEMReceiver ( const ctor_key& key ) : FieldPoints(key), moment(1), referenceTime(0) {
 
     }  // -----  end of method TEMReceiver::TEMReceiver  (constructor)  -----
 
-#ifdef HAVE_YAMLCPP
     //--------------------------------------------------------------------------------------
     //       Class:  TEMReceiver
     //      Method:  TEMReceiver
     // Description:  constructor (protected)
     //--------------------------------------------------------------------------------------
-    TEMReceiver::TEMReceiver (const YAML::Node& node) : ReceiverPoints(node) {
+    TEMReceiver::TEMReceiver (const YAML::Node& node, const ctor_key& key) : FieldPoints(node, key) {
 
         moment = node["moment"].as<Real>();
         referenceTime = node["referenceTime"].as<Real>();
         noiseSTD      = node["noiseSTD"].as<VectorXr>();
         //location = node["location"].as<Vector3r>();
     }  // -----  end of method TEMReceiver::TEMReceiver  (constructor)  -----
-#endif
 
     //--------------------------------------------------------------------------------------
     //       Class:  TEMReceiver
     //      Method:  New()
     // Description:  public constructor
     //--------------------------------------------------------------------------------------
-    TEMReceiver* TEMReceiver::New() {
-        TEMReceiver*  Obj = new TEMReceiver("TEMReceiver");
-        Obj->AttachTo(Obj);
-        return Obj;
+    std::shared_ptr<TEMReceiver> TEMReceiver::NewSP() {
+        return std::make_shared<TEMReceiver> ( ctor_key() );
     }
 
 
     //       Class:  TEMReceiver
     //      Method:  Clone
     //--------------------------------------------------------------------------------------
+/*
     TEMReceiver* TEMReceiver::Clone() {
         TEMReceiver* Copy = TEMReceiver::New();
             Copy->SetNumberOfReceivers( this->NumberOfReceivers );
             Copy->noiseSTD = this->noiseSTD;
         return Copy;
     }		// -----  end of method TEMReceiver::Clone  -----
+*/
 
     //--------------------------------------------------------------------------------------
     //       Class:  TEMReceiver
 
     //--------------------------------------------------------------------------------------
     //       Class:  TEMReceiver
-    //      Method:  Delete
-    // Description:  public destructor
-    //--------------------------------------------------------------------------------------
-    void TEMReceiver::Delete() {
-        this->DetachFrom(this);
-    }
-
-    //--------------------------------------------------------------------------------------
-    //       Class:  TEMReceiver
-    //      Method:  Release
-    // Description:  destructor (protected)
-    //--------------------------------------------------------------------------------------
-    void TEMReceiver::Release() {
-        delete this;
-    }
-
-
-    //--------------------------------------------------------------------------------------
-    //       Class:  TEMReceiver
     //      Method:  SetWindows
     //--------------------------------------------------------------------------------------
     void TEMReceiver::SetWindows ( const VectorXr& centres, const VectorXr& widths, const TIMEUNITS& Units ) {
     //      Method:  SampleNoise
     //--------------------------------------------------------------------------------------
     VectorXr TEMReceiver::SampleNoise (  ) {
-        
-	/* we have C++-11 now! No Boost! 
+
+	/* we have C++-11 now! No Boost!
         boost::mt19937 rng(time(0));
         boost::normal_distribution<> nd(0.0, 1.0);
         boost::variate_generator<boost::mt19937&, boost::normal_distribution<> > var_nor(rng, nd);
 	*/
 
         std::random_device rd;
-        std::mt19937 gen(rd()); 
+        std::mt19937 gen(rd());
         std::normal_distribution<> d(0.0, 1.00);
 
         VectorXr noise = VectorXr::Zero( windowCentres.size() );
     //      Method:  SetLocation
     //--------------------------------------------------------------------------------------
     void TEMReceiver::SetRxLocation ( const Vector3r& loc ) {
-        this->SetNumberOfReceivers(1); // Valgrind doesn't like??
+        this->SetNumberOfPoints(1); // Valgrind doesn't like??
         this->SetLocation(0, loc);
         //location = loc;
         return ;
     }		// -----  end of method TEMReceiver::GetReferenceTime  -----
 
 
-#ifdef HAVE_YAMLCPP
     //--------------------------------------------------------------------------------------
     //       Class:  TEMReceiver
     //      Method:  Serialize
     //--------------------------------------------------------------------------------------
     YAML::Node  TEMReceiver::Serialize (  ) const {
-        YAML::Node node = ReceiverPoints::Serialize();
-        node.SetTag( this->Name );
+        YAML::Node node = FieldPoints::Serialize();
+        node.SetTag( GetName() );
         node["moment"] = moment;
         node["referenceTime"] = referenceTime;
         node["component"] = enum2String(component);
     //       Class:  TEMReceiver
     //      Method:  DeSerialize
     //--------------------------------------------------------------------------------------
-    TEMReceiver* TEMReceiver::DeSerialize ( const YAML::Node& node  ) {
-        TEMReceiver* Object = new TEMReceiver(node);
-        Object->AttachTo(Object);
-        DESERIALIZECHECK( node, Object )
-        return Object ;
-
+    std::shared_ptr<TEMReceiver> TEMReceiver::DeSerialize ( const YAML::Node& node  ) {
+        if (node.Tag() != "TEMReceiver") {
+            throw  DeSerializeTypeMismatch( "TEMReceiver", node.Tag());
+        }
+        return std::make_shared<TEMReceiver> ( node, ctor_key() );
     }		// -----  end of method TEMReceiver::DeSerialize  -----
-#endif
 
 }		// -----  end of Lemma  name  -----