Cleaning up Doxygen warnings, and added DCIP Module

Modules/DCIP/CMakeLists.txt

+# Configure EMSchur3D 
+set(DCIP_VERSION_MAJOR "0")
+set(DCIP_VERSION_MINOR "0")
+set(DCIP_VERSION_PATCH "1")
+set(DCIP_VERSION "\"${DCIP_VERSION_MAJOR}.${DCIP_VERSION_MINOR}.${DCIP_VERSION_PATCH}\"")
+set(DCIP_VERSION_NOQUOTES "${DCIP_VERSION_MAJOR}.${DCIP_VERSION_MINOR}.${DCIP_VERSION_PATCH}")
+
+option ( LEMMA_MODULE_DCIP TRUE )
+
+configure_file (
+	"${CMAKE_CURRENT_SOURCE_DIR}/config/DCIPConfig.h.in"
+	"${PROJECT_BINARY_DIR}/include/DCIPConfig.h"
+	)
+install ( FILES  ${PROJECT_BINARY_DIR}/include/EMSchur3DConfig.h   DESTINATION ${CMAKE_INSTALL_PREFIX}/include/Lemma/ )
+
+	add_subdirectory("src")
+	add_library( dcip ${DCIPSOURCE} )  
+	target_include_directories( dcip PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include" )
+
+	set_target_properties(dcip PROPERTIES 
+		VERSION  "${DCIP_VERSION_NOQUOTES}"
+		SOVERSION "${DCIP_VERSION_MAJOR}.${LEMMA_VERSION_MINOR}"
+		PROJECT_LABEL "DCIP ${LABEL_SUFFIX}"
+    	CXX_STANDARD_14
+    	CXX_STANDARD_REQUIRED_ON
+	)
+
+	# Linking
+	target_link_libraries(dcip "lemmacore" "fdem1d" )
+
+	# Linking
+	target_link_libraries(dcip ${VTK_LIBRARIES})
+
+	# Testing
+	#if (LEMMA_ENABLE_TESTING)
+	#	add_subdirectory(testing)
+	#endif()
+
+	# Install
+	install ( TARGETS dcip DESTINATION ${CMAKE_INSTALL_PREFIX}/lib )
+	install ( FILES include/EMSchur3D  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/LemmaCore/examples/utSkyTEM.cpp → Modules/DCIP/config/DCIPConfig.h.in

 
 /**
  * @file
- * @date      02/27/2015 11:02:43 AM
+ * @date      10/23/2018 01:57:40 PM
  * @version   $Id$
  * @author    Trevor Irons (ti)
- * @email     Trevor.Irons@xri-geo.com
- * @copyright Copyright (c) 2015, XRI Geophysics, LLC
- * @copyright Copyright (c) 2015, Trevor Irons
+ * @email     Trevor.Irons@utah.edu
+ * @copyright Copyright (c) 2018, University of Utah
+ * @copyright Copyright (c) 2018, Lemma Software, LLC
  */
 
-// SkyTEM forward modelling programme
-
-#include "TEMSurvey.h"
-
-int main() {
-
-    std::cout << "SkyTEM modelling\n";
-
-
-
-}
-
+#define DCIP_VERSION_MAJOR @DCIP_VERSION_MAJOR@
+#define DCIP_VERSION_MINOR @DCIP_VERSION_MINOR@
+#define DCIP_VERSION_PATCH @DCIP_VERSION_PATCH@
+#define DCIP_VERSION @DCIP_VERSION@

Modules/DCIP/include/DCIPElectrode.h

 namespace Lemma {
 
     /**
-      \brief
-      \details
+      \brief    Describes the location of an electrode used in a DC/IP survey
+      \details  This class is used together with FEM4EllipticPDE to solve DC/IP
+                problems.
      */
     class DCIPElectrode : public LemmaObject {
 
         // ====================  LIFECYCLE     =======================
 
         /**
-         * @copybrief LemmaObject::New()
-         * @copydetails LemmaObject::New()
+         * \brief   Returns new shared pointer to DCIP object.
+         * \details Use this method, as the default constructor is locked.
          */
-        static DCIPElectrode* New();
+        static std::shared_ptr<DCIPElectrode> NewSP();
 
         /**
-         *  @copybrief   LemmaObject::Delete()
-         *  @copydetails LemmaObject::Delete()
+         *  Uses YAML to serialize this object.
+         *  @return a YAML::Node
          */
-        void Delete();
+        YAML::Node Serialize() const;
+
+        /**
+         *   Constructs an object from a YAML::Node.
+         */
+        static std::shared_ptr<DCIPElectrode> DeSerialize(const YAML::Node& node);
+
+        /** Default protected constructor, use New */
+        explicit DCIPElectrode (const ctor_key& key);
+
+        /** Protected DeDerializing constructor, use factory DeSerialize  method*/
+        DCIPElectrode (const YAML::Node& node, const ctor_key& key);
+
+        /** Default protected destructor, use Delete */
+        virtual ~DCIPElectrode ();
 
         // ====================  OPERATORS     =======================
 
         int GetNodeID() {return Node_ID;}
         // ====================  INQUIRY       =======================
 
-#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 DCIPElectrode* DeSerialize(const YAML::Node& node);
-#endif
+        /** Returns the name of the underlying class, similiar to Python's type */
+        virtual std::string GetName() const {
+            return this->CName;
+        }
 
         protected:
 
         // ====================  LIFECYCLE     =======================
 
-        /** Default protected constructor, use New */
-        DCIPElectrode (const std::string& name);
-
-#ifdef HAVE_YAMLCPP
-        /** Protected DeDerializing constructor, use factory DeSerialize  method*/
-        DCIPElectrode (const YAML::Node& node);
-#endif
-
-        /** Default protected destructor, use Delete */
-        ~DCIPElectrode ();
-
-        /**
-         *  @copybrief   LemmaObject::Release()
-         *  @copydetails LemmaObject::Release()
-         */
-        void Release();
-
         private:
 
         // ====================  DATA MEMBERS  =========================
 
+        /** ASCII string representation of the class name */
+        static constexpr auto CName = "DCIPElectrode";
+
+        /** no copy */
+        DCIPElectrode ( const DCIPElectrode& ) = delete;
+
         /** The location of the electrode */
         Vector3r Location;
 

Modules/DCIP/include/DCSurvey.h

 /**
  * @file
  * @date      10/08/2014 01:51:50 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@lemmasoftware.org
+ * @copyright Copyright (c) 2014, 2018 Trevor Irons
  */
 
 #ifndef  DCSURVEY
 #include "LemmaObject.h"
 #include "DCIPElectrode.h"
 
-#ifdef HAVE_YAMLCPP
-#include "yaml-cpp/yaml.h"
-#endif
-
 #ifdef LEMMAUSEVTK
 #include <vtkDataSet.h>
 #endif
         // ====================  LIFECYCLE     =======================
 
         /**
-         * @copybrief LemmaObject::New()
-         * @copydetails LemmaObject::New()
+         * \brief   Returns new shared pointer to DCIP object.
+         * \details Use this method, as the default constructor is locked.
          */
-        static DCSurvey* New();
+        static std::shared_ptr<DCSurvey> NewSP();
 
         /**
-         *  @copybrief   LemmaObject::Delete()
-         *  @copydetails LemmaObject::Delete()
+         *  Uses YAML to serialize this object.
+         *  @return a YAML::Node
          */
-        void Delete();
+        YAML::Node Serialize() const;
+
+        /**
+         *   Constructs an object from a YAML::Node.
+         */
+        static std::shared_ptr<DCSurvey> DeSerialize(const YAML::Node& node);
+
+        /** Default protected constructor, use New */
+        explicit DCSurvey (const ctor_key& key);
+
+        /** Default protected constructor, use New */
+        DCSurvey (const YAML::Node& node, const ctor_key& key);
+
+        /** Default protected destructor, use Delete */
+        virtual ~DCSurvey ();
 
         // ====================  OPERATORS     =======================
 
          *   @param[in] label is an optional tag for electrode.
          *   @param[in] nodeID is the optional node ID on a mesh
          */
-        int PoundElectrode( DCIPElectrode* Electrode, const std::string& label = "NULL", const int& nodeID=-1 );
+        int PoundElectrode( std::shared_ptr<DCIPElectrode> Electrode, const std::string& label = "NULL", const int& nodeID=-1 );
 
         /** Alternative Factory method of setting electrodes. IN this manner all memoy management
          *  is handled by DCSurvey.
          *  @param[in] label is an optional label for electrode.
          *  @param[in] nodeID is the optional node ID on a mesh
          */
-        DCIPElectrode* PoundElectrode( const Vector3r& loc, const std::string& label = "NULL", const int& nodeID=-1  );
+        std::shared_ptr<DCIPElectrode> PoundElectrode( const Vector3r& loc, const std::string& label = "NULL", const int& nodeID=-1  );
 
 #ifdef LEMMAUSEVTK
-        DCIPElectrode* PoundElectrode( const int& nodeID, vtkDataSet* Mesh, const std::string& label = "NULL" );
+        std::shared_ptr<DCIPElectrode> PoundElectrode( const int& nodeID, vtkDataSet* Mesh, const std::string& label = "NULL" );
 #endif
 
         /**
          *   @param[in] J is the current intensity
          *   @see AddInjection(const int& iA, const int& iB, const Real& J)
          *   @see AddInjection(const int& iA, const Real& J)
-         *   @see AddInjection(DCIPElectrode* A, const Real& J)
+         *   @see AddInjection(std::shared_ptr<DCIPElectrode> A, const Real& J)
          */
-        int AddInjection( DCIPElectrode* A, DCIPElectrode* B, const Real& J);
+        int AddInjection( std::shared_ptr<DCIPElectrode> A, std::shared_ptr<DCIPElectrode> B, const Real& J);
 
         /**
          *   Adds an injection point.
          *   B,  the negative current electrode is taken to be infinity
          *   @see AddInjection(const int& iA, const int& iB, const Real& J)
          *   @see AddInjection(const int& iA, const Real& J)
-         *   @see AddInjection(DCIPElectrode* A, DCIPElectrode* B, const Real& J)
+         *   @see AddInjection(std::shared_ptr<DCIPElectrode> A, std::shared_ptr<DCIPElectrode> B, const Real& J)
          */
-        int AddInjection( DCIPElectrode* A, const Real& J );
+        int AddInjection( std::shared_ptr<DCIPElectrode> A, const Real& J );
 
         /**
          *   Adds an injection point.
          *   @param[in] A is the positive current electrode index
          *   @param[in] B is the negative current electrode index
          *   @param[in] J is the current intensity
-         *   @see AddInjection(DCIPElectrode* A, DCIPElectrode* B, const Real& J)
-         *   @see AddInjection(DCIPElectrode* A, const Real& J)
+         *   @see AddInjection(std::shared_ptr<DCIPElectrode> A, std::shared_ptr<DCIPElectrode> B, const Real& J)
+         *   @see AddInjection(std::shared_ptr<DCIPElectrode> A, const Real& J)
          *   @see AddInjection(const int& iA, const Real& J)
          */
         int AddInjection( const int& iA, const int& iB, const Real& J );
          *   Adds an injection point with the negative electrode at infinity.
          *   @param[in] A is the positive current electrode index
          *   @param[in] J is the current intensity
-         *   @see AddInjection(DCIPElectrode* A, DCIPElectrode* B, const Real& J)
-         *   @see AddInjection(DCIPElectrode* A, const Real& J)
+         *   @see AddInjection(std::shared_ptr<DCIPElectrode> A, std::shared_ptr<DCIPElectrode> B, const Real& J)
+         *   @see AddInjection(std::shared_ptr<DCIPElectrode> A, const Real& J)
          *   @see AddInjection(const int& iA, const int& iB, const Real& J)
          */
         int AddInjection( const int& iA, const Real& J );
          *   @param[in] N is a pointer to the `negative' electrode
          *   @param[in] iJ is the current injection index to associate with this measurement
          */
-        void AddMeasurement( const int& iJ, DCIPElectrode* M, DCIPElectrode* N );
+        void AddMeasurement( const int& iJ, std::shared_ptr<DCIPElectrode> M, std::shared_ptr<DCIPElectrode> N );
 
         /** Adds a potential measurement via the electrode pair comparison \f$ M - N \f$.
          *   @param[in] M is the `positive' electrode string label name
          *   @param[in] N is the `negative' electrode string label name
          *   @param[in] iJ is the current injection index to associate with this measurement
-         *   @see AddMeasurement( const int& iJ, DCIPElectrode* M, DCIPElectrode* N )
+         *   @see AddMeasurement( const int& iJ, std::shared_ptr<DCIPElectrode> M, std::shared_ptr<DCIPElectrode> N )
          */
         void AddMeasurement( const int& ij, const std::string& M, const std::string& N);
 
 
         // ====================  INQUIRY       =======================
 
-        #ifdef HAVE_YAMLCPP
-        YAML::Node Serialize() const;
-        static DCSurvey* DeSerialize(const YAML::Node& node);
-        #endif
-
         protected:
 
         // ====================  LIFECYCLE     =======================
 
-        /** Default protected constructor, use New */
-        DCSurvey (const std::string& name);
-
-        #ifdef HAVE_YAMLCPP
-        /** Default protected constructor, use New */
-        DCSurvey (const YAML::Node& node);
-        #endif
-
-        /** Default protected destructor, use Delete */
-        ~DCSurvey ();
-
-        /**
-         *  @copybrief   LemmaObject::Release()
-         *  @copydetails LemmaObject::Release()
-         */
-        void Release();
-
         private:
 
         // ====================  DATA MEMBERS  =========================
 
+        /** ASCII string representation of the class name */
+        static constexpr auto CName = "DCSurvey";
+
+        /** no copy */
+        DCSurvey ( const DCSurvey& ) = delete;
+
         /** The electrodes */
-        std::vector<DCIPElectrode*>                Electrodes;
+        std::vector< std::shared_ptr<DCIPElectrode> >                Electrodes;
 
         /** Tags for the electrodes, lines etc. Ordered with Electrodes std::vector */
         std::vector<std::string>                   OrderedElectrodeLabels;
 
         /** Map of tags for the electrodes, lines etc. */
-        std::map<std::string, std::pair<DCIPElectrode*, int> >      ElectrodeLabelMap;
+        std::map<std::string, std::pair< std::shared_ptr<DCIPElectrode>, int> >      ElectrodeLabelMap;
 
         /** The A Injection electrodes */
         std::vector<int>     A_Electrodes;

Modules/DCIP/src/CMakeLists.txt

+set (DCIPSOURCE
+	
+	${CMAKE_CURRENT_SOURCE_DIR}/DCIPElectrode.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/DCSurvey.cpp
+	
+	PARENT_SCOPE
+)

Modules/DCIP/src/DCIPElectrode.cpp

 
 
     // ====================  FRIEND METHODS  =====================
-#ifdef HAVE_YAMLCPP
+
     std::ostream &operator << (std::ostream &stream, const DCIPElectrode &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulate thingy
-        return stream;
-    }
-#else
-    std::ostream &operator<<(std::ostream &stream, const DCIPElectrode& ob) {
-        stream << *(LemmaObject*)(&ob);
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
-#endif
 
     // ====================  LIFECYCLE     =======================
 
     //--------------------------------------------------------------------------------------
     //       Class:  DCIPElectrode
     //      Method:  DCIPElectrode
-    // Description:  constructor (protected)
+    // Description:  constructor (locked)
     //--------------------------------------------------------------------------------------
-    DCIPElectrode::DCIPElectrode (const std::string& name) : LemmaObject(name), Node_ID(-1), Label(std::string("None")) {
+    DCIPElectrode::DCIPElectrode (const ctor_key& key) :
+            LemmaObject(key), Node_ID(-1), Label(std::string("None")) {
 
     }  // -----  end of method DCIPElectrode::DCIPElectrode  (constructor)  -----
 
-#ifdef HAVE_YAMLCPP
     //--------------------------------------------------------------------------------------
     //       Class:  DCIPElectrode
     //      Method:  DCIPElectrode
-    // Description:  DeSerializing constructor (protected)
+    // Description:  DeSerializing constructor (locked)
     //--------------------------------------------------------------------------------------
-    DCIPElectrode::DCIPElectrode (const YAML::Node& node) : LemmaObject(node) {
-        if (node.Tag() != this->Name) {
+    DCIPElectrode::DCIPElectrode (const YAML::Node& node, const ctor_key& key) : LemmaObject(node, key) {
+        if (node.Tag() != DCIPElectrode::CName) {
             throw std::runtime_error("In DCIPElectrode(node), node is of wrong type");
         }
         this->Location = node["Location"].as<Vector3r>();
         this->Node_ID = node["Node_ID"].as<int>();
         this->Label = node["Label"].as<std::string>();
     }  // -----  end of method DCIPElectrode::DCIPElectrode  (constructor)  -----
-#endif
 
     //--------------------------------------------------------------------------------------
     //       Class:  DCIPElectrode
     //      Method:  New()
     // Description:  public constructor
     //--------------------------------------------------------------------------------------
-    DCIPElectrode* DCIPElectrode::New() {
-        DCIPElectrode*  Obj = new DCIPElectrode("DCIPElectrode");
-        Obj->AttachTo(Obj);
-        return Obj;
+    std::shared_ptr<DCIPElectrode> DCIPElectrode::NewSP() {
+        return std::make_shared<DCIPElectrode>( ctor_key() );
     }
 
     //--------------------------------------------------------------------------------------
 
     //--------------------------------------------------------------------------------------
     //       Class:  DCIPElectrode
-    //      Method:  Delete
-    // Description:  public destructor
-    //--------------------------------------------------------------------------------------
-    void DCIPElectrode::Delete() {
-        this->DetachFrom(this);
-    }
-
-    //--------------------------------------------------------------------------------------
-    //       Class:  DCIPElectrode
-    //      Method:  Release
-    // Description:  destructor (protected)
-    //--------------------------------------------------------------------------------------
-    void DCIPElectrode::Release() {
-        delete this;
-    }
-
-
-#ifdef HAVE_YAMLCPP
-    //--------------------------------------------------------------------------------------
-    //       Class:  DCIPElectrode
     //      Method:  Serialize
     //--------------------------------------------------------------------------------------
     YAML::Node  DCIPElectrode::Serialize (  ) const {
         YAML::Node node = LemmaObject::Serialize();
-        node.SetTag( this->Name );
+        node.SetTag( this->GetName() );
         // FILL IN CLASS SPECIFICS HERE
         node["Location"] = Location;
         node["Node_ID"] = Node_ID;
         return node;
     }		// -----  end of method DCIPElectrode::Serialize  -----
 
-
     //--------------------------------------------------------------------------------------
     //       Class:  DCIPElectrode
     //      Method:  DeSerialize
     //--------------------------------------------------------------------------------------
-    DCIPElectrode* DCIPElectrode::DeSerialize ( const YAML::Node& node  ) {
-        DCIPElectrode* Object = new DCIPElectrode(node);
-        Object->AttachTo(Object);
-        DESERIALIZECHECK( node, Object )
-        return Object ;
+    std::shared_ptr<DCIPElectrode> DCIPElectrode::DeSerialize ( const YAML::Node& node  ) {
+        if ( node.Tag() != DCIPElectrode::CName ) {
+            throw  DeSerializeTypeMismatch( DCIPElectrode::CName, node.Tag());
+        }
+        return std::make_shared< DCIPElectrode > ( node, ctor_key() );
     }		// -----  end of method DCIPElectrode::DeSerialize  -----
-#endif
-
 
     //--------------------------------------------------------------------------------------
     //       Class:  DCIPElectrode

Modules/DCIP/src/DCSurvey.cpp

 /**
  * @file
  * @date      10/08/2014 01:52:04 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@lemmasoftware.org
+ * @copyright Copyright (c) 2014, 2018 Trevor Irons
  */
 
 #include	"DCSurvey.h"
 
 namespace Lemma {
 
-
     // ====================  FRIEND METHODS  =====================
 
-    #ifdef HAVE_YAMLCPP
     std::ostream &operator << (std::ostream &stream, const DCSurvey &ob) {
-        stream << ob.Serialize()  << "\n---\n"; // End of doc --- a direct stream should encapsulate object
-        return stream;
-    }
-    #else
-    std::ostream &operator<<(std::ostream &stream, const DCSurvey &ob) {
-        stream << *(LemmaObject*)(&ob);
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
-    #endif
 
     // ====================  LIFECYCLE     =======================
 
     //      Method:  DCSurvey
     // Description:  constructor (protected)
     //--------------------------------------------------------------------------------------
-    DCSurvey::DCSurvey (const std::string& name) : LemmaObject(name) {
+    DCSurvey::DCSurvey (const ctor_key& key) : LemmaObject(key) {
 
     }  // -----  end of method DCSurvey::DCSurvey  (constructor)  -----
 
     //      Method:  DCSurvey
     // Description:  DeSerializing constructor (protected)
     //--------------------------------------------------------------------------------------
-    #ifdef HAVE_YAMLCPP
-    DCSurvey::DCSurvey (const YAML::Node& node) : LemmaObject(node) {
+    DCSurvey::DCSurvey (const YAML::Node& node, const ctor_key& key) : LemmaObject(node, key) {
 
         if (node.Tag() != "DCSurvey") {
             throw std::runtime_error("DCSurvey->DeSerialize cannot deserialize non-DCSurvey");
         for(YAML::const_iterator it=node["Electrodes"].begin(); it!=node["Electrodes"].end(); ++it) {
             std::string e = it->first.as<std::string>();
             Electrodes.push_back( DCIPElectrode::DeSerialize( node["Electrodes"][e] ) );
-            Electrodes[Electrodes.size()-1]->AttachTo(this);
             eMap[ node["Electrodes"][Electrodes.size()-1] ] = Electrodes.size() -1 ;
             OrderedElectrodeLabels.push_back(e);
-            ElectrodeLabelMap[e] = std::pair<DCIPElectrode*, int>(Electrodes[Electrodes.size()-1], Electrodes.size()-1);
+            ElectrodeLabelMap[e] = std::pair< std::shared_ptr<DCIPElectrode>, int>(Electrodes[Electrodes.size()-1], Electrodes.size()-1);
         }
 
         //std::cout << "J-0\n" << node["Injections"]["J-0"] << std::endl;
         }
 
     }  // -----  end of method DCSurvey::DCSurvey  (constructor)  -----
-    #endif
 
     //--------------------------------------------------------------------------------------
     //       Class:  DCSurvey
     //      Method:  New()
     // Description:  public constructor
     //--------------------------------------------------------------------------------------
-    DCSurvey* DCSurvey::New() {
-        DCSurvey*  Obj = new DCSurvey("DCSurvey");
-        Obj->AttachTo(Obj);
-        return Obj;
+    std::shared_ptr<DCSurvey> DCSurvey::NewSP() {
+        return std::make_shared<DCSurvey>( ctor_key() );
     }
 
     //--------------------------------------------------------------------------------------
 
     //--------------------------------------------------------------------------------------
     //       Class:  DCSurvey
-    //      Method:  Delete
-    // Description:  public destructor
-    //--------------------------------------------------------------------------------------
-    void DCSurvey::Delete() {
-        this->DetachFrom(this);
-    }
-
-    //--------------------------------------------------------------------------------------
-    //       Class:  DCSurvey
-    //      Method:  Release
-    // Description:  destructor (protected)
-    //--------------------------------------------------------------------------------------
-    void DCSurvey::Release() {
-        this->PullElectrodes();
-        delete this;
-    }
-
-    #ifdef HAVE_YAMLCPP
-    //--------------------------------------------------------------------------------------
-    //       Class:  DCSurvey
     //      Method:  Serialize
     //--------------------------------------------------------------------------------------
     YAML::Node  DCSurvey::Serialize (  ) const {
         YAML::Node node = LemmaObject::Serialize();
-        node.SetTag( this->Name );
+        node.SetTag( this->GetName() );
         node["NumberOfElectrodes"] = Electrodes.size();
 
         // All the electrodes
-        for (std::map<std::string, std::pair<DCIPElectrode*, int> >::const_iterator it  = ElectrodeLabelMap.begin();
+        for (std::map<std::string, std::pair< std::shared_ptr<DCIPElectrode>, int> >::const_iterator it  = ElectrodeLabelMap.begin();
                                                                                     it != ElectrodeLabelMap.end(); ++it) {
             node["Electrodes"][ it->first ] = it->second.first->Serialize();
         }
         return node;
     }		// -----  end of method DCSurvey::Serialize  -----
 
-
     //--------------------------------------------------------------------------------------
     //       Class:  DCSurvey
     //      Method:  DeSerialize
     //--------------------------------------------------------------------------------------
-    DCSurvey* DCSurvey::DeSerialize ( const YAML::Node& node  ) {
-        DCSurvey* Object = new DCSurvey(node);
-        Object->AttachTo(Object);
-        DESERIALIZECHECK( node, Object )
-        return Object ;
+    std::shared_ptr<DCSurvey> DCSurvey::DeSerialize ( const YAML::Node& node  ) {
+        if ( node.Tag() != DCSurvey::CName ) {
+            throw  DeSerializeTypeMismatch( DCSurvey::CName, node.Tag());
+        }
+        return std::make_shared< DCSurvey > ( node, ctor_key() );
     }		// -----  end of method DCSurvey::DeSerialize  -----
-    #endif
 
     //--------------------------------------------------------------------------------------
     //       Class:  DCSurvey
     //      Method:  PoundElectrode
     //--------------------------------------------------------------------------------------
-    int DCSurvey::PoundElectrode ( DCIPElectrode* Electrode, const std::string& tag, const int&nodeID ) {
+    int DCSurvey::PoundElectrode ( std::shared_ptr<DCIPElectrode> Electrode, const std::string& tag, const int&nodeID ) {
         Electrodes.push_back(Electrode);
         if (tag != "NULL") {
             OrderedElectrodeLabels.push_back(tag);
             //ElectrodeTagMap[tag] = Electrode;
-            ElectrodeLabelMap[tag] = std::pair<DCIPElectrode*, int> (Electrode, Electrodes.size()-1);
+            ElectrodeLabelMap[tag] = std::pair< std::shared_ptr<DCIPElectrode>, int> (Electrode, Electrodes.size()-1);
             Electrode->SetLabel(tag);
         } else {
             OrderedElectrodeLabels.push_back( std::string("E") + to_string(Electrodes.size()-1) );
             //ElectrodeTagMap[std::string("E") + to_string(Electrodes.size()-1)] = Electrode;
             ElectrodeLabelMap[std::string("E") + to_string(Electrodes.size()-1)] =
-                std::pair<DCIPElectrode*, int>(Electrode, Electrodes.size()-1);
+                std::pair< std::shared_ptr<DCIPElectrode>, int>(Electrode, Electrodes.size()-1);
             Electrode->SetLabel( std::string("E") + to_string(Electrodes.size()-1) );
         }
-        Electrode->AttachTo(this);
         return  static_cast<int>( Electrodes.size() ) ;
     }		// -----  end of method DCSurvey::PoundElectrode  -----
 
     //       Class:  DCSurvey
     //      Method:  PoundElectrode
     //--------------------------------------------------------------------------------------
-    DCIPElectrode* DCSurvey::PoundElectrode ( const Vector3r& loc, const std::string& tag, const int& nodeID ) {
-        DCIPElectrode* Electrode = DCIPElectrode::New();
+    std::shared_ptr<DCIPElectrode> DCSurvey::PoundElectrode ( const Vector3r& loc, const std::string& tag, const int& nodeID ) {
+        auto Electrode = DCIPElectrode::NewSP();
             Electrode->SetLocation( loc );
         Electrodes.push_back(Electrode);
         if (tag != "NULL") {
             OrderedElectrodeLabels.push_back(tag);
-            ElectrodeLabelMap[tag] = std::pair<DCIPElectrode*, int> (Electrode, Electrodes.size()-1);
+            ElectrodeLabelMap[tag] = std::pair< std::shared_ptr<DCIPElectrode>, int> (Electrode, Electrodes.size()-1);
             Electrode->SetLabel(tag);
         } else {
             OrderedElectrodeLabels.push_back( std::string("E") + to_string(Electrodes.size()-1) );
             ElectrodeLabelMap[std::string("E") + to_string(Electrodes.size()-1)] =
-                std::pair<DCIPElectrode*, int>(Electrode, Electrodes.size()-1);
+                std::pair< std::shared_ptr<DCIPElectrode>, int>(Electrode, Electrodes.size()-1);
             Electrode->SetLabel( std::string("E") + to_string(Electrodes.size()-1) );
         }
-        Electrode->AttachTo(this);
         return  Electrode;
     }		// -----  end of method DCSurvey::PoundElectrode  -----
 
     //      Method:  PoundElectrode
     //--------------------------------------------------------------------------------------
 #ifdef LEMMAUSEVTK
-    DCIPElectrode* DCSurvey::PoundElectrode( const int& nodeID, vtkDataSet* Mesh, const std::string& tag ) {
-        DCIPElectrode* Electrode = DCIPElectrode::New();
+    std::shared_ptr<DCIPElectrode> DCSurvey::PoundElectrode( const int& nodeID, vtkDataSet* Mesh, const std::string& tag ) {
+        auto Electrode = DCIPElectrode::NewSP();
         double* loc = Mesh->GetPoint(nodeID);
         Electrode->SetLocation( Vector3r(loc[0], loc[1], loc[2]) );
         Electrodes.push_back(Electrode);
         if (tag != "NULL") {
             OrderedElectrodeLabels.push_back(tag);
-            ElectrodeLabelMap[tag] = std::pair<DCIPElectrode*, int> (Electrode, Electrodes.size()-1);
+            ElectrodeLabelMap[tag] = std::pair< std::shared_ptr<DCIPElectrode>, int> (Electrode, Electrodes.size()-1);
             Electrode->SetLabel(tag);
         } else {
             OrderedElectrodeLabels.push_back( std::string("E") + to_string(Electrodes.size()-1) );
             ElectrodeLabelMap[std::string("E") + to_string(Electrodes.size()-1)] =
-                std::pair<DCIPElectrode*, int>(Electrode, Electrodes.size()-1);
+                std::pair< std::shared_ptr<DCIPElectrode>, int>(Electrode, Electrodes.size()-1);
             Electrode->SetLabel( std::string("E") + to_string(Electrodes.size()-1) );
         }
-        Electrode->AttachTo(this);
         return Electrode;
     }		// -----  end of method DCSurvey::PoundElectrode  -----
 #endif
     //      Method:  PullElectrodes
     //--------------------------------------------------------------------------------------
     void DCSurvey::PullElectrodes (  ) {
-        for (std::vector<DCIPElectrode*>::iterator it = Electrodes.begin() ; it != Electrodes.end(); ++it) {
-            (*it)->DetachFrom(this);
-        }
         Electrodes.clear();
         OrderedElectrodeLabels.clear();
         ElectrodeLabelMap.clear();
     //       Class:  DCSurvey
     //      Method:  AddInjection
     //--------------------------------------------------------------------------------------
-    int DCSurvey::AddInjection ( DCIPElectrode* A, DCIPElectrode* B, const Real& J ) {
+    int DCSurvey::AddInjection ( std::shared_ptr<DCIPElectrode> A, std::shared_ptr<DCIPElectrode> B, const Real& J ) {
         bool fA = false;
         bool fB = false;
         for (unsigned int i=0; i<Electrodes.size(); ++i) {
     //       Class:  DCSurvey
     //      Method:  AddMeasurement
     //--------------------------------------------------------------------------------------
-    void DCSurvey::AddMeasurement ( const int& iJ, DCIPElectrode* M, DCIPElectrode* N  ) {
+    void DCSurvey::AddMeasurement ( const int& iJ, std::shared_ptr<DCIPElectrode> M, std::shared_ptr<DCIPElectrode> N  ) {
         bool fM = false;
         bool fN = false;
         for (unsigned int i=0; i<Electrodes.size(); ++i) {
 
     void DCSurvey::AddMeasurement ( const int& iJ, const std::string& M, const std::string& N ) {
 
-        std::pair<DCIPElectrode*, int> Mp = ElectrodeLabelMap[M];
-        std::pair<DCIPElectrode*, int> Np = ElectrodeLabelMap[N];
+        std::pair< std::shared_ptr<DCIPElectrode>, int> Mp = ElectrodeLabelMap[M];
+        std::pair< std::shared_ptr<DCIPElectrode>, int> Np = ElectrodeLabelMap[N];
 
         if (Mp.first == NULL) {
             throw std::runtime_error( "Injection point M not found" );

Modules/FDEM1D/include/FHTKey101.h

         ~FHTKey101 ();
 
         /**
-         * @copybrief LemmaObject::New()
-         * @copydetails LemmaObject::New()
+         * \brief   returns shared_ptr with new object
+         * \details Use this method as default constructor is locked.
          */
         static std::shared_ptr<FHTKey101> NewSP();
 

Modules/FDEM1D/include/GroundedElectricDipole.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      01/29/2014 06:59:39 AM
- * @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
- */
-
-
-#ifndef  GROUNDEDELECTRICDIPOLE_INC
-#define  GROUNDEDELECTRICDIPOLE_INC
-
-#include "dipolesource.h"
-
-namespace Lemma {
-
-    /**
-      \ingroup FDEM1D
-      \brief   Grounded electric dipole
-      \details Used to model an idealised grounded electrid dipole of arbitrary
-               polarisation.
-     */
-    class GroundedElectricDipole : public DipoleSource {
-
-        friend std::ostream &operator<<(std::ostream &stream,
-                const GroundedElectricDipole &ob);
-
-        public:
-
-        // ====================  LIFECYCLE     =======================
-
-        /**
-         * @copybrief LemmaObject::New()
-         * @copydetails LemmaObject::New()
-         */
-        static GroundedElectricDipole* New();
-
-        /**
-         *  @copybrief   LemmaObject::Delete()
-         *  @copydetails LemmaObject::Delete()
-         */
-        void Delete();
-
-        // ====================  OPERATORS     =======================
-
-        // ====================  OPERATIONS    =======================
-
-        // ====================  ACCESS        =======================
-
-        // ====================  INQUIRY       =======================
-
-        protected:
-
-        // ====================  LIFECYCLE     =======================
-
-        /** Default protected constructor, use New */
-        GroundedElectricDipole (const std::string& name);
-
-        /** Default protected destructor, use Delete */
-        ~GroundedElectricDipole ();
-
-        /**
-         *  @copybrief   LemmaObject::Release()
-         *  @copydetails LemmaObject::Release()
-         */
-        void Release();
-
-        private:
-
-        // ====================  DATA MEMBERS  =========================
-
-    }; // -----  end of class  GroundedElectricDipole  -----
-
-}		// -----  end of Lemma  name  -----
-
-#endif   // ----- #ifndef GROUNDEDELECTRICDIPOLE_INC  -----
-

Modules/FDEM1D/include/KernelEM1DBase.h

     // ===================================================================
     //  Class:  KernelEM1DBase
     /**
-      @class
       \ingroup FDEM1D
       \brief   Pure virtual base class of KernelEm1D
       \details Defines interface for HankelTransform classes

Modules/FDEM1D/include/KernelEM1DManager.h

     // ===================================================================
     //  Class:  KernelEM1DManager
     /**
-      @class
       \ingroup FDEM1D
       \brief   Keeps track of Kernels for EM1D
       \details This class keeps track of the various types of kernel terms

Modules/FDEM1D/include/KernelEM1DReflBase.h

     // ===================================================================
     //  Class:  KernelEM1DReflBase
     /**
-      @class
       \ingroup FDEM1D
       \brief   Abstract class defining EM1DRefl class.
       \details Derived classes are template specialized for optimal performance.

Modules/FDEM1D/include/KernelEM1DReflSpec.h

     // ===================================================================
     //  Class:  KernelEM1DReflSpec
     /**
-      @class
       \ingroup FDEM1D
       \brief   Specialized version of KernelEM1DReflBase
       \details Through use of template specialisations, this KernelEm1D

Modules/FDEM1D/include/KernelEM1DSpec.h

     // ===================================================================
     //  Class:  KernelEM1DSpec
     /**
-      @class
       \ingroup FDEM1D
       \brief   Optimized version of KernelEm1D
       \details Through use of template specialisations, this KernelEm1D

Modules/FDEM1D/include/MagneticDipole.h

 namespace Lemma {
 
 /**
-  @class
   \ingroup FDEM1D
   \brief   Magnetic Dipole
   \details Used to model an idealised magnetic dipole of arbitrary

Modules/FDEM1D/include/digitalfilterintegrator.h

     // ===================================================================
     //  Class:  DigitalFilterIntegrator
     /**
-      @class
       \brief   Reimplimentation of Walt Anderson's digital filtering
                algorithms which are public domain.
       \details Walt Anderson wrote several routines for digital filtering

Modules/FDEM1D/include/integrationkernel.h

     // ===================================================================
     //  Class:  IntegrationKernel
     /**
-      @class
       \brief    Abstract class that computes arguments for numerical
                 integrators.
       \details  Needs to provide Argument function, as well as be able to

Modules/FDEM1D/include/inversesolver.h

     // ===================================================================
     //  Class:  InverseSolver
     /**
-      @class  InverseSolver
       \brief   Abstract class for inverse problem solver.
       \details General solution of inverse problems.
      */

Modules/FDEM1D/include/sintransintegrationkernel.h

     // ===================================================================
     //  Class:  SinTransIntegrationKernel
     /**
-      @class
       \brief    Integration kernel for testing sinine transform.
       \details  Evaluates sinine at the argument, using lagged convolution.
                 all of these kernels have exact solutions.

Modules/FDEM1D/src/GroundedElectricDipole.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/29/2014 07:05:13 AM
- * @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
- */
-
-#include "GroundedElectricDipole.h"
-
-
-namespace Lemma {
-
-    // ====================  FRIEND METHODS  =====================
-
-    std::ostream &operator<<(std::ostream &stream, const GroundedElectricDipole &ob) {
-
-        stream << *(DipoleSource*)(&ob);
-
-        return stream;
-    }
-
-    // ====================  LIFECYCLE     =======================
-
-    //--------------------------------------------------------------------------------------
-    //       Class:  GroundedElectricDipole
-    //      Method:  GroundedElectricDipole
-    // Description:  constructor (protected)
-    //--------------------------------------------------------------------------------------
-    GroundedElectricDipole::GroundedElectricDipole (const std::string& name) : DipoleSource(name) {
-
-    }  // -----  end of method GroundedElectricDipole::GroundedElectricDipole  (constructor)  -----
-
-
-    //--------------------------------------------------------------------------------------
-    //       Class:  GroundedElectricDipole
-    //      Method:  New()
-    // Description:  public constructor
-    //--------------------------------------------------------------------------------------
-    GroundedElectricDipole* GroundedElectricDipole::New() {
-        GroundedElectricDipole*  Obj = new GroundedElectricDipole("GroundedElectricDipole");
-        Obj->AttachTo(Obj);
-        return Obj;
-    }
-
-    //--------------------------------------------------------------------------------------
-    //       Class:  GroundedElectricDipole
-    //      Method:  ~GroundedElectricDipole
-    // Description:  destructor (protected)
-    //--------------------------------------------------------------------------------------
-    GroundedElectricDipole::~GroundedElectricDipole () {
-
-    }  // -----  end of method GroundedElectricDipole::~GroundedElectricDipole  (destructor)  -----
-
-    //--------------------------------------------------------------------------------------
-    //       Class:  GroundedElectricDipole
-    //      Method:  Delete
-    // Description:  public destructor
-    //--------------------------------------------------------------------------------------
-    void GroundedElectricDipole::Delete() {
-        this->DetachFrom(this);
-    }
-
-    //--------------------------------------------------------------------------------------
-    //       Class:  GroundedElectricDipole
-    //      Method:  Release
-    // Description:  destructor (protected)
-    //--------------------------------------------------------------------------------------
-    void GroundedElectricDipole::Release() {
-        delete this;
-    }
-
-}		// -----  end of Lemma  name  -----
-

Modules/LemmaCore/examples/utORS.cpp

-// ===========================================================================
-//
-//       Filename:  utdipolesource.cpp
-//
-//    Description:
-//
-//        Version:  0.0
-//        Created:  12/02/2009 11:57:14 AM
-//       Revision:  none
-//       Compiler:  g++ (c++)
-//
-//         Author:  Trevor Irons (ti)
-//
-//   Organisation:  Colorado School of Mines (CSM)
-//                  United States Geological Survey (USGS)
-//
-//          Email:  tirons@mines.edu, tirons@usgs.gov
-//
-//  This program is free software: you can redistribute it and/or modify
-//  it under the terms of the GNU General Public License as published by
-//  the Free Software Foundation, either version 3 of the License, or
-//  (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-// ===========================================================================
-
-#include <iostream>
-#include <fstream>
-
-#include "dipolesource.h"
-#include "layeredearth.h"
-#include "receiverpoints.h"
-#include "emearth1d.h"
-#include "WireAntenna.h"
-#include "PolygonalWireAntenna.h"
-
-#if  LEMMAUSEVTK
-#include "vtkRenderer.h"
-#include "vtkRenderWindow.h"
-#include "vtkRenderWindowInteractor.h"
-#include "vtkRenderLargeImage.h"
-#include "vtkPNGWriter.h"
-#include "vtkRectilinearGrid.h"
-#include "vtkXMLRectilinearGridWriter.h"
-#include "vtkDoubleArray.h"
-#include "vtkFieldData.h"
-#include "vtkCellData.h"
-#endif     // -----  not LEMMA_USE_VTK  -----
-
-// For testing purposes disable VTK and run scale.sh
-//#undef LEMMAUSEVTK
-
-#include "timer.h"
-
-using namespace Lemma;
-
-double randDouble(double low, double high) {
-	//srand(time(0));
-	double temp;
-	/* swap low & high around if the user makes no sense */
-	if (low > high)	{
-	temp = low;
-	low = high;
-	high = temp;
-	}
-	/* calculate the random number & return it */
-	temp = (rand() / (static_cast<double>(RAND_MAX) + 1.0))
-	* (high - low) + low;
-	return temp;
-}
-
-
-int main() {
-
-	// Keep track of time
-	jsw_timer timer;
-
-
-	srand(time(0));
-
-	PolygonalWireAntenna *pa = PolygonalWireAntenna::New();
-	pa->SetNumberOfFrequencies(1);
-	pa->SetFrequency(0, 540000);
-    Real Depth  =   370;  // nominal depth
-    Real Width  = 0.14;  // transmitter height
-    Real Height = 0.70;//  .14;  //.014;  // transmitter width
-
-
-	pa->SetNumberOfPoints(5);
-    /*
-    pa->SetPoint(0, Vector3r(       0,       0, Depth));
-	pa->SetPoint(1, Vector3r(       0,       0, Depth+Height));
-	pa->SetPoint(2, Vector3r(       0,   Width, Depth+Height));
-	pa->SetPoint(3, Vector3r(       0,   Width, Depth));
-	pa->SetPoint(4, Vector3r(       0,       0, Depth));
-    */
-
-    pa->SetPoint(0, Vector3r(   -Width/2., -Height/2., Depth));
-	pa->SetPoint(1, Vector3r(    Width/2., -Height/2., Depth));
-	pa->SetPoint(2, Vector3r(    Width/2.,  Height/2., Depth));
-	pa->SetPoint(3, Vector3r(   -Width/2.,  Height/2., Depth));
-	pa->SetPoint(4, Vector3r(   -Width/2., -Height/2., Depth));
-
-	pa->SetCurrent(1.);
-    pa->SetNumberOfTurns(6);
-	//Vector3r rp = Vector3r::Random(3);
-	//rp << 150., 10, 0.;
-	//rp << -27.1456, 15.2350, -1e-3;
-	//rp << randDouble(-35,35), randDouble(-35,35), randDouble(-35,35);
-	//rp << 3.22806, -13.1548, 14.9695;
-	//rp.setRandom(3);
-	//std::cout <<  "rp " << rp.transpose() << std::endl;
-	//pa->ApproximateWithElectricDipoles(rp);
-
-
-	// Define model
-    Real Sigma = 1.0/20. ; // .05;
-	VectorXcr sigma(2);
-		sigma << Complex(0.,0), Complex(Sigma,0);
-	VectorXr  thick(1);
-		thick << 10;
-	LayeredEarthEM *earth = LayeredEarthEM::New();
-		earth->SetNumberOfLayers(2);
-		earth->SetLayerConductivity(sigma);
-		//earth->SetLayerThickness(thick);
-
-	// Receivers
-	ReceiverPoints *receivers = ReceiverPoints::New();
-		Vector3r loc;
-		Real ox    =    -5.*Width - .003373;
-		Real oy    =    -3.*Height - .003373;
-		Real oz    =    Depth - Height/2. - .003373;
-		int nx     =   120; // 60;
-		int ny     =   180; //  50;
-		int nz     =   100; // 40;
-		Real hx    =    11.*Width/nx;
-		Real hy    =     7.*Height/ny;
-		Real hz    =     1.*Height/nz;
-
-        receivers->SetNumberOfReceivers(nx*ny*nz);
-		int ir = 0;
-		for (int iz=0; iz<nz; ++iz) {
-		for (int iy=0; iy<ny; ++iy) {
-		for (int ix=0; ix<nx; ++ix) {
-			loc << ox+ix*hx, oy+iy*hy, oz+iz*hz;
-			receivers->SetLocation(ir, loc);
-			++ ir;
-		}
-        }
-        }
-
-	// EmEarth
-	EMEarth1D  *EmEarth = EMEarth1D::New();
-		//EmEarth->AttachWireAntenna(wire);
-		EmEarth->AttachWireAntenna(pa);
-		EmEarth->AttachLayeredEarthEM(earth);
-		EmEarth->AttachReceiverPoints(receivers);
-		EmEarth->SetFieldsToCalculate(E);
-        //EmEarth->SetHankelTransformMethod(GAUSSIANQUADRATURE);
-        EmEarth->SetHankelTransformMethod(ANDERSON801);
-
-	// Do calculation
-	timer.begin();
-	EmEarth->CalculateWireAntennaFields();
-	Real paTime = timer.end();
-	std::cout << "Polygonal wire antennae time: " << paTime << "\n";
-
-	//EmEarth->AttachWireAntenna(wire);
-	//timer.begin();
-	//EmEarth->CalculateWireAntennaFields();
-	//Real waTime = timer.end();
-	//std::cout << "Fixed wire antennae time: " << waTime << "\n";
-/*
-	depth = depth2;
-	std::fstream real("reale_lay.dat", std::ios::out);
-	std::fstream imag("image_lay.dat", std::ios::out);
-	for (int iz=0; iz<nz; ++iz) {
-		Vector3cr temp = receivers->GetEfield(0,iz);
-		real << ox << "\t" << oy << "\t" << depth << "\t"
-				<< temp(0).real() << "\t" << temp(1).real()
-				<< "\t" << temp(2).real() << std::endl;
-		imag << ox << "\t" << oy << "\t" << depth << "\t"
-				<< std::imag(temp(0)) << "\t" << std::imag(temp(1))
-				<< "\t" << std::imag(temp(2)) << std::endl;
-		depth += dx;
-	}
-	real.close();
-	imag.close();
-*/
-
-	//wire->Delete();
-#if  LEMMAUSEVTK
-
-    // Set Coordinates
-    vtkDoubleArray *xCoords = vtkDoubleArray::New();
-    xCoords->InsertNextValue(ox-hx/2.);
-    double xm1 = ox-hx/2.;
-    for (int ix=0; ix<nx; ix++) {
-        xCoords->InsertNextValue(xm1 + hx);
-        xm1 += hx;
-    }
-
-    vtkDoubleArray *yCoords = vtkDoubleArray::New();
-    yCoords->InsertNextValue(oy-hy/2.);
-    double ym1 = oy-hy/2.;
-    for (int iy=0; iy<ny; iy++) {
-        yCoords->InsertNextValue(ym1 + hy);
-        ym1 += hy;
-    }
-
-    vtkDoubleArray *zCoords = vtkDoubleArray::New();
-    zCoords->InsertNextValue(oz-hz/2.);
-    double zm1 = oz-hz/2.;
-    for (int iz=0; iz<nz; iz++) {
-        zCoords->InsertNextValue(zm1 + hz);
-        zm1 += hz;
-    }
-
-    vtkDoubleArray *EReal = vtkDoubleArray::New();
-    vtkDoubleArray *EImag = vtkDoubleArray::New();
-    vtkDoubleArray *Watts = vtkDoubleArray::New();
-    EReal->SetNumberOfComponents(3);
-    EImag->SetNumberOfComponents(3);
-    Watts->SetNumberOfComponents(1);
-
-    ir = 0;
-    Real WattsTotal(0);
-    Real WattsInterior(0);
-    for (int iz=0; iz<nz; ++iz) {
-    for (int iy=0; iy<ny; ++iy) {
-    for (int ix=0; ix<nx; ++ix) {
-        //sigmaArray->InsertTuple1(i,  sigma[ix][iy][iz] );
-		Vector3cr E = receivers->GetEfield(0, ir);
-        EReal-> InsertTuple3(ir, real(E(0)), real(E(1)), real(E(2)));
-        EImag-> InsertTuple3(ir, imag(E(0)), imag(E(1)), imag(E(2)));
-        //std::cout << std::abs(ox+ix*hx) << "\t"  <<  Width/2. << endl; // && std::abs(oy+iy*hy) > Height/2. ) { // && std::abs(oz+iz*hz - Depth) > Width/2. ) {
-        //if ( std::abs( ox+ix*hx ) < Width/2. && std::abs(oy+iy*hy) < Height/2. && std::abs(oz+iz*hz - Depth) < Width/2. ) {
-        if ( std::sqrt( std::pow(ox+ix*hx,2)  + std::pow(oz+iz*hz - Depth, 2) ) < .085 && std::abs(oy+iy*hy) < Height/2. ) {
-            Watts-> InsertTuple1(ir,  1e-20 );
-            WattsInterior += .5*  (( pow((std::abs(E(0)) + std::abs(E(1)) + std::abs(E(2))), 2)*Sigma)*hx*hy*hz );
-        } else {
-            Watts-> InsertTuple1(ir, .5* (pow( (std::abs(E(0)) + std::abs(E(1)) + std::abs(E(2))), 2)*Sigma)*hx*hy*hz );
-            //Watts-> InsertTuple1(ir,  1e-20 );
-            WattsTotal += .5*  (( pow((std::abs(E(0)) + std::abs(E(1)) + std::abs(E(2))), 2)*Sigma)*hx*hy*hz );
-        }
-		++ ir;
-    }
-    }
-    }
-    std::cout << "Total Power: " << Sigma << "\t" << WattsTotal << "\t" << WattsInterior << endl;
-
-    EReal->SetName("E_real");
-    EImag->SetName("E_imag");
-    Watts->SetName("Power");
-
-    vtkRectilinearGrid *rgrid = vtkRectilinearGrid::New();
-        rgrid->SetDimensions(nx+1,ny+1,nz+1);
-        rgrid->SetXCoordinates(xCoords);
-        rgrid->SetYCoordinates(yCoords);
-        rgrid->SetZCoordinates(zCoords);
-
-        rgrid->GetCellData()->AddArray(EReal);
-        rgrid->GetCellData()->AddArray(EImag);
-        rgrid->GetCellData()->AddArray(Watts);
-        //rgrid->Update();
-
-    vtkXMLRectilinearGridWriter *gridWrite = vtkXMLRectilinearGridWriter::New();
-        gridWrite->SetInputData(rgrid);
-        gridWrite->SetFileName("ors.vtr");
-        gridWrite->Write();
-        //gridWrite->Update();
-
-#endif
-	EmEarth->Delete();
-	receivers->Delete();
-	earth->Delete();
-
-#if  LEMMAUSEVTKX
-	// Create the usual rendering stuff.
-	vtkRenderer           *renderer = vtkRenderer::New();
-	vtkRenderWindow         *renWin = vtkRenderWindow::New();
-	vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
-
-	std::cout << "wire antennae approximating " << std::endl;
-	loc << 0, .5*Width, Depth+.5*Height;
-	pa->ApproximateWithElectricDipoles(loc);
-    std::cout <<  "Wire approximated with " << pa->GetNumberOfDipoles() << std::endl;
-
-    vtkActor **pdipActors = new vtkActor*[pa->GetNumberOfDipoles()];
-	for (int id=0; id<pa->GetNumberOfDipoles(); ++id) {
-		pdipActors[id] = pa->GetVtkActor(id);
-		renderer->AddActor(pdipActors[id]);
-	}
-
-    /*
-    vtkActor **dipActors = new vtkActor*[wire->GetNumberOfDipoles()];
-	for (int id=0; id<wire->GetNumberOfDipoles(); ++id) {
-		dipActors[id] = wire->GetVtkActor(id);
-		renderer->AddActor(dipActors[id]);
-	}
-    */
-
-	renderer->SetBackground(1,1,1);
-
-	// Render the window
-	renWin->AddRenderer(renderer);
-	renWin->SetWindowName("Wire antennae");
-
-	iren->SetRenderWindow(renWin);
-	iren->Initialize();
-	iren->Start();
-	iren->Render();
-
-    #if 0
-	cout << "Enter File name?: ";
-	std::string pngName;
-	std::cin >> pngName;
-	vtkPNGWriter *pngwrite = vtkPNGWriter::New();
-	vtkRenderLargeImage *renlarge = vtkRenderLargeImage::New();
-	renlarge->SetInput(renderer);
-	renlarge->SetMagnification(2);
-	pngwrite->SetInputConnection(renlarge->GetOutputPort());
-	pngName.append(".png");
-	pngwrite->SetFileName(pngName.c_str());
-	pngwrite->Write();
-    #endif
-
-#endif     // -----  not LEMMA_USE_VTK  -----
-
-
-	//std::cout << *pa << std::endl;
-	//pa->Delete();
-
-	return 0;
-}

Modules/LemmaCore/examples/utQWEKey.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      02/12/2014 01:01:29 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
- */
-
-#include "QWEKey.h"
-using namespace Lemma;
-
-int main() {
-
-    // TODO chech
-
-    QWEKey* QWE = QWEKey::New();
-    QWE->TestPrivate( 5 );
-    QWE->Delete();
-
-    return 0;
-}
-
-

Modules/LemmaCore/examples/utSerialize.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      09/29/2014 01:31:26 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
- */
-
-#include "Lemma"
-
-using namespace Lemma;
-
-#ifdef  HAVE_YAMLCPP
-#include "yaml-cpp/yaml.h"
-
-int main() {
-
-    std::ofstream ofstr("output.yaml");
-    //ofstr << "%YAML 1.2\n" << "---\n";
-    //ofstr << "LEMMA_CLASSES:\n";
-
-    // This works for individual classes or even groups of unrelated classes. But
-    // How should references work? One option would be to hack YAML and allow for references
-    // across 'Docs'. This is maybe undesireable, as then it's not valid YAML anymore.
-    // OR we could have some other kind of IDENTIFIER that could be used and Connections could be
-    // made AFTER the whole file is processed?
-
-    // Alternative is each class is written to it's own file. And then implicit on the Serialize function, the file tags are written
-    // into the YAML instead of the pointer. Alternatively, tags could do this too.
-
-    // Or file could be saved as pointer.yaml
-
-    // *
-    // * Or a file contains all the subclasses it point to. So that it's self-enclosed. This is nice as it's quite
-    // * flexible. The only downwside is possible repeat of classes. Basically if the API is careful though, only 1
-    // * instance will need to be serialized.
-    // *
-
-
-    TEMTransmitter* Seq = TEMTransmitter::New();
-        Seq->SetRepFrequency( 20, KHZ );
-        VectorXr Times (18);
-        VectorXr Amps (18);
-        Times << 0.0, 0.03051, 0.10267, 0.19408, 0.19889, 0.21332, 0.74249, 1.3775, 1.83452, 2.52245, \
-                3.191132, 3.9031135, 4.0, 4.00484486, 4.123904, 4.200182, 4.20732, 4.212946;
-        Amps << 0.0, 14.71872, 62.34372, 114.84372, 117.84372, 118.96872, 118.96872, 118.96872, 118.96872,\
-                118.59372, 119.34372, 120.0, 120.0, 117.94176, 47.60364, 0.8905848, 0.1203888, 0.0;
-        Seq->SetWaveform(Times, Amps, MILLISEC);
-    // OK dump to disk
-    ofstr << *Seq ;
-    ofstr.close();
-    Seq->Delete();
-
-
-    // OK now load
-    std::ifstream ifstr("output.yaml");
-    std::vector<YAML::Node> nodes = YAML::LoadAll(ifstr);
-
-    TEMTransmitter* Seq2 = TEMTransmitter::DeSerialize( nodes[0] );
-    std::cout << "Loaded\n" << *Seq2;
-    Seq2->Delete();
-    ifstr.close();
-
-    //YAML::Node nodes = YAML::LoadFile("output.yaml");
-    //std::cout << nodes[0] << std::endl;
-    //std::cout << nodes[1] << std::endl;
-
-    exit(EXIT_SUCCESS);
-}
-
-#else
-int main() {
-
-}
-#endif

Modules/LemmaCore/examples/utTEMSurvey.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      10/06/2014 10:37:30 AM
- * @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
- */
-
-#include "Lemma"
-using namespace Lemma;
-
-int main() {
-
-    // Each pulse sequence functions as an autonomous transmitter. A record may contain multiple transmitters (moments).
-    // There is some small overhead for wire loop locations, but generality is retained doing this, as well as monitoring of
-    // slight changes in geometry for both pulses.
-    TEMTransmitter* TxHM = TEMTransmitter::New();
-        TxHM->SetRepFrequency( 20, KHZ );
-        VectorXr Times (18);
-        VectorXr Amps (18);
-        Times << 0.0, 0.03051, 0.10267, 0.19408, 0.19889, 0.21332, 0.74249, 1.3775, 1.83452, 2.52245, \
-                3.191132, 3.9031135, 4.0, 4.00484486, 4.123904, 4.200182, 4.20732, 4.212946;
-        Amps << 0.0, 14.71872, 62.34372, 114.84372, 117.84372, 118.96872, 118.96872, 118.96872, 118.96872,\
-                118.59372, 119.34372, 120.0, 120.0, 117.94176, 47.60364, 0.8905848, 0.1203888, 0.0;
-        TxHM->SetWaveform( Times, Amps, MILLISEC );
-        // Define wire loop
-        TxHM->SetNumberOfPoints(8);
-        TxHM->SetPoint(0, Vector3r( -16.10,    2.13,  -34));
-        TxHM->SetPoint(1, Vector3r(  -7.51,   10.72,  -34));
-        TxHM->SetPoint(2, Vector3r(   7.51,   10.72,  -34));
-        TxHM->SetPoint(3, Vector3r(  14.92,    3.31,  -34));
-        TxHM->SetPoint(4, Vector3r(  14.92,   -3.31,  -34));
-        TxHM->SetPoint(5, Vector3r(   7.51,  -10.72,  -34));
-        TxHM->SetPoint(6, Vector3r(  -7.51,  -10.72,  -34));
-        TxHM->SetPoint(7, Vector3r( -16.10,   -2.13,  -34));
-        TxHM->SetNumberOfTurns(8);
-
-    // Each Transmitter needs its own `Receiver(s)', the only difference may be the time gates, but that's OK.
-    //     It's a minor amount of overhead for greatly improved genearality. As sometimes different gates are
-    //     masked.
-    TEMInductiveReceiver* RxHM = TEMInductiveReceiver::New();
-        RxHM->SetComponent( ZCOMPONENT );      // What about Overloaded to take (X), (X,Y), or (X,Y,Z) or what about tilt?
-        RxHM->SetMoment( 1 );                  // Normalized
-        RxHM->SetReferenceTime( 4., MILLISEC );
-        RxHM->SetRxLocation( (Vector3r() << -16.80, 0, -36.00).finished() );
-
-        // Gate Centres  ms
-        VectorXr centres (37);
-        centres << 7.15000000e-04,   2.21500000e-03,   4.21500000e-03,   6.21500000e-03,
-                   8.21500000e-03,   1.02150000e-02,   1.22150000e-02,   1.47150000e-02,
-                   1.82150000e-02,   2.27150000e-02,   2.82150000e-02,   3.52150000e-02,
-                   4.42150000e-02,   5.57150000e-02,   7.02150000e-02,   8.82150000e-02,
-                   1.10715000e-01,   1.38715000e-01,   1.74215000e-01,   2.19715000e-01,
-                   2.76715000e-01,   3.48715000e-01,   4.39715000e-01,   5.53715000e-01,
-                   6.97715000e-01,   8.79215000e-01,   1.10771500e+00,   1.39621500e+00,
-                   1.76021500e+00,   2.21871500e+00,   2.79671500e+00,   3.52571500e+00,
-                   4.44471500e+00,   5.60321500e+00,   7.06321500e+00,   8.90421500e+00,
-                   1.10667200e+01;
-        //centres.array() += 4.;
-
-        // Gate Widths  ms
-        VectorXr widths (37);
-        widths <<   4.30000000e-04,   1.43000000e-03,   3.43000000e-03,   5.43000000e-03,
-                    7.43000000e-03,   9.43000000e-03,   1.14300000e-02,   1.34300000e-02,
-                    1.64300000e-02,   2.04300000e-02,   2.54300000e-02,   3.14300000e-02,
-                    3.94300000e-02,   4.94300000e-02,   6.24300000e-02,   7.84300000e-02,
-                    9.84300000e-02,   1.23430000e-01,   1.54430000e-01,   1.94430000e-01,
-                    2.45430000e-01,   3.08430000e-01,   3.89430000e-01,   4.90430000e-01,
-                    6.17430000e-01,   7.78430000e-01,   9.80430000e-01,   1.23543000e+00,
-                    1.55743000e+00,   1.96343000e+00,   2.47443000e+00,   3.11943000e+00,
-                    3.93243000e+00,   4.95743000e+00,   6.24943000e+00,   7.87743000e+00,
-                    9.93143000e+00;
-
-        RxHM->SetWindows(centres, widths, MILLISEC);
-
-    TEMTransmitter* TxLM = TEMTransmitter::New();
-        TxLM->SetRepFrequency( 20, KHZ );
-        VectorXr TimesLM (18);
-        VectorXr AmpsLM (18);
-
-        TimesLM << -8.00000E-004, -7.86965E-004, -7.66493E-004, -7.23688E-004,
-                   -6.39938E-004, -5.16174E-004, -3.93340E-004, -2.63993E-004,
-                   -1.43952E-004, -7.15990E-006, -2.50712E-006,  0.00000E+000,
-                    2.19597E-007,  1.47193E-006,  3.34398E-006,  4.68669E-006,
-                    5.96484E-006,  7.04934E-006;
-        TimesLM.array() = TimesLM.array() + 8e-4;  // Valgrind Hack += yields error. Correct for SkyTEM convention
-
-
-        AmpsLM <<  0.00000E+000,  3.67188E-002,  6.17188E-002,  1.17969E-001,
-                   2.14844E-001,  3.28906E-001,	 4.75781E-001,  6.30469E-001,
-                   7.82031E-001,  9.92969E-001,	 1.00000E+000,  1.00000E+000,
-                   9.63459E-001,  6.01030E-001,  2.29652E-001,  8.64702E-002,
-                   2.53196E-002,  0.00000E+000;
-        AmpsLM.array() = AmpsLM.array() * 8.;   // Also correct for SkyTEM convention in .geo file
-
-        TxLM->SetWaveform( TimesLM, AmpsLM, SEC );
-        // Define wire loop
-        TxLM->SetNumberOfPoints(8);
-        TxLM->SetPoint(0, Vector3r( -16.10,    2.13,  -34));
-        TxLM->SetPoint(1, Vector3r(  -7.51,   10.72,  -34));
-        TxLM->SetPoint(2, Vector3r(   7.51,   10.72,  -34));
-        TxLM->SetPoint(3, Vector3r(  14.92,    3.31,  -34));
-        TxLM->SetPoint(4, Vector3r(  14.92,   -3.31,  -34));
-        TxLM->SetPoint(5, Vector3r(   7.51,  -10.72,  -34));
-        TxLM->SetPoint(6, Vector3r(  -7.51,  -10.72,  -34));
-        TxLM->SetPoint(7, Vector3r( -16.10,   -2.13,  -34));
-        TxLM->SetNumberOfTurns(8);
-
-
-    TEMInductiveReceiver* RxLM = TEMInductiveReceiver::New();
-        RxLM->SetComponent( ZCOMPONENT );      // What about Overloaded to take (X), (X,Y), or (X,Y,Z) or what about tilt?
-        RxLM->SetMoment( 1 );                  // Normalized
-        RxLM->SetReferenceTime( 8e-4, SEC );
-        RxLM->SetRxLocation( (Vector3r() << -16.80, 0, -36.00).finished() );
-
-        // Gate Centres  ms
-        VectorXr centresLM (26);
-            centresLM << 7.150000E-07, 2.215000E-06, 4.215000E-06, 6.215000E-06, 8.215000E-06,
-                         1.021500E-05, 1.221500E-05, 1.471500E-05, 1.821500E-05, 2.271500E-05,
-                         2.821500E-05, 3.521500E-05, 4.421500E-05, 5.571500E-05, 7.021500E-05,
-                         8.821500E-05, 1.107150E-04, 1.387150E-04, 1.742150E-04, 2.197150E-04,
-                         2.767150E-04, 3.487150E-04, 4.397150E-04, 5.537150E-04, 6.977150E-04,
-                         8.792150E-04;
-
-        VectorXr widthsLM (26);
-            widthsLM << 5.700000E-07, 1.570000E-06, 1.570000E-06, 1.570000E-06, 1.570000E-06,
-                        1.570000E-06, 1.570000E-06, 2.570000E-06, 3.570000E-06, 4.570000E-06,
-                        5.570000E-06, 7.570000E-06, 9.570000E-06, 1.257000E-05, 1.557000E-05,
-                        1.957000E-05, 2.457000E-05, 3.057000E-05, 3.957000E-05, 5.057000E-05,
-                        6.257000E-05, 8.057000E-05, 1.005700E-04, 1.265700E-04, 1.605700E-04,
-                        2.015700E-04;
-
-        RxLM->SetWindows(centresLM, widthsLM, SEC);
-
-
-
-    // Specifies survey, this is the Glue Class, the top of the structure, etc.
-    TEMSurvey* Survey = TEMSurvey::New();
-        Survey->SetNumberOfLines(1);  // Flight lines or
-                                      // Internally each line is a class? But that's sort of hidden to the
-                                      // end user. Having each line seperate is nice for constrained inversion, where
-                                      // each line is a nice thing to deal with.
-        Survey->GetLine(0)->SetNumberOfRecords(1);    // Each Record then contains everything needed for modelling response curve(s)
-        Survey->GetLine(0)->GetRecord(0)->SetNumberOfPulseSequences( 1 );
-        Survey->GetLine(0)->GetRecord(0)->SetTransmitterReceiverPair( 0, TxHM, RxHM );
-        //Survey->GetLine(0)->GetRecord(0)->SetTransmitterReceiverPair( 1, TxHM, RxHM );
-
-
-    LayeredEarthEM* Earth = LayeredEarthEM::New();
-        Earth->SetNumberOfLayers(31);
-        Earth->SetLayerThickness( (VectorXr(29) <<  5.00E+00,  5.40E+00,
-             5.80E+00, 6.30E+00, 6.80E+00, 7.30E+00, 7.80E+00, 8.50E+00,
-             9.10E+00, 9.80E+00, 1.06E+01, 1.14E+01, 1.23E+01, 1.33E+01,
-             1.43E+01, 1.54E+01, 1.66E+01, 1.79E+01, 1.93E+01, 2.08E+01,
-             2.25E+01, 2.42E+01, 2.61E+01, 2.81E+01, 3.03E+01, 3.27E+01,
-             3.52E+01, 3.80E+01, 4.10E+01).finished() );
-
-        VectorXcr rho = ( (VectorXcr(31) << 0, 1.54E+01, 4.21E+01,
-            9.25E+01, 1.26E+02, 1.17E+02, 7.57E+01, 3.21E+01, 1.40E+01, 1.96E+01,
-            2.67E+01, 2.56E+01, 2.00E+01, 1.86E+01, 2.31E+01, 2.97E+01, 3.50E+01,
-            3.79E+01, 3.75E+01, 3.32E+01, 2.52E+01, 1.57E+01, 8.38E+00, 5.38E+00,
-            5.49E+00, 6.34E+00, 7.07E+00, 7.81E+00, 8.67E+00, 9.59E+00, 1.05E+01
-        ).finished() ); // 200 Ohm-m half space
-
-        Earth->SetLayerConductivity( 1./rho.array() );
-        // ALL SET UP
-        std::cout << *Survey << std::endl;
-
-        // OK do your thinc
-        //DataTEM* data =
-        Survey->ForwardModel( Earth );
-
-
-    // Clean up
-
-
-
-//     //Survey->Delete();
-//     Earth->Delete();
-//
-//     TxHM->Delete();
-//     RxHM->Delete();
-//     TxLM->Delete();
-//     RxLM->Delete();
-
-}

Modules/LemmaCore/examples/utXMLParse.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      04/03/2014 01:08:28 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
- */
-
-#include "Lemma"
-#ifdef TINYXMLSUPPORT
-#include "tinyxml2.h"
-
-#include <ctime>
-using namespace tinyxml2;
-using namespace Lemma;
-
-void ParseTEM( XMLElement* element );
-
-template <typename T>
-std::vector<T> ReadLine( const int& nr, const std::string& line ) ;
-
-int main(int argc, char **argv) {
-
-    if ( argc > 1 ) {
-		XMLDocument* doc = new XMLDocument();
-		clock_t startTime = clock();
-		doc->LoadFile( argv[1] );
-		clock_t loadTime = clock();
-		int errorID = doc->ErrorID();
-
-        // Get some info
-        //static const char* xml = "<element/>";
-        //doc->Parse( xml );
-        //XMLNode* titleElement = doc->FirstChild(); //Element()->FirstChildElement( "PLAY" )->FirstChildElement( "TITLE" );
-        XMLElement* titleElement = doc->FirstChildElement( ); //->FirstChildElement( "TITLE" );
-        //const char* title = titleElement->Value(); //GetText();
-        const char* title = titleElement->Value(); //GetText();
-
-        printf( "Test file '%s' loaded. ErrorID=%d\n", argv[1], errorID );
-        printf( "Name of FirstChildElement: %s\n", title );
-
-        if (strcmp ( titleElement->Value(), "NGXFile" ) != 0) {
-            std::cout <<"NGX file was not detected!" << std::endl;
-            exit(EXIT_FAILURE);
-        } else {
-            //std::cout <<
-            //titleElement->FirstAttribute() ;//"type");// << std::endl;;
-            if (strcmp(  titleElement->FindAttribute("type")->Value(),"tem") == 0) {
-                // Parse TEM file
-                ParseTEM( titleElement );
-            } else {
-                std::cout << "No parser for NGX filetype " << titleElement->FindAttribute("type")->Value() << std::endl;
-                std::cout << "YOU should write one!\n";
-                exit(EXIT_FAILURE);
-            }
-
-        }
-
-		delete doc; doc = 0;
-
-        clock_t deleteTime = clock();
-		if ( !errorID ) {
-			printf( "========================================================\n");
-			printf( "Load time=%u\n",   (unsigned)(loadTime - startTime) );
-			printf( "Delete time=%u\n", (unsigned)(deleteTime - loadTime) );
-			printf( "Total time=%u\n",  (unsigned)(deleteTime - startTime) );
-		}
-
-
-		exit(0);
-	} else {
-        std::cout << "Enter NGX.x file to parse\n";
-    }
-}
-
-void ParseTEM( XMLElement* element ) {
-
-    std::cout << "This is a NGX.t file" << std::endl;
-
-
-    if (strcmp( element->FindAttribute("version")->Value(),"0.1") == 0) {
-        std::cout << "Version 0.1 detected" << std::endl;
-    } else {
-        std::cout << "Unsupported NGX.t version" << std::endl;
-    }
-
-    // system description
-    std::cout << "System description" << std::endl;
-    std::cout << element->FirstChildElement("system")->FirstChildElement("name")->GetText() << std::endl;
-    XMLElement* system = element->FirstChildElement("system");
-        int ntx = atoi(system->FirstChildElement("transmitters")->FindAttribute("num")->Value());
-        std::cout << "numTx = " << ntx << std::endl;
-        // OK Parse Transmitter(s)
-        XMLElement* tx = system->FirstChildElement("transmitters")->FirstChildElement("transmitter");
-        //    std::cout << "Tx id = " << tx->FindAttribute("id")->Value() << std::endl;
-        //std::cout << tx->FirstChildElement("loop.coordinates")->FindAttribute("npoint")->Value();//->FirstChildElement("northingPoints")->Value() << std::endl;
-        //std::cout << tx->FirstChildElement("loop.coordinates")->FirstChildElement("northing.points")->GetText();//->FirstChildElement("northingPoints")->Value() << std::endl;
-        for (int it=0; it<ntx; ++it) {
-            std::cout << "\nTransmitter " << it << std::endl;
-            if (it > 0) tx = tx->NextSiblingElement();
-            int npoints = atoi(tx->FirstChildElement("loop.coordinates")->FindAttribute("npoint")->Value());
-
-            std::cout << "points= " << npoints; // tx->FirstChildElement("loop.coordinates")->FindAttribute("npoint")->Value();//->FirstChildElement("northingPoints")->Value() << std::endl;
-            std::vector<Real> LP = ReadLine<Real>( npoints, std::string(tx->FirstChildElement("loop.coordinates")->FirstChildElement("northing.points")->GetText()) );
-            for (int ii=0; ii<npoints; ++ii) std::cout << "\t"<< LP[ii] ;
-            //std::cout << tx->FirstChildElement("loop.coordinates")->FirstChildElement("northing.points")->GetText();//->FirstChildElement("northingPoints")->Value() << std::endl;
-            //std::cout << tx->FirstChildElement("loop.coordinates")->FirstChildElement("easting.points")->GetText();//->FirstChildElement("northingPoints")->Value() << std::endl;
-        }
-    std::cout << "\nEND system description\n";
-
-}
-
-
-template <typename T>
-std::vector<T> ReadLine( const int& nr, const std::string& line ) {
-
-    std::vector<T>   lineData;
-    std::stringstream  lineStream(line);
-
-    T value;
-    while(lineStream >> value) {
-        lineData.push_back(value);
-    }
-    return lineData;
-}
-#else
-
-int main() {
-    std::cout << "you have to compile lemma with external tinyxml library to use this" << std::endl;
-}
-
-#endif
-
-    //--------------------------------------------------------------------------------------
-    //       Class:  ASCIIParser
-    //      Method:  ReadInts
-    //--------------------------------------------------------------------------------------
-//     std::vector<int> ReadInts ( const int& nr ) {
-//         std::string buf;
-//         char *dump = new char[BufferSize];
-//         std::vector<int> vals(0);
-//         while (input >> buf) {
-//             if (buf.substr(0, CommentString.size()) == CommentString) {
-//                 input.getline(dump, BufferSize);
-//             } else {
-//                 vals.push_back( atoi(buf.c_str() ));
-//             }
-//             if (static_cast<int>(vals.size()) == nr) {
-//                 delete [] dump;
-//                 return vals;
-//             }
-//
-//         }
-//         delete [] dump;
-//         return vals;
-//     }		// -----  end of method ASCIIParser::ReadInts  -----
-

Modules/LemmaCore/examples/utYAMLconfig.cpp

-#ifdef HAVE_YAMLCPP
-
-#include "yaml-cpp/yaml.h"
-#include "yaml-cpp/eventhandler.h"
-#include <fstream>
-#include <iostream>
-#include <vector>
-
-struct Params {
-	bool hasFile;
-	std::string fileName;
-};
-
-Params ParseArgs(int argc, char **argv) {
-	Params p;
-
-	std::vector<std::string> args(argv + 1, argv + argc);
-
-	return p;
-}
-
-class NullEventHandler: public YAML::EventHandler
-{
-public:
-	virtual void OnDocumentStart(const YAML::Mark&) {}
-	virtual void OnDocumentEnd() {}
-
-	virtual void OnNull(const YAML::Mark&, YAML::anchor_t) {}
-	virtual void OnAlias(const YAML::Mark&, YAML::anchor_t) {}
-	virtual void OnScalar(const YAML::Mark&, const std::string&, YAML::anchor_t, const std::string&) {}
-
-	virtual void OnSequenceStart(const YAML::Mark&, const std::string&, YAML::anchor_t) {}
-	virtual void OnSequenceEnd() {}
-
-	virtual void OnMapStart(const YAML::Mark&, const std::string&, YAML::anchor_t) {}
-	virtual void OnMapEnd() {}
-};
-
-void parse(std::istream& input)
-{
-	try {
-		YAML::Node doc = YAML::Load(input);
-		std::cout << doc << "\n";
-	} catch(const YAML::Exception& e) {
-		std::cerr << e.what() << "\n";
-	}
-}
-
-int main(int argc, char **argv)
-{
-	Params p = ParseArgs(argc, argv);
-
-	if(argc > 1) {
-		std::ifstream fin;
-		fin.open(argv[1]);
-		parse(fin);
-	} else {
-		parse(std::cin);
-	}
-
-	return 0;
-}
-#else
-int main() {
-}
-#endif
-

Modules/LemmaCore/examples/utgaussquad.cpp

-// ===========================================================================
-// 
-//       Filename:  utqaussquad.cpp
-// 
-//    Description:  Test for gaussian quadrature algorithm
-// 
-//        Version:  0.0
-//        Created:  10/05/2010 08:54:26 AM
-//       Revision:  none
-//       Compiler:  Tested with g++
-// 
-//         Author:  M. Andy Kass (MAK)
-//
-//   Organisation:  Colorado School of Mines (CSM)
-//                  Broken Spoke Development, LLC
-//
-//          Email:  mkass@numericalgeo.com
-// 
-//  This program is free software: you can redistribute it and/or modify
-//  it under the terms of the GNU General Public License as published by
-//  the Free Software Foundation, either version 3 of the License, or
-//  (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-// ===========================================================================
-
-#include "Lemma"
-using namespace Lemma;
-using namespace std;
-
-#ifdef LEMMAUSEVTK
-#include "matplot.h"
-using namespace matplot;
-#endif
-
-int main() {
-
-	int N = 600;
-	int upb = 5;
-	int lowb = -1;
-	VectorXr func(N);
-	VectorXr wx(N);
-	Real integrationres,actres;
-
-	gaussianquadrature *lgqw = gaussianquadrature::New();
-	lgqw->SetFreqs(N,upb,lowb);
-	lgqw->CalcAW();
-
-	wx=lgqw->GetAbscissae();
-	func=cos(wx.array());
-//	for (int ii=0;ii<N;++ii) {
-//		cout << wx(ii) << "  " << func(ii) << endl;
-//	}
-
-	lgqw->SetFunc(func);
-	lgqw->Integrate();
-	integrationres=lgqw->GetResult();
-
-	actres = -sin((Real)upb)+sin((Real)lowb);
-	
-	cout << "Gaussian Quadrature Result: " << integrationres << endl;
-	cout << "Actual Result: " << actres << endl;
-	
-		
-	//Plot things
-	#ifdef LEMMAUSEVTK
-	double colour1[3] = {0.0,0.0,1.0};
-
-	Plot2D_VTK p1("X", "Y", 800,600);
-	p1.plot(wx,func,colour1,".-");
-	p1.show();
-
-	#endif
-
-	return EXIT_SUCCESS;
-}
-

Modules/LemmaCore/examples/utgmrprint.cpp

-// ===========================================================================
-//   This file is distributed with Lemma,
-//
-//       Filename:  utsnmrinversion1d.cpp
-//
-//        Created:  10/07/2010 08:57:04 AM
-//       Compiler:  Tested with g++, icpc, and MSVC 2010
-//
-//         Author:  Trevor Irons (ti)
-//
-//   Organisation:  Colorado School of Mines (CSM)
-//                  United States Geological Survey (USGS)
-//
-//          Email:  tirons@mines.edu, tirons@usgs.gov
-//
-//  This program is free software: you can redistribute it and/or modify
-//  it under the terms of the GNU General Public License as published by
-//  the Free Software Foundation, either version 3 of the License, or
-//  (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-// ===========================================================================
-
-/**
-  @file
-  @author   Trevor Irons
-  @date     10/07/2010
-  @version   0.0
- **/
-
-#ifdef LEMMAUSEVTK
-#include "vtkRenderer.h"
-#include "vtkRenderWindow.h"
-#include "vtkRenderWindowInteractor.h"
-#include "vtkPNGWriter.h"
-#include "vtkRenderLargeImage.h"
-#endif
-
-#include "receiverpoints.h"
-#include "emearth1d.h"
-#include "PolygonalWireAntenna.h"
-
-using namespace Lemma;
-
-std::vector<Real>  readinpfile(const std::string& fname);
-
-int main(int argc, char** argv) {
-
-    std::cout <<
-    "\n"
-    << "hantenna - a programme for computing the h field from polygonal wire\n"
-    << "loop sources \n\n"
-    << "The following copyrights apply to this application:\n"
-    << "Copyright (C) 2009, 2010, 2011, 2012 Colorado School of Mines\n"
-    << "Copyright (C) 2009, 2010, 2011, 2012 Trevor Irons\n"
-    << "Copyright (C) 2011 Broken Spoke Development, LLC\n\n"
-    << "hantenna was built using Lemma (Lemma is an Electromagnetics Modelling API)\n"
-    << "More information may be found at https://lemmasoftware.org\n\n"
-    << "This program is free software: you can redistribute it and/or modify\n"
-    << "it under the terms of the GNU General Public License as published by\n"
-    << "the Free Software Foundation, either version 3 of the License, or\n"
-    << "(at your option) any later version.\n\n"
-
-    << "This program is distributed in the hope that it will be useful,\n"
-    << "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
-    << "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
-    << "GNU General Public License for more details.\n\n"
-
-    << "You should have received a copy of the GNU General Public License\n"
-    << "along with this program.  If not, see <http://www.gnu.org/licenses/>.\n\n";
-
-    if (argc < 4) {
-        std::cout << "usage: hantenna.exe  trans.inp cond.inp points.inp \n";
-        exit(0);
-    }
-
-    std::vector<Real> Trans   = readinpfile(std::string(argv[1]));
-    std::vector<Real> CondMod = readinpfile(std::string(argv[2]));
-    std::vector<Real> Points  = readinpfile(std::string(argv[3]));
-
-    //////////////////////////////////////
-    // Define transmitter
-    PolygonalWireAntenna* trans = PolygonalWireAntenna::New();
-        trans->SetNumberOfPoints((int)(Trans[0]));
-        int ip=1;
-        for ( ; ip<=(int)(Trans[0])*2; ip+=2) {
-            trans->SetPoint(ip/2, Vector3r (Trans[ip], Trans[ip+1], -1e-3));
-        }
- 	    trans->SetNumberOfFrequencies(1);
- 	    trans->SetFrequency(0, Trans[ip]);
-        trans->SetCurrent(Trans[ip+1]);
-
-	// Receivers
- 	ReceiverPoints *receivers = ReceiverPoints::New();
-        int nx = (int)Points[0];
-        int ny = (int)Points[1];
-        int nz = (int)Points[2];
-        Real ox = Points[3];
-        Real oy = Points[4];
-        Real oz = Points[5];
-     	Vector3r loc;
-        VectorXr dx(nx-1); // TODO map the dx, dy, dz vectors
-        VectorXr dy(ny-1);
-        VectorXr dz(nz-1);
-        ip = 6;
-        int ir = 0;
-        for ( ; ip <6+nx-1; ++ip) {
-            dx[ir] = Points[ip];
-            ++ir;
-        }
-        ir = 0;
-        for ( ; ip <6+ny-1+nx-1; ++ip) {
-            dy[ir] = Points[ip];
-            ++ir;
-        }
-        ir = 0;
-        for ( ; ip <6+nz-1+ny-1+nx-1; ++ip) {
-            dz[ir] = Points[ip];
-            ++ir;
-        }
- 		receivers->SetNumberOfReceivers(nx*ny*nz);
- 		ir = 0;
-        Real pz  = oz;
- 		for (int iz=0; iz<nz; ++iz) {
- 		    Real py    =  oy;
- 		    for (int iy=0; iy<ny; ++iy) {
- 		        Real px    =  ox;
- 		        for (int ix=0; ix<nx; ++ix) {
- 			        loc << px, py, pz;
- 			        receivers->SetLocation(ir, loc);
- 			        if (ix < nx-1) px += dx[ix];
- 			        ++ ir;
-     	        }
-                if (iy<ny-1) py += dy[iy];
-            }
-            if (iz<nz-1) pz += dz[iz];
-        }
-
-    ////////////////////////////////////
-    // Define model
-    LayeredEarthEM *earth = LayeredEarthEM::New();
-    VectorXcr sigma;
-    VectorXr  thick;
- 	earth->SetNumberOfLayers(CondMod[0]+1);
- 	sigma.resize(CondMod[0]+1); sigma(0) = 0; // airlayer
-    thick.resize(CondMod[0]-1);
-    int ilay=1;
-    for ( ; ilay/2<CondMod[0]-1; ilay+=2) {
-        sigma(ilay/2+1) =  1./CondMod[ilay];
-        thick(ilay/2) =  CondMod[ilay+1];
-    }
-    sigma(ilay/2+1) = 1./ CondMod[ilay];
-	earth->SetLayerConductivity(sigma);
-    if (thick.size() > 0) earth->SetLayerThickness(thick);
-
-	EMEarth1D  *EmEarth = EMEarth1D::New();
-		EmEarth->AttachWireAntenna(trans);
-		EmEarth->AttachLayeredEarthEM(earth);
-		EmEarth->AttachReceiverPoints(receivers);
-		EmEarth->SetFieldsToCalculate(H);
-        EmEarth->CalculateWireAntennaFields();
-
-    #ifdef LEMMAUSEVTK
-	vtkRenderer           *renderer = vtkRenderer::New();
-	vtkRenderWindow         *renWin = vtkRenderWindow::New();
-	vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
-    trans->ApproximateWithElectricDipoles( (VectorXr (3) << 0,0,0).finished() );
-	vtkActor **dipActors = new vtkActor*[trans->GetNumberOfDipoles()];
-	for (int id=0; id<trans->GetNumberOfDipoles(); ++id) {
-		dipActors[id] = trans->GetVtkActor(id);
-		renderer->AddActor(dipActors[id]);
-	}
-    vtkActor *hfield  = receivers->GetVtkGlyphActor (HFIELDREAL, 3, 1e2, 0);
- 	vtkActor *hfieldi = receivers->GetVtkGlyphActor (HFIELDIMAG, 3, 1e2, 0);
-    hfieldi->GetProperty()->SetColor(1,0,1);
- 	hfield->GetProperty()->SetColor(0,1,0);
- 	renderer->AddActor(hfield);
- 	renderer->AddActor(hfieldi);
-	renderer->SetBackground(0,0,0);
-	// Render the window
-	renWin->AddRenderer(renderer);
-	iren->SetRenderWindow(renWin);
-	iren->Initialize();
-	iren->Start();
-	iren->Render();
-	cout << "Enter File name?: ";
-	std::string pngName;
-	std::cin >> pngName;
-	vtkPNGWriter *pngwrite = vtkPNGWriter::New();
-	vtkRenderLargeImage *renlarge = vtkRenderLargeImage::New();
-	renlarge->SetInput(renderer);
-	renlarge->SetMagnification(2);
-	pngwrite->SetInputConnection(renlarge->GetOutputPort());
-	pngName.append(".png");
-	pngwrite->SetFileName(pngName.c_str());
-	pngwrite->Write();
-	iren->Delete();
-	renWin->Delete();
-	renderer->Delete();
-    #endif
-
-    ////////////////////////////////////
-    // Report
- 	std::fstream hreal("hfield.dat", std::ios::out);
-    hreal << *trans << std::endl;
-    hreal << *earth << std::endl;
-    hreal << "Right hand coordinate system, z is positive down\n";
-    hreal << "x[m]\ty[m]\tz[m]\tHx[A/m]\tHy[A/m]\tHz[A/m]\n";
-    hreal.precision(8);
-    int i=0;
-	for (int iz=0; iz<nz; ++iz) {
-	for (int iy=0; iy<ny; ++iy) {
-	for (int ix=0; ix<nx; ++ix) {
-        hreal << receivers->GetLocation(i).transpose() << "\t";
- 		hreal << std::real(receivers->GetHfield(0, i).transpose()[0]) << "\t";
- 		hreal << std::imag(receivers->GetHfield(0, i).transpose()[0]) << "\t";
- 		hreal << std::real(receivers->GetHfield(0, i).transpose()[1]) << "\t";
- 		hreal << std::imag(receivers->GetHfield(0, i).transpose()[1]) << "\t";
- 		hreal << std::real(receivers->GetHfield(0, i).transpose()[2]) << "\t";
- 		hreal << std::imag(receivers->GetHfield(0, i).transpose()[2]) << "\n";
-        ++i;
-    }
-    }
-    }
-    hreal.close();
-
-    // Clean up
-    EmEarth->Delete();
-    earth->Delete();
-    receivers->Delete();
-    trans->Delete();
-}
-
-std::vector<Real>  readinpfile(const std::string& fname) {
-    std::string buf;
-    char dump[255];
-    std::vector<Real> vals;
-    std::fstream input(fname.c_str(), std::ios::in);
-    if (input.fail()) {
-        std::cerr << "Input file " << fname << " failed to open\n";
-        exit(EXIT_FAILURE);
-    }
-    while (input >> buf) {
-        if (buf.substr(0,2) == "//") {
-            input.getline(dump, 255);
-        } else {
-            vals.push_back( atof(buf.c_str() ));
-        }
-    }
-    return vals;
-}

Modules/LemmaCore/examples/uthankel2.cpp

-// ===========================================================================
-//
-//       Filename:  uthankel2.cpp
-//
-//    Description:
-//
-//        Version:  0.0
-//        Created:  05/14/2010 10:26:59 AM
-//       Revision:  none
-//       Compiler:  Tested with g++, icpc, and MSVC 2000
-//
-//         Author:  Trevor Irons (ti)
-//
-//   Organisation:  Colorado School of Mines (CSM)
-//                  United States Geological Survey (USGS)
-//
-//          Email:  tirons@mines.edu, tirons@usgs.gov
-//
-//  This program is free software: you can redistribute it and/or modify
-//  it under the terms of the GNU General Public License as published by
-//  the Free Software Foundation, either version 3 of the License, or
-//  (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-// ===========================================================================
-
-#include "hankeltransformhankel2.h"
-#include "hankeltransformgaussianquadrature.h"
-#include "kernelem1d.h"
-#include "layeredearthem.h"
-
-using namespace Lemma;
-
-int main() {
-
-	// Define model
-	LayeredEarthEM *Earth = LayeredEarthEM::New();
-		VectorXcr sigma(3);
-		sigma << 0., .1, 0.01;
-		VectorXr  thick(1);
-		thick << 10;
-		Earth->SetNumberOfLayers(3);
-		Earth->SetLayerConductivity(sigma);
-		Earth->SetLayerThickness(thick);
-
-	// Source
-	// Test with a single dipole
-	DipoleSource *dipole = DipoleSource::New();
-		dipole->SetMoment(2);
-		dipole->SetType(MAGNETICDIPOLE);
-		dipole->SetPolarisation(ZPOLARISATION);
-		dipole->SetLocation(0,0,0);
-		dipole->SetNumberOfFrequencies(1);
-		dipole->SetFrequency(0,1000);
-		dipole->SetPhase(0);
-
-	KernelEm1D *Kernel = KernelEm1D::New();
-		Kernel->Initialise(Earth);
-		Kernel->SetUpSource(dipole, 0);
-		Kernel->SetUpReceiver(-0.4);
-    //std::vector< KernelEm1DBase* > KernelVec;
-    //    KernelVec.push_back( )
-
-	std::cout.precision(10);
-
-	Hankel2 *dig = Hankel2::New();
-//         dig->ComputeRelated(.23 , Kernel);
-//  		std::cout << "  dig->Zgauss "
-//  				  << dig->Zgauss(0, TE, 0, 100.,
-//  								  1000.*std::sqrt(MU0*EPSILON0), Kernel)
-//  			      << std::endl;
-
-// 	HankelTransformGaussianQuadrature *gauss =
-// 			HankelTransformGaussianQuadrature::New();
-// 		std::cout << "gauss->Zgauss "
-// 				  << gauss->Zgauss(0, TE, 0, 100.,
-// 								  1000.*std::sqrt(MU0*EPSILON0), Kernel)
-// 			      << std::endl;
-
-	Earth->Delete();
-	dig->Delete();
-	//gauss->Delete();
-    dipole->Delete();
-	Kernel->Delete();
-	return EXIT_SUCCESS;
-}

Modules/LemmaCore/examples/uthantenna.cpp

-// ===========================================================================
-//
-//       Filename:  hantenna.cpp
-//
-//        Created:  10/07/2010 08:57:04 AM
-//       Modified:  14 Aug 2012
-//       Compiler:  Tested with g++, icpc, and MSVC 2010
-//
-//         Author:  Trevor Irons (ti)
-//
-//       Copyright (C) 2011    Broken Spoke Development, LLC
-//       Copyright (C) 2012    Trevor Irons
-//
-//   Organisation:  Colorado School of Mines (CSM)
-//
-//          Email:  tirons@mines.edu
-//
-//  This program is free software: you can redistribute it and/or modify
-//  it under the terms of the GNU General Public License as published by
-//  the Free Software Foundation, either version 3 of the License, or
-//  (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-// ===========================================================================
-
-/**
-  @file
-  @author   Trevor Irons
-  @date     10/07/2010
-  @version  $Revision: 208 $
-  $Id$
- **/
-
-#include "receiverpoints.h"
-#include "emearth1d.h"
-#include "PolygonalWireAntenna.h"
-#ifdef LEMMAUSEOMP
-#include "omp.h"
-#endif
-
-#include "timer.h"
-
-using namespace Lemma;
-
-std::vector<Real>  readinpfile(const std::string& fname);
-
-std::vector<std::string>  readinpfile2(const std::string& fname);
-
-int main(int argc, char** argv) {
-
-    std::cout <<
-    "\n"
-    << "hantenna- $Date: 2015-01-26 10:11:24 -0700 (Mon, 26 Jan 2015) $ $Revision: 208 $\n\n"
-    << "hantenna is a programme for computing the h field from polygonal wire\n"
-    << "loop sources \n\n"
-    << "hantenna was built using Lemma (Lemma is an Electromagnetics Modelling API)\n"
-    << "Lemma is Free and Open Source Software (FOSS) and is released under\n"
-    << "the MPL, it is covered by the following copyrights:\n"
-    << "Copyright (C) 2009, 2010, 2011, 2012      Colorado School of Mines\n"
-    << "Copyright (C) 2009, 2010, 2011, 2012      Trevor P. Irons\n"
-    << "Copyright (C) 2011, 2012                  M. Andy Kass\n\n"
-    << "More information may be found at: https://lemmasoftware.org\n"
-    << "                                  info@lemmasoftware.org\n\n"
-    << "=====================================================================\n"
-    << "This programme is part of Lemma, a geophysical modelling and inversion API \n"
-    << "This Source Code Form is subject to the terms of the Mozilla Public\n"
-    << "License, v. 2.0. If a copy of the MPL was not distributed with this\n"
-    << "file, You can obtain one at http://mozilla.org/MPL/2.0/. \n"
-    << "=====================================================================\n\n\n";
-
-    if (argc < 5) {
-        std::cout << "usage: hantenna.exe  trans.inp cond.inp points.inp config.inp \n";
-        exit(0);
-    }
-
-    #ifdef LEMMAUSEOMP
-    std::cout << "OpenMP is using " << omp_get_max_threads() << " threads" << std::endl;
-    #endif
-
-    std::vector<Real> Trans   = readinpfile(std::string(argv[1]));
-    std::vector<Real> CondMod = readinpfile(std::string(argv[2]));
-    std::vector<Real> Points  = readinpfile(std::string(argv[3]));
-    std::vector<std::string> config  = readinpfile2(std::string(argv[4]));
-
-    //////////////////////////////////////
-    // Define transmitter
-    PolygonalWireAntenna* trans = PolygonalWireAntenna::New();
-        trans->SetNumberOfPoints((int)(Trans[0]));
-        int ip=1;
-        for ( ; ip<=(int)(Trans[0])*2; ip+=2) {
-            trans->SetPoint(ip/2, Vector3r (Trans[ip], Trans[ip+1], -1e-3));
-        }
- 	    trans->SetNumberOfFrequencies(1);
- 	    trans->SetFrequency(0, Trans[ip]);
-        trans->SetCurrent(Trans[ip+1]);
-        trans->SetMinDipoleRatio(atof(config[1].c_str()));
-        trans->SetMinDipoleMoment(atof(config[2].c_str()));
-        trans->SetMaxDipoleMoment(atof(config[3].c_str()));
-
-	// Receivers
- 	ReceiverPoints *receivers = ReceiverPoints::New();
-        int nx = (int)Points[0];
-        int ny = (int)Points[1];
-        int nz = (int)Points[2];
-        Real ox = Points[3];
-        Real oy = Points[4];
-        Real oz = Points[5];
-     	Vector3r loc;
-        VectorXr dx(nx-1);
-        VectorXr dy(ny-1);
-        VectorXr dz(nz-1);
-        ip = 6;
-        int ir = 0;
-        for ( ; ip <6+nx-1; ++ip) {
-            dx[ir] = Points[ip];
-            ++ir;
-        }
-        ir = 0;
-        for ( ; ip <6+ny-1+nx-1; ++ip) {
-            dy[ir] = Points[ip];
-            ++ir;
-        }
-        ir = 0;
-        for ( ; ip <6+nz-1+ny-1+nx-1; ++ip) {
-            dz[ir] = Points[ip];
-            ++ir;
-        }
- 		receivers->SetNumberOfReceivers(nx*ny*nz);
- 		ir = 0;
-        Real pz  = oz;
- 		for (int iz=0; iz<nz; ++iz) {
- 		    Real py    =  oy;
- 		    for (int iy=0; iy<ny; ++iy) {
- 		        Real px    =  ox;
- 		        for (int ix=0; ix<nx; ++ix) {
- 			        loc << px, py, pz;
- 			        receivers->SetLocation(ir, loc);
- 			        if (ix < nx-1) px += dx[ix];
- 			        ++ ir;
-     	        }
-                if (iy<ny-1) py += dy[iy];
-            }
-            if (iz<nz-1) pz += dz[iz];
-        }
-
-    ////////////////////////////////////
-    // Define model
-    LayeredEarthEM *earth = LayeredEarthEM::New();
-    VectorXcr sigma;
-    VectorXr  thick;
- 	earth->SetNumberOfLayers(CondMod[0]+1);
- 	sigma.resize(CondMod[0]+1); sigma(0) = 0; // airlayer
-    thick.resize(CondMod[0]-1);
-    int ilay=1;
-    for ( ; ilay/2<CondMod[0]-1; ilay+=2) {
-        sigma(ilay/2+1) =  1./CondMod[ilay];
-        thick(ilay/2) =  CondMod[ilay+1];
-    }
-    sigma(ilay/2+1) = 1./ CondMod[ilay];
-	earth->SetLayerConductivity(sigma);
-    if (thick.size() > 0) earth->SetLayerThickness(thick);
-
-	EMEarth1D  *EmEarth = EMEarth1D::New();
-		EmEarth->AttachWireAntenna(trans);
-		EmEarth->AttachLayeredEarthEM(earth);
-		EmEarth->AttachReceiverPoints(receivers);
-		EmEarth->SetFieldsToCalculate(H);
-        EmEarth->SetHankelTransformMethod(string2Enum<HANKELTRANSFORMTYPE>(config[0]));
-        EmEarth->SetHankelTransformMethod(FHTKEY201);
-
-	// Keep track of time
-	jsw_timer timer;
-  	timer.begin();
-    clock_t launch = clock();
-    EmEarth->CalculateWireAntennaFields(true);    // true=status bar
-	Real paTime = timer.end();
-
-    std::cout << "\n\n===========================================\ncalc. real time: " << paTime/60. << "\t[m]\n";
-
-    std::cout << "calc. user time: " <<  (clock()-launch)/CLOCKS_PER_SEC/60.   << "\t[CPU m]"
-		 << std::endl;
-
-    ////////////////////////////////////
-    // Report
- 	std::fstream hrep("hfield.yaml", std::ios::out);
-    std::fstream hreal("hfield.dat", std::ios::out);
-
-    hrep << *EmEarth << std::endl;
-    hrep.close();
-    //hreal << *trans << std::endl;
-    //hreal << *earth << std::endl;
-
-    hreal << "// Right hand coordinate system, z is positive down\n";
-    hreal << "// x[m]\ty[m]\tz[m]\tHx[A/m]\tHy[A/m]\tHz[A/m]\n";
-    hreal.precision(8);
-    int i=0;
-	for (int iz=0; iz<nz; ++iz) {
-	for (int iy=0; iy<ny; ++iy) {
-	for (int ix=0; ix<nx; ++ix) {
-        hreal << receivers->GetLocation(i).transpose() << "\t";
- 		hreal << receivers->GetHfield(0, i).transpose() << "\n";
-        ++i;
-    }
-    }
-    }
-    hreal.close();
-    // Clean up
-    EmEarth->Delete();
-    earth->Delete();
-    receivers->Delete();
-    trans->Delete();
-}
-
-std::vector<Real>  readinpfile(const std::string& fname) {
-    std::string buf;
-    char dump[255];
-    std::vector<Real> vals;
-    std::fstream input(fname.c_str(), std::ios::in);
-    if (input.fail()) {
-        std::cerr << "Input file " << fname << " failed to open\n";
-        exit(EXIT_FAILURE);
-    }
-    while (input >> buf) {
-        if (buf.substr(0,2) == "//") {
-            input.getline(dump, 255);
-        } else {
-            vals.push_back( atof(buf.c_str() ));
-        }
-    }
-    return vals;
-}
-
-std::vector<std::string>  readinpfile2(const std::string& fname) {
-    std::string buf;
-    char dump[255];
-    std::vector<std::string> vals;
-    std::fstream input(fname.c_str(), std::ios::in);
-    if (input.fail()) {
-        std::cerr << "Input file " << fname << " failed to open\n";
-        exit(EXIT_FAILURE);
-    }
-    while (input >> buf) {
-        if (buf.substr(0,2) == "//") {
-            input.getline(dump, 255);
-        } else {
-            vals.push_back( std::string(buf.c_str() ));
-        }
-    }
-    return vals;
-}

Modules/LemmaCore/examples/utlogbarriercg.cpp

-// ===========================================================================
-//
-//       Filename:  utlogbarriercg.cpp
-//
-//        Created:  12/29/2010 09:40:23 AM
-//       Compiler:  Tested with g++, icpc, and MSVC 2010
-//
-//         Author:  Trevor Irons (ti)
-//
-//   Organisation:  Colorado School of Mines (CSM)
-//                  United States Geological Survey (USGS)
-//
-//          Email:  tirons@mines.edu, tirons@usgs.gov
-//
-//  This program is free software: you can redistribute it and/or modify
-//  it under the terms of the GNU General Public License as published by
-//  the Free Software Foundation, either version 3 of the License, or
-//  (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-// ===========================================================================
-
-/**
-  @file
-  @author   Trevor Irons
-  @date     12/29/2010
-  @version   0.0
- **/
-
-#include "LemmaObject.h"
-//#include "logbarriercg.h"
-//#include "datasnmr.h"
-#include <ctime>
-
-#ifdef HAVEBOOSTRANDOM
-#include <boost/random.hpp>
-#include <boost/random/normal_distribution.hpp>
-#endif
-
-using namespace std;
-using namespace Lemma;
-
-MatrixXr BuildG(const Real& T2, const Real& Larmor, const Real& T,
-        const Real& dt, const VectorXr& nT2Bins, const Real& scale);
-
-MatrixXr BuildGw(const Real& T2, const Real& Larmor, const Real& T,
-        const Real& dt, const VectorXr& nT2Bins, const Real& scale,
-        const VectorXr& freqs);
-
-/// test driver program for log-barrier optimization algorithm
-int main() {
-    return 0;
-}
-
-#ifdef AA
-    // Parameters
-    Real T2(.200);
-    Real Larmor(2000); // Hz
-    Real wL = 2.*PI * Larmor;
-    Real T(.6);
-    Real dt(1e-4);
-    int  nT2(20);
-    Real T2Low(.020);
-    Real T2Hi(.220);
-
-    // T2 bins
-    VectorXr T2Bins = VectorXr::LinSpaced(nT2, T2Low, T2Hi);
-
-    // Build true model
-    VectorXr m = VectorXr::Zero(T2Bins.size());
-    //m[4]  = .15;
-    //m[5]  = .15;
-    //m[6]  = .15;
-    m[7]  = .15;
-    m[8]  = .15;
-    m[11] = .15;
-    m[12] = .15;
-    m[13] = .15;
-    m[14] = .15;
-
-    // Build G
-    srand ( std::time(NULL) );
-    Real scale = 1e-4*std::abs(VectorXr::Random(1)[0]);
-    MatrixXr G = BuildG(T2, wL, T, dt, T2Bins, scale);
-
-    #ifdef HAVEBOOSTRANDOM
-    Real mean = 0;
-    Real variance = scale*.05*(.5+.15);
-    boost::mt19937 randgen(static_cast<unsigned int> (std::time(0)));
-    boost::normal_distribution<Real> noise(mean, variance);
-    boost::variate_generator<boost::mt19937, boost::normal_distribution<Real> > nD(randgen, noise);
-    VectorXr noisy = G*m;
-//     for (int i=0; i < noisy.size(); ++i) {
-//        noisy(i) += nD();
-//     }
-    #else
-    VectorXr d = G * m;
-    VectorXr noisy = d.array();// + .05*( .5 + .15 ) *Eigen::ArrayXd::Random(d.size());
-    #endif
-
-    // Clean Data, and 10% random noise data
-    VectorXr RefMod = VectorXr::Zero(m.size());
-
-    // todo let alpha's be set.
-    Real alpha_s  =  .0;
-    Real alpha_t2 = 1.0;
-    Eigen::SparseMatrix<Real> Wd (G.rows(), G.rows());
-    Eigen::SparseMatrix<Real> Wm (G.cols(), G.cols());
-
-    /////////////////
-    // Model objective function
-    int ii = 0;
-    for (int iT2=0; iT2<nT2; ++iT2) {
-        Wm.coeffRef(ii, ii) += alpha_s - alpha_t2;
-        if (iT2 < nT2-1) {
-            Wm.coeffRef(ii, ii+1) += alpha_t2;
-        }
-        ++ii;
-    }
-    Wm.finalize();
-    std::fstream  WmOut( "wmMatrix.dat" , std::ios::out);
-    WmOut << Wm << std::endl;
-    WmOut.close();
-
-    // Data objective function
-    /// @todo add measure of suspected std dev to this.
-    for (int id=0; id<G.rows(); ++id) {
-        Wd.coeffRef(id, id) = 1.; // 1/sigma(i);
-    }
-    Wd.finalize();
-
-    // invert time-domain sinusoid exponent
-    //LogBarrierCG(G, RefMod, noisy, (Real)0., (Real)1e5, nT2, Wd, Wm, scale*1e1);
-    return EXIT_SUCCESS;
-
-//     #if 0
-//     // invert FD
-//     Eigen::FFT<Real> fft;
-//     fft.SetFlag(fft.HalfSpectrum);
-//     VectorXcr dw;
-//     fft.fwd(dw, noisy);
-//
-//     // Compute freqs Hz
-//     VectorXr freqs = DataSNMR::GetNMRSampledFrequencies(T/dt, dt);
-//     Real df = freqs[1];
-//     Real window = 300; // Hz
-//     int iL = (int)(Larmor/df);
-//     MatrixXr Gw = BuildGw(T2, wL, T, dt, T2Bins, scale, freqs.segment(iL-window/2, window));
-//
-//     VectorXr dwu = VectorXr::Zero(2.*window);
-//     dwu.head(window) = dw.segment(iL-window/2, window).real();
-//     dwu.tail(window) = dw.segment(iL-window/2, window).imag();
-//
-//     Eigen::DynamicSparseMatrix<Real> Wdw (Gw.rows(), Gw.rows());
-//     for (int id=0; id<Gw.rows(); ++id) {
-//         Wdw.coeffRef(id, id) = 1.; // 1/sigma(i);
-//     }
-//     Wdw.finalize();
-//     std::cout << "psize " << (Gw*RefMod).size() << std::endl;
-//     VectorXr dw2 = Gw*m;
-//     //std::cout << dw2 << std::endl;
-//     std::cout << "Gw " << Gw.rows() << "\t" << Gw.cols() << std::endl;
-//     std::cout << "dwu " << dwu.size() << std::endl;
-//     //RefMod.array() += .1;
-//     VectorXr mod = LogBarrierCG(Gw, RefMod, dwu, 0., 3., nT2, Wdw, Wm,scale*1e5);
-//     //VectorXr mod = LogBarrierCG(Gw, dwu, 0., 1e5);
-//
-//     std::fstream Gws("gw.out", std::ios::out);
-//     Gws << Gw << std::endl;
-//     Gws.close();
-//     #endif
-}
-
-#endif
-
-MatrixXr BuildG(const Real& T2, const Real& wL, const Real& T,
-            const Real& dt, const VectorXr& T2Bins, const Real& scale) {
-    std::cout << "scale " << scale << std::endl;
-    int nt = T/dt;
-    int nT2 = T2Bins.size();
-    MatrixXr G = MatrixXr::Zero(nt,nT2);
-    for (int iT2=0; iT2<nT2; ++iT2) {
-        Real t=0;
-        for (int it=0; it<nt; ++it) {
-            G(it, iT2) = scale * exp(-t/T2Bins(iT2)) * sin(wL * t);
-            t += dt;
-        }
-    }
-    return G;
-}
-
-
-MatrixXr BuildGw(const Real& T2, const Real& wL, const Real& T,
-            const Real& dt, const VectorXr& T2Bins, const Real& scale,
-            const VectorXr &freqs) {
-    VectorXr omegas = freqs.array() * 2.*PI;
-    std::cout << "scale " << scale << std::endl;
-    int nT2 = T2Bins.size();
-    MatrixXr Gw = MatrixXr::Zero(2*freqs.size(), nT2);
-    int nW = freqs.size();
-    Real sc = 1./dt;
-    for (int iT2=0; iT2<nT2; ++iT2) {
-        for (int iw=0; iw<freqs.size(); ++iw) {
-            Real a = 1./T2Bins(iT2);
-            Complex T = wL / ( wL*wL + (a+Complex(0, omegas[iw]))*(a+Complex(0,omegas[iw])) ) ;
-            Gw(iw, iT2)     = sc * scale * std::real(T);
-            Gw(iw+nW, iT2) = sc * scale * std::imag(T);
-        }
-    }
-    return Gw;
-}

Modules/LemmaCore/examples/utpolygonalantenna.cpp

-// ===========================================================================
-//
-//       Filename:  utpolygonalantennae.cpp
-//
-//    Description:  Unit test of PolygonalAntenna
-//
-//        Version:  0.0
-//        Created:  05/26/2010 04:30:56 PM
-//       Revision:  none
-//       Compiler:  Tested with g++, icpc, and MSVC 2000
-//
-//         Author:  Trevor Irons (ti)
-//
-//   Organisation:  Colorado School of Mines (CSM)
-//                  United States Geological Survey (USGS)
-//
-//          Email:  tirons@mines.edu, tirons@usgs.gov
-//
-//  This program is free software: you can redistribute it and/or modify
-//  it under the terms of the GNU General Public License as published by
-//  the Free Software Foundation, either version 3 of the License, or
-//  (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-// ===========================================================================
-
-#include "Lemma"
-
-using namespace Lemma;
-
-int main() {
-
-    PolygonalWireAntenna *pa = PolygonalWireAntenna::New();
-        pa->SetNumberOfPoints(5);
-        pa->SetPoint(0, Vector3r(  0,  0, -1e-3));
-        pa->SetPoint(1, Vector3r( 10,  0, -1e-3));
-        pa->SetPoint(2, Vector3r( 10, 10, -1e-3));
-        pa->SetPoint(3, Vector3r(  0, 10, -1e-3));
-        pa->SetPoint(4, Vector3r(  0,  0, -1e-3));
-        pa->SetNumberOfFrequencies(1);
-        pa->SetFrequency(0,1000.);
-        pa->SetCurrent(10.);
-        pa->SetNumberOfTurns(1);
-
-    Vector3r pos;
-    pos << 23,23,23;
-    pa->ApproximateWithElectricDipoles(pos);
-    std::cout << "pos "<< pos.transpose() << "  ndipoles="
-              << pa->GetNumberOfDipoles() << std::endl;
-    pos << 2,2,2;
-    pa->ApproximateWithElectricDipoles(pos);
-    std::cout << "pos "<< pos.transpose() << "  ndipoles="
-              << pa->GetNumberOfDipoles() << std::endl;
-    pos << 1,1,1;
-    pa->ApproximateWithElectricDipoles(pos);
-    std::cout << "pos "<< pos.transpose() << "  ndipoles="
-              << pa->GetNumberOfDipoles() << std::endl;
-
-    pa->Delete();
-}

Modules/LemmaCore/examples/utreadfemubc.cpp

-// ===========================================================================
-// 
-//       Filename:  utreadfemubc.cpp
-// 
-//    Description:  
-// 
-//        Version:  0.0
-//        Created:  01/03/2013 02:47:24 PM
-//       Revision:  none
-//       Compiler:  Tested with g++ 
-// 
-//         Author:  M. Andy Kass (MAK)
-//
-//   Organisation:  Broken Spoke Development, LLC
-//                  
-//
-//          Email:  mkass@numericalgeo.com
-// 
-//  This program is free software: you can redistribute it and/or modify
-//  it under the terms of the GNU General Public License as published by
-//  the Free Software Foundation, either version 3 of the License, or
-//  (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-// ===========================================================================
-
-#include "Lemma"
-
-using namespace Lemma;
-
-#ifdef LEMMAUSEVTK
-#include "matplot.h"
-using namespace matplot;
-#endif
-
-int main() {
-
-	std::string datfile;
-
-	datfile = "126.obs";
-	
-	DataReaderFemUBC* Reader = DataReaderFemUBC::New();
-	DataFEM* thedata = DataFEM::New();
-
-	Reader->SetDataFEM(thedata);
-
-	try {
-	Reader->ReadData(datfile,1);
-	} catch(std::exception& e) {
-		exit(EXIT_FAILURE);
-	}
-
-	std::cout << *Reader << std::endl;
-	std::cout << *thedata << std::endl;
-
-
-	thedata->Delete();
-	Reader->Delete();
-
-	return EXIT_SUCCESS;
-}

Modules/LemmaCore/examples/utsandbox.cpp

-// ===========================================================================
-//
-//       Filename:  utsandbox.cpp
-//
-//        Created:  07/29/2010 10:34:23 AM
-//       Compiler:  Tested with g++, icpc, and MSVC 2010
-//
-//         Author:  Trevor Irons (ti)
-//
-//   Organisation:  Colorado School of Mines (CSM)
-//                  United States Geological Survey (USGS)
-//
-//          Email:  tirons@mines.edu, tirons@usgs.gov
-//
-//  This program is free software: you can redistribute it and/or modify
-//  it under the terms of the GNU General Public License as published by
-//  the Free Software Foundation, either version 3 of the License, or
-//  (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-// ===========================================================================
-
-/**
-  @file test sandbox helm1rameters
-  @author   Trevor Irons
-  @date     07/29/2010
-  @version   0.0
- **/
-
-#include "Lemma"
-
-using namespace Lemma;
-
-int main() {
-
-    PolygonalWireAntenna *helm1 = PolygonalWireAntenna::New();
-	helm1->SetNumberOfFrequencies(1);
-	helm1->SetFrequency(0, 1000);
-	helm1->SetNumberOfPoints(5);
-	helm1->SetPoint(0, Vector3r(   0,   0, 0));
-	helm1->SetPoint(1, Vector3r(   0,   0, 0));
-	helm1->SetPoint(2, Vector3r(   0,   0, 0));
-	helm1->SetPoint(3, Vector3r(   0,   0, 0));
-	helm1->SetPoint(4, Vector3r(   0,   0, 0));
-	helm1->SetCurrent(1.);
-    helm1->Delete();
-}

Modules/LemmaCore/examples/uttemforward.cpp

-// ===========================================================================
-//
-//       Filename:  uttemforward.cpp
-//
-//    Description:  TEM Forward Modeller
-//
-//        Version:  0.0
-//        Created:  02/10/2011 03:32:18 PM
-//       Revision:  none
-//       Compiler:  Tested with g++, icpc, and MSVC 2000
-//
-//         Author:  M. Andy Kass (MAK)
-//
-//		Copyright:  2011 Trevor Irons and M. Andy Kass
-//
-//   Organisation:  Colorado School of Mines (CSM)
-//                  Broken Spoke Development, LLC
-//
-//          Email:  mkass@numericalgeo.com
-//
-//  This program is free software: you can redistribute it and/or modify
-//  it under the terms of the GNU General Public License as published by
-//  the Free Software Foundation, either version 3 of the License, or
-//  (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-// ===========================================================================
-
-#include <time.h>
-#include "Lemma"
-#include "banner.h"
-
-using namespace Lemma;
-
-#ifdef LEMMAUSEVTK
-#include "matplot.h"
-using namespace matplot;
-#endif
-
-int main(int argv, char** argc) {
-
-	// Just for timing
-	clock_t launch =clock();
-
-	// Banner display
-	std::string name;
-	std::string version;
-	std::string usage;
-	name = "TEM Forward Modeller - 1D";
-	version = "1.0beta";
-	usage = "temforward1d [inputfile]";
-	banner(name,version,usage);
-    if ( argv < 2 ) {
-        std::cout << "No input file specified, should be of format\n";
-        std::cout <<
-"origparabk.obsy        ! Observations-style file.\n\
-origpara.con           ! Starting model.\n\
-100                    ! Number of Hankel kernel evaluations.\n\
-100 1. 1.0E+10         ! Number of Fourier kernel evaluations, & min & max freq.\n\
-N                      ! Is noise to be added?\n\
-5.  1.0E-08  30        ! Noise to be added: percentage, threshold, seed.\n\
-" << std::endl;
-
-        exit(0);
-    }
-
-	time_t curr=time(0);
-	std::cout << std::endl;
-	std::cout << "  Start time: " << ctime(&curr) << std::endl;
-
-	// Define objects
-	PolygonalWireAntenna* Trans = PolygonalWireAntenna::New();
-//     PolygonalWireAntenna* pa = PolygonalWireAntenna::New();
-//         pa->SetNumberOfPoints(5);
-// 	    pa->SetPoint(0, Vector3r(   0,   0, -30.001));
-// 	    pa->SetPoint(1, Vector3r(   0,  20, -35.001));
-// 	    pa->SetPoint(2, Vector3r(  20 , 20, -35.001));
-// 	    pa->SetPoint(3, Vector3r(  20,   0, -30.001));
-// 	    pa->SetPoint(4, Vector3r(   0,   0, -30.001));
-// 	    pa->SetCurrent(100.);
-//         pa->SetNumberOfTurns(1);
-
-
-	//DipoleSource* Trans = DipoleSource::New();
-	ReceiverPoints *Receivers = ReceiverPoints::New();
-	LayeredEarthEM *Earth = LayeredEarthEM::New();
-	VectorXr maintimes;
-
-    /////////////////////////////////////
-	// Using model reader
-	ModelReaderTem1DUBC* Reader = ModelReaderTem1DUBC::New();
-	    Reader->SetEMEarth1D(Earth);
-	    Reader->SetTransmitter(Trans);
-	    Reader->SetReceiver(Receivers);
-	    Reader->ReadParameters( argc[1] );
-	    maintimes = Reader->GetTimes();
-
-	// Attach it to instrumentTEM
-	InstrumentTem *instrument = InstrumentTem::New();
-	    instrument->EMEarthModel(Earth);
-	    instrument->SetTransmitLoop(Trans);
-	    //instrument->SetTransmitLoop(pa);
-	    //instrument->SetDipoleSource(Trans);
-	    instrument->SetReceiver(Receivers);
-
-
-
-        // TODO need to input these
-        VectorXr widths = VectorXr::Ones(maintimes.size()); // * 1e-5;
-        /*
-        widths.segment(0,5).array()  *= 5e-6;
-        widths.segment(5,5).array()  *= 1e-5;
-        widths.segment(10,5).array() *= 5e-5;
-        widths.segment(15,5).array() *= 2e-4;
-        widths.segment(20,5).array() *= 4e-4;
-        //widths.segment(25,5).array() *= 4e-4;
-        */
-        /*
-        widths << .48,4.,8.,8.,8.,8.,8.,12.,12.,12.,16.,16.,16.,20.,24.,24.,28.,32.,32.,36.,40.,44.,52.,
-  				56.,64.,68.,76.,88.,96.,104.,120.,132.,144.,160.,180.,200.,220.,248.,272.,304.,336.,376.,
-  				416.,464.,516.,572.,636.,708.,784.,872.,968.,1076.,1196.,1328.,1476.,1640.,1824.,2024.,
-  				2248.,2500. ;
-        */
-        widths *= 1e-6;
-        std::cout << widths.transpose() << std::endl;
-
-        instrument->SetReferenceTime(.025);
-        //instrument->SetReferenceTime(.025);
-	    instrument->SetTimeGates(maintimes, widths);
-
-        //instrument->SetReceiverType(MAGNETOMETER);
-        instrument->SetReceiverType(INDUCTIVE);
-        // Set the pulse
-        VectorXr Amp(4); Amp << 0,1,1,0;
-        VectorXr Times(4); Times << 0., .0005, .02497, .025;
-
-        //VectorXr Amp(4); Amp << 0,1,1,0;
-        //VectorXr Times(4); Times << -0.025, -0.0245, -0.00003, 0.0;
-        //instrument->SetPulse(Amp, Times);
-
-        //VectorXr Amp(3); Amp << 0,1,0;
-        //VectorXr Times(3); Times << 0, .015, .030;
-        //instrument->SetPulse(Amp, Times);
-
-        //VectorXr Amp(3); Amp << 0,1,0;
-        //VectorXr Times(3); Times << 0, .01, .020;
-        instrument->SetPulse(Amp, Times);
-
-    std::cout << *Earth << "\n" << *Trans << "\n" << *Receivers << std::endl;
-
-	// Perform the forward model
-	//instrument->MakeDirectCalculation( FHTKEY201  );
-	//instrument->MakeLaggedCalculation( ANDERSON801 );
-	//instrument->MakeLaggedCalculation( QWEKEY );
-	//instrument->MakeLaggedCalculation( CHAVE );
-	instrument->MakeLaggedCalculation( FHTKEY201 );
-	//instrument->MakeLaggedCalculation( FHTKEY101 );
-
-    int nlag = instrument->GetMeasurements().rows();
-	// Output results to screen
-	for (int ii=0; ii<nlag; ii++) {
-		std::cout<<"  "<<instrument->GetMeasurements()(ii,0)<<"  "<<instrument->GetMeasurements()(ii,1)<<std::endl;
-	}
-
-	// Output results to file
-	std::ofstream outfile1;
-	outfile1.open("solution.out");
-    //outfile1 << "//timegate [ms]\t dB/dt [nT/s]" << std::endl;
-    outfile1 << "//timegate [s]\t dB/dt [T/s]" << std::endl;
-	for (int ii=0; ii<nlag; ii++) {
-		//outfile1 << 1e3*instrument->GetMeasurements()(ii,0)<< "\t" << (MU0*1e9)*instrument->GetMeasurements()(ii,1)<<std::endl;
-		outfile1 << instrument->GetMeasurements()(ii,0)<< "\t" << MU0*instrument->GetMeasurements()(ii,1) << std::endl;
-		//outfile1 << instrument->GetMeasurements()(ii,0)<< "\t" << instrument->GetMeasurements()(ii,1)<<std::endl;
-	}
-	outfile1.close();
-
-
-	// Timing stuff
-	std::cout << "  Time for execution: " <<  (clock()-launch)/CLOCKS_PER_SEC   << " [CPU] seconds."
-		 << std::endl;
-
-
-	instrument->Delete();
-	Trans->Delete();
-	Earth->Delete();
-	Receivers->Delete();
-	Reader->Delete();
-
-	return EXIT_SUCCESS;
-}
-
-

Modules/LemmaCore/examples/utteminv1d.cpp

-// ===========================================================================
-//
-//       Filename:  utteminv1d.cpp
-//
-//    Description:  Invert for the difference in water table
-//
-//        Version:  0.0
-//        Created:  03/23/2011 02:07:19 PM
-//       Revision:  none
-//       Compiler:  Tested with g++, icpc, and MSVC 2000
-//
-//         Author:  M. Andy Kass (MAK)
-//
-//   Organisation:  Colorado School of Mines (CSM)
-//                  Broken Spoke Development, LLC
-//
-//          Email:  mkass@numericalgeo.com
-//
-//  This program is free software: you can redistribute it and/or modify
-//  it under the terms of the GNU General Public License as published by
-//  the Free Software Foundation, either version 3 of the License, or
-//  (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-// ===========================================================================
-
-#include "Lemma"
-#include "banner.h"
-
-using namespace Lemma;
-
-int main () {
-
-	VectorXr maintimes;
-	int ntimes;
-
-	//Banner
-	std::string name;
-	std::string version;
-	std::string usage;
-	name = "TEM Inversion - 1D";
-	version = "1.0beta";
-	usage = "teminv1d [inputfile]";
-	banner(name,version,usage);
-
-	PolygonalWireAntenna* Trans = PolygonalWireAntenna::New();
-	ReceiverPoints* Receivers = ReceiverPoints::New();
-	LayeredEarthEM* StartingMod = LayeredEarthEM::New();
-	//LayeredEarthEM* RecoveredMod = LayeredEarthEM::New();
-	InverseSolverTEM1D* Inverse = InverseSolverTEM1D::New();
-
-
-	Trans->SetNumberOfPoints(5);
-    Trans->SetPoint(0, Vector3r(   0,   0, -1e-3));
-    Trans->SetPoint(1, Vector3r( 100,   0, -1e-3));
-    Trans->SetPoint(2, Vector3r( 100, 100, -1e-3));
-    Trans->SetPoint(3, Vector3r(   0, 100, -1e-3));
-    Trans->SetPoint(4, Vector3r(   0,   0, -1e-3));
-	Trans->SetCurrent(1);
-	Trans->SetNumberOfTurns(1);
-    Trans->SetMinDipoleRatio(1/2.);
-
-	Vector3r loc;
-	Real ox = 50.;
-	Real oy = 50.;
-	Real depth = -1.e-3;
-	Receivers->SetNumberOfReceivers(1);
-	loc << ox,oy,depth;
-	Receivers->SetLocation(0,loc);
-
-	StartingMod->SetNumberOfLayers(22);
-	StartingMod->SetLayerConductivity( (VectorXcr(22) << 0.,1.e-3,
-		1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,
-		1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,1.e-3,1.e-3).finished() );
-	StartingMod->SetLayerThickness((VectorXr(20)<<4,4,4,4,4,4,4,4,4,4,4,4,4,
-		4,4,4,4,4,4,4).finished());
-	//EM-47 gate times
-	ntimes = 30;
-	maintimes.resize(ntimes);
-	maintimes << 36.,45.25,57.,72.25,92.,117.,148.,186.5,234.,290.,
-		352.5,427.5,525.,647.5,802.5,1002.5,1257.5,1582.5,1997.5,2525.,
-		3197.5,4055.,5147.5,6542.5,8322.5,10592.,13490.,17187.,21902.,
-		27915.;
-	maintimes = maintimes.array() /1000000;
-
-	Inverse->AttachStartMod(StartingMod);
-	Inverse->AttachWireAntenna(Trans);
-	Inverse->AttachReceiver(Receivers);
-	Inverse->SetTimes(maintimes);
-	LayeredEarthEM* RecoveredMod = StartingMod->Clone();
-	Inverse->AttachRecMod(RecoveredMod);
-
-	//Read input data - temp for SEG!
-	/// TODO write a TEM data reader class.  and a functional TEM data class
-	std::fstream infile("rotateddat.dat",std::ios::in);
-	if (infile.fail()) {
-		std::cout << "Shit!" << std::endl;
-	}
-	MatrixXr rotinpdata;
-	rotinpdata.resize(30,1);
-	for (int ii=0;ii<30;ii++) {
-		infile >> rotinpdata(ii);
-	}
-	infile.close();
-
-
-	Inverse->AttachMeasuredData(rotinpdata);
-	//Inverse->SetFreeParams( (VectorXi(2)<<0,1).finished(),
-	//	(VectorXi(3)<<1,2,3).finished());
-
-	std::cout << *Inverse << std::endl;
-
-	Inverse->Calculate();
-	//Inverse->ShowSoln();
-	//Inverse->WriteSoln("temp.dat");
-
-	Inverse->Delete();
-	RecoveredMod->Delete();
-	StartingMod->Delete();
-	Receivers->Delete();
-	Trans->Delete();
-
-	return EXIT_SUCCESS;
-}

Modules/LemmaCore/examples/uttemreader.cpp

-// ===========================================================================
-// 
-//       Filename:  uttemreader.cpp
-// 
-//    Description:  
-// 
-//        Version:  0.0
-//        Created:  02/19/2011 12:30:59 PM
-//       Revision:  none
-//       Compiler:  Tested with g++, icpc, and MSVC 2000 
-// 
-//         Author:  M. Andy Kass (MAK)
-//
-//   Organisation:  Colorado School of Mines (CSM)
-//                  Broken Spoke Brewery, LLC
-//
-//          Email:  mkass@numericalgeo.com
-// 
-//  This program is free software: you can redistribute it and/or modify
-//  it under the terms of the GNU General Public License as published by
-//  the Free Software Foundation, either version 3 of the License, or
-//  (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-// ===========================================================================
-
-#include "Lemma"
-
-using namespace Lemma;
-
-
-int main() {
-
-	/*
-	ModelReaderTem1DUBC* Reader = ModelReaderTem1DUBC::New();
-	PolygonalWireAntenna* Trans = PolygonalWireAntenna::New();
-	ReceiverPoints *Receivers = ReceiverPoints::New();
-	LayeredEarthEM *Earth = LayeredEarthEM::New();
-	Reader->SetEMEarth1D(Earth);
-	Reader->SetTransmitter(Trans);
-	Reader->SetReceiver(Receivers);
-	Reader->ReadParameters("em1dtmfwd.in");
-
-	Reader->Delete();
-	Earth->Delete();
-	Receivers->Delete();
-	Trans->Delete();
-	*/
-
-	int rnObs;
-	int rnGates;
-	std::string inputfile;
-	MatrixXr somedata;
-	Vector3Xr somepositions;
-
-	DataTEM* TheData = DataTEM::New();
-	DataReaderTem* Reader = DataReaderTem::New();
-
-	inputfile = "temreadertest.txt";
-
-	Reader->SetDataTEM(TheData);
-	Reader->ReadData(inputfile);
-
-	rnObs = TheData->GetnObs();
-	rnGates = TheData->GetnGates();
-	somedata = TheData->GetData();
-	somepositions = TheData->GetPositions();
-
-	std::cout << rnObs << " " << rnGates << std::endl;
-	std::cout << somedata << std::endl;
-	std::cout << somepositions << std::endl;
-
-	Reader->Delete();
-	TheData->Delete();
-
-	return EXIT_SUCCESS;
-}

Modules/LemmaCore/examples/uttemsandbox.cpp

-// ===========================================================================
-//
-//       Filename:  uttemsandbox.cpp
-//
-//        Created:  09/29/2010 07:38:26 AM
-//       Compiler:  Tested with g++, icpc, and MSVC 2010
-//
-//         Author:  Trevor Irons (ti), M. Andy Kass
-//
-//
-//   Organisation:  Colorado School of Mines (CSM)
-//                  United States Geological Survey (USGS)
-//					Broken Spoke Development, LLC
-//
-//          Email:  tirons@mines.edu, tirons@usgs.gov
-//					mkass@numericalgeo.com
-//
-//  This program is free software: you can redistribute it and/or modify
-//  it under the terms of the GNU General Public License as published by
-//  the Free Software Foundation, either version 3 of the License, or
-//  (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-// ===========================================================================
-
-/**
-  @file
-  @author   Trevor Irons
-  @date     09/29/2010
-  @version   0.0
- **/
-
-#include "Lemma"
-using namespace Lemma;
-
-#ifdef LEMMAUSEVTK
-#include "matplot.h"
-using namespace matplot;
-#endif
-
-int main() {
-
-
-    int nfreq  =    6000;  // Number of frequencies
-
-	// Specify receiver times
-	int ntimes	=	30;
-	VectorXr times(ntimes);
-	times <<
-	36.0, 45.25, 57.0, 72.25, 92.0,
-	117.0, 148.0, 186.5, 234.0, 290.0,
-	352.5, 427.5, 525.0, 647.5, 802.5,
-	1002.5, 1257.5, 1582.5, 1997.5, 2525.0,
-	3197.5, 4055.0, 5147.5, 6542.5, 8322.5,
-	10592.0, 13490.0, 17187.0, 21902.0, 27915.0;
-
-	times = times.array()*1.0e-6;
-
-	//CALCULATE ABSCISSA
-	//define bounds
-
-	gaussianquadrature *lgqw = gaussianquadrature::New();
-
-	Real lowb;
-	Real upb;
-	lowb = 1.0;
-	upb = 6000000.0;
-	lgqw->SetFreqs(nfreq,upb,lowb);
-	lgqw->CalcAW();
-
-	VectorXr xu(nfreq);
-	xu=lgqw->GetAbscissae();
-	DipoleSource* Trans=DipoleSource::New();
-	Trans->SetType(MAGNETICDIPOLE);
-	Trans->SetPolarisation(ZPOLARISATION);
-	Trans->SetLocation(0.0,0.0,-1e-4);
-
-
-    // Specify Transmitter
-    //PolygonalWireAntenna* Trans  = PolygonalWireAntenna::New();
-    //Trans->SetNumberOfPoints(5);
-    //Trans->SetPoint(0, Vector3r(   0,   0, -1e-3));
-    //Trans->SetPoint(1, Vector3r( 100,   0, -1e-3));
-    //Trans->SetPoint(2, Vector3r( 100, 100, -1e-3));
-    //Trans->SetPoint(3, Vector3r(   0, 100, -1e-3));
-    //Trans->SetPoint(4, Vector3r(   0,   0, -1e-3));
-    Trans->SetNumberOfFrequencies(nfreq);
-    VectorXr  f(nfreq);
-    for (int ifreq=0; ifreq<nfreq; ++ifreq) {
-    //    Trans->SetFrequency(ifreq, 1e-3 + dfreq*(Real)(ifreq));
-		Trans->SetFrequency(ifreq,xu(ifreq));
-        f(ifreq) = xu(ifreq);
-    }
-	//cout << Trans->GetFrequencies();
-    //Trans->SetCurrent(1);
-    //Trans->SetNumberOfTurns(1);
-
-    // Earth properties, top layer is air layer 0 conductivity is fine
-    LayeredEarthEM *Earth = LayeredEarthEM::New();
-        Earth->SetNumberOfLayers(4);
-        Earth->SetLayerConductivity( (VectorXcr(4) << 0.,1.e-6,1.e-2,1.e-6 ).finished() );
-        Earth->SetLayerThickness( (VectorXr(2) << 50, 20).finished() );
-
-    // Receivers, just 1 in the centre for now
-   	ReceiverPoints *Receivers = ReceiverPoints::New();
-		Vector3r loc;
-		Real ox     =    50.;
-		Real oy     =    50.;
-		Real depth  =  -1e-2;
-		Receivers->SetNumberOfReceivers(1);
-		loc << ox, oy, depth;
-		Receivers->SetLocation(0, loc);
-
-	// EmEarth
-	EMEarth1D  *EmEarth = EMEarth1D::New();
-		//EmEarth->AttachWireAntenna(Trans);
-		EmEarth->AttachDipoleSource(Trans);
-		EmEarth->AttachLayeredEarthEM(Earth);
-		EmEarth->AttachReceiverPoints(Receivers);
-		EmEarth->SetFieldsToCalculate(H);
-        // slower but may be more accurate, depending on frequencies
-        EmEarth->SetHankelTransformMethod(CHAVE);
-        //EmEarth->SetHankelTransformMethod(DIGITALFILTERING);
-
-    // Do calculation
-   	//EmEarth->CalculateWireAntennaFields();
-	//EmEarth->MakeCalc();
-	EmEarth->MakeCalc3();
-
-    // Grab Z component
-    // A little painful, I'll try to clean up the API
-    VectorXcr Hw(nfreq);
-    VectorXr  e(nfreq);
-    Hw(0) = 0.; // DC component
-    for (int ifreq=0; ifreq<nfreq; ++ifreq) {
-        Hw(ifreq) = (Receivers->GetHfield(ifreq, 0))(2);
-        e(ifreq) = ifreq;
-    }
-
-    VectorXr Ht(ntimes);                   // Time domain H field
-
-	//Sine transform
-	VectorXr func(nfreq);
-	for (int ii=0;ii<ntimes;++ii) {
-		func = (Hw.imag().array()*((f.array()*times(ii)).sin()));
-		lgqw->SetFunc(func);
-		lgqw->Integrate();
-		Ht(ii)=lgqw->GetResult();
-	}
-	Ht = Ht.array()*(-2.0/PI);
-
-	std::ofstream myfile1;
-	myfile1.open("solution.txt");
-	for (int ii=0;ii<ntimes;++ii) {
-		myfile1 << times(ii) << "   " << Ht(ii) << std::endl;
-	}
-	myfile1.close();
-
-	std::ofstream myfile2;
-	myfile2.open("freq_domain.txt");
-	for (int ii=0;ii<nfreq;++ii) {
-		myfile2 << f(ii) << "  " << Hw(ii).real() << "  " << Hw(ii).imag()
-			<< std::endl;
-	}
-	myfile2.close();
-
-    //std::cout << Ht << std::endl;
-    //std::cout << Hw.real() << std::endl;
-
-    // Quick and dirty plot
-    #ifdef  LEMMAUSEVTK
-    double colour1[3] = {0.0,0.0,1.0};
-    double colour2[3] = {1.0,0.0,0.0};
-
-    Plot2D_VTK p1("Hz", "Re(Hw)", 800, 600);
-    p1.plot(f, Hw.real().eval(), colour1, ".-");
-    p1.show();
-
-    Plot2D_VTK p2("Hz", "Im(Hw)", 800, 600);
-    p2.plot(f, Hw.imag().eval(), colour2, ".-");
-    p2.show();
-
-    Plot2D_VTK p3("Time (seconds)", "Ht", 800, 600);
-    p3.plot(times, Ht, colour2, ".-");
-    p3.show();
-
-	//Plot2D_VTK p4("index", "frequency",800,600);
-	//p4.plot(e,f,colour1,".-");
-	//p4.show();
-
-    #endif
-
-    // Clean up
-    Trans->Delete();
-    Earth->Delete();
-    Receivers->Delete();
-    EmEarth->Delete();
-
-    return EXIT_SUCCESS;
-}

Modules/LemmaCore/examples/wireantenna.cpp

-// ===========================================================================
-//
-//       Filename:  utdipolesource.cpp
-//
-//    Description:
-//
-//        Version:  0.0
-//        Created:  12/02/2009 11:57:14 AM
-//       Revision:  none
-//       Compiler:  g++ (c++)
-//
-//         Author:  Trevor Irons (ti)
-//
-//   Organisation:  Colorado School of Mines (CSM)
-//                  United States Geological Survey (USGS)
-//
-//          Email:  tirons@mines.edu, tirons@usgs.gov
-//
-//  This program is free software: you can redistribute it and/or modify
-//  it under the terms of the GNU General Public License as published by
-//  the Free Software Foundation, either version 3 of the License, or
-//  (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-// ===========================================================================
-
-#include <iostream>
-#include <fstream>
-
-#include "dipolesource.h"
-#include "layeredearth.h"
-#include "receiverpoints.h"
-#include "emearth1d.h"
-#include "WireAntenna.h"
-#include "PolygonalWireAntenna.h"
-
-#if  LEMMAUSEVTK
-#include "vtkRenderer.h"
-#include "vtkRenderWindow.h"
-#include "vtkRenderWindowInteractor.h"
-#include "vtkRenderLargeImage.h"
-#include "vtkPNGWriter.h"
-#endif     // -----  not LEMMA_USE_VTK  -----
-
-// For testing purposes disable VTK and run scale.sh
-//#undef LEMMAUSEVTK
-
-#include "timer.h"
-
-using namespace Lemma;
-
-double randDouble(double low, double high) {
-	//srand(time(0));
-	double temp;
-	/* swap low & high around if the user makes no sense */
-	if (low > high)	{
-	temp = low;
-	low = high;
-	high = temp;
-	}
-	/* calculate the random number & return it */
-	temp = (rand() / (static_cast<double>(RAND_MAX) + 1.0))
-	* (high - low) + low;
-	return temp;
-}
-
-
-int main() {
-
-	// Keep track of time
-	jsw_timer timer;
-
-
-	srand(time(0));
-
-	PolygonalWireAntenna *pa = PolygonalWireAntenna::New();
-	pa->SetNumberOfFrequencies(1);
-	pa->SetFrequency(0, 1000);
-	pa->SetNumberOfPoints(5);
-	pa->SetPoint(0, Vector3r(   0,   0, -.001));
-	pa->SetPoint(1, Vector3r( 100,   0, -.001));
-	pa->SetPoint(2, Vector3r( 100, 100, -.001));
-	pa->SetPoint(3, Vector3r(   0, 100, -.001));
-	pa->SetPoint(4, Vector3r(   0,   0, -.001));
-	pa->SetCurrent(1.);
-    pa->SetNumberOfTurns(1);
-	//Vector3r rp = Vector3r::Random(3);
-	//rp << 150., 10, 0.;
-	//rp << -27.1456, 15.2350, -1e-3;
-	//rp << randDouble(-35,35), randDouble(-35,35), randDouble(-35,35);
-	//rp << 3.22806, -13.1548, 14.9695;
-	//rp.setRandom(3);
-	//std::cout <<  "rp " << rp.transpose() << std::endl;
-	//pa->ApproximateWithElectricDipoles(rp);
-
-	WireAntenna *wire = WireAntenna::New();
-		wire->SetNumberOfPoints(5);
-		wire->SetPoint(0, Vector3r(   0,   0, -1e-3));
-		wire->SetPoint(1, Vector3r( 10,   0, -1e-3));
-		wire->SetPoint(2, Vector3r( 10, 10, -1e-3));
-		wire->SetPoint(3, Vector3r(   0, 10, -1e-3));
-		wire->SetPoint(4, Vector3r(   0,   0, -1e-3));
-		// TODO change wire antennae to use my class
-		//wire->SetNumberOfFrequencies(1);
-		wire->SetCurrent(1.);
-		wire->SetNumberOfFrequencies(1);
-		wire->SetFrequency(0, 1000);
-        wire->SetNumberOfTurns(1);
-		//wire->ApproximateWithElectricDipoles(5);
-
-	// Define model
-	VectorXcr sigma(2);
-		sigma << Complex(0.,0), Complex(.1,0);
-	VectorXr  thick(1);
-		thick << 10;
-	LayeredEarthEM *earth = LayeredEarthEM::New();
-		earth->SetNumberOfLayers(2);
-		earth->SetLayerConductivity(sigma);
-		//earth->SetLayerThickness(thick);
-
-	// Receivers
-	ReceiverPoints *receivers = ReceiverPoints::New();
-		Vector3r loc;
-		Real ox    =    50.561 ;
-		Real oy    =   105.235 ;
-		Real depth =    -3.75e1;
-		Real depth2 =   depth;
-		Real dx    =    1.;
-		int nz     =    1;
-		receivers->SetNumberOfReceivers(nz);
-		int ir = 0;
-		for (int iz=0; iz<nz; ++iz) {
-			loc << ox, oy, depth;
-			receivers->SetLocation(ir, loc);
-			depth += dx;
-			++ ir;
-		}
-
-	// EmEarth
-	EMEarth1D  *EmEarth = EMEarth1D::New();
-		//EmEarth->AttachWireAntenna(wire);
-		EmEarth->AttachWireAntenna(pa);
-		EmEarth->AttachLayeredEarthEM(earth);
-		EmEarth->AttachReceiverPoints(receivers);
-		EmEarth->SetFieldsToCalculate(H);
-        //EmEarth->SetHankelTransformMethod(GAUSSIANQUADRATURE);
-
-	// Do calculation
-	timer.begin();
-	EmEarth->CalculateWireAntennaFields();
-	Real paTime = timer.end();
-	std::cout << "Polygonal wire antennae time: " << paTime << "\n";
-
-	//EmEarth->AttachWireAntenna(wire);
-	//timer.begin();
-	//EmEarth->CalculateWireAntennaFields();
-	//Real waTime = timer.end();
-	//std::cout << "Fixed wire antennae time: " << waTime << "\n";
-
-	depth = depth2;
-	std::fstream real("reale_lay.dat", std::ios::out);
-	std::fstream imag("image_lay.dat", std::ios::out);
-	std::fstream hreal("real_lay.dat", std::ios::out);
-	std::fstream himag("imag_lay.dat", std::ios::out);
-	for (int iz=0; iz<nz; ++iz) {
-		Vector3cr temp = receivers->GetEfield(0,iz);
-		real << ox << "\t" << oy << "\t" << depth << "\t"
-				<< temp(0).real() << "\t" << temp(1).real()
-				<< "\t" << temp(2).real() << std::endl;
-		imag << ox << "\t" << oy << "\t" << depth << "\t"
-				<< std::imag(temp(0)) << "\t" << std::imag(temp(1))
-				<< "\t" << std::imag(temp(2)) << std::endl;
-		temp = receivers->GetHfield(0, iz);
-		hreal << ox << "\t" << oy << "\t" << depth << "\t"
-				<< std::real(temp(0)) << "\t" << std::real(temp(1))
-				<< "\t" << std::real(temp(2)) << std::endl;
-		himag << ox << "\t" << oy << "\t" << depth << "\t"
-				<< std::imag(temp(0)) << "\t" << std::imag(temp(1))
-				<< "\t" << std::imag(temp(2)) << std::endl;
-		depth += dx;
-	}
-	real.close();
-	imag.close();
-	hreal.close();
-	himag.close();
-	EmEarth->Delete();
-	receivers->Delete();
-	earth->Delete();
-	//wire->Delete();
-
-#if  LEMMAUSEVTK
-	// Create the usual rendering stuff.
-	vtkRenderer           *renderer = vtkRenderer::New();
-	vtkRenderWindow         *renWin = vtkRenderWindow::New();
-	vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
-
-	// Line of tx
-	vtkLineSource       *vline = vtkLineSource::New();
-	vtkTubeFilter       *vTube = vtkTubeFilter::New();
- 	vtkPolyDataMapper   *vMapper = vtkPolyDataMapper::New();
-	vtkActor             *vActor = vtkActor::New();
-	vline->SetPoint1(0,0,0);
-	vline->SetPoint2(10,0,0);
-
-	vTube->SetInputConnection(vline->GetOutputPort());
-	vTube->SetRadius(.2);
-	vTube->SetNumberOfSides(6);
-	vMapper->SetInputConnection(vTube->GetOutputPort());
-	vActor->SetMapper(vMapper);
-	vActor->GetProperty()->SetColor(0.0, .0, 1.0);
-	vActor->GetProperty()->SetOpacity(.15);
-	renderer->AddActor(vActor);
-
-	vtkLineSource       *vline2 = vtkLineSource::New();
-	vtkTubeFilter       *vTube2 = vtkTubeFilter::New();
- 	vtkPolyDataMapper   *vMapper2 = vtkPolyDataMapper::New();
-	vtkActor             *vActor2 = vtkActor::New();
-	vline2->SetPoint1(10,0,0);
-	vline2->SetPoint2(10,10,0);
-
-	vTube2->SetInputConnection(vline2->GetOutputPort());
-	vTube2->SetRadius(.2);
-	vTube2->SetNumberOfSides(6);
-	vMapper2->SetInputConnection(vTube2->GetOutputPort());
-	vActor2->SetMapper(vMapper2);
-	vActor2->GetProperty()->SetColor(0.0, .0, 1.0);
-	vActor2->GetProperty()->SetOpacity(.15);
-	renderer->AddActor(vActor2);
-
-	vtkLineSource       *vline3 = vtkLineSource::New();
-	vtkTubeFilter       *vTube3 = vtkTubeFilter::New();
- 	vtkPolyDataMapper   *vMapper3 = vtkPolyDataMapper::New();
-	vtkActor             *vActor3 = vtkActor::New();
-	vline3->SetPoint1(10,10,0);
-	vline3->SetPoint2(0,10,0);
-
-	vTube3->SetInputConnection(vline3->GetOutputPort());
-	vTube3->SetRadius(.2);
-	vTube3->SetNumberOfSides(6);
-	vMapper3->SetInputConnection(vTube3->GetOutputPort());
-	vActor3->SetMapper(vMapper3);
-	vActor3->GetProperty()->SetColor(0.0, .0, 1.0);
-	vActor3->GetProperty()->SetOpacity(.15);
-	renderer->AddActor(vActor3);
-
-	vtkLineSource       *vline4 = vtkLineSource::New();
-	vtkTubeFilter       *vTube4 = vtkTubeFilter::New();
- 	vtkPolyDataMapper   *vMapper4 = vtkPolyDataMapper::New();
-	vtkActor             *vActor4 = vtkActor::New();
-	vline4->SetPoint1(0,10,0);
-	vline4->SetPoint2(0,0,0);
-
-	vTube4->SetInputConnection(vline4->GetOutputPort());
-	vTube4->SetRadius(.2);
-	vTube4->SetNumberOfSides(6);
-	vMapper4->SetInputConnection(vTube4->GetOutputPort());
-	vActor4->SetMapper(vMapper4);
-	vActor4->GetProperty()->SetColor(0.0, .0, 1.0);
-	vActor4->GetProperty()->SetOpacity(.15);
-	renderer->AddActor(vActor4);
-
-    loc << 50, 50, -1e-3;
-	pa->ApproximateWithElectricDipoles(loc);
-
-    vtkActor **pdipActors = new vtkActor*[pa->GetNumberOfDipoles()];
-    std::cout <<  "Wire approximated with " << pa->GetNumberOfDipoles() << std::endl;
-	for (int id=0; id<pa->GetNumberOfDipoles(); ++id) {
-		pdipActors[id] = pa->GetVtkActor(id);
-		renderer->AddActor(pdipActors[id]);
-	}
-
-    /*
-    vtkActor **dipActors = new vtkActor*[wire->GetNumberOfDipoles()];
-	for (int id=0; id<wire->GetNumberOfDipoles(); ++id) {
-		dipActors[id] = wire->GetVtkActor(id);
-		renderer->AddActor(dipActors[id]);
-	}
-    */
-
-	renderer->SetBackground(1,1,1);
-
-	// Render the window
-	renWin->AddRenderer(renderer);
-	renWin->SetWindowName("Wire antennae");
-
-	iren->SetRenderWindow(renWin);
-	iren->Initialize();
-	iren->Start();
-	iren->Render();
-
-    #if 0
-	cout << "Enter File name?: ";
-	std::string pngName;
-	std::cin >> pngName;
-	vtkPNGWriter *pngwrite = vtkPNGWriter::New();
-	vtkRenderLargeImage *renlarge = vtkRenderLargeImage::New();
-	renlarge->SetInput(renderer);
-	renlarge->SetMagnification(2);
-	pngwrite->SetInputConnection(renlarge->GetOutputPort());
-	pngName.append(".png");
-	pngwrite->SetFileName(pngName.c_str());
-	pngwrite->Write();
-    #endif
-
-#endif     // -----  not LEMMA_USE_VTK  -----
-
-
-	//std::cout << *pa << std::endl;
-	//pa->Delete();
-
-	return 0;
-}

Modules/LemmaCore/include/CubicSplineInterpolator.h

 
 namespace Lemma {
 
-// Simple struct to hold spline terms
+
+/**
+ * \brief Simple struct to hold spline terms
+ * \details This struct holds the actual knot and spline interpolation terms.
+ */
 struct SplineSet{
     VectorXr a;
     VectorXr b;

Modules/LemmaCore/include/EarthModel.h

     // ===================================================================
     //        Class:  EarthModel
     /// \ingroup LemmaCore
-    /// \brief abstract class for Earth models
+    /// \brief   abstract class for Earth models
     /// \details
     // ===================================================================
     class EarthModel : public LemmaObject {
             void SetMagneticFieldComponents(const Vector3r &bfield,
                             const MAGUNITS &unit);
 
-            /// Sets the magnetic field using inclination, declination,
-            /// and magnitude, units of Tesla
-            /// @param[in] inc is the field's inclination
-            /// @param[in] dec is the field's declination
-            /// @param[in] Mag is the field's magnitude
-            /// @param[in] unit specifies the the units used.
-            /// The components are set according to
-            /// \f{eqnarray*} { B_x =& B \cos(inc (\pi/180)) \cos(dec (\pi/180))
-            ///            \\   B_y =& B \cos(inc (\pi/180)) \sin(dec (\pi/180))
-            ///            \\   B_z =& B \sin(inc (\pi/180))
-            /// \f}
+            /** Sets the magnetic field using inclination, declination,
+                and magnitude, units of Tesla
+                @param[in] inc is the field's inclination
+                @param[in] dec is the field's declination
+                @param[in] Mag is the field's magnitude
+                @param[in] unit specifies the the units used.
+                The components are set according to
+                \f{eqnarray*} { B_x =& B \cos(inc (\pi/180)) \cos(dec (\pi/180))
+                           \\   B_y =& B \cos(inc (\pi/180)) \sin(dec (\pi/180))
+                           \\   B_z =& B \sin(inc (\pi/180))
+                \f}
+             */
             void SetMagneticFieldIncDecMag(const Real& inc, const Real&dec,
                             const Real& Mag, const MAGUNITS &unit);
 
             // ====================  INQUIRY       =======================
 
-            /// Gets the magnetic field of the earth, in T
+            /** @return the magnetic field of the earth, in T
+             */
             Vector3r GetMagneticField( );
 
-            /// Gets the magnetic field of the earth, in T
+            /** @return the magnetic field of the earth, in Gauss
+             */
             Vector3r GetMagneticFieldInGauss(  );
 
-            /// Gets the magnetic field unit vector of the earth
+            /** @return the magnetic field unit vector of the earth
+             */
             Vector3r GetMagneticFieldUnitVector( );
 
-            /// Returns the magnitude of the magnetic field \f$ \Vert
-            /// \mathbf{B}_0 \Vert \f$
+            /** @return the magnitude of the magnetic field (in T)
+             * \f$ \Vert \mathbf{B}_0 \Vert \f$
+             */
             Real GetMagneticFieldMagnitude();
 
-            /// Returns the magnitude of the magnetic field \f$ \Vert
-            /// \mathbf{B}_0 \Vert \f$ in Gauss units
+            /** @return the magnitude of the magnetic field
+             *  \f$ \Vert \mathbf{B}_0 \Vert \f$ in Gauss units
+             */
             Real GetMagneticFieldMagnitudeInGauss( );
 
-            /** Returns the name of the underlying class, similiar to Python's type */
+            /** @return the name of the underlying class, similiar to Python's
+                        type
+             */
             virtual inline std::string GetName() const;
 
         protected:

Modules/LemmaCore/include/Filter.h

     // ===================================================================
     //  Class:  Filter
     /**
-      @class  Filter
       \ingroup LemmaCore
       \brief  Abstract class for filtering.
       \details Derived classes include fourier domain and time domain filters.

Modules/LemmaCore/include/GridReader.h

 namespace Lemma {
 
     /**
-      @class
       \ingroup LemmaCore
       \brief   Abstract class for grid readers.
       \details Provides a consistent interface for reading grid files in Lemma.

Modules/LemmaCore/include/RectilinearGridReader.h

 namespace Lemma {
 
     /**
-      @class
       \ingroup LemmaCore
       \brief   Base Class for rectilinear grid reader data files
       \details

Modules/LemmaCore/include/WindowFilter.h

     // ===================================================================
     //  Class:  WindowFilter
     /**
-      @class   WindowFilter
       \ingroup LemmaCore
       \brief   Fourier domain window filter.
       \details Current types are Hamming and Hanning. Others to be added.

Modules/LemmaCore/include/helper.h

   }
 };
 
+/**
+ *   \brief Serializes and Deserializes VectorXr arrays
+ */
 template<>
 struct convert<Lemma::VectorXr> {
   static Node encode(const Lemma::VectorXr& rhs) {

Modules/Optimization/include/bicgstab.h

-/*
- modifed from http://www.netlib.org/templates/cpp//
- Iterative template routine -- BiCGSTAB
-
- BiCGSTAB solves the unsymmetric linear system Ax = b
- using the Preconditioned BiConjugate Gradient Stabilized method
-
- BiCGSTAB follows the algorithm described on p. 27 of the
- SIAM Templates book.
-
- The return value indicates convergence within max_iter (input)
- iterations (0), or no convergence within max_iter iterations (1).
-
- Upon successful return, output arguments have the following values:
-
-        x  --  approximate solution to Ax = b
- max_iter  --  the number of iterations performed before the
-               tolerance was reached
-      tol  --  the residual after the final iteration
-*/
-
-#include <iostream>
-#include <fstream>
-#include "lemma.h"
-
-namespace Lemma {
-
-    template <typename Scalar>
-    VectorXr BiCGSTAB(const MatrixXr &A, const VectorXr &x0, const VectorXr &b,
-          const MatrixXr &M, int &max_iter, Scalar& tol) {
-        Scalar resid;
-        Scalar rho_1(0), rho_2(0), alpha(0), beta(0), omega(0);
-        VectorXr p, phat, s, shat, t, v;
-        VectorXr x = x0;
-        Scalar normb = b.norm();
-        VectorXr r = b - A * x;
-        VectorXr rtilde = r;
-
-        if (normb == 0.0)
-          normb = 1;
-
-        if ((resid = r.norm() / normb) <= tol) {
-          tol = resid;
-          max_iter = 0;
-          //return 0;
-          return x;
-        }
-
-        for (int i = 1; i <= max_iter; i++) {
-          rho_1 = rtilde.dot(r);
-          if (rho_1 == 0) {
-            tol = r.norm() / normb;
-            //return 2;
-            return x;
-          }
-          if (i == 1)
-            p = r;
-          else {
-            beta = (rho_1/rho_2) * (alpha/omega);
-            p = r + beta * (p - omega * v);
-          }
-          phat = M*p; //M.solve(p);
-          v = A * phat;
-          alpha = rho_1 / rtilde.dot(v);
-          s = r - alpha * v;
-          if ((resid = s.norm()/normb) < tol) {
-            x += alpha * phat;
-            tol = resid;
-            //return 0;
-            return x;
-          }
-          shat = M*s;//M.solve(s);
-          t = A * shat;
-          omega = t.dot(s) / t.dot(t);
-          x += alpha * phat + omega * shat;
-          r = s - omega * t;
-
-          rho_2 = rho_1;
-          if ((resid = r.norm() / normb) < tol) {
-            tol = resid;
-            max_iter = i;
-            //return 0;
-            return x;
-          }
-          if (omega == 0) {
-            tol = r.norm() / normb;
-            //return 3;
-            return x;
-          }
-        }
-
-        tol = resid;
-        return x;
-    }
-}
-
-/* vim: set tabstop=4 expandtab: */
-/* vim: set filetype=cpp: */

Modules/Optimization/include/cg.h

-/* This file is part of Lemma, a geophysical modelling and inversion API */
-
-/* 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
-  @author   Trevor Irons
-  @version  $Id: cg.h 87 2013-09-05 22:44:05Z tirons $
- **/
-
-#ifndef  CG_INC
-#define  CG_INC
-
-
-#include <iostream>
-#include <fstream>
-#include "lemma.h"
-
-namespace Lemma {
-
-    /** Port of netlib.org http://www.netlib.org/templates/cpp//cg.h
-     *  Solves the symmetric postive definite system Ax=b.
-     *  No preconditioner is used.
-     *  Iterative template routine -- CG
-     *
-     *  CG solves the symmetric positive definite linear
-     *  system Ax=b using the Conjugate Gradient method.
-     *
-     *  CG follows the algorithm described on p. 15 in the
-     *  SIAM Templates book.
-     *
-     *  The return value indicates convergence within max_iter (input)
-     *  iterations (0), or no convergence within max_iter iterations (1).
-     *
-     *  Upon successful return, output arguments have the following values:
-     *
-     *         x  --  approximate solution to Ax = b
-     *  max_iter  --  the number of iterations performed before the
-     *                tolerance was reached
-     *       tol  --  the residual after the final iteration
-     *  @param[in] A is a Real matrix A to be solved.
-     *  @param[in] x0 is the starting model.
-     *  @param[in] b is the right hand side.
-     */
-    template < typename Scalar >
-    VectorXr CG(const MatrixXr &A, const VectorXr &x0, const VectorXr &b,
-        int &max_iter, Scalar &tol) {
-
-        VectorXr p, q;
-        Scalar alpha, beta, rho, rho_1(0);
-        VectorXr x = x0;
-        Scalar normb = b.norm( );
-        VectorXr r = b - A*x;
-
-        if (normb == 0.0) {
-            normb = 1;
-        }
-
-        Scalar resid = r.norm() / normb;
-        if (resid <= tol) {
-            tol = resid;
-            max_iter = 0;
-            return x;
-        }
-
-        for (int i = 1; i <= max_iter; i++) {
-
-            rho = r.transpose()*r;
-
-            if (i == 1) {
-                p = r;
-            }
-            else {
-                beta = rho / rho_1;
-                p = r + beta * p;
-            }
-
-            q = A*p;
-            alpha = rho / p.dot(q);
-
-            x += alpha * p;
-            r -= alpha * q;
-
-            if ((resid = r.norm() / normb) <= tol) {
-                tol = resid;
-                max_iter = i;
-                return x;
-            }
-            rho_1 = rho;
-        }
-        tol = resid;
-        std::cerr << "CG FAILED TO REACH CONVERGENCE\n";
-        return x;
-    }
-
-    // Specialised routine that appliex mod(Ax) so that b and x are in real, but
-    // A is complex.
-    template < typename Scalar >
-    VectorXr CG_ModulusAx(const MatrixXcr &A, const VectorXr &x0, const VectorXr &b,
-        int &max_iter, Scalar &tol) {
-
-        VectorXr p, q;
-        Scalar beta, rho, rho_1(0);
-        Scalar alpha;
-        VectorXr x = x0;
-        Scalar normb = b.norm( );
-        VectorXr r = b.array() - (A*x).array().abs();
-
-        if (normb == 0.0) {
-            normb = 1;
-        }
-
-        Scalar resid = r.norm() / normb;
-        if (resid <= tol) {
-            tol = resid;
-            max_iter = 0;
-            return x;
-        }
-
-        for (int i = 1; i <= max_iter; i++) {
-
-            rho = r.dot(r); //conjugate().transpose()*r;
-
-            if (i == 1) {
-                p = r;
-            }
-            else {
-                beta = rho / rho_1;
-                p = r + beta * p;
-            }
-
-            q = (A*p).array().abs();
-            alpha = rho / p.dot(q);
-
-            x += alpha * p;
-            r -= alpha * q;
-
-            if ((resid = r.norm() / normb) <= tol) {
-                tol = resid;
-                max_iter = i;
-                return x;
-            }
-            rho_1 = rho;
-        }
-
-        tol = resid;
-        std::cerr << "CG FAILED TO REACH CONVERGENCE\n";
-        return x;
-    }
-
-// Preconditioned version of above
-//*****************************************************************
-// Iterative template routine -- CG
-//
-// CG solves the symmetric positive definite linear
-// system Ax=b using the Conjugate Gradient method.
-//
-// CG follows the algorithm described on p. 15 in the
-// SIAM Templates book.
-//
-// The return value indicates convergence within max_iter (input)
-// iterations (0), or no convergence within max_iter iterations (1).
-//
-// Upon successful return, output arguments have the following values:
-//
-//        x  --  approximate solution to Ax = b
-// max_iter  --  the number of iterations performed before the
-//               tolerance was reached
-//      tol  --  the residual after the final iteration
-//
-//*****************************************************************
-
-//template < class Matrix, class Vector, class Preconditioner, class Real >
-//int
-//CG(const Matrix &A, Vector &x, const Vector &b,
-//   const Preconditioner &M, int &max_iter, Real &tol)
-//{
-    #include <limits>
-    template <typename Preconditioner>
-    VectorXr CG(const MatrixXr &A, const VectorXr &x0, const VectorXr &b,
-        const Preconditioner &M, int &max_iter, Real &tol) {
-        //const Eigen::SparseMatrix<Real> &M, int &max_iter, Real &tol) {
-
-        VectorXr p, z, q;
-        VectorXr x = x0;
-        Real alpha(0), beta(0), rho(0), rho_1(0);
-        Real normb;
-        VectorXr r;
-        #ifdef LEMMAUSEOMP
-        #pragma omp parallel sections
-        {
-        #endif
-            #ifdef LEMMAUSEOMP
-            #pragma omp section
-            #endif
-            {
-                normb = b.norm();
-            }
-            #ifdef LEMMAUSEOMP
-            #pragma omp section
-            #endif
-            {
-                r = b - A*x;
-            }
-        #ifdef LEMMAUSEOMP
-        }
-        #endif
-        if (normb <= std::numeric_limits<double>::epsilon() ) {
-            normb = 1;
-        }
-        Real resid = r.norm() / normb;
-        if (resid <= tol) {
-            tol = resid;
-            max_iter = 0;
-            return x;
-        }
-        // todo do 0th loop manually, gets rid of if statement
-        for (int i = 1; i <= max_iter; i++) {
-            z = M.solve(r);
-            //z = M*r;
-            rho = r.transpose()*z;
-            if (i == 1) {
-                p = z;
-            } else {
-                beta = rho / rho_1;
-                p = z + beta * p;
-            }
-            q = A*p;
-            alpha = rho / p.dot(q);
-            #ifdef LEMMAUSEOMP
-            #pragma omp parallel sections
-            {
-            #endif
-                #ifdef LEMMAUSEOMP
-                #pragma omp section
-                #endif
-                {
-                    x += alpha * p;
-                }
-                #ifdef LEMMAUSEOMP
-                #pragma omp section
-                #endif
-                {
-                    r -= alpha * q;
-                }
-            #ifdef LEMMAUSEOMP
-            }
-            #endif
-            if ((resid = r.norm() / normb) <= tol) {
-               tol = resid;
-               max_iter = i;
-               return x;
-            }
-            rho_1 = rho;
-        }
-        tol = resid;
-        std::cerr << "Preconditioned CG failed to converge\n";
-        return x;
-    }
-
-    template < typename Scalar >
-    VectorXr CGJ(const MatrixXr &A, const VectorXr &x0, const VectorXr &b,
-        const Eigen::SparseMatrix<Scalar> &M, int &max_iter, Scalar &tol) {
-
-        VectorXr p, z, q;
-        VectorXr x = x0;
-        Scalar alpha(0), beta(0), rho(0), rho_1(0);
-        Scalar normb;
-        VectorXr r;
-        #ifdef LEMMAUSEOMP
-        #pragma omp parallel sections
-        {
-        #endif
-            #ifdef LEMMAUSEOMP
-            #pragma omp section
-            #endif
-            {
-                normb = b.norm();
-            }
-            #ifdef LEMMAUSEOMP
-            #pragma omp section
-            #endif
-            {
-                r = b - A*x;
-            }
-        #ifdef LEMMAUSEOMP
-        }
-        #endif
-        if (normb <= std::numeric_limits<double>::epsilon() ) {
-            normb = 1;
-        }
-        Scalar resid = r.norm() / normb;
-        if (resid <= tol) {
-            tol = resid;
-            max_iter = 0;
-            return x;
-        }
-        // todo do 0th loop manually, gets rid of if statement
-        for (int i = 1; i <= max_iter; i++) {
-            //z = M.solve(r);
-            z = M*r;
-            rho = r.transpose()*z;
-            if (i == 1) {
-                p = z;
-            } else {
-                beta = rho / rho_1;
-                p = z + beta * p;
-            }
-            q = A*p;
-            alpha = rho / p.dot(q);
-            #ifdef LEMMAUSEOMP
-            #pragma omp parallel sections
-            {
-            #endif
-                #ifdef LEMMAUSEOMP
-                #pragma omp section
-                #endif
-                {
-                    x += alpha * p;
-                }
-                #ifdef LEMMAUSEOMP
-                #pragma omp section
-                #endif
-                {
-                    r -= alpha * q;
-                }
-            #ifdef LEMMAUSEOMP
-            }
-            #endif
-            if ((resid = r.norm() / normb) <= tol) {
-               tol = resid;
-               max_iter = i;
-               return x;
-            }
-            rho_1 = rho;
-        }
-        tol = resid;
-        std::cerr << "Preconditioned CG failed to converge\n";
-        return x;
-    }
-
-    ///////////////////////////////////////////////////////
-    // Log Barrier
-    /** Solves one iteration, using implicit multiplication of At*b, and ATA.
-     *  @param[in] G is the sensitivity matrix to be inverted.
-     *  @param[in] WdTWd is the data weighting matrix, usually sparse.
-     *  @param[in] WmTWm is the model weighting matrix, usually sparse.
-     *  @param[in] X1 is a vector of the inverse of the current model X. Used in
-     *  log barrier. Should be computed as X1 = VectorXr( 1. / (x.array() - minVal ))
-     *  @param[in] Y1 is a vector of the inverse of the current model X. Used in
-     *  log barrier. Should be computed as X1 = VectorXr( 1. / (maxVal - x.array() ))
-     *  @param[in] X2 is the analaogous inverse of X^2 diagonal matrix, stored
-     *  as a Vector.
-     *  @param[in] Y2 is the analaogous inverse of (maxVal-X)^2 diagonal matrix, stored
-     *  as a Vector.
-     *  @param[in] D2 is the datamisfit vector, formally (d_predicted - d_observed).
-     *  @param[in,out] Mk is the input / output solution vector. The input value is
-     *  an itital guess, and output is the solution.
-     *  @param[in] Mr is the reference model.
-     *  @param[in] BETA is the regularisation (Tikhonov parameter) to apply
-     *  @param[in] P is a preconditioner of G. The product Pb ~ x
-     *  @param[in,out] max_iter is the number of iterations.
-     *  @param[in,out] tol is the desired tolerance on input, and achieved on
-     *  output.
-     */
-    template < typename  Scalar >
-    int implicit_log_CG(const MatrixXr& G, const MatrixXr& WdTWd, const VectorXr& WmTWm,
-				const VectorXr& X1, const VectorXr& X2,
-				const VectorXr& Y1, const VectorXr& Y2,
-				const VectorXr& D2, VectorXr& Mk, const VectorXr& Mr,
-				const Scalar& BETA, const MatrixXr& P,
-                int& max_iter, Scalar& tol) {
-
-        // TODO add WdTWD to this!
-
-        Scalar resid;
-        VectorXr p, z, q;
-        Scalar alpha(0), beta(0), rho(0), rho_1(0);
-
-        // Calculate 'B'
-        VectorXr delM = Mk - Mr;
-        VectorXr B = (-G.transpose()*D2).array() - BETA*((WmTWm.asDiagonal()*delM).array())
-                     + X1.array() + Y1.array();
-
-        Scalar normb = B.norm();
-
-        // Implicit calc of A*x
-        VectorXr Y = BETA*(WmTWm.asDiagonal()*Mk).array() +
-                (X2.asDiagonal()*Mk).array() + (Y2.asDiagonal()*Mk).array();
-        VectorXr Z = G*Mk;
-        VectorXr U = G.transpose()*Z;
-
-        VectorXr r = B - (Y + U);
-
-        if (normb == 0.0) normb = 1;
-
-        if ((resid = r.norm() / normb) <= tol) {
-            tol = resid;
-            max_iter = 0;
-            return 0;
-        }
-
-        for (int i = 1; i <= max_iter; i++) {
-            //z = M.solve(r); // we can solve directly z = P*r
-            z = P*r;
-            rho = r.dot(z);
-            if (i == 1)  p = z;
-            else {
-                beta = rho / rho_1;
-                p = beta * p;
- 	            p = p+z;
-            }
-            Y = BETA*(WmTWm.array()*p.array()) + X2.array()*p.array() + Y2.array()*p.array();
-            Z = G*p;
-            U = G.transpose()*Z;
-            q = Y+U;
-
-            alpha = rho / p.dot(q);
-
-            Mk = Mk + alpha * p;
-            r  = r - (alpha * q);
-
-            if ((resid = r.norm() / normb) <= tol) {
-                tol = resid;
-                max_iter = i;
-                return 0;
-            }
-            rho_1 = rho;
-        }
-        tol = resid;
-        return 1;
-    }
-} // end of namespace Lemma
-
-#endif   // ----- #ifndef CG_INC  -----

Modules/Optimization/include/quasinewtonbfgs.h

-/* This file is part of Lemma, a geophysical modelling and inversion API */
-
-/* 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
-  @author   Trevor Irons
-  @date     08/09/2010
-  @version  $Id: quasinewtonbfgs.h 193 2014-11-10 23:51:41Z tirons $
- **/
-
-#ifndef  QUASINEWTONBFGS_INC
-#define  QUASINEWTONBFGS_INC
-
-#include "inversesolver.h"
-
-namespace Lemma {
-
-
-    // ===================================================================
-    //  Class:  QuasiNewtonBFGS
-    /**
-      @class  QuasiNewtonBFGS
-      \brief  Implimentation of a quasi-newton BFGS solver applied to
-              inverse problems.
-      \details Based of the algorithm described in Nocedal and Wright book.
-     */
-    // ===================================================================
-    class QuasiNewtonBFGS : public InverseSolver {
-
-        friend  std::ostream &operator<<(std::ostream &stream,
-                const QuasiNewtonBFGS &ob);
-
-        public:
-
-            // ====================  LIFECYCLE     =======================
-
-            /** Returns a pointer to a new object of type QuasiNewtonBFGS.
-             * It allocates all necessary memory.
-             */
-            static QuasiNewtonBFGS* New();
-
-            /**
-             * @copybrief LemmaObject::Delete()
-             * @copydetails LemmaObject::Delete()
-             */
-            void Delete();
-
-            // ====================  OPERATORS     =======================
-
-            // ====================  OPERATIONS    =======================
-
-            // ====================  ACCESS        =======================
-
-            // ====================  INQUIRY       =======================
-
-            /** @copybrief InverseSolver::NumberOfIterations()
-             *  @copydetails InverseSolver::NumberOfIterations()
-             */
-            int NumberOfIterations();
-
-            /** @copybrief InverseSolver::Success()
-             *  @copydetails InverseSolver::Success()
-             */
-            bool Success();
-
-            /** @copybrief InverseSolver::GetPhiMVector()
-             *  @copydetails InverseSolver::GetPhiMVector()
-             */
-            VectorXr GetPhiMVector();
-
-            /** @copybrief InverseSolver::GetPhiDVector()
-             *  @copydetails InverseSolver::GetPhiDVector()
-             */
-            VectorXr GetPhiDVector();
-
-            /// TODO remove this, test
-            void PrintNorm();
-
-        protected:
-
-            // ====================  LIFECYCLE     =======================
-
-            /// Default protected constructor.
-            QuasiNewtonBFGS (const std::string& cname);
-
-            /// Default protected constructor.
-            ~QuasiNewtonBFGS ();
-
-            /**
-             * @copybrief LemmaObject::Release()
-             * @copydetails LemmaObject::Release()
-             */
-            void Release();
-
-            // ====================  OPERATIONS    =======================
-
-            /// Just a filler
-            void FillInG(const Vector3r& pos, const Vector3r& step);
-
-            // ====================  DATA MEMBERS  =========================
-
-        private:
-
-    }; // -----  end of class  QuasiNewtonBFGS  -----
-
-}		// -----  end of Lemma  name  -----
-
-#endif   // ----- #ifndef QUASINEWTONBFGS_INC  -----

Modules/Optimization/src/quasinewtonbfgs.cpp

-/* This file is part of Lemma, a geophysical modelling and inversion API */
-
-/* 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
-  @author   Trevor Irons
-  @date     08/09/2010
-  @version  $Id: quasinewtonbfgs.cpp 87 2013-09-05 22:44:05Z tirons $
- **/
-
-#include "quasinewtonbfgs.h"
-
-
-namespace Lemma {
-
-    // ====================  STREAMS       =======================
-
-    std::ostream &operator<<(std::ostream &stream,
-            const QuasiNewtonBFGS &ob) {
-        stream << *(InverseSolver*)(&ob);
-        return stream;
-    }
-
-
-    // ====================  LIFECYCLE     =======================
-
-    QuasiNewtonBFGS* QuasiNewtonBFGS::New() {
-        QuasiNewtonBFGS* Object = new QuasiNewtonBFGS("QuasiNewtonBFGS");
-        Object->AttachTo(Object);
-        return Object;
-    }
-
-    QuasiNewtonBFGS::QuasiNewtonBFGS(const std::string &name) :
-        InverseSolver(name) {
-    }
-
-    void QuasiNewtonBFGS::Delete() {
-        this->DetachFrom(this);
-    }
-
-    void QuasiNewtonBFGS::Release() {
-        delete this;
-    }
-
-    QuasiNewtonBFGS::~QuasiNewtonBFGS() {
-        if (this->NumberOfReferences != 0)
-            throw DeleteObjectWithReferences( this );
-    }
-
-    // ====================  INQUIRY       =======================
-
-    int QuasiNewtonBFGS::NumberOfIterations() {
-        return 0;
-    }
-
-    bool QuasiNewtonBFGS::Success () {
-        return false;
-    }
-
-    void QuasiNewtonBFGS::PrintNorm() {
-        std::cout << "Norm " << std::endl;
-        PredictedData->Zero();
-        std::cout << ObservedData->Norm(PredictedData) << std::endl;
-    }
-
-    VectorXr QuasiNewtonBFGS::GetPhiMVector() {
-        VectorXr NewVec(2);
-        return NewVec;
-    }
-
-    VectorXr QuasiNewtonBFGS::GetPhiDVector() {
-        VectorXr NewVec(2);
-        return NewVec;
-    }
-
-    void QuasiNewtonBFGS::FillInG(const Vector3r& pos, const Vector3r& step) {
-
-    }
-
-    // ====================  ACCESS        =======================
-
-}		// -----  end of Lemma  name  -----