Merlin 2.0 has been started conforming with changes to Lemma. Leaner, meaner and more elegant. Kernel calculations are up first.

CMakeLists.txt

@@ -0,0 +1,30 @@
+add_subdirectory("src")
+add_library( merlin ${MERLINSOURCE} )  
+target_include_directories( merlin PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include" )
+
+set_target_properties(merlin PROPERTIES 
+	VERSION  "${LEMMA_VERSION_NOQUOTES}"
+	SOVERSION "${LEMMA_VERSION_MAJOR}.${LEMMA_VERSION_MINOR}"
+	PROJECT_LABEL "FDEM1D ${LABEL_SUFFIX}"
+)
+
+# Linking
+target_link_libraries(merlin "lemmacore" "fdem1d" )
+
+# Testing
+if (LEMMA_ENABLE_TESTING)
+	add_subdirectory(testing)
+endif()
+
+# Install
+install ( TARGETS merlin DESTINATION ${CMAKE_INSTALL_PREFIX}/lib )
+install ( FILES include/MERLIN  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()

Merlin.dox

@@ -0,0 +1,14 @@
+/**
+ * @file
+ * @date      09/15/2016 04:28:16 PM
+ * @author    Trevor Irons (ti)
+ * @email     tirons@egi.utah.edu
+ * @copyright Copyright (c) 2016, University of Utah
+ * @copyright Copyright (c) 2016, Lemma Software, LLC
+ */
+
+/**
+    \defgroup Merlin Merlin
+    @brief    Merlin provides surface NMR capabilities.
+    @details  Merlin provides classes and methods for sNMR modelling and inversion.
+*/

examples/CMakeLists.txt

@@ -0,0 +1,6 @@
+add_executable( KernelV0 KernelV0.cpp  )
+target_link_libraries(  KernelV0  "lemmacore" "fdem1d" "merlin")
+
+INSTALL_TARGETS( "/share/Merlin/"
+	KernelV0
+)

examples/KernelV0.cpp

@@ -0,0 +1,69 @@
+/* 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      11/11/2016 02:44:37 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     tirons@egi.utah.edu
+ * @copyright Copyright (c) 2016, University of Utah
+ * @copyright Copyright (c) 2016, Lemma Software, LLC
+ */
+
+#include <Merlin>
+using namespace Lemma;
+
+std::shared_ptr<PolygonalWireAntenna> CircularLoop ( int nd, Real radius, Real Offsetx, Real Offsety ) ;
+
+int main() {
+
+	auto earth = LayeredEarthEM::NewSP();
+		earth->SetNumberOfLayers(3);
+		earth->SetLayerConductivity( (VectorXcr(3) << Complex(0.,0), Complex(1./50.,0), Complex(1./100.)).finished() );
+		earth->SetLayerThickness( (VectorXr(1) << 10).finished() );
+
+    // Transmitter loops
+    auto Tx1 = CircularLoop(60, 15, 0, 0);
+    auto Tx2 = CircularLoop(60, 15, 15, 0);
+    //auto Tx1 = CircularLoop(60, 15, 0, 0); // was 60
+
+    auto Kern = KernelV0::NewSP();
+        Kern->PushCoil( "Coil 1", Tx1 );
+        Kern->PushCoil( "Coil 2", Tx2 );
+        Kern->SetLayeredEarthEM( earth );
+        // std::cout << *Kern << std::endl;
+
+    // We could, I suppose, take the earth model in here? For non-linear that
+    // may be more natural to work with?
+    std::vector<std::string> tx = {std::string("Coil 1")};
+    std::vector<std::string> rx = {std::string("Coil 1")};
+    Kern->CalculateK0( tx, rx );
+    //Kern->CalculateK0( "Coil 1", "Coil 1" );
+
+}
+
+std::shared_ptr<Lemma::PolygonalWireAntenna> CircularLoop ( int nd, Real Radius, Real Offsetx, Real Offsety ) {
+    auto Tx1 = Lemma::PolygonalWireAntenna::NewSP();
+         Tx1->SetNumberOfPoints(nd);
+
+    VectorXr range = VectorXr::LinSpaced(nd, 0, 2*PI);
+    int ii;
+    for (ii=0; ii<nd-1; ++ii) {
+        Tx1->SetPoint(ii, Vector3r(Offsetx+Radius*std::cos(range(ii)), Offsety+Radius*std::sin(range(ii)),  -1e-3));
+    }
+    Tx1->SetPoint(ii, Vector3r(Offsetx+Radius*1, Offsety,  -1e-3));
+
+    Tx1->SetCurrent(1.);
+    Tx1->SetNumberOfTurns(1);
+    Tx1->SetNumberOfFrequencies(1);
+    Tx1->SetFrequency(0,2500);
+
+    return Tx1;
+}

include/KernelV0.h

@@ -0,0 +1,163 @@
+/* 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      11/11/2016 01:47:34 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     tirons@egi.utah.edu
+ * @copyright Copyright (c) 2016, University of Utah
+ * @copyright Copyright (c) 2016, Lemma Software, LLC
+ */
+#ifndef  KERNELV0_INC
+#define  KERNELV0_INC
+
+#pragma once
+#include "LemmaObject.h"
+#include "LayeredEarthEM.h"
+#include "PolygonalWireAntenna.h"
+
+namespace Lemma {
+
+    /**
+     * \ingroup Merlin
+     * \brief
+     * \details
+     */
+    class KernelV0 : public LemmaObject {
+
+        friend std::ostream &operator<<(std::ostream &stream, const KernelV0 &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 KernelV0::NewSP
+         */
+        explicit KernelV0 ( 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 KernelV0::DeSerialize
+         */
+        KernelV0 ( 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 ~KernelV0 ();
+
+        /**
+         *  Uses YAML to serialize this object.
+         *  @return a YAML::Node
+         *  @see KernelV0::DeSerialize
+         */
+        virtual YAML::Node Serialize() const;
+
+        /*
+         *  Factory method for generating concrete class.
+         *  @return a std::shared_ptr of type KernelV0
+         */
+        static std::shared_ptr< KernelV0 > NewSP();
+
+        /**
+         *   Constructs an KernelV0 object from a YAML::Node.
+         *   @see KernelV0::Serialize
+         */
+        static std::shared_ptr<KernelV0> DeSerialize(const YAML::Node& node);
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        /**
+         * @return std::shared_ptr<LayeredEarthEM>
+         */
+        inline std::shared_ptr<LayeredEarthEM> GetSigmaModel (  ) {
+            return SigmaModel;
+        }		// -----  end of method KernelV0::get_SigmaModel  -----
+
+        /**
+         * @param[in] value the 1D-EM model used for calculations
+         */
+        inline void SetLayeredEarthEM ( std::shared_ptr< LayeredEarthEM > value ) {
+            SigmaModel	= value;
+            return ;
+        }		// -----  end of method KernelV0::set_SigmaModel  -----
+
+        /**
+         *   Assign transmiter coils
+         */
+        inline void PushCoil( const std::string& label, std::shared_ptr<PolygonalWireAntenna> ant ) {
+            TxRx[label] = ant;
+        }
+
+        /**
+         *
+         */
+        void CalculateK0 (const std::vector< std::string >& tx, const std::vector< std::string >& rx );
+
+        void CalculateK0 (const char* tx, const char* rx );
+
+        // ====================  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 */
+        KernelV0( const KernelV0& ) = delete;
+
+        // ====================  DATA MEMBERS  =========================
+
+        private:
+
+        std::shared_ptr< LayeredEarthEM >        SigmaModel;
+
+        std::map< std::string , std::shared_ptr< PolygonalWireAntenna > >  TxRx;
+
+        /** ASCII string representation of the class name */
+        static constexpr auto CName = "KernelV0";
+
+    }; // -----  end of class  KernelV0  -----
+}  // -----  end of namespace Lemma ----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+
+#endif   // ----- #ifndef KERNELV0_INC  -----

include/Merlin

@@ -0,0 +1,4 @@
+#include "KernelV0.h"
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */

src/CMakeLists.txt

@@ -0,0 +1,4 @@
+set (MERLINSOURCE
+	${CMAKE_CURRENT_SOURCE_DIR}/KernelV0.cpp
+	PARENT_SCOPE
+)

src/KernelV0.cpp

@@ -0,0 +1,139 @@
+/* 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      11/11/2016 01:47:25 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     tirons@egi.utah.edu
+ * @copyright Copyright (c) 2016, University of Utah
+ * @copyright Copyright (c) 2016, Lemma Software, LLC
+ */
+
+
+#include "KernelV0.h"
+#include "EMEarth1D.h"
+#include "FieldPoints.h"
+
+namespace Lemma {
+
+    // ====================  FRIEND METHODS  =====================
+
+    std::ostream &operator << (std::ostream &stream, const KernelV0 &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        return stream;
+    }
+
+    // ====================  LIFECYCLE     =======================
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  KernelV0
+    //      Method:  KernelV0
+    // Description:  constructor (locked)
+    //--------------------------------------------------------------------------------------
+    KernelV0::KernelV0 (const ctor_key&) : LemmaObject( ) {
+
+    }  // -----  end of method KernelV0::KernelV0  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  KernelV0
+    //      Method:  KernelV0
+    // Description:  DeSerializing constructor (locked)
+    //--------------------------------------------------------------------------------------
+    KernelV0::KernelV0 (const YAML::Node& node, const ctor_key&) : LemmaObject(node) {
+
+    }  // -----  end of method KernelV0::KernelV0  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  KernelV0
+    //      Method:  NewSP()
+    // Description:  public constructor returing a shared_ptr
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr< KernelV0 >  KernelV0::NewSP() {
+        return std::make_shared< KernelV0 >( ctor_key() );
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  KernelV0
+    //      Method:  ~KernelV0
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
+    KernelV0::~KernelV0 () {
+
+    }  // -----  end of method KernelV0::~KernelV0  (destructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  KernelV0
+    //      Method:  Serialize
+    //--------------------------------------------------------------------------------------
+    YAML::Node  KernelV0::Serialize (  ) const {
+        YAML::Node node = LemmaObject::Serialize();
+        node.SetTag( GetName() );
+
+        // Coils Transmitters & Receivers
+        for ( auto txm : TxRx) {
+            node[txm.first] = txm.second->Serialize();
+        }
+
+        // LayeredEarthEM
+        node["SigmaModel"] = SigmaModel->Serialize();
+
+        return node;
+    }		// -----  end of method KernelV0::Serialize  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  KernelV0
+    //      Method:  DeSerialize
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr<KernelV0> KernelV0::DeSerialize ( const YAML::Node& node  ) {
+        if (node.Tag() !=  "KernelV0" ) {
+            throw  DeSerializeTypeMismatch( "KernelV0", node.Tag());
+        }
+        return std::make_shared< KernelV0 > ( node, ctor_key() );
+    }		// -----  end of method KernelV0::DeSerialize  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  KernelV0
+    //      Method:  DeSerialize
+    //--------------------------------------------------------------------------------------
+    void KernelV0::CalculateK0 (const std::vector< std::string>& Tx, const std::vector<std::string >& Rx ) {
+
+        for (auto tx : Tx) {
+            // Set up EMEarth
+            auto EmEarth = EMEarth1D::NewSP();
+                EmEarth->AttachWireAntenna(TxRx[tx]);
+                EmEarth->AttachLayeredEarthEM(SigmaModel);
+         		EmEarth->SetFieldsToCalculate(H);
+                // TODO query for method, altough with flat antennae, this is fastest
+                EmEarth->SetHankelTransformMethod(ANDERSON801);
+
+// 		EmEarth->AttachFieldPoints(receivers);
+//         //EmEarth->SetHankelTransformMethod(FHTKEY101);
+// 	    EmEarth->CalculateWireAntennaFields();
+//         Vector3Xcr Rx1 = receivers->GetHfield(0);
+//         //receivers->ClearFields();
+//
+// 		//EmEarth->AttachWireAntenna(Tx2);
+// 	    EmEarth->CalculateWireAntennaFields();
+//         Rx1 += receivers->GetHfield(0);
+
+        }
+
+    }
+
+    void KernelV0::CalculateK0 ( const char* tx, const char* rx ) {
+
+    }
+
+} // ----  end of namespace Lemma  ----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+