Adding CircularLoop for optmized use cases

Modules/FDEM1D/include/CircularLoop.h

@@ -0,0 +1,134 @@
+/* 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/01/2018 10:24:02 AM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     tirons@egi.utah.edu
+ * @copyright Copyright (c) 2018, University of Utah
+ * @copyright Copyright (c) 2018, Lemma Software, LLC
+ */
+
+#ifndef  CIRCULARLOOP_INC
+#define  CIRCULARLOOP_INC
+
+#pragma once
+#include "CompactSupportEMSource.h"
+
+namespace Lemma {
+
+    /**
+     * \ingroup FDEM1D
+     * \brief   Analytic solution of a circular loop.
+     * \details This specialized class provides the EM response of a circular loop on the surface of the earth.
+     *          More general use cases can use PolygonalWireAntenna.
+     */
+    class CircularLoop : public CompactSupportEMSource {
+
+        friend std::ostream &operator<<(std::ostream &stream, const CircularLoop &ob);
+
+        protected:
+        /*
+         *  This key is used to lock the constructor. It is protected so that inhereted
+         *  classes also have the key to contruct their base class.
+         */
+        struct ctor_key {};
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        /**
+         * Default constructor.
+         * @note This method is locked, and cannot be called directly.
+         *       The reason that the method is public is to enable the use
+         *       of make_shared whilst enforcing the use of shared_ptr,
+         *       in c++-17, this curiosity may be resolved.
+         * @see CircularLoop::NewSP
+         */
+        explicit CircularLoop ( const ctor_key& );
+
+        /**
+         * DeSerializing constructor.
+         * @note This method is locked, and cannot be called directly.
+         *       The reason that the method is public is to enable the use
+         *       of make_shared whilst enforcing the use of shared_ptr,
+         *       in c++-17, this curiosity may be resolved.
+         * @see CircularLoop::DeSerialize
+         */
+        CircularLoop ( const YAML::Node& node, const ctor_key& );
+
+        /**
+         * Default destructor.
+         * @note This method should never be called due to the mandated
+         *       use of smart pointers. It is necessary to keep the method
+         *       public in order to allow for the use of the more efficient
+         *       make_shared constructor.
+         */
+        virtual ~CircularLoop ();
+
+        /**
+         *  Uses YAML to serialize this object.
+         *  @return a YAML::Node
+         *  @see CircularLoop::DeSerialize
+         */
+        virtual YAML::Node Serialize() const;
+
+        /*
+         *  Factory method for generating concrete class.
+         *  @return a std::shared_ptr of type CircularLoop
+         */
+        static std::shared_ptr< CircularLoop > NewSP();
+
+        /**
+         *   Constructs an CircularLoop object from a YAML::Node.
+         *   @see CircularLoop::Serialize
+         */
+        static std::shared_ptr<CircularLoop> DeSerialize(const YAML::Node& node);
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        // ====================  ACCESS        =======================
+
+        // ====================  INQUIRY       =======================
+        /**
+         *  Returns the name of the underlying class, similiar to Python's type
+         *  @return string of class name
+         */
+        virtual inline std::string GetName() const {
+            return CName;
+        }
+
+        protected:
+
+        // ====================  LIFECYCLE     =======================
+
+        /** Copy is disabled */
+        CircularLoop( const CircularLoop& ) = delete;
+
+        // ====================  DATA MEMBERS  =========================
+
+        private:
+
+        /** ASCII string representation of the class name */
+        static constexpr auto CName = "CircularLoop";
+
+    }; // -----  end of class  CircularLoop  -----
+}  // -----  end of namespace Lemma ----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+
+
+#endif   // ----- #ifndef CIRCULARLOOP_INC  -----
+

Modules/FDEM1D/include/CompactSupportEMSource.h

@@ -0,0 +1,133 @@
+/* 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/01/2018 08:26:44 AM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     tirons@egi.utah.edu
+ * @copyright Copyright (c) 2018, University of Utah
+ * @copyright Copyright (c) 2018, Lemma Software, LLC
+ */
+
+#ifndef  COMPACTSUPPORTEMSOURCE_INC
+#define  COMPACTSUPPORTEMSOURCE_INC
+
+#pragma once
+#include "LemmaObject.h"
+
+namespace Lemma {
+
+    /**
+     * \ingroup FDEM1D
+     * \brief   Abstract base class representing an EM source.
+     * \details Derived types include simple dipoles, as well as line sources or wire loops.
+     */
+    class CompactSupportEMSource : public LemmaObject {
+
+        friend std::ostream &operator<<(std::ostream &stream, const CompactSupportEMSource &ob);
+
+        protected:
+        /*
+         *  This key is used to lock the constructor. It is protected so that inhereted
+         *  classes also have the key to contruct their base class.
+         */
+        struct ctor_key {};
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        /**
+         * Default constructor.
+         * @note This method is locked, and cannot be called directly.
+         *       The reason that the method is public is to enable the use
+         *       of make_shared whilst enforcing the use of shared_ptr,
+         *       in c++-17, this curiosity may be resolved.
+         * @see CompactSupportEMSource::NewSP
+         */
+        explicit CompactSupportEMSource ( const ctor_key& );
+
+        /**
+         * DeSerializing constructor.
+         * @note This method is locked, and cannot be called directly.
+         *       The reason that the method is public is to enable the use
+         *       of make_shared whilst enforcing the use of shared_ptr,
+         *       in c++-17, this curiosity may be resolved.
+         * @see CompactSupportEMSource::DeSerialize
+         */
+        CompactSupportEMSource ( const YAML::Node& node, const ctor_key& );
+
+        /**
+         * Default destructor.
+         * @note This method should never be called due to the mandated
+         *       use of smart pointers. It is necessary to keep the method
+         *       public in order to allow for the use of the more efficient
+         *       make_shared constructor.
+         */
+        virtual ~CompactSupportEMSource ();
+
+        /**
+         *  Uses YAML to serialize this object.
+         *  @return a YAML::Node
+         *  @see CompactSupportEMSource::DeSerialize
+         */
+        virtual YAML::Node Serialize() const;
+
+        /*
+         *  Factory method for generating concrete class.
+         *  @return a std::shared_ptr of type CompactSupportEMSource
+         */
+        static std::shared_ptr< CompactSupportEMSource > NewSP();
+
+        /**
+         *   Constructs an CompactSupportEMSource object from a YAML::Node.
+         *   @see CompactSupportEMSource::Serialize
+         */
+        static std::shared_ptr<CompactSupportEMSource> DeSerialize(const YAML::Node& node);
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        // ====================  ACCESS        =======================
+
+        // ====================  INQUIRY       =======================
+        /**
+         *  Returns the name of the underlying class, similiar to Python's type
+         *  @return string of class name
+         */
+        virtual inline std::string GetName() const {
+            return CName;
+        }
+
+        protected:
+
+        // ====================  LIFECYCLE     =======================
+
+        /** Copy is disabled */
+        CompactSupportEMSource( const CompactSupportEMSource& ) = delete;
+
+        // ====================  DATA MEMBERS  =========================
+
+        private:
+
+        /** ASCII string representation of the class name */
+        static constexpr auto CName = "CompactSupportEMSource";
+
+    }; // -----  end of class  CompactSupportEMSource  -----
+}  // -----  end of namespace Lemma ----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+
+
+#endif   // ----- #ifndef COMPACTSUPPORTEMSOURCE_INC  -----
+

Modules/FDEM1D/include/FDEM1D

@@ -3,6 +3,8 @@
 
 #include "FieldPoints.h"
 
+#include "CircularLoop.h"
+
 #include "WireAntenna.h"
 #include "PolygonalWireAntenna.h"
 

Modules/FDEM1D/include/WireAntenna.h

@@ -24,7 +24,8 @@ namespace Lemma {
 
 
     // ===================================================================
-    /**      Class:  WireAntenna
+    /**
+      * \ingroup FDEM1D
       * \brief   Class representing a wire antennae.
       * \details This is an abstract class.
 	  */

Modules/FDEM1D/src/CMakeLists.txt

@@ -1,30 +1,43 @@
 set (FDEM1DSOURCE
 	${FDEM1DSOURCE}
 
+	# model space
 	${CMAKE_CURRENT_SOURCE_DIR}/LayeredEarthEM.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/LayeredEarthEMReader.cpp
 	
+	# Calculation points
 	${CMAKE_CURRENT_SOURCE_DIR}/FieldPoints.cpp
-	
+
+	# Sources	
+	${CMAKE_CURRENT_SOURCE_DIR}/CompactSupportEMSource.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/CircularLoop.cpp
+
 	${CMAKE_CURRENT_SOURCE_DIR}/DipoleSource.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/WireAntenna.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/PolygonalWireAntenna.cpp
-	
+
+	# Kernel management	
 	${CMAKE_CURRENT_SOURCE_DIR}/KernelEM1DManager.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/KernelEM1DSpec.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/KernelEM1DReflSpec.cpp
 
+	#####################
+	# Hankel transforms #
+	#####################
+	# FHT
 	${CMAKE_CURRENT_SOURCE_DIR}/HankelTransform.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/FHTAnderson801.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/FHTKey201.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/FHTKey101.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/FHTKey51.cpp
-
+	# Gaussian Quadrature
 	${CMAKE_CURRENT_SOURCE_DIR}/GQChave.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/QWEKey.cpp
 	
+	# Calculation
 	${CMAKE_CURRENT_SOURCE_DIR}/EMEarth1D.cpp
 
+	# AEM 
 	${CMAKE_CURRENT_SOURCE_DIR}/AEMSurvey.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/AEMSurveyReader.cpp
 	

Modules/FDEM1D/src/CircularLoop.cpp

@@ -0,0 +1,96 @@
+/* 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/01/2018 10:45:39 AM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     tirons@egi.utah.edu
+ * @copyright Copyright (c) 2018, University of Utah
+ * @copyright Copyright (c) 2018, Lemma Software, LLC
+ */
+
+#include "CircularLoop.h"
+
+namespace Lemma {
+
+    // ====================  FRIEND METHODS  =====================
+
+    std::ostream &operator << (std::ostream &stream, const CircularLoop &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        return stream;
+    }
+
+    // ====================  LIFECYCLE     =======================
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CircularLoop
+    //      Method:  CircularLoop
+    // Description:  constructor (locked)
+    //--------------------------------------------------------------------------------------
+    CircularLoop::CircularLoop (const ctor_key&) : CompactSupportEMSource( CompactSupportEMSource::ctor_key()  ) {
+
+    }  // -----  end of method CircularLoop::CircularLoop  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CircularLoop
+    //      Method:  CircularLoop
+    // Description:  DeSerializing constructor (locked)
+    //--------------------------------------------------------------------------------------
+    CircularLoop::CircularLoop (const YAML::Node& node, const ctor_key&) : CompactSupportEMSource(node, CompactSupportEMSource::ctor_key()) {
+
+    }  // -----  end of method CircularLoop::CircularLoop  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CircularLoop
+    //      Method:  NewSP()
+    // Description:  public constructor returing a shared_ptr
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr< CircularLoop >  CircularLoop::NewSP() {
+        return std::make_shared< CircularLoop >( ctor_key() );
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CircularLoop
+    //      Method:  ~CircularLoop
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
+    CircularLoop::~CircularLoop () {
+
+    }  // -----  end of method CircularLoop::~CircularLoop  (destructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CircularLoop
+    //      Method:  Serialize
+    //--------------------------------------------------------------------------------------
+    YAML::Node  CircularLoop::Serialize (  ) const {
+        YAML::Node node = CompactSupportEMSource::Serialize();
+        node.SetTag( GetName() );
+        // FILL IN CLASS SPECIFICS HERE
+        return node;
+    }		// -----  end of method CircularLoop::Serialize  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CircularLoop
+    //      Method:  DeSerialize
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr<CircularLoop> CircularLoop::DeSerialize ( const YAML::Node& node  ) {
+        if (node.Tag() !=  "CircularLoop" ) {
+            throw  DeSerializeTypeMismatch( "CircularLoop", node.Tag());
+        }
+        return std::make_shared< CircularLoop > ( node, ctor_key() );
+    }		// -----  end of method CircularLoop::DeSerialize  -----
+
+} // ----  end of namespace Lemma  ----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+
+

Modules/FDEM1D/src/CompactSupportEMSource.cpp

@@ -0,0 +1,96 @@
+/* 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/01/2018 08:33:23 AM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     tirons@egi.utah.edu
+ * @copyright Copyright (c) 2018, University of Utah
+ * @copyright Copyright (c) 2018, Lemma Software, LLC
+ */
+
+
+#include "CompactSupportEMSource.h"
+
+namespace Lemma {
+
+    // ====================  FRIEND METHODS  =====================
+
+    std::ostream &operator << (std::ostream &stream, const CompactSupportEMSource &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        return stream;
+    }
+
+    // ====================  LIFECYCLE     =======================
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CompactSupportEMSource
+    //      Method:  CompactSupportEMSource
+    // Description:  constructor (locked)
+    //--------------------------------------------------------------------------------------
+    CompactSupportEMSource::CompactSupportEMSource (const ctor_key&) : LemmaObject( LemmaObject::ctor_key() ) {
+
+    }  // -----  end of method CompactSupportEMSource::CompactSupportEMSource  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CompactSupportEMSource
+    //      Method:  CompactSupportEMSource
+    // Description:  DeSerializing constructor (locked)
+    //--------------------------------------------------------------------------------------
+    CompactSupportEMSource::CompactSupportEMSource (const YAML::Node& node, const ctor_key&) : LemmaObject(node, LemmaObject::ctor_key()) {
+
+    }  // -----  end of method CompactSupportEMSource::CompactSupportEMSource  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CompactSupportEMSource
+    //      Method:  NewSP()
+    // Description:  public constructor returing a shared_ptr
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr< CompactSupportEMSource >  CompactSupportEMSource::NewSP() {
+        return std::make_shared< CompactSupportEMSource >( ctor_key() );
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CompactSupportEMSource
+    //      Method:  ~CompactSupportEMSource
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
+    CompactSupportEMSource::~CompactSupportEMSource () {
+
+    }  // -----  end of method CompactSupportEMSource::~CompactSupportEMSource  (destructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CompactSupportEMSource
+    //      Method:  Serialize
+    //--------------------------------------------------------------------------------------
+    YAML::Node  CompactSupportEMSource::Serialize (  ) const {
+        YAML::Node node = LemmaObject::Serialize();
+        node.SetTag( GetName() );
+        // FILL IN CLASS SPECIFICS HERE
+        return node;
+    }		// -----  end of method CompactSupportEMSource::Serialize  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CompactSupportEMSource
+    //      Method:  DeSerialize
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr<CompactSupportEMSource> CompactSupportEMSource::DeSerialize ( const YAML::Node& node  ) {
+        if (node.Tag() !=  "CompactSupportEMSource" ) {
+            throw  DeSerializeTypeMismatch( "CompactSupportEMSource", node.Tag());
+        }
+        return std::make_shared< CompactSupportEMSource > ( node, ctor_key() );
+    }		// -----  end of method CompactSupportEMSource::DeSerialize  -----
+
+} // ----  end of namespace Lemma  ----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+

Modules/FDEM1D/testing/GetNameCheck.h

@@ -51,6 +51,12 @@ class MyTestSuite : public CxxTest::TestSuite
         TS_ASSERT_EQUALS( Obj->GetName(), std::string("WireAntenna") );
     }
 
+    void testCircularLoop( void )
+    {
+        auto Obj = CircularLoop::NewSP();
+        TS_ASSERT_EQUALS( Obj->GetName(), std::string("CircularLoop") );
+    }
+
     void testPolygonalWireAntenna( void )
     {
         auto Obj = PolygonalWireAntenna::NewSP();

vim/lemma.cpp.template

@@ -287,7 +287,7 @@ std::ostream &operator << (std::ostream &stream, const |CLASSNAME| &ob) {
 //      Method:  |CLASSNAME|
 // Description:  constructor (locked)
 //--------------------------------------------------------------------------------------
-|CLASSNAME|::|CLASSNAME| (const ctor_key&) : |?BASECLASS|( ) {
+|CLASSNAME|::|CLASSNAME| (const ctor_key&) : |?BASECLASS|( |BASECLASS|::ctor_key()  ) {
 
 }  // -----  end of method |CLASSNAME|::|CLASSNAME|  (constructor)  -----
 
@@ -296,7 +296,7 @@ std::ostream &operator << (std::ostream &stream, const |CLASSNAME| &ob) {
 //      Method:  |CLASSNAME|
 // Description:  DeSerializing constructor (locked)
 //--------------------------------------------------------------------------------------
-|CLASSNAME|::|CLASSNAME| (const YAML::Node& node, const ctor_key&) : |BASECLASS|(node) {
+|CLASSNAME|::|CLASSNAME| (const YAML::Node& node, const ctor_key&) : |BASECLASS|(node, |BASECLASS|::ctor_key()) {
 
 }  // -----  end of method |CLASSNAME|::|CLASSNAME|  (constructor)  -----