Lemma is compiling with the exception of TEMIntegrationKernel.

CMakeLists.txt

@@ -76,8 +76,10 @@ configure_file (
 )
 include_directories("${PROJECT_BINARY_DIR}/include")
 
-
-include_directories ("${PROJECT_SOURCE_DIR}/LemmaCore")
+include_directories ("${PROJECT_SOURCE_DIR}/LemmaCore/include")
+include_directories ("${CMAKE_INSTALL_PREFIX}/include/eigen3")
+include_directories ("${CMAKE_INSTALL_PREFIX}/include/")
+link_directories ("${CMAKE_INSTALL_PREFIX}/lib/")
 add_subdirectory (LemmaCore) 
 
 # TODO add compiler specific instructions
@@ -86,6 +88,6 @@ add_compile_options(-std=c++11)
 include_directories(${CMAKE_INSTALL_PREFIX}/include)
 add_executable(Hello "${PROJECT_SOURCE_DIR}/src/test.cpp")
 target_link_libraries(Hello lemmacore)
-
+add_dependencies(Hello YAML-CPP)
 
 

LemmaCore/CMakeLists.txt

@@ -1,13 +1,24 @@
 include_directories(${CMAKE_INSTALL_PREFIX}/include)
 
-add_compile_options(-std=c++11) 
+add_compile_options(-std=c++11 -DHAVE_YAMLCPP) 
+
+#file(GLOB LemmaCore_SRC
+#    "${CMAKE_CURRENT_DIR}/src/*.cpp"
+#)
+add_subdirectory("src")
 
 # TODO fill all the files
+add_library( lemmacore ${SOURCE} )  
+#		"src/lemma.cpp" 
+#		"src/dipolesource.cpp" 
+#		"src/GroundedElectricDipole.cpp" 
+#		"src/UngroundedElectricDipole.cpp"
+#)
 
-add_library( lemmacore  "lemma.cpp" )
 
 add_dependencies(lemmacore YAML-CPP)
 add_dependencies(lemmacore TINYXML2)
 add_dependencies(lemmacore MATIO)
 
 target_link_libraries(lemmacore ${VTK_LIBRARIES})
+target_link_libraries(lemmacore "yaml-cpp")

LemmaCore/include/AEMSurvey.h

@@ -0,0 +1,112 @@
+/* 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/24/2013 04:06:42 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@xri-geo.com
+ * @copyright Copyright (c) 2013, XRI Geophysics, LLC
+ * @copyright Copyright (c) 2013, Trevor Irons
+ */
+
+#ifndef  AEMSURVEY_INC
+#define  AEMSURVEY_INC
+
+#include "LemmaObject.h"
+#include "dipolesource.h"
+
+namespace Lemma {
+
+/**
+  \brief   Contains pertinant information about an AEM survey
+  \details All important details about an AEM survey are stored here, but
+           nothing about the underlying earth model.
+ */
+class AEMSurvey : public LemmaObject {
+
+    friend std::ostream &operator<<(std::ostream &stream,
+            const AEMSurvey &ob);
+
+    /// AEMSurveyReader currently provides the only concrete way to use this class.
+    /// @todo consider making this an abstract class, that can only then exist through
+    ///       the reader. That is if you will not allow users to build their own.
+    friend class AEMSurveyReader;
+
+    public:
+
+    // ====================  LIFECYCLE     =======================
+
+    /**
+     * @copybrief LemmaObject::New()
+     * @copydetails LemmaObject::New()
+     */
+    static AEMSurvey* New();
+
+    /**
+     *  @copybrief   LemmaObject::Delete()
+     *  @copydetails LemmaObject::Delete()
+     */
+    void Delete();
+
+    // ====================  OPERATORS     =======================
+
+    // ====================  OPERATIONS    =======================
+
+    // ====================  ACCESS        =======================
+
+    /** Returns a particular EM source. For now only dipole sources are supported,
+     *  general loops int the new future.
+     *  @param[in] isource is the source fiducial to return
+     */
+    DipoleSource* GetSource(const int& isource);
+
+    /** @return the total number of sources
+     */
+    int GetNumberOfSources();
+
+    /** Returns vector of all frequencies used in the survey
+     *  @return a vector of the unique frequencies
+     */
+    VectorXr GetFrequencies();
+
+    // ====================  INQUIRY       =======================
+
+    protected:
+
+    // ====================  LIFECYCLE     =======================
+
+    /** Default protected constructor, use New */
+    AEMSurvey (const std::string& name);
+
+    /** Default protected destructor, use Delete */
+    ~AEMSurvey ();
+
+    /**
+     *  @copybrief   LemmaObject::Release()
+     *  @copydetails LemmaObject::Release()
+     */
+    void Release();
+
+    private:
+
+    // ====================  DATA MEMBERS  =========================
+
+    std::vector<DipoleSource*>  Sources;
+
+    VectorXr Freqs;
+
+
+}; // -----  end of class  AEMSurvey  -----
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef AEMSURVEY_INC  -----
+

LemmaCore/include/AEMSurveyReader.h

@@ -0,0 +1,137 @@
+/* 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/24/2013 04:29:27 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@xri-geo.com
+ * @copyright Copyright (c) 2013, XRI Geophysics, LLC
+ * @copyright Copyright (c) 2013, Trevor Irons
+ */
+
+#ifndef  AEMSURVEYREADER_INC
+#define  AEMSURVEYREADER_INC
+
+#include "LemmaObject.h"
+#include "AEMSurvey.h"
+#include "ASCIIParser.h"
+
+namespace Lemma {
+
+    /**
+      \brief   Reads an ASCII description of an AEM survey
+      \details The file format is described as follows.
+     */
+    class AEMSurveyReader : public LemmaObject {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const AEMSurveyReader &ob);
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        /*c
+         * @copybrief LemmaObject::New()
+         * @copydetails LemmaObject::New()
+         */
+        static AEMSurveyReader* New();
+
+        /**
+         *  @copybrief   LemmaObject::Delete()
+         *  @copydetails LemmaObject::Delete()
+         */
+        void Delete();
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        /**
+         *
+@code
+// AEM Survey Specification file
+
+     5    // N sources
+
+400       // Source 1 frequency Hz
+MD        // Source 1 type
+-7  0 -10 // Source 1 relative position front/back, left/right, up/down
+1         // Source 1 moment
+
+1800      // Source 2  frequency Hz
+VMD       // Source 2 type
+-7  0 -10 // Source 2 relative position
+1         // Source 2 moment
+
+8200      // Source 3  freqeuncy Hz
+MD        // Source 3 type
+-7  0 -10 // Source 3 relative position
+1         // Source 3 moment
+
+40000     // Source 4  frequency Hz
+MD        // Source 4 type
+-7  0 -10 // Source 4 relative position
+1         // Source 4 moment
+
+140000    // Source 5  frequency Hz
+MD        // Source 5 type
+-7  0 -10 // Source 5 relative position
+1         // Source 5 moment
+
+// Flight Plan (in same coordinates as grid)
+2     // Number of points
+
+// location in x, y, z, polarisation [x,y,z]
+
+-200 -200 -30  0  0  1
+-190 -200 -30  0  0  1
+@endcode
+         */
+        void ReadASCIIAEMFile( const std::string& name );
+
+        // ====================  ACCESS        =======================
+
+        /**
+         * @return the AEMSurvey based on the file read
+         */
+        AEMSurvey* GetSurvey();
+
+        // ====================  INQUIRY       =======================
+
+        protected:
+
+        // ====================  LIFECYCLE     =======================
+
+        /** Default protected constructor, use New */
+        AEMSurveyReader (const std::string& name);
+
+        /** Default protected destructor, use Delete */
+        ~AEMSurveyReader ();
+
+        /**
+         *  @copybrief   LemmaObject::Release()
+         *  @copydetails LemmaObject::Release()
+         */
+        void Release();
+
+        private:
+
+        // ====================  DATA MEMBERS  =========================
+
+        AEMSurvey*  Survey;
+
+    }; // -----  end of class  AEMSurveyReader  -----
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef AEMSURVEYREADER_INC  -----
+

LemmaCore/include/ASCIIParser.h

@@ -0,0 +1,142 @@
+/* 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/23/2013 02:31:24 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@xri-geo.com
+ * @copyright Copyright (c) 2013, XRI Geophysics, LLC
+ * @copyright Copyright (c) 2013, Trevor Irons
+ */
+
+#ifndef  ASCIIPARSER_INC
+#define  ASCIIPARSER_INC
+
+#include "LemmaObject.h"
+#include <fstream>
+
+namespace Lemma {
+
+/**
+  \brief   Provides ASCII input file parsing
+  \details Able to accomodate various inputs and comment styles
+ */
+class ASCIIParser : public LemmaObject {
+
+    friend std::ostream &operator<<(std::ostream &stream,
+            const ASCIIParser &ob);
+
+    public:
+
+    // ====================  LIFECYCLE     =======================
+
+    /** @copybrief LemmaObject::New()
+     *  @copydetails LemmaObject::New()
+     */
+    static ASCIIParser* New();
+
+    /** @copybrief   LemmaObject::Delete()
+     *  @copydetails LemmaObject::Delete()
+     */
+    void Delete();
+
+    // ====================  OPERATORS     =======================
+
+    // ====================  OPERATIONS    =======================
+
+    /** Opens the file up for reading. Throws an exception if something bad happens.
+        @param[in] fname is the filename to be parsed.
+     */
+    void Open (const std::string& fname);
+
+
+    /** Closes the file. Throws an exception if something bad happens.
+     */
+    void Close ( );
+
+    /** Reads a series of Reals.
+     *  @param[in] nr is the number of reals to read. Enter -1 for the entire file
+     *  @todo throw exception if no file is open
+     */
+    std::vector<Real> ReadReals( const int& nr);
+
+    /** Reads a series of Reals.
+     *  @param[in] nr is the number of ints to read. Enter -1 for the entire file
+     *  @todo throw exception if no file is open
+     */
+    std::vector<int> ReadInts( const int& nr);
+
+    /** Reads a series of space delimited strings
+     *  @param[in] nr is the number of strings to read. Enter -1 for the entire file
+     *  @todo throw exception if no file is open
+     */
+    std::vector< std::string > ReadStrings( const int& nr);
+
+    /**
+     * @param[in] loc is the point in the file to jump to. Uses seekg
+     */
+    void JumpToLocation(const int& loc);
+
+    // ====================  ACCESS        =======================
+
+    /** Sets the comment identifier key.
+     * @param[in] key is a string identifying comments. All text after the key will be
+     *  ignored by the parser. Default is //
+     */
+    void SetCommentString( const std::string& key );
+
+    /** Sets the buffer size. This affects the maximum number of column in a line. Defaults
+     *  is 255.
+     *  @param[in] BufferSize is the size of the buffer to use
+     */
+    void SetBufferSize( const int& BufferSize);
+
+    /**
+     * @return the current position in the file, as reported by istream::tellg
+     */
+    int GetFileLocation();
+
+    // ====================  INQUIRY       =======================
+
+    protected:
+
+    // ====================  LIFECYCLE     =======================
+
+    /** Default protected constructor, use New */
+    ASCIIParser (const std::string& name);
+
+    /** Default protected destructor, use Delete */
+    ~ASCIIParser ();
+
+    /**
+     *  @copybrief   LemmaObject::Release()
+     *  @copydetails LemmaObject::Release()
+     */
+    void Release();
+
+    private:
+
+    // ====================  DATA MEMBERS  =========================
+
+    /** c++ style file IO */
+    std::fstream input;
+
+    /** comment string, defaults to c++ style // */
+    std::string  CommentString;
+
+    /** Buffer size, max line width supported, defaults to 255 */
+    int BufferSize;
+
+}; // -----  end of class  ASCIIParser  -----
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef ASCIIPARSER_INC  -----

LemmaCore/include/CubicSplineInterpolator.h

@@ -0,0 +1,181 @@
+/* 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/25/2013 08:20:14 AM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@xri-geo.com
+ * @copyright Copyright (c) 2013, XRI Geophysics, LLC
+ * @copyright Copyright (c) 2013, Trevor Irons
+ */
+
+#ifndef  CUBICSPLINEINTERPOLATOR_INC
+#define  CUBICSPLINEINTERPOLATOR_INC
+
+#include "LemmaObject.h"
+
+namespace Lemma {
+
+// Simple struct to hold spline terms
+struct SplineSet{
+    VectorXr a;
+    VectorXr b;
+    VectorXr c;
+    VectorXr d;
+    VectorXr x;
+
+    SplineSet( ) {
+    }
+
+    SplineSet(const int&n) {
+        a = VectorXr::Zero(n+1);
+        b = VectorXr::Zero(n);
+        c = VectorXr::Zero(n+1);
+        d = VectorXr::Zero(n);
+        x = VectorXr::Zero(n+1);
+    }
+};
+
+/**
+  \brief   Real 1D Natural cubic spline interpolator.
+  \details Splines are fit between knots \f$j\f$ according to the forulae
+           \f[ S_j(x) =  a_j + b_j(x - x_j) + c_j(x-x_j)^2 + d_j(x-x_y)^3  \f]
+           The spline must satisfy the following conditions
+            \f{eqnarray} {
+                S_i(x_i) & = & y_i = S_{i-1}(x_i), i = 1,..., n-1 \\
+                S'_i(x_i) & = &  S'_{i-1}(x_i), i = 1,..., n-1 \\
+                S''_i(x_i) & = & S''_{i-1}(x_i), i = 1,..., n-1 \\
+                S''_0(x_0) & = & S''_{n-1}(x_n) = 0
+            \f}
+ */
+class CubicSplineInterpolator : public LemmaObject {
+
+    friend std::ostream &operator<<(std::ostream &stream,
+            const CubicSplineInterpolator &ob);
+
+    public:
+
+    // ====================  LIFECYCLE     =======================
+
+    /**
+     * @copybrief LemmaObject::New()
+     * @copydetails LemmaObject::New()
+     */
+    static CubicSplineInterpolator* New();
+
+    /**
+     *  @copybrief   LemmaObject::Delete()
+     *  @copydetails LemmaObject::Delete()
+     */
+    void Delete();
+
+    // ====================  OPERATORS     =======================
+
+    // ====================  OPERATIONS    =======================
+
+    /** Sets the knots to use for interpolation.
+        @param[in] x are the absissa values
+        @param[in] y are the ordinate values
+     */
+    void SetKnots(const VectorXr& x, const VectorXr& y);
+
+    /** Resets the knots to use for interpolation, when abscissa values haven't changed.
+        @param[in] y are the ordinate values
+     */
+    void ResetKnotOrdinate( const VectorXr& y );
+
+    /** Interpolate a monotonically increasing ordered set.
+        @param[in] x are the interpolation abscissa points
+        @return the ordinate values at x
+     */
+    VectorXr InterpolateOrderedSet(const VectorXr& x);
+
+    /** integrates the spline from x0 to x1. Uses composite Simpson's rule and n is the number of segments
+     *  @param[in] x0 is left argument
+     *  @param[in] x1 is right argument
+     *  @param[in] n is the number of points, must be even
+     */
+    Real Integrate(const Real& x0, const Real& x1, const int& n);
+
+    /** integrates using cubic spline values. Taken from AMRIRA P223F project code Leroi, which in turn was based on
+        This is a modification of the FUNCTION PPVALU in the book
+        "A PRACTICAL GUIDE TO SPLINES"  by C. DE BOOR
+     */
+    Real Integrate(const Real& x0, const Real& x1);
+
+    /** @returns the know abscissa values
+     */
+    VectorXr GetKnotAbscissa();
+
+    /** @returns the know abscissa values
+     */
+    VectorXr GetKnotOrdinate();
+
+    /** Interpolation at a single point.
+        @param[in] x is the interpolation abscissa point
+        @param[in] i is an optional index to start searching at. Defaults to zero
+        @return the ordinate value at x
+     */
+    Real Interpolate(const Real& x, int& i);
+
+    /** Interpolation at a single point.
+        @param[in] x is the interpolation abscissa point
+        @return the ordinate value at x
+     */
+    Real Interpolate(const Real& x);
+
+    // ====================  ACCESS        =======================
+
+    // ====================  INQUIRY       =======================
+
+    protected:
+
+    // ====================  LIFECYCLE     =======================
+
+    /** Default protected constructor, use New */
+    CubicSplineInterpolator (const std::string& name);
+
+    /** Default protected destructor, use Delete */
+    ~CubicSplineInterpolator ();
+
+    /**
+     *  @copybrief   LemmaObject::Release()
+     *  @copydetails LemmaObject::Release()
+     */
+    void Release();
+
+    // ====================  OPERATIONS    =======================
+
+    /**
+        Performs spline fitting.
+     */
+    //void Spline() {
+    // }
+
+    /** Finds the interval of knots in spline to use for integration.
+     */
+    int Interval(const Real& x);
+
+    private:
+
+    SplineSet Spline;
+
+    int ilo;
+
+    int mflag;
+
+    // ====================  DATA MEMBERS  =========================
+
+}; // -----  end of class  CubicSplineInterpolator  -----
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef CUBICSPLINEINTERPOLATOR_INC  -----

LemmaCore/include/DCIPElectrode.h

@@ -0,0 +1,127 @@
+/* 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/10/2014 10:53:34 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  DCIPELECTRODE_INC
+#define  DCIPELECTRODE_INC
+
+#include "LemmaObject.h"
+
+namespace Lemma {
+
+    /**
+      \brief
+      \details
+     */
+    class DCIPElectrode : public LemmaObject {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const DCIPElectrode &ob);
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        /**
+         * @copybrief LemmaObject::New()
+         * @copydetails LemmaObject::New()
+         */
+        static DCIPElectrode* New();
+
+        /**
+         *  @copybrief   LemmaObject::Delete()
+         *  @copydetails LemmaObject::Delete()
+         */
+        void Delete();
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        // ====================  ACCESS        =======================
+
+        /** Sets the physical location of the electrode
+         *  @param[in] loc is the location
+         */
+        void SetLocation(const Vector3r& loc);
+
+        /** Sets the tag (label) for the electrode
+         */
+        void SetLabel(const std::string& tag);
+
+        /** Sets the tag (label) for the electrode
+         */
+        std::string GetLabel( );
+
+        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
+
+        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  =========================
+
+        /** The location of the electrode */
+        Vector3r Location;
+
+        /** Local Node_ID on a mesh */
+        int Node_ID;
+
+        /** String label for the electrode */
+        std::string Label;
+
+    }; // -----  end of class  DCIPElectrode  -----
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef DCIPELECTRODE_INC  -----
+

LemmaCore/include/DCSurvey.h

@@ -0,0 +1,240 @@
+/* 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/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
+ */
+
+#ifndef  DCSURVEY
+#define  DCSURVEY
+
+#include "LemmaObject.h"
+#include "DCIPElectrode.h"
+
+#ifdef HAVE_YAMLCPP
+#include "yaml-cpp/yaml.h"
+#endif
+
+#ifdef LEMMAUSEVTK
+#include <vtkDataSet.h>
+#endif
+
+namespace Lemma {
+
+    #define EINFINITY -9999
+
+    /**
+      \brief   Describes a DC survey.
+      \details This class aims to encapulate any type of DC survey.
+     */
+    class DCSurvey : public LemmaObject {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const DCSurvey &ob);
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        /**
+         * @copybrief LemmaObject::New()
+         * @copydetails LemmaObject::New()
+         */
+        static DCSurvey* New();
+
+        /**
+         *  @copybrief   LemmaObject::Delete()
+         *  @copydetails LemmaObject::Delete()
+         */
+        void Delete();
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        /**
+         *   Adds new electrode to the survey.
+         *   @param[in] Electrode `Pounds' a new Electrode into place.
+         *   @return integer index to this electrode.
+         *   @note Single electrodes cannot be pulled once they are pounded. The reason for this is that
+         *         every index then would become invalid. Furthurmore these are stored in a std::vector and
+         *         removing arbitrary items is inefficient.
+         *   @see PullElectrodes
+         *   @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 );
+
+        /** Alternative Factory method of setting electrodes. IN this manner all memoy management
+         *  is handled by DCSurvey.
+         *  @note there is no logic preventing one from pounding coincident electrodes. Don't do it.
+         *  @note Single electrodes cannot be pulled once they are pounded. The reason for this is that
+         *         every index then would become invalid. Furthurmore these are stored in a std::vector and
+         *         removing arbitrary items is inefficient.
+         *  @see PullElectrodes
+         *  @param[in] loc is the location of the electrode.
+         *  @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  );
+
+#ifdef LEMMAUSEVTK
+        DCIPElectrode* PoundElectrode( const int& nodeID, vtkDataSet* Mesh, const std::string& label = "NULL" );
+#endif
+
+        /**
+         *  Pulls all electrodes and removes connections.
+         */
+        void PullElectrodes();
+
+        /**
+         *   Adds an injection point.
+         *   @param[in] A is the positive current electrode
+         *   @param[in] B is the negative current electrode
+         *   @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)
+         */
+        int AddInjection( DCIPElectrode* A, DCIPElectrode* B, const Real& J);
+
+        /**
+         *   Adds an injection point.
+         *   @param[in] A is the positive current electrode.
+         *   @param[in] J is the current intensity.
+         *   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)
+         */
+        int AddInjection( 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(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(const int& iA, const int& iB, const Real& J)
+         */
+        int AddInjection( const int& iA, const Real& J );
+
+        /** Adds a potential measurement via the electrode pair comparison \f$ M - N \f$.
+         *   @param[in] M is a pointer to the `positive' electrode
+         *   @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 );
+
+        /** 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 )
+         */
+        void AddMeasurement( const int& ij, const std::string& M, const std::string& N);
+
+        /**
+         *  Used to probe for the index and current of an injection
+         *  @param[in] ij is the current injection indes
+         *  @param[out] ii is the node index
+         *  @param[out] jj is the current
+         */
+        void GetA( const int& ij, int& ii, Real& jj );
+
+        /**
+         *  Used to probe for the index and current of an injection
+         *  @param[in] ij is the current injection indes
+         *  @param[out] ii is the node index
+         *  @param[out] jj is the current
+         */
+        void GetB( const int& ij, int& ii, Real& jj );
+
+
+        // ====================  ACCESS        =======================
+
+        // ====================  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  =========================
+
+        /** The electrodes */
+        std::vector<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;
+
+        /** The A Injection electrodes */
+        std::vector<int>     A_Electrodes;
+
+        /** The A Injection electrodes */
+        std::vector<int>     B_Electrodes;
+
+        /** The A Injection electrodes */
+        std::vector<Real>    J_Electrodes;
+
+        /** First Potential electrodes */
+        std::vector< std::vector<int> > M_Electrodes;
+
+        /** Second Potential electrodes */
+        std::vector< std::vector<int> > N_Electrodes;
+
+    }; // -----  end of class  DCSurvey  -----
+
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef DCSURVEY  -----

LemmaCore/include/FHTKey.h

@@ -0,0 +1,112 @@
+/* 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/11/2014 03:33:08 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
+ */
+
+
+#ifndef  FHTKEY_INC
+#define  FHTKEY_INC
+
+#include "hankeltransform.h"
+
+namespace Lemma {
+
+    /**
+      \brief   Impliments the fast Hankel transform as outlines by Key 2011
+      \details This filter uses 61, 121, or 201 filter points and supports both lagged and related
+                kernel arguments. This algorithm is a port of code carrying the following copyright and
+                restriction:
+                %------------------------------------------------------------------%
+                % Copyright (c) 2012 by the Society of Exploration Geophysicists.  %
+                % For more information, go to http://software.seg.org/2012/0003 .  %
+                % You must read and accept usage terms at:                         %
+                % http://software.seg.org/disclaimer.txt before use.               %
+                %------------------------------------------------------------------%
+     */
+    class FHTKey : public HankelTransform {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const FHTKey &ob);
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        /**
+         * @copybrief LemmaObject::New()
+         * @copydetails LemmaObject::New()
+         */
+        static FHTKey* New();
+
+        /**
+         *  @copybrief   LemmaObject::Delete()
+         *  @copydetails LemmaObject::Delete()
+         */
+        void Delete();
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        Complex Zgauss(const int &ikk, const EMMODE &imode,
+                            const int &itype, const Real &rho,
+                            const Real &wavef, KernelEm1DBase *Kernel);
+
+        /// Computes related kernels, if applicable, otherwise this is
+        /// just a dummy function.
+        void ComputeRelated(const Real& rho, KernelEm1DBase* Kernel);
+
+        void ComputeRelated(const Real& rho, std::vector< KernelEm1DBase* > KernelVec);
+
+        void ComputeRelated(const Real& rho, KernelEM1DManager* KernelManager);
+
+        // ====================  ACCESS        =======================
+
+        // ====================  INQUIRY       =======================
+
+        protected:
+
+        // ====================  LIFECYCLE     =======================
+
+        /** Default protected constructor, use New */
+        FHTKey (const std::string& name);
+
+        /** Default protected destructor, use Delete */
+        ~FHTKey ();
+
+        /**
+         *  @copybrief   LemmaObject::Release()
+         *  @copydetails LemmaObject::Release()
+         */
+        void Release();
+
+        private:
+
+        // ====================  DATA MEMBERS  =========================
+
+        // Shared Filter Weights
+		static const Eigen::Matrix<Real, 201, 3>  WT201;
+
+        /// Holds answer, dimensions are NumConv, and NumberRelated.
+        Eigen::Matrix<Complex, Eigen::Dynamic, Eigen::Dynamic> Zans;
+
+    }; // -----  end of class  FHTKey  -----
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef FHTKEY_INC  -----
+

LemmaCore/include/FHTKey101.h

@@ -0,0 +1,112 @@
+/* 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/11/2014 03:33:08 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
+ */
+
+
+#ifndef  FHTKEY101_INC
+#define  FHTKEY101_INC
+
+#include "hankeltransform.h"
+
+namespace Lemma {
+
+    /**
+      \brief   Impliments the fast Hankel transform as outlines by Key 2011
+      \details This filter uses 51, 101, or 201 filter points and supports both lagged and related
+                kernel arguments. This algorithm is a port of code carrying the following copyright and
+                restriction:
+                %------------------------------------------------------------------%
+                % Copyright (c) 2012 by the Society of Exploration Geophysicists.  %
+                % For more information, go to http://software.seg.org/2012/0003 .  %
+                % You must read and accept usage terms at:                         %
+                % http://software.seg.org/disclaimer.txt before use.               %
+                %------------------------------------------------------------------%
+     */
+    class FHTKey101 : public HankelTransform {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const FHTKey101 &ob);
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        /**
+         * @copybrief LemmaObject::New()
+         * @copydetails LemmaObject::New()
+         */
+        static FHTKey101* New();
+
+        /**
+         *  @copybrief   LemmaObject::Delete()
+         *  @copydetails LemmaObject::Delete()
+         */
+        void Delete();
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        Complex Zgauss(const int &ikk, const EMMODE &imode,
+                            const int &itype, const Real &rho,
+                            const Real &wavef, KernelEm1DBase *Kernel);
+
+        /// Computes related kernels, if applicable, otherwise this is
+        /// just a dummy function.
+        void ComputeRelated(const Real& rho, KernelEm1DBase* Kernel);
+
+        void ComputeRelated(const Real& rho, std::vector< KernelEm1DBase* > KernelVec);
+
+        void ComputeRelated(const Real& rho, KernelEM1DManager* KernelManager);
+
+        // ====================  ACCESS        =======================
+
+        // ====================  INQUIRY       =======================
+
+        protected:
+
+        // ====================  LIFECYCLE     =======================
+
+        /** Default protected constructor, use New */
+        FHTKey101 (const std::string& name);
+
+        /** Default protected destructor, use Delete */
+        ~FHTKey101 ();
+
+        /**
+         *  @copybrief   LemmaObject::Release()
+         *  @copydetails LemmaObject::Release()
+         */
+        void Release();
+
+        private:
+
+        // ====================  DATA MEMBERS  =========================
+
+        // Shared Filter Weights
+		static const Eigen::Matrix<Real, 101, 3>  WT101;
+
+        /// Holds answer, dimensions are NumConv, and NumberRelated.
+        Eigen::Matrix<Complex, Eigen::Dynamic, Eigen::Dynamic> Zans;
+
+    }; // -----  end of class  FHTKey101  -----
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef FHTKEY101_INC  -----
+

LemmaCore/include/FHTKey51.h

@@ -0,0 +1,112 @@
+/* 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/11/2014 03:33:08 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
+ */
+
+
+#ifndef  FHTKEY51_INC
+#define  FHTKEY51_INC
+
+#include "hankeltransform.h"
+
+namespace Lemma {
+
+    /**
+      \brief   Impliments the fast Hankel transform as outlines by Key 2011
+      \details This filter uses 51, 101, or 201 filter points and supports both lagged and related
+                kernel arguments. This algorithm is a port of code carrying the following copyright and
+                restriction:
+                %------------------------------------------------------------------%
+                % Copyright (c) 2012 by the Society of Exploration Geophysicists.  %
+                % For more information, go to http://software.seg.org/2012/0003 .  %
+                % You must read and accept usage terms at:                         %
+                % http://software.seg.org/disclaimer.txt before use.               %
+                %------------------------------------------------------------------%
+     */
+    class FHTKey51 : public HankelTransform {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const FHTKey51 &ob);
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        /**
+         * @copybrief LemmaObject::New()
+         * @copydetails LemmaObject::New()
+         */
+        static FHTKey51* New();
+
+        /**
+         *  @copybrief   LemmaObject::Delete()
+         *  @copydetails LemmaObject::Delete()
+         */
+        void Delete();
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        Complex Zgauss(const int &ikk, const EMMODE &imode,
+                            const int &itype, const Real &rho,
+                            const Real &wavef, KernelEm1DBase *Kernel);
+
+        /// Computes related kernels, if applicable, otherwise this is
+        /// just a dummy function.
+        void ComputeRelated(const Real& rho, KernelEm1DBase* Kernel);
+
+        void ComputeRelated(const Real& rho, std::vector< KernelEm1DBase* > KernelVec);
+
+        void ComputeRelated(const Real& rho, KernelEM1DManager* KernelManager);
+
+        // ====================  ACCESS        =======================
+
+        // ====================  INQUIRY       =======================
+
+        protected:
+
+        // ====================  LIFECYCLE     =======================
+
+        /** Default protected constructor, use New */
+        FHTKey51 (const std::string& name);
+
+        /** Default protected destructor, use Delete */
+        ~FHTKey51 ();
+
+        /**
+         *  @copybrief   LemmaObject::Release()
+         *  @copydetails LemmaObject::Release()
+         */
+        void Release();
+
+        private:
+
+        // ====================  DATA MEMBERS  =========================
+
+        // Shared Filter Weights
+		static const Eigen::Matrix<Real, 51, 3>  WT51;
+
+        /// Holds answer, dimensions are NumConv, and NumberRelated.
+        Eigen::Matrix<Complex, Eigen::Dynamic, Eigen::Dynamic> Zans;
+
+    }; // -----  end of class  FHTKey51  -----
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef FHTKEY51_INC  -----
+

LemmaCore/include/GridReader.h

@@ -0,0 +1,76 @@
+/* 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
+  @date      09/23/2013 11:25:11 AM
+  @version   $Id$
+  @author    Trevor Irons (ti)
+  @email     Trevor.Irons@xri-geo.com
+  @copyright Copyright (c) 2013, XRI Geophysics, LLC
+  @copyright Copyright (c) 2013, Trevor Irons
+ **/
+
+#ifndef  GRIDREADER_INC
+#define  GRIDREADER_INC
+
+#include "LemmaObject.h"
+#include "grid.h"
+
+namespace Lemma {
+
+    /**
+      @class
+      \brief   Abstract class for grid readers.
+      \details Provides a consistent interface for reading grid files in Lemma.
+     */
+    class GridReader : public LemmaObject {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const GridReader &ob) {
+            stream << *(LemmaObject*)(&ob);
+            return stream;
+        }
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+
+            // ====================  OPERATORS     =======================
+
+            // ====================  OPERATIONS    =======================
+
+            virtual void ReadASCIIGridFile( const std::string& name )=0;
+
+            virtual Grid* GetGrid( )=0;
+
+            // ====================  ACCESS        =======================
+
+            // ====================  INQUIRY       =======================
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /** Default protected constructor, use New */
+            GridReader (const std::string& name) : LemmaObject(name) {
+            }
+
+            /** Default protected constructor, use Delete */
+            ~GridReader () {
+            }
+
+        private:
+
+            // ====================  DATA MEMBERS  =========================
+
+    }; // -----  end of class  GridReader  -----
+
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef GRIDREADER_INC  -----

LemmaCore/include/GroundedElectricDipole.h

@@ -0,0 +1,87 @@
+/* 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 {
+
+    /**
+      \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  -----
+

LemmaCore/include/LayeredEarthEMReader.h

@@ -0,0 +1,105 @@
+/* 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/27/2013 01:44:36 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@xri-geo.com
+ * @copyright Copyright (c) 2013, XRI Geophysics, LLC
+ * @copyright Copyright (c) 2013, Trevor Irons
+ */
+
+#ifndef  LAYEREDEARTHEMREADER_INC
+#define  LAYEREDEARTHEMREADER_INC
+
+#include "LemmaObject.h"
+#include "ASCIIParser.h"
+#include "layeredearthem.h"
+
+namespace Lemma {
+
+    /**
+      \brief
+      \details
+     */
+    class LayeredEarthEMReader : public LemmaObject {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const LayeredEarthEMReader &ob);
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        /**
+         * @copybrief LemmaObject::New()
+         * @copydetails LemmaObject::New()
+         */
+        static LayeredEarthEMReader* New();
+
+        /**
+         *  @copybrief   LemmaObject::Delete()
+         *  @copydetails LemmaObject::Delete()
+         */
+        void Delete();
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        /** Reads ASCII input file. The format is as follows
+@code
+4           // Number of NON-AIR layers
+200   10    // resistivity, thickness layer 1 [Ohm-m] [m]
+20    10    // resistivity, thickness layer 2 [Ohm-m] [m]
+1120  10    // resistivity, thickness layer 3 [Ohm-m] [m]
+200         // resistivity of bottom layer [Ohm-m]
+@endcode
+         * @param[in] name is the filename
+         */
+        void ReadASCIIInputFile( const std::string& name );
+
+        // ====================  ACCESS        =======================
+
+        /** @return the pointer address of the LayeredEarthEM
+         */
+        LayeredEarthEM* GetLayeredEarth();
+
+        // ====================  INQUIRY       =======================
+
+        protected:
+
+        // ====================  LIFECYCLE     =======================
+
+        /** Default protected constructor, use New */
+        LayeredEarthEMReader (const std::string& name);
+
+        /** Default protected destructor, use Delete */
+        ~LayeredEarthEMReader ();
+
+        /**
+         *  @copybrief   LemmaObject::Release()
+         *  @copydetails LemmaObject::Release()
+         */
+        void Release();
+
+        private:
+
+        // ====================  DATA MEMBERS  =========================
+
+        LayeredEarthEM*         LayEarth;
+
+    }; // -----  end of class  LayeredEarthEMReader  -----
+
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef LAYEREDEARTHEMREADER_INC  -----

LemmaCore/include/LemmaObject.h

@@ -0,0 +1,223 @@
+/* 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     06/25/2009
+  @version  $Id: LemmaObject.h 199 2014-12-29 19:25:20Z tirons $
+ **/
+
+#ifndef __LEMMAOBJECT_H
+#define __LEMMAOBJECT_H
+
+#include "helper.h"
+#include "lemma.h"
+
+#ifdef HAVE_YAMLCPP
+#include "yaml-cpp/yaml.h"
+#endif
+
+namespace Lemma {
+
+// ==========================================================================
+//        Class:  LemmaObject
+/** \brief    Abstract class providing simple reference counting and memory
+  *           management.
+  * \details  Since objects can be members of other objects, and may be
+  *           of multiple objects it becomes useful to count the number of
+  *           Classes an object is a member of. Objects cannot be deleted that
+  *           contain references to other objects.
+  */
+// ==========================================================================
+
+/** Base class for all of Lemma. Reference counted object provides simple
+ * reference counting. This allows for much easier maintainance of shared
+ * objects among classes.
+ */
+class LemmaObject {
+
+    /** Recursively prints information about this object
+     */
+    friend std::ostream &operator<<(std::ostream &stream, const LemmaObject &ob);
+
+    #ifdef HAVE_YAMLCPP
+    friend YAML::Emitter& operator << (YAML::Emitter& out, const LemmaObject &ob) ;
+    #endif
+
+    friend class DeleteObjectWithReferences;
+
+    public:
+
+        // Needed because some derived classes have Eigen vectors as members,
+        // causing alignment issues when vectorisation is enabled.
+        EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+
+        // ====================  OPERATORS     ==============================
+
+        // ====================  OPERATIONS    ==============================
+
+        /**
+         * Deletes this objects self reference. If there are no remaining
+         * references, Release is called freeing all memory. Otherwise Release
+         * is called if/when the last reference is removed.
+         */
+        virtual void Delete()=0;
+
+        /** Attaches this object to another object */
+        void AttachTo(LemmaObject *);
+
+        /** Detaches this object from another object */
+        void DetachFrom(LemmaObject *);
+
+        // ====================  ACCESS        ==============================
+
+        // ====================  INQUIRY       ==============================
+
+        /** Returns the number of objects attached to this. */
+        unsigned int GetNumberOfReferences();
+
+        /** Returns address(s) to class(es) of which this is a member
+         */
+        std::vector<LemmaObject*> GetReferences();
+
+        /** Returns name of this model */
+        std::string GetName();
+
+        #ifdef HAVE_YAMLCPP
+        /**
+         *  Uses YAML to serialize this object.
+         *  @return a YAML::Node
+         *  FOR NOT LemmaObject does not write out any YAML info,
+         *      in the future the reference count could be logged? But the utility
+         *      of that is minimal.
+         *  @note Not every Lemma class needs to be Serializable, for instance HankelTransform
+         *        classes will never need to be Serialized. There may be a need to differentiate these
+         *        two families in to a LemmaInternalClass without serializing and perhaps this class for
+         *        all external classes that might need to be serialized.
+         */
+        virtual YAML::Node Serialize() const{
+            return YAML::Node();
+        };
+        #endif
+
+    protected:
+
+        // ====================  LIFECYCLE     ==============================
+
+        /** Protected default constructor. This is an abstract class and
+         *  cannot be instantiated.
+         */
+        LemmaObject (const std::string &name);
+
+        #ifdef HAVE_YAMLCPP
+        /** Protected DeDerializing constructor, use factory DeSerialize  method*/
+        LemmaObject (const YAML::Node& node);
+        #endif
+
+        // ====================  DATA MEMBERS  ==============================
+        /** Protected default destructor. This is an abstract class and
+         *  cannot be instantiated.
+         */
+        virtual ~LemmaObject ();
+
+        /**
+         *  Releases all memory back to the heap. Just calls the protected
+         *  destructor at the derived class level.
+         */
+        virtual void Release()=0;
+
+        // ====================  OPERATIONS    ==============================
+
+        // ====================  DATA MEMBERS  ==============================
+
+        /** Number of other classes claiming this as a member. */
+        unsigned int NumberOfReferences;
+
+        /** List of the addresses of the other classes referencing this as a
+         * member
+         */
+        std::vector<LemmaObject *> RefPtrList;
+
+        /** Stores an ASCII string representation of the class name */
+        std::string Name;
+
+}; // -----  end of class  LemmaObject  -----
+
+    /////////////////////////////////////////////////////////////////
+    // BOILERPLATE MACROS
+    #define DESERIALIZECHECK( node, Object ) { \
+        if (node.Tag() != Object->GetName()) {  \
+            throw  DeSerializeTypeMismatch(Object, node.Tag()) ; \
+        } } \
+
+    /////////////////////////////////////////////////////////////////
+    // Error Classes
+
+    /** Error called when ReferenceCounting breaks. If an object is
+     * deleted that has refences still, this is thrown.
+     */
+    class DeleteObjectWithReferences : public std::runtime_error {
+
+        public:
+
+            /** Call this method internally when an object is deleted with
+             * references.
+             */
+            DeleteObjectWithReferences(LemmaObject *ptr);
+
+            /** @deprecated this error may be thrown, but the error message is much
+            * less insightful than
+            * DeleteObjectWithReferences(LemmaObject* ptr).
+            */
+            DeleteObjectWithReferences( );
+    };
+
+
+    /** Error called when DeSerializing breaks. If the node type is not the expected one
+     *  this error is thown.
+     */
+    class DeSerializeTypeMismatch : public std::runtime_error {
+        public:
+            DeSerializeTypeMismatch(LemmaObject *ptr, const std::string& got);
+
+    };
+
+    /** If an assignment is made that is out of bounts, throw this.
+     */
+    class AssignmentOutOfBounds : public std::runtime_error {
+        public:
+            /** Throw when an assignment is out of bounds.
+             *  @param[in] ptr is a pointer to the class throwing the exception.
+             */
+            AssignmentOutOfBounds(LemmaObject *ptr);
+    };
+
+    /** If a pointer to a class is requested, but it is NULL valued, throw this
+     */
+    class RequestToReturnNullPointer : public std::runtime_error {
+        public:
+            /** Thrown when the pointer is NULL
+             *  @param[in] ptr is a pointer to the class throwing the exception.
+             */
+            RequestToReturnNullPointer(LemmaObject *ptr);
+    };
+
+    /** If an error in opening a .mat file is encountered, throw this.
+     */
+    class MatFileCannotBeOpened : public std::runtime_error {
+        /** thown when a mat file fails to be opened.
+         */
+            public: MatFileCannotBeOpened();
+    };
+
+	/** Generic file I/O error. */
+	class GenericFileIOError : public std::runtime_error {
+			public: GenericFileIOError(LemmaObject *ptr, const std::string &filename);
+	};
+
+}
+#endif // __LEMMAOBJECT_H

LemmaCore/include/MagneticDipole.h

@@ -0,0 +1,88 @@
+/* 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/25/2013 08:20:14 AM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@xri-geo.com
+ * @copyright Copyright (c) 2013, XRI Geophysics, LLC
+ * @copyright Copyright (c) 2013, Trevor Irons
+ */
+
+#ifndef  MAGNETICDIPOLE_INC
+#define  MAGNETICDIPOLE_INC
+
+#include "dipolesource.h"
+
+namespace Lemma {
+
+/**
+  @class
+  \brief   Magnetic Dipole
+  \details Used to model an idealised magnetic dipole of arbitrary
+           polarisation.
+ */
+class MagneticDipole : public DipoleSource {
+
+    friend std::ostream &operator<<(std::ostream &stream,
+            const MagneticDipole &ob);
+
+    public:
+
+    // ====================  LIFECYCLE     =======================
+
+    /**
+     * @copybrief LemmaObject::New()
+     * @copydetails LemmaObject::New()
+     */
+    static MagneticDipole* New();
+
+    /**
+     *  @copybrief   LemmaObject::Delete()
+     *  @copydetails LemmaObject::Delete()
+     */
+    void Delete();
+
+    // ====================  OPERATORS     =======================
+
+    // ====================  OPERATIONS    =======================
+
+    // ====================  ACCESS        =======================
+
+    // ====================  INQUIRY       =======================
+
+    protected:
+
+    // ====================  LIFECYCLE     =======================
+
+    /** Default protected constructor, use New */
+    MagneticDipole (const std::string& name);
+
+    /** Default protected destructor, use Delete */
+    ~MagneticDipole ();
+
+    /**
+     *  @copybrief   LemmaObject::Release()
+     *  @copydetails LemmaObject::Release()
+     */
+    void Release();
+
+    private:
+
+    // ====================  DATA MEMBERS  =========================
+
+    KernelEM1DManager*          Kernels;
+
+}; // -----  end of class  MagneticDipole  -----
+
+} // namespace Lemma
+
+#endif   // ----- #ifndef MAGNETICDIPOLE_INC  -----

LemmaCore/include/ParticleSwarmOptimizer.h

@@ -0,0 +1,109 @@
+/* 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/27/2015 01:50:59 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
+ */
+
+#ifndef  PARTICLESWARMOPTIMIZER_INC
+#define  PARTICLESWARMOPTIMIZER_INC
+
+#include "LemmaObject.h"
+
+namespace Lemma {
+
+struct Particle{
+    Real       fitness;
+    VectorXr   best;
+};
+
+/**
+  \brief
+  \details
+ */
+class ParticleSwarmOptimizer : public LemmaObject {
+
+    friend std::ostream &operator<<(std::ostream &stream,
+            const ParticleSwarmOptimizer &ob);
+
+    public:
+
+    // ====================  LIFECYCLE     =======================
+
+    /**
+     * @copybrief LemmaObject::New()
+     * @copydetails LemmaObject::New()
+     */
+    static ParticleSwarmOptimizer* New();
+
+    /**
+     *  @copybrief   LemmaObject::Delete()
+     *  @copydetails LemmaObject::Delete()
+     */
+    void Delete();
+
+    // ====================  OPERATORS     =======================
+
+    // ====================  OPERATIONS    =======================
+
+    // ====================  ACCESS        =======================
+
+    // ====================  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 ParticleSwarmOptimizer* DeSerialize(const YAML::Node& node);
+#endif
+
+    protected:
+
+    // ====================  LIFECYCLE     =======================
+
+    /** Default protected constructor, use New */
+    ParticleSwarmOptimizer (const std::string& name);
+
+#ifdef HAVE_YAMLCPP
+    /** Protected DeDerializing constructor, use factory DeSerialize  method*/
+    ParticleSwarmOptimizer (const YAML::Node& node);
+#endif
+
+    /** Default protected destructor, use Delete */
+    ~ParticleSwarmOptimizer ();
+
+    /**
+     *  @copybrief   LemmaObject::Release()
+     *  @copydetails LemmaObject::Release()
+     */
+    void Release();
+
+    private:
+
+    // ====================  DATA MEMBERS  =========================
+
+}; // -----  end of class  ParticleSwarmOptimizer  -----
+
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef PARTICLESWARMOPTIMIZER_INC  -----
+

LemmaCore/include/PolygonalWireAntenna.h

@@ -0,0 +1,169 @@
+/* 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     05/18/2010
+  @version  $Id: PolygonalWireAntenna.h 211 2015-02-27 05:43:26Z tirons $
+ **/
+
+#include "WireAntenna.h"
+
+#ifndef  POLYGONALWIREANTENNA_INC
+#define  POLYGONALWIREANTENNA_INC
+
+namespace Lemma {
+
+    // ===================================================================
+    //        Class:  PolygonalWireAntenna
+    /// \brief   Class representing polygonal wire antennae.
+    /// \details For EM calculations, dipoles representing this loop are
+    ///    created dynamically, depending on receiver location.
+    /// @todo enforce minimum dipole moment.
+    // ===================================================================
+    class PolygonalWireAntenna : public WireAntenna {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const PolygonalWireAntenna &ob);
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+
+            /**
+             * Declares all memory and returns a new instance.
+             */
+            static PolygonalWireAntenna* New();
+
+            /**
+             * @copybrief LemmaObject::Delete()
+             * @copydetails LemmaObject::Delete()
+             */
+            void Delete();
+
+            /// Makes a deep copy of this antenna with all connections except
+            /// the dipole approximation.
+            PolygonalWireAntenna* Clone();
+
+            // ====================  OPERATORS     =======================
+
+            // ====================  OPERATIONS    =======================
+
+            /// Approximates with ungrounded electrical dipoles, such that
+            /// minDipoleRatio is satisfied.
+            virtual void ApproximateWithElectricDipoles(const Vector3r &rp);
+
+            /** Sets the minimum ratio for dipole moments to be used to
+             * approximate the loop. A smaller ratio yields a more accurate
+             * result, but is more expensive. Default is (1/5).
+             */
+            void SetMinDipoleRatio(const Real& ratio);
+
+            /** Sets the minimum moment for dipole moments to be used to
+             * approximate the loop.
+             */
+            void SetMinDipoleMoment(const Real& m);
+
+            /** Sets the minimum moment for dipole moments to be used to
+             * approximate the loop.
+             */
+            void SetMaxDipoleMoment(const Real& m);
+
+            // ====================  ACCESS        =======================
+
+            // ====================  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 PolygonalWireAntenna* DeSerialize(const YAML::Node& node);
+            #endif
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /// Default protected constructor.
+            PolygonalWireAntenna (const std::string& name);
+
+#ifdef HAVE_YAMLCPP
+            /// Default protected constructor.
+            PolygonalWireAntenna (const YAML::Node& node);
+#endif
+
+            /// Default protected constructor.
+            ~PolygonalWireAntenna ();
+
+            /**
+             * @copybrief LemmaObject::Release()
+             * @copydetails LemmaObject::Release()
+             */
+            void Release();
+
+            // ====================  DATA MEMBERS  =======================
+
+            /// minimum ratio of dipole moment to distance to receiver point
+            Real minDipoleRatio;
+
+            /// Maximum dipole moment allowed
+            Real minDipoleMoment;
+
+            /// Maximum dipole moment allowed
+            Real maxDipoleMoment;
+
+            /// appends
+            void PushXYZDipoles(const Vector3r &step, const Vector3r &cp,
+                            const Vector3r &dir,
+                            std::vector<DipoleSource*> &Dipoles) ;
+
+            /// corrects for overstep
+            void CorrectOverstepXYZDipoles(const Vector3r &step,
+                            const Vector3r &cp,
+                            const Vector3r &dir,
+                            std::vector<DipoleSource*> &Dipoles );
+
+            // ====================  OPERATIONS    =======================
+
+
+            /// Returns the nearest point on a line segment to another point.
+            /// if the point is not on the line-segment, return the
+            /// nearest end-point
+            /// @param[in] p0, p1 define the line segement
+            /// @param[in] rp is a point in space. The function returns the
+            /// closest point on the line to this point.
+            /// @return The point (Lemma::Vector3r) on the line defined by p0,
+            /// and p1, closest to rp
+            Vector3r ClosestPointOnLine(const Vector3r &p0, const Vector3r &p1,
+                            const Vector3r &rp);
+
+            /// Interpolates dipoles along line segment defined by p0 and p1.
+            void InterpolateLineSegment(const Vector3r &p0, const Vector3r &p1,
+                            const Vector3r &rp);
+
+
+            /// List of the dipoles
+            //std::vector<DipoleSource*>           Dipoles;
+
+            /// Points that define this loop
+            //Vector3Xr                            Points;
+
+        private:
+
+            Vector3r                               rRepeat;
+
+    }; // -----  end of class  PolygonalWireAntenna  -----
+
+}       // -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef POLYGONALWIREANTENNA_INC  -----

LemmaCore/include/QWEKey.h

@@ -0,0 +1,197 @@
+/* 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 10:20:18 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  QWEKEY_INC
+#define  QWEKEY_INC
+
+#include	"hankeltransform.h"
+#include    <Eigen/Eigenvalues>
+#ifdef HAVEBOOSTSPECIALFUNCTIONS
+#include "boost/math/special_functions.hpp"
+#include "boost/math/special_functions/bessel.hpp"
+#endif
+
+namespace Lemma {
+
+    /** breakpoint to use in division of domain, based on zeros of bessel function or
+        regular nPi spacing.
+     */
+    enum sZeroType{J0, J1, NPI};
+
+    /**
+      \brief  Port of Key's quadrature with extrapolation Hankel transform algorithm.
+      \details Details of the algorithm can be found in Key2011. This code is a port
+               of the published algorithm, which contains the following notice:
+        %------------------------------------------------------------------%
+        % Copyright (c) 2012 by the Society of Exploration Geophysicists.  %
+        % For more information, go to http://software.seg.org/2012/0003 .  %
+        % You must read and accept usage terms at:                         %
+        % http://software.seg.org/disclaimer.txt before use.               %
+        %------------------------------------------------------------------%
+     */
+    class QWEKey : public HankelTransform {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const QWEKey &ob);
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        /**
+         * @copybrief LemmaObject::New()
+         * @copydetails LemmaObject::New()
+         */
+        static QWEKey* New();
+
+        /**
+         *  @copybrief   LemmaObject::Delete()
+         *  @copydetails LemmaObject::Delete()
+         */
+        void Delete();
+
+        // ====================  OPERATORS     =======================
+
+        void TestPrivate(const int& N);
+
+        // ====================  OPERATIONS    =======================
+
+
+        Complex Zgauss(const int &ikk, const EMMODE &imode,
+                            const int &itype, const Real &rho,
+                            const Real &wavef, KernelEm1DBase *Kernel);
+
+        /// Computes related kernels, if applicable, otherwise this is
+        /// just a dummy function.
+        void ComputeRelated(const Real& rho, KernelEm1DBase* Kernel);
+
+        void ComputeRelated(const Real& rho, std::vector< KernelEm1DBase* > KernelVec);
+
+        void ComputeRelated(const Real& rho, KernelEM1DManager* KernelManager);
+
+        // ====================  ACCESS        =======================
+
+        // ====================  INQUIRY       =======================
+
+        protected:
+
+        // ====================  LIFECYCLE     =======================
+
+        /** Default protected constructor, use New */
+        QWEKey (const std::string& name);
+
+        /** Default protected destructor, use Delete */
+        ~QWEKey ();
+
+        /**
+         *  @copybrief   LemmaObject::Release()
+         *  @copydetails LemmaObject::Release()
+         */
+        void Release();
+
+        /** Calculates Gauss quadrature weights of order N on the interval -1,1
+            Algorithm from p 129 in:
+            Trefethen, L. N., 2000, Spectral methods in MATLAB: Society for
+            Industrial and Applied Mathematics (SIAM), volume 10 of Software,
+            Environments, and Tools.
+        */
+        void GaussQuadWeights(const int& N);
+
+        /** Returns the quadrature intervals and Bessel function weights used for the
+            QWE method.
+
+         */
+        void BesselWeights( const sZeroType& sType);
+
+        /**  Computes an infinite integral using the partial sum of quadrature terms
+             accelerated by sequence extrapolation using the Shanks transformation
+             implemented with Wynn's epsilon algorithm.
+         */
+        void QWE(const Real& rho);
+
+        /** Calls the underlying kernel functions evaluated as necessary
+         */
+        void getEyKernel(const int& i, const int& idx, const Real& rho);
+
+        private:
+
+        // ====================  DATA MEMBERS  =========================
+
+        /** Relative tolerance, default is 1e-6 */
+        Real    RelTol;
+
+        /** Absolute tolerance, default is 1e-24 */
+        Real    AbsTol;
+
+        /** Quadrature order, higher is more accurate but more expensive. Eefault is 9 */
+        int     nQuad;
+
+        /** in QWE partial integrals before Shanks recurive algorithm. Defaults to 1  */
+        int nDelay;
+
+        /** Maximum number of intervals to integrate over . Defaults to 40  */
+        int nIntervalsMax;
+
+        /** Weighing of gaussian quadrature points */
+        VectorXr GaussWeights;
+
+        /** Abscissa locations of quadrature points */
+        VectorXr GaussAbscissa;
+
+        /** Breakpoints for dividing up the global integral */
+        VectorXr xInt;
+
+        /** All quadrature points between all breakpoints */
+        VectorXr Bx;
+
+        /** J0 weights */
+        VectorXr BJ0;
+
+        /** J1 weights */
+        VectorXr BJ1;
+
+        /** array of lambda arguments */
+        VectorXr Lambda;
+
+        /** array of lambda arguments */
+        VectorXr Intervals;
+
+        MatrixXcr TS;
+        VectorXi  Tn;
+        MatrixXcr Textrap;
+        MatrixXr  TrelErr;
+        MatrixXr  TabsErr;
+
+        /** Container to hold bessel arguments */
+        Eigen::Matrix<Complex, Eigen::Dynamic, Eigen::Dynamic > Zwork;
+
+        /** Container to hold bessel arguments */
+        Eigen::Matrix<Complex, Eigen::Dynamic, Eigen::Dynamic > Zans;
+
+        /** Manager for related kernels to evaluate */
+        KernelEM1DManager* KernelManager;
+
+    }; // -----  end of class  QWEKey  -----
+
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef QWEKEY_INC  -----
+
+

LemmaCore/include/RectilinearGridReader.h

@@ -0,0 +1,112 @@
+/* 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
+  @date      09/23/2013 11:05:11 AM
+  @version   $Id$
+  @author    Trevor Irons (ti)
+  @email     Trevor.Irons@xri-geo.com
+  @copyright Copyright (c) 2013, XRI Geophysics, LLC
+  @copyright Copyright (c) 2013, Trevor Irons
+ **/
+
+#ifndef  RECTILINEARGRIDREADER_INC
+#define  RECTILINEARGRIDREADER_INC
+
+#include "GridReader.h"
+#include "rectilineargrid.h"
+#include "ASCIIParser.h"
+
+namespace Lemma {
+
+    /**
+      @class
+      \brief
+      \details
+     */
+    class RectilinearGridReader : public GridReader {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const RectilinearGridReader &ob);
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+
+            /**
+             * @copybrief LemmaObject::New()
+             * @copydetails LemmaObject::New()
+             */
+            static RectilinearGridReader* New();
+
+            /**
+             *  @copybrief   LemmaObject::Delete()
+             *  @copydetails LemmaObject::Delete()
+             */
+            void Delete();
+
+            // ====================  OPERATORS     =======================
+
+            // ====================  OPERATIONS    =======================
+
+            /**
+            Reads a .mod file, a simple representation of the grid. These files
+            have the following format:
+            @verbatim
+            nx ny nz  // number of cells in x, y, and z
+            ox oy oz  // grid offset of top SW corner
+
+            hx[0] hx[1] ... hx[nx-1]  // grid cell spacing in x, from 0 to nx-1
+            hy[0] hy[1] ... hy[ny-1]  // grid cell spacing in y, from 0 to ny-1
+            hz[0] hz[1] ... hz[nz-1]  // grid cell spacing in z, from 0 to nz-1
+
+            // c++ style (//) comments are allowed anywhere, c-style are not
+            @endverbatim
+            */
+            void ReadASCIIGridFile( const std::string& name );
+
+            // ====================  ACCESS        =======================
+            /**
+             * Accessor method for the underlying RectilinearGrid class constructed
+             * from the input file.
+             */
+            RectilinearGrid* GetGrid();
+
+            // ====================  INQUIRY       =======================
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /** Default protected constructor, use New */
+            RectilinearGridReader (const std::string& name);
+
+            /** Default protected constructor, use Delete */
+            ~RectilinearGridReader ();
+
+            /**
+             *  @copybrief   LemmaObject::Release()
+             *  @copydetails LemmaObject::Release()
+             */
+            void Release();
+
+        private:
+
+            // ====================  DATA MEMBERS  =========================
+
+            /** Object holding constructed Grid */
+            RectilinearGrid* Grid;
+
+            /** Performs actual file parsing */
+            ASCIIParser* Parser;
+
+    }; // -----  end of class  RectilinearGridReader  -----
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef RECTILINEARGRIDREADER_INC  -----

LemmaCore/include/RectilinearGridVTKExporter.h

@@ -0,0 +1,120 @@
+/* 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/25/2013 08:20:01 AM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@xri-geo.com
+ * @copyright Copyright (c) 2013, XRI Geophysics, LLC
+ * @copyright Copyright (c) 2013, Trevor Irons
+ */
+
+
+#ifndef  RECTILINEARGRIDVTKEXPORTER_INC
+#define  RECTILINEARGRIDVTKEXPORTER_INC
+
+#ifdef  LEMMAUSEVTK
+
+#include "LemmaObject.h"
+#include "rectilineargrid.h"
+
+#include "vtkXMLRectilinearGridWriter.h"
+#include "vtkRectilinearGrid.h"
+#include "vtkDoubleArray.h"
+#include "vtkFieldData.h"
+#include "vtkCellData.h"
+
+namespace Lemma {
+
+/**
+  \brief   Exports a LemmaRectilinearGrid into a VTKRectilinearGrid.
+  \details Results can then be dumped to a VTK file or used directly.
+ */
+class RectilinearGridVTKExporter : public LemmaObject {
+
+    friend std::ostream &operator<<(std::ostream &stream,
+            const RectilinearGridVTKExporter &ob);
+
+    public:
+
+    // ====================  LIFECYCLE     =======================
+
+    /**
+     * @copybrief LemmaObject::New()
+     * @copydetails LemmaObject::New()
+     */
+    static RectilinearGridVTKExporter* New();
+
+    /**
+     *  @copybrief   LemmaObject::Delete()
+     *  @copydetails LemmaObject::Delete()
+     */
+    void Delete();
+
+    // ====================  OPERATORS     =======================
+
+    // ====================  OPERATIONS    =======================
+
+    // ====================  ACCESS        =======================
+    /**
+     * Sets the Grid to be exported
+     */
+    void SetGrid(RectilinearGrid* Grid);
+
+    // ====================  INQUIRY       =======================
+
+    /**
+     *  @return Returns a pointer to a vtkRectilinearGrid containing same information as the Lemma Grid.
+     */
+    vtkRectilinearGrid*  GetVTKGrid();
+
+    /**
+     *  Writes the exported VTKGrid out to a .vtr XML file
+     *  @param[in] name is the filename to write to. The .vtr extension will be added
+     */
+    void WriteVTKGrid( const std::string& name );
+
+    protected:
+
+    // ====================  LIFECYCLE     =======================
+
+    /** Default protected constructor, use New */
+    RectilinearGridVTKExporter (const std::string& name);
+
+    /** Default protected destructor, use Delete */
+    ~RectilinearGridVTKExporter ();
+
+    /**
+     *  @copybrief   LemmaObject::Release()
+     *  @copydetails LemmaObject::Release()
+     */
+    void Release();
+
+    private:
+
+    void BuildVTKRectilinearGrid();
+
+    // ====================  DATA MEMBERS  =========================
+
+    /** The Grid to convert from */
+    RectilinearGrid*    Grid;
+
+    /** The Grid to convert to */
+    vtkRectilinearGrid*    VTKGrid;
+
+}; // -----  end of class  RectilinearGridVTKExporter  -----
+
+}		// -----  end of Lemma  name  -----
+
+#endif     // -----  not LEMMAUSEVTK  -----
+
+#endif   // ----- #ifndef RECTILINEARGRIDVTKEXPORTER_INC  -----
+

LemmaCore/include/TEMInductiveReceiver.h

@@ -0,0 +1,106 @@
+/* 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/08/2014 03:17:52 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
+ */
+
+
+#ifndef  TEMINDUCTIVERECEIVER_INC
+#define  TEMINDUCTIVERECEIVER_INC
+
+#include "TEMReceiver.h"
+
+namespace Lemma {
+
+    /**
+      \brief   Derived class of TEMReceiver.
+      \details An inductive receiver, measures dB/dt
+     */
+    class TEMInductiveReceiver : public TEMReceiver {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const TEMInductiveReceiver &ob);
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        /**
+         * @copybrief LemmaObject::New()
+         * @copydetails LemmaObject::New()
+         */
+        static TEMInductiveReceiver* New();
+
+        /**
+         *  @copybrief   LemmaObject::Delete()
+         *  @copydetails LemmaObject::Delete()
+         */
+        void Delete();
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        // ====================  ACCESS        =======================
+
+        // ====================  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 TEMInductiveReceiver* DeSerialize(const YAML::Node& node);
+#endif
+
+        protected:
+
+        // ====================  LIFECYCLE     =======================
+
+        /** Default protected constructor, use New */
+        TEMInductiveReceiver (const std::string& name);
+
+#ifdef HAVE_YAMLCPP
+        /** Default protected constructor, use New */
+        TEMInductiveReceiver (const YAML::Node& node);
+#endif
+
+        /** Default protected destructor, use Delete */
+        ~TEMInductiveReceiver ();
+
+        /**
+         *  @copybrief   LemmaObject::Release()
+         *  @copydetails LemmaObject::Release()
+         */
+        void Release();
+
+        private:
+
+        // ====================  DATA MEMBERS  =========================
+
+    }; // -----  end of class  TEMInductiveReceiver  -----
+
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef TEMINDUCTIVERECEIVER_INC  -----
+
+

LemmaCore/include/TEMReceiver.h

@@ -0,0 +1,183 @@
+/* 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/08/2014 02:36:47 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@xri-geo.com
+ * @copyright Copyright (c) 2014, XRI Geophysics, LLC
+ * @copyright Copyright (c) 2014, Trevor Irons
+ */
+
+#ifndef  TEMRECEIVER_INC
+#define  TEMRECEIVER_INC
+
+#include "receiverpoints.h"
+
+#include <boost/random.hpp>
+#include <boost/random/normal_distribution.hpp>
+
+namespace Lemma {
+
+#ifdef HAVE_YAMLCPP
+#include "yaml-cpp/yaml.h"
+#endif
+
+
+/**
+  \brief
+  \details
+ */
+class TEMReceiver : public ReceiverPoints {
+
+    friend std::ostream &operator<<(std::ostream &stream,
+            const TEMReceiver &ob);
+
+    public:
+
+    // ====================  LIFECYCLE     =======================
+
+    /**
+     * @copybrief LemmaObject::New()
+     * @copydetails LemmaObject::New()
+     */
+    static TEMReceiver* New();
+
+    /**
+     *   @return a deep copy of this
+     */
+    TEMReceiver* Clone();
+
+    /**
+     *  @copybrief   LemmaObject::Delete()
+     *  @copydetails LemmaObject::Delete()
+     */
+    void Delete();
+
+    // ====================  OPERATORS     =======================
+
+    // ====================  OPERATIONS    =======================
+
+    /**
+     * Uses the standard deviations provided to provide an instance
+     * of the expected noise. A realisation of the noise.
+     */
+    VectorXr SampleNoise();
+
+    // ====================  ACCESS        =======================
+
+    /**
+     *    Sets the gate integration windows
+     */
+    void SetWindows(const VectorXr& centres, const VectorXr& widths, const TIMEUNITS& Units);
+
+    /**
+     *   Sets the moment of the receiver. Defaults to 1 for normalized response.
+     */
+    void SetMoment( const Real&  moment);
+
+    /**
+     *  Sets std deviation values for noise channels.
+     *  @param[in] noise must be of the same length as the number of windows.
+     */
+    void SetNoiseSTD( const VectorXr& noise );
+
+    /**
+     *  Gets std deviation values for noise channels.
+     *  @return noise std dev.
+     */
+    VectorXr GetNoiseSTD(  );
+
+    /**
+     *  @param[in] refTime sets the reference time, defaults to 0
+     */
+    void SetReferenceTime( const Real& refTime, const TIMEUNITS& units );
+
+    /**
+     *  What field component to return
+     */
+    void SetComponent ( const FIELDCOMPONENT& COMP );
+
+    /**
+     *   @param[in] loc is the location of the dipole receiver
+     */
+    void SetRxLocation ( const Vector3r& loc );
+
+    // ====================  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 TEMReceiver* DeSerialize(const YAML::Node& node);
+     #endif
+
+    /**
+     * @return centre point of gates in sec
+     */
+    VectorXr GetWindowCentres();
+
+    /**
+     * @return width of gates in sec
+     */
+    VectorXr GetWindowWidths();
+
+    /**
+     *  @return the reference time
+     */
+    Real    GetReferenceTime();
+    protected:
+
+    // ====================  LIFECYCLE     =======================
+
+    /** Default protected constructor, use New */
+    TEMReceiver (const std::string& name);
+
+     #ifdef HAVE_YAMLCPP
+    /** Default protected de-serializing constructor, use factory DeSerialize */
+    TEMReceiver (const YAML::Node& node);
+    #endif
+
+    /** Default protected destructor, use Delete */
+    ~TEMReceiver ();
+
+    /**
+     *  @copybrief   LemmaObject::Release()
+     *  @copydetails LemmaObject::Release()
+     */
+    void Release();
+
+    private:
+
+    // ====================  DATA MEMBERS  =========================
+
+    Real            moment;
+    Real            referenceTime;
+    Vector3r        nHat;
+    FIELDCOMPONENT  component;
+
+    VectorXr        windowCentres;
+    VectorXr        windowWidths;
+    VectorXr        noiseSTD;
+    //Vector3r        location;
+
+}; // -----  end of class  TEMReceiver  -----
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef TEMRECEIVER_INC  -----
+

LemmaCore/include/TEMSurvey.h

@@ -0,0 +1,137 @@
+/* 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/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
+ */
+
+#ifndef  TEMSURVEY_INC
+#define  TEMSURVEY_INC
+
+#include "LemmaObject.h"
+#include "TEMSurveyLine.h"
+#include "TEMSurveyData.h"
+
+#include "layeredearthem.h"
+
+#ifdef HAVE_YAMLCPP
+#include "yaml-cpp/yaml.h"
+#endif
+
+namespace Lemma {
+
+
+    /**
+      \brief   Describes a TEM survey.
+      \details This class aims to encapulate any type of TEM survey.
+     */
+    class TEMSurvey : public LemmaObject {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const TEMSurvey &ob);
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        /**
+         * @copybrief LemmaObject::New()
+         * @copydetails LemmaObject::New()
+         */
+        static TEMSurvey* New();
+
+        /**
+         *  @copybrief   LemmaObject::Delete()
+         *  @copydetails LemmaObject::Delete()
+         */
+        void Delete();
+
+        // ====================  OPERATORS     =======================
+
+        /**  @param[in] idx the index to return
+         *   @return the SurveyLine with index idx
+         */
+        TEMSurveyLine* operator( ) ( const int& idx ) const ;
+
+        /**  @param[in] iline the line index to return
+         *   @param[in] irec the line index to return
+         *   @return the SurveyLine with index iline, irec
+         */
+        TEMSurveyLineRecord* operator( ) ( const int& iline, const int& irec ) const;
+
+        // ====================  OPERATIONS    =======================
+
+        /**
+         *  @param[in] nlines sets the number of lines (TEMSurveyLine) in the survey. A line is any kind of
+         *             related set of measurements. In Airborne EM, this is a flight line, but
+         *             the idea extends to ground based profile lines.
+         */
+        void SetNumberOfLines( const int& nlines );
+
+        /**
+         *  Most basic form of forward modelling. Uses input model for ALL TEMSurveyLines and
+         *  TEMSurveyLineRecords (atomic). Most useful in the
+         *  case that there is only 1 line and 1 record. But even in that case it can be called directly from
+         *  the record. This method will likely be replaced  soon.
+         */
+        TEMSurveyData* ForwardModel(LayeredEarthEM* model, bool additiveNoise=false);
+
+        // ====================  ACCESS        =======================
+
+        /**
+         *   @return pointer to requested TEMSurveyLine
+         */
+        TEMSurveyLine*  GetLine(const unsigned int& iline);
+
+        // ====================  INQUIRY       =======================
+
+        #ifdef HAVE_YAMLCPP
+        YAML::Node Serialize() const;
+        static TEMSurvey* DeSerialize(const YAML::Node& node);
+        #endif
+
+        protected:
+
+        // ====================  LIFECYCLE     =======================
+
+        /** Default protected constructor, use New */
+        TEMSurvey (const std::string& name);
+
+        #ifdef HAVE_YAMLCPP
+        /** Default protected constructor, use New */
+        TEMSurvey (const YAML::Node& node);
+        #endif
+
+        /** Default protected destructor, use Delete */
+        ~TEMSurvey ();
+
+        /**
+         *  @copybrief   LemmaObject::Release()
+         *  @copydetails LemmaObject::Release()
+         */
+        void Release();
+
+        private:
+
+        // ====================  DATA MEMBERS  =========================
+
+        std::vector<TEMSurveyLine*>     Lines;
+
+    }; // -----  end of class  TEMSurvey  -----
+
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef TEMSURVEY_INC  -----

LemmaCore/include/TEMSurveyData.h

@@ -0,0 +1,161 @@
+/* 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      03/03/2015 09:54:25
+ * @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
+ */
+
+#ifndef  TEMSURVEYDATA_INC
+#define  TEMSURVEYDATA_INC
+
+#include "LemmaObject.h"
+#include "TEMSurveyLineData.h"
+
+namespace Lemma {
+
+    /**
+      \brief    Holds data from a TEMSurvey.
+      \details  Any form of TEMSurvey may be represented here. The
+                majority of the specification can be found in the associated
+                TEMSurvey. The TEMSurveyData object is intended to be lightweight.
+     */
+    class TEMSurveyData : public LemmaObject {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const TEMSurveyData &ob);
+
+        friend class TEMSurvey;
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        /**
+         * @copybrief LemmaObject::New()
+         * @copydetails LemmaObject::New()
+         */
+        static TEMSurveyData* New();
+
+        /**
+         *  @return a deep copy of this, this is acomplished through Serialize
+         *          and DeSerialize methods.
+         */
+        TEMSurveyData* Clone();
+
+        /**
+         *  @copybrief   LemmaObject::Delete()
+         *  @copydetails LemmaObject::Delete()
+         */
+        void Delete();
+
+        // ====================  OPERATORS     =======================
+
+        /** Surveys can be added or subtracted from each other, throws a
+         *  pointer that will need to be managed (Deleted)
+         */
+        TEMSurveyData* operator+(const TEMSurveyData& Survey);
+
+        /** Surveys can be added or subtracted from each other, throws a
+         *  pointer that will need to be managed (Deleted).
+         */
+        TEMSurveyData* operator-(const TEMSurveyData& Survey);
+
+        /** Surveys can be added or subtracted from each other
+         */
+        void operator+=(const TEMSurveyData& Survey);
+
+        /** Surveys can be added or subtracted from each other
+         */
+        void operator-=(const TEMSurveyData& Survey);
+
+
+        /**  @param[in] idx the index to return
+         *   @return the SurveyLine with index idx
+         */
+        TEMSurveyLineData* operator( ) ( const int& idx ) const;
+
+        /**  @param[in] iline the line index to return
+         *   @param[in] irec the line index to return
+         *   @return the SurveyLine with index iline, irec
+         */
+        TEMSurveyLineRecordData* operator( ) ( const int& iline, const int& irec ) const;
+
+
+        // ====================  OPERATIONS    =======================
+
+        /** Sets the number of lines
+         */
+        void SetNumberOfLines( const int& nlines );
+
+        // ====================  ACCESS        =======================
+
+        /** @return the number of lines in the data
+         */
+        int GetNumberOfLines() const;
+
+        /**
+         *   @return pointer to line
+         */
+        TEMSurveyLineData* GetLine(const int& iline) const;
+
+        // ====================  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 TEMSurveyData* DeSerialize(const YAML::Node& node);
+#endif
+
+        protected:
+
+        // ====================  LIFECYCLE     =======================
+
+        /** Default protected constructor, use New */
+        TEMSurveyData (const std::string& name);
+
+#ifdef HAVE_YAMLCPP
+        /** Protected DeDerializing constructor, use factory DeSerialize  method*/
+        TEMSurveyData (const YAML::Node& node);
+#endif
+
+        /** Default protected destructor, use Delete */
+        ~TEMSurveyData ();
+
+        /**
+         *  @copybrief   LemmaObject::Release()
+         *  @copydetails LemmaObject::Release()
+         */
+        void Release();
+
+        private:
+
+        // ====================  DATA MEMBERS  =========================
+
+        std::vector<TEMSurveyLineData*>  LineData;
+
+    }; // -----  end of class  TEMSurveyData  -----
+
+
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef TEMSURVEYDATA_INC  -----

LemmaCore/include/TEMSurveyLine.h

@@ -0,0 +1,117 @@
+/* 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/10/2014 11:14: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  TEMSURVEYLINE_INC
+#define  TEMSURVEYLINE_INC
+
+#include "LemmaObject.h"
+#include "TEMSurveyLineRecord.h"
+#include "TEMSurveyLineData.h"
+
+namespace Lemma {
+
+    /**
+      \brief    Represents a TEM survey line.
+      \details  This class is managed by TEMSurvey. You cannot create a TEMSurvey line directly
+                this should be done through a TEMSurvey.
+                @todo neeed to impliment a BaseClass besides LemmaObject without pure virtual Delete.
+     */
+    class TEMSurveyLine : public LemmaObject {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const TEMSurveyLine &ob);
+
+        friend class TEMSurvey;
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        // ====================  ACCESS        =======================
+
+        /**
+            @return returns pointer to a specific record along the line
+         */
+        TEMSurveyLineRecord*  GetRecord(const unsigned int& irec);
+
+        /**
+            @param[in] nrec is the number of records along the line
+         */
+        void SetNumberOfRecords( const int& nrec );
+
+        // ====================  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 TEMSurveyLine* DeSerialize(const YAML::Node& node);
+#endif
+
+        protected:
+
+        TEMSurveyLineData* ForwardModel(LayeredEarthEM* model, bool additiveNoise = false);
+
+        // ====================  LIFECYCLE     =======================
+
+        /** Default protected constructor, use New */
+        TEMSurveyLine (const std::string& name);
+
+#ifdef HAVE_YAMLCPP
+        /** Protected DeDerializing constructor, use factory DeSerialize  method*/
+        TEMSurveyLine (const YAML::Node& node);
+#endif
+
+        /** Default protected destructor, use Delete */
+        ~TEMSurveyLine ();
+
+        /**
+         *  @copybrief   LemmaObject::Release()
+         *  @copydetails LemmaObject::Release()
+         */
+        void Release();
+
+        private:
+
+        /**
+         *   Delete should not be called...
+         */
+        void Delete();
+
+        // ====================  DATA MEMBERS  =========================
+
+        std::vector<TEMSurveyLineRecord*>     Records;
+
+    }; // -----  end of class  TEMSurveyLine  -----
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef TEMSURVEYLINE_INC  -----

LemmaCore/include/TEMSurveyLineData.h

@@ -0,0 +1,146 @@
+/* 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      03/03/2015 10:16:47
+ * @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
+ */
+
+#ifndef  TEMSURVEYLINEDATA_INC
+#define  TEMSURVEYLINEDATA_INC
+
+#include "LemmaObject.h"
+#include "TEMSurveyLineRecordData.h"
+
+namespace Lemma {
+
+/**
+  \brief   Holds Data for a TEM survey line
+  \details An entire flight line worth of data is stored here.
+ */
+class TEMSurveyLineData : public LemmaObject {
+
+    friend std::ostream &operator<<(std::ostream &stream,
+            const TEMSurveyLineData &ob);
+
+    //friend class TEMSurveyData;
+    friend class TEMSurveyLine;
+
+    public:
+
+    // ====================  LIFECYCLE     =======================
+
+    /**
+     * @copybrief LemmaObject::New()
+     * @copydetails LemmaObject::New()
+     */
+    static TEMSurveyLineData* New();
+
+    /**
+     *  @return a deep copy of this, this is acomplished through Serialize
+     *          and DeSerialize methods.
+     */
+    TEMSurveyLineData* Clone();
+
+    /**
+     *  @copybrief   LemmaObject::Delete()
+     *  @copydetails LemmaObject::Delete()
+     */
+    void Delete();
+
+    // ====================  OPERATORS     =======================
+
+    /** Survey lines can be added or subtracted from each other
+     */
+    TEMSurveyLineData* operator+(const TEMSurveyLineData& Survey);
+
+    /** Survey lines can be added or subtracted from each other
+     */
+    TEMSurveyLineData* operator-(const TEMSurveyLineData& Survey);
+
+    /** Survey lines can be added or subtracted from each other
+     */
+    void operator+=(const TEMSurveyLineData& Survey);
+
+    /** Survey lines can be added or subtracted from each other
+     */
+    void operator-=(const TEMSurveyLineData& Survey);
+
+    /**  @param[in] ir the index to return
+     *   @return the SurveyLineRecord with index ir
+     */
+    TEMSurveyLineRecordData* operator( ) ( const int& ir ) const ;
+
+    // ====================  OPERATIONS    =======================
+
+    // ====================  ACCESS        =======================
+
+    /**
+     *    @return pointer to specified record
+     */
+    TEMSurveyLineRecordData*  GetRecord(const int& ir) const ;
+
+    /**
+     * @return the number of records
+     */
+    int GetNumberOfRecords() const;
+
+    // ====================  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 TEMSurveyLineData* DeSerialize(const YAML::Node& node);
+#endif
+
+    protected:
+
+    // ====================  LIFECYCLE     =======================
+
+    /** Default protected constructor, use New */
+    TEMSurveyLineData (const std::string& name);
+
+#ifdef HAVE_YAMLCPP
+    /** Protected DeDerializing constructor, use factory DeSerialize  method*/
+    TEMSurveyLineData (const YAML::Node& node);
+#endif
+
+    /** Default protected destructor, use Delete */
+    ~TEMSurveyLineData ();
+
+    /**
+     *  @copybrief   LemmaObject::Release()
+     *  @copydetails LemmaObject::Release()
+     */
+    void Release();
+
+    private:
+
+    // ====================  DATA MEMBERS  =========================
+
+    std::vector<TEMSurveyLineRecordData*>   RecordData;
+
+}; // -----  end of class  TEMSurveyLineData  -----
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef TEMSURVEYLINEDATA_INC  -----
+

LemmaCore/include/TEMSurveyLineRecord.h

@@ -0,0 +1,140 @@
+/* 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/10/2014 12:15:03 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
+ */
+
+#ifndef  TEMSURVEYLINERECORD_INC
+#define  TEMSURVEYLINERECORD_INC
+
+#include "LemmaObject.h"
+#include "TEMReceiver.h"
+#include "TEMTransmitter.h"
+#include "TEMSurveyLineRecordData.h"
+#include "instrumenttem.h"
+
+namespace Lemma {
+
+    /**
+      \brief    Class holding everything necessary to create a TEM record.
+      \details  A TEM record represents the nexus of a transmitter with
+                receiver(s) and pulse moment(s). Therefore a record can contain
+                multiple sounding curves.
+     */
+    class TEMSurveyLineRecord : public LemmaObject {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const TEMSurveyLineRecord &ob);
+
+        friend class TEMSurveyLine;
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        /**
+         *  Perfoms forward modelling given model.
+         *  @param[in] model is the earth model responsible for the response
+         *  @param[in] additiveNoise is whether or not to add noise to the response, defaults to false
+         *  @return the modelled data.
+         */
+        TEMSurveyLineRecordData* ForwardModel(LayeredEarthEM* model, bool additiveNoise=false);
+
+        /**
+         *  @param[in] nseq is the number of pulse sequences
+         */
+        void SetNumberOfPulseSequences( const int& nseq );
+
+        /**
+         *  @return the number of pulse sequences
+         */
+        int GetNumberOfPulseSequences();
+
+        /**
+         *  Sets the PulseSequence and Receiver pair used to model a *SINGLE* response curve.
+         *  @param[in] Seq is the Pulse Sequence
+         *  @param[in] Rx is the receiver for that pulse sequence
+         */
+        void SetTransmitterReceiverPair( const int& ii, TEMTransmitter* Seq, TEMReceiver* Rx );
+
+        // ====================  ACCESS        =======================
+
+        /**
+         *  @return a pointer to the specified receiver
+         */
+        TEMReceiver*   GetReceiver(const int& irec);
+
+        // ====================  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 TEMSurveyLineRecord* DeSerialize(const YAML::Node& node);
+#endif
+
+        protected:
+
+
+
+        // ====================  LIFECYCLE     =======================
+
+        /** Default protected constructor, use New */
+        TEMSurveyLineRecord (const std::string& name);
+
+#ifdef HAVE_YAMLCPP
+        /** Protected DeDerializing constructor, use factory DeSerialize  method*/
+        TEMSurveyLineRecord (const YAML::Node& node);
+#endif
+
+        /** Default protected destructor, use Delete */
+        ~TEMSurveyLineRecord ();
+
+        /**
+         *  @copybrief   LemmaObject::Release()
+         *  @copydetails LemmaObject::Release()
+         */
+        void Release();
+
+        private:
+
+        /**
+         *   Delete is private, this class is managed through TEMSurvey
+         */
+        void Delete();
+
+        // ====================  DATA MEMBERS  =========================
+
+        int     numberOfPulseSequences;
+
+        std::vector<TEMTransmitter*>    Transmitters;
+        std::vector<TEMReceiver*>       Receivers;
+
+    }; // -----  end of class  TEMSurveyLineRecord  -----
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef TEMSURVEYLINERECORD_INC  -----

LemmaCore/include/TEMSurveyLineRecordData.h

@@ -0,0 +1,141 @@
+/* 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      03/03/2015 10:29:01
+ * @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
+ */
+#ifndef  TEMSURVEYLINERECORDDATA_INC
+#define  TEMSURVEYLINERECORDDATA_INC
+
+#include "LemmaObject.h"
+
+namespace Lemma {
+
+    /**
+      \brief
+      \details
+     */
+    class TEMSurveyLineRecordData : public LemmaObject {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const TEMSurveyLineRecordData &ob);
+
+        friend class TEMSurveyLineRecord;
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        /**
+         * @copybrief LemmaObject::New()
+         * @copydetails LemmaObject::New()
+         */
+        static TEMSurveyLineRecordData* New();
+
+
+        /** Provides deep copy
+         */
+        TEMSurveyLineRecordData* Clone();
+
+        /**
+         *  @copybrief   LemmaObject::Delete()
+         *  @copydetails LemmaObject::Delete()
+         */
+        void Delete();
+
+        // ====================  OPERATORS     =======================
+
+        /**
+         * Records can be added
+         */
+        TEMSurveyLineRecordData* operator + (const TEMSurveyLineRecordData&);
+
+        /**
+         * Records can be subtracted
+         */
+        TEMSurveyLineRecordData* operator - (const TEMSurveyLineRecordData&);
+
+        /**
+         * Records can be added in place
+         */
+        void operator += (const TEMSurveyLineRecordData&);
+
+        /**
+         * Records can be subtracted in place
+         */
+        void operator -= (const TEMSurveyLineRecordData&);
+
+        // ====================  OPERATIONS    =======================
+
+        // ====================  ACCESS        =======================
+
+        /** @return a VectorXr of the merged data (all moments)
+         * @todo TODO this is actually a copy? is this intended?
+         */
+        VectorXr GetCombinedData();
+
+        /** @return a VectorXr of the combined gate centres alligned with
+         *          GetCombinedData();
+         */
+        VectorXr GetCombinedGateCentres();
+        // ====================  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 TEMSurveyLineRecordData* DeSerialize(const YAML::Node& node);
+#endif
+
+        protected:
+
+        // ====================  LIFECYCLE     =======================
+
+        /** Default protected constructor, use New */
+        TEMSurveyLineRecordData (const std::string& name);
+
+#ifdef HAVE_YAMLCPP
+        /** Protected DeDerializing constructor, use factory DeSerialize  method*/
+        TEMSurveyLineRecordData (const YAML::Node& node);
+#endif
+
+        /** Default protected destructor, use Delete */
+        ~TEMSurveyLineRecordData ();
+
+        /**
+         *  @copybrief   LemmaObject::Release()
+         *  @copydetails LemmaObject::Release()
+         */
+        void Release();
+
+        private:
+
+        // ====================  DATA MEMBERS  =========================
+
+        std::vector<VectorXr>           DataSeries;
+
+        std::vector<VectorXr>           GateCentres;
+
+    }; // -----  end of class  TEMSurveyLineRecordData  -----
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef TEMSURVEYLINERECORDDATA_INC  -----

LemmaCore/include/TEMTransmitter.h

@@ -0,0 +1,125 @@
+/* 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 11:43:17 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  TEMTRANSMITTER_INC
+#define  TEMTRANSMITTER_INC
+
+#include "PolygonalWireAntenna.h"
+
+#ifdef HAVE_YAMLCPP
+#include "yaml-cpp/yaml.h"
+#endif
+
+namespace Lemma {
+
+/**
+  \brief   Describes a TEM pulse sequence
+  \details Flexible class desribing a pulse sequence used by
+           a TEM instruement. Can be used by Airborne or Ground
+           instruments.
+ */
+class TEMTransmitter : public PolygonalWireAntenna {
+
+    friend std::ostream &operator<<(std::ostream &stream, const TEMTransmitter &ob);
+
+    public:
+
+    // ====================  LIFECYCLE     =======================
+
+    /**
+     * @copybrief LemmaObject::New()
+     * @copydetails LemmaObject::New()
+     */
+    static TEMTransmitter* New();
+
+    /**
+     *  Performs a deep copy of this and returns pointer
+     */
+    TEMTransmitter* Clone();
+
+    /**
+     *  @copybrief   LemmaObject::Delete()
+     *  @copydetails LemmaObject::Delete()
+     */
+    void Delete();
+
+    // ====================  OPERATORS     =======================
+
+    // ====================  OPERATIONS    =======================
+
+    // ====================  ACCESS        =======================
+
+    /** Sets the repetition frequency
+     */
+    void SetRepFrequency(const Real& fr, const FREQUENCYUNITS& units);
+
+    void SetWaveform( const VectorXr& times, const VectorXr& amps, const TIMEUNITS& units );
+
+    /**
+     *  @return the waveform times in seconds
+     */
+    VectorXr GetWfmTimes();
+
+    /** @return the waveform current in amps
+     */
+    VectorXr GetWfmAmps();
+
+    // ====================  INQUIRY       =======================
+
+#ifdef HAVE_YAMLCPP
+    YAML::Node Serialize() const;
+    static TEMTransmitter* DeSerialize(const YAML::Node& node);
+#endif
+
+    protected:
+
+    // ====================  LIFECYCLE     =======================
+
+    /** Default protected constructor, use New */
+    TEMTransmitter (const std::string& name);
+
+#ifdef HAVE_YAMLCPP
+    /** Default protected constructor, use New */
+    TEMTransmitter (const YAML::Node& node);
+#endif
+
+    /** Default protected destructor, use Delete */
+    ~TEMTransmitter ();
+
+    /**
+     *  @copybrief   LemmaObject::Release()
+     *  @copydetails LemmaObject::Release()
+     */
+    void Release();
+
+    private:
+
+    // ====================  DATA MEMBERS  =========================
+
+    Real                    repFreq;
+    FREQUENCYUNITS          repFreqUnits;
+    VectorXr                wfmTimes;
+    VectorXr                wfmAmps;
+
+}; // -----  end of class  TEMTransmitter  -----
+
+} // namespace Lemma
+
+#endif   // ----- #ifndef TEMTRANSMITTER_INC  -----
+

LemmaCore/include/UngroundedElectricDipole.h

@@ -0,0 +1,88 @@
+/* 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 08:52:43 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  UNGROUNDEDELECTRICDIPOLE_INC
+#define  UNGROUNDEDELECTRICDIPOLE_INC
+
+#include "dipolesource.h"
+
+namespace Lemma {
+
+    /**
+      \brief  Ungrounded electric dipole
+      \details Used to model an idealised ungrounded electric dipole. Used primarily in integrating
+                around current sources.
+     */
+    class UngroundedElectricDipole : public DipoleSource {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const UngroundedElectricDipole &ob);
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        /**
+         * @copybrief LemmaObject::New()
+         * @copydetails LemmaObject::New()
+         */
+        static UngroundedElectricDipole* New();
+
+        /**
+         *  @copybrief   LemmaObject::Delete()
+         *  @copydetails LemmaObject::Delete()
+         */
+        void Delete();
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        // ====================  ACCESS        =======================
+
+        // ====================  INQUIRY       =======================
+
+        protected:
+
+        // ====================  LIFECYCLE     =======================
+
+        /** Default protected constructor, use New */
+        UngroundedElectricDipole (const std::string& name);
+
+        /** Default protected destructor, use Delete */
+        ~UngroundedElectricDipole ();
+
+        /**
+         *  @copybrief   LemmaObject::Release()
+         *  @copydetails LemmaObject::Release()
+         */
+        void Release();
+
+        private:
+
+        // ====================  DATA MEMBERS  =========================
+
+    }; // -----  end of class  UngroundedElectricDipole  -----
+
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef UNGROUNDEDELECTRICDIPOLE_INC  -----
+

LemmaCore/include/WireAntenna.h

@@ -0,0 +1,249 @@
+/* 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     12/16/2009
+  @version  $Id: WireAntenna.h 201 2015-01-03 00:07:47Z tirons $
+ **/
+
+#ifndef __WIREANTENNA_H
+#define __WIREANTENNA_H
+
+#include "LemmaObject.h"
+#include "dipolesource.h"
+
+#ifdef LEMMAUSEVTK
+#include "vtkActor.h"
+#endif
+
+namespace Lemma {
+
+
+    // ===================================================================
+    /**      Class:  WireAntenna
+      * \brief   Class representing a wire antennae.
+      * \details This is an abstract class.
+	  */
+    // ===================================================================
+    class WireAntenna : public LemmaObject {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+            const WireAntenna &ob);
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+
+            /**
+             * Initialises antenna to contain no points, with no current
+             * and no frequency. NumberOfTurns set to 1
+             */
+            static WireAntenna* New();
+
+            /**
+             * Provides deep copy
+             */
+            virtual WireAntenna* Clone();
+
+            /**
+             * @copybrief LemmaObject::Delete()
+             * @copydetails LemmaObject::Delete()
+             */
+            void Delete();
+
+            // ====================  OPERATORS     =======================
+
+            // ====================  OPERATIONS    =======================
+
+            /**
+              * Approximates with evenly spaced electric dipoles around loop
+              * @param[in] delta is the spacing between moments
+			  */
+            virtual void ApproximateWithElectricDipoles(const Real &delta);
+
+            // ====================  ACCESS        =======================
+
+			/**
+              * Sets the number of turns in the loop, default is 1
+              * @param[in] nturns is the number of turns of the loop.
+			  */
+            void SetNumberOfTurns(const int &nturns);
+
+            /**
+              * Sets the number of points in the loop
+			  */
+            void SetNumberOfPoints(const int &np);
+
+			/**
+              * Sets a corner point of the loop. Counting starts at 0. It
+              * is not required to have the loop be closed right now, but
+              * its a good idea.
+			  */
+            void SetPoint(const int &p, const Vector3r &pos);
+
+            /**
+              * Sets a corner point of the loop. Counting starts at 0. It
+              * is not required to have the loop be closed right now, but
+              * its a good idea.
+			  */
+            void SetPoint(const int &p, const Real&x, const Real& y, const Real& z);
+
+            /** Sets the frequency of the current in the loop, default is 0
+			  * @param[in] ifreq is the frequency number to set
+              * @param[in] freq is the frequency (Hz) of the current
+			  */
+            void SetFrequency(const int& ifreq, const Real &freq);
+			/**
+              * Sets the number of frequencies.
+              * @param[in] nfreq is the number of frequencies that will be
+              * computed.
+			  */
+            void SetNumberOfFrequencies(const int& nfreq);
+
+			/**
+              * Sets the current in the loop, default is 0
+              * @param[in] amp is the current in the loop, in Amperes
+			  */
+            void SetCurrent(const Real &amp);
+
+            // ====================  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 WireAntenna* DeSerialize(const YAML::Node& node);
+            #endif
+
+			/**
+              * Returns the number of turns
+              * @return the number of turns of the loop.
+			  */
+            int GetNumberOfTurns( );
+
+            /**
+             * Returns all of the points
+             */
+            Vector3Xr GetPoints();
+
+            /**
+             * Returns all of the points in a general matrix, useful for python wrapper
+             */
+            MatrixXr GetPointsMat();
+
+			/**
+              * Returns the frequency in the loop.
+              * @return is the frequency in the loop in Hz
+			  */
+            Real GetFrequency(const int& ifreq);
+
+
+			/**
+              * Returns the current in the loop.
+              * @return is the Current
+			  */
+            Real GetCurrent( );
+
+
+			/**
+              * Returns pointer to a dipole source
+			  */
+            DipoleSource* GetDipoleSource(const int &dip);
+
+			/**
+              * returns number of dipoles used to approximate this
+              * loop
+			  */
+            int GetNumberOfDipoles();
+
+			/**
+              * @return the number of frequencies of this wire loop.
+			  */
+            int GetNumberOfFrequencies();
+
+            #ifdef LEMMAUSEVTK
+            /** Returns an actor that can be placed into a vtk scene easily
+              * Note that this function throws a pointer, it is the
+              * receivers job to manage this memory!
+			  */
+            vtkActor* GetVtkActor(const int &idip);
+            #endif
+
+            /** Returns true or false if loop is horizontally planar
+             */
+            bool IsHorizontallyPlanar();
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+			/**
+              * Default protected constructor.
+			  */
+            WireAntenna (const std::string &name);
+
+#ifdef HAVE_YAMLCPP
+        /** Protected DeDerializing constructor, use factory DeSerialize  method*/
+            WireAntenna (const YAML::Node& node);
+#endif
+
+			/**
+              * Default protected destructor.
+			  */
+            ~WireAntenna ();
+
+            /**
+             * @copybrief LemmaObject::Release()
+             * @copydetails LemmaObject::Release()
+             */
+            void Release();
+
+            // ====================  DATA MEMBERS  =======================
+
+			/**
+              * Number of points that define the loop
+			  */
+            int NumberOfPoints;
+
+			/**
+              * Current in antennae (Amps)
+			  */
+            Real Current;
+
+			/**
+              * Number of turns
+			  */
+            int NumberOfTurns;
+
+			/**
+              * List of the dipoles
+			  */
+            std::vector<DipoleSource*>           Dipoles;
+
+			/**
+              * Points that define this loop
+			  */
+            Vector3Xr                            Points;
+
+			/**
+              * Frequencies of the loop.
+			  */
+            VectorXr                             Freqs;
+
+        private:
+
+    }; // -----  end of class  WireAntenna  -----
+
+}
+#endif // __WIREANTENNA_H

LemmaCore/include/banner.h

@@ -0,0 +1,24 @@
+/* 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   M. Andy Kass
+  @date     05/03/2010
+  @version  $Id: banner.h 87 2013-09-05 22:44:05Z tirons $
+ **/
+
+#ifndef __BANNER_H
+#define __BANNER_H
+#include <iostream>
+#include <ostream>
+void banner(const std::string &name, const std::string &version,
+		const std::string &usage);
+#endif
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */

LemmaCore/include/bicgstab.h

@@ -0,0 +1,98 @@
+/*
+ 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: */

LemmaCore/include/cg.h

@@ -0,0 +1,437 @@
+/* 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  -----

LemmaCore/include/costransintegrationkernel.h

@@ -0,0 +1,101 @@
+/* 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     02/08/2011
+  @version  $Id: costransintegrationkernel.h 87 2013-09-05 22:44:05Z tirons $
+ **/
+
+#ifndef  COSTRANSINTEGRATIONKERNEL_INC
+#define  COSTRANSINTEGRATIONKERNEL_INC
+
+#include "integrationkernel.h"
+
+namespace Lemma {
+
+    // ===================================================================
+    //  Class:  CosTransIntegrationKernel
+    /**
+      @class
+      \brief    Integration kernel for testing cosine transform.
+      \details  Evaluates cosine at the argument, using lagged convolution.
+                all of these kernels have exact solutions.
+     */
+    // ===================================================================
+    class CosTransIntegrationKernel : public IntegrationKernel<Real> {
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+
+            /** Returns a pointer to a new object of type CosTransIntegrationKernel.
+             * It allocates all necessary memory.
+             */
+            static CosTransIntegrationKernel* New();
+
+            /** Deletes this object. Delete also disconnects any
+             * attachments to this object.
+             */
+            void Delete();
+
+            // ====================  OPERATORS     =======================
+
+            Real Argument(const Real&x, const int& iRelated);
+
+            int GetNumRel();
+
+            /// Sets the value 'A' used in test cases
+            void SetA(const Real& A);
+
+            /** Sets the integral to evaluate (1, 2, 3)
+             */
+            void SetIntegral(const int& i);
+
+            /** Returns the analytical answer at A and B */
+            Real GetAnalytical(const Real& B);
+            // ====================  OPERATIONS    =======================
+
+            // ====================  ACCESS        =======================
+
+            // ====================  INQUIRY       =======================
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /** Deletes this object. Delete also disconnects any
+             * attachments to this object.
+             */
+            void Release();
+
+            /// Default protected constructor.
+            CosTransIntegrationKernel (const std::string& name);
+
+            /// Default protected constructor.
+            ~CosTransIntegrationKernel ();
+
+            // ====================  DATA MEMBERS  =========================
+
+            /** Value used in test cases  */
+            Real A;
+
+            /** Test integral to evaluate */
+            int Integral;
+
+        private:
+
+    }; // -----  end of class  CosTransIntegrationKernel  -----
+
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef COSTRANSINTEGRATIONKERNEL_INC  -----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */

LemmaCore/include/data.h

@@ -0,0 +1,85 @@
+/* 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     03/01/2010
+  @version  $Id: data.h 193 2014-11-10 23:51:41Z tirons $
+ **/
+
+#ifndef  _DATA_H_INC
+#define  _DATA_H_INC
+
+#include "LemmaObject.h"
+
+namespace Lemma {
+
+    // ===================================================================
+    //        Class:  Data
+    /** \brief Abstract class for data from an instrument
+     *  \details Currently provides no functionality, but this will likely
+     *          change in the near future.
+     */
+    // ===================================================================
+    class Data : public LemmaObject {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const Data &ob);
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+
+            /** Copies the *structure* of this class to a new object and
+             * returns a pointer to this object. Memory management is
+             * the responsibility of the receiver!. The data values are
+             * not copied.
+             */
+            virtual Data* Clone()=0;
+
+            // ====================  OPERATORS     =======================
+
+            // ====================  OPERATIONS    =======================
+
+            /** Clears all data arrays and containers
+             */
+            virtual void Zero()=0;
+
+            /** Data2 needs to be compatible with the calling class. Data2 will
+             * be cast into the calling class type. Most of the time this
+             * cast will not perform anything, as Data2 *is* the same type
+             * as the calling class.
+             */
+            virtual Real Norm(Data* Data2)=0;
+
+            // ====================  ACCESS        =======================
+
+            // ====================  INQUIRY       =======================
+
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /** Default protected constructor. */
+            Data (const std::string &name);
+
+            /** Default protected constructor. */
+            ~Data ();
+
+            // ====================  DATA MEMBERS  =========================
+
+        private:
+
+    }; // -----  end of class  Data  -----
+
+}       // -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef _DATA_H_INC  -----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */

LemmaCore/include/datafem.h

@@ -0,0 +1,181 @@
+/* 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   M. Andy Kass
+  @date     01/03/2013
+  @version  $Id$
+ **/
+
+#ifndef DATAFEM_H
+#define DATAFEM_H
+
+#include "data.h"
+
+namespace Lemma {
+
+// ===================================================================
+//        Class:  DataFEM
+/// \brief
+/// \details
+// ===================================================================
+	class DataFEM : public Data {
+
+		friend std::ostream &operator<<(std::ostream &stream,
+			const DataFEM &ob);
+
+	public:
+
+	// ====================  LIFECYCLE     =======================
+
+	static DataFEM* New();
+
+	DataFEM* Clone();
+
+	void Delete();
+
+	// ====================  OPERATORS     =======================
+
+
+	// ====================  OPERATIONS    =======================
+
+	void Zero();
+
+	Real Norm(Data* Data2);
+
+
+	// ====================  ACCESS        =======================
+
+	/// Set data dimensions
+	void SetSize(const int &nobs,const int &nfreq);
+
+	/// Input the data
+	void SetData(const MatrixXr &inputdata);
+
+	/// Input uncertainties
+	void SetUncertainties(const MatrixXr &uncertain);
+
+	/// Input the positions
+	void SetPositions(const Vector3Xr &positions);
+
+	/// Set the frequencies
+	void SetFreq(const VectorXr &freqs);
+
+	/// Set Tx Orientation
+	void SetTxOrientation(const Eigen::Matrix<ORIENTATION, Eigen::Dynamic, 1> &txorientation);
+
+	/// Set Rx Orientation
+	void SetRxOrientation(const Eigen::Matrix<ORIENTATION, Eigen::Dynamic, 1> &rxorientation);
+
+	/// Set the transmitter moments
+	void SetTxMom(const VectorXr &txmom);
+
+	/// Set Tx/Rx Separation
+	void SetTxRxSep(const Vector3Xr &txrxsep);
+
+	/// Set Scale Factor
+	void SetScaleFac(const VectorXr &scalefac);
+
+	// ====================  INQUIRY       =======================
+
+	/// Get number of frequencies used
+	int GetnFreq();
+
+	/// Get number of observation locations
+	int GetnObs();
+
+	/// Get the data cube
+	MatrixXr GetFEMDataCube();
+
+	/// Get the uncertainties
+	MatrixXr GetFEMUncertainCube();
+
+	/// Get a single data coefficient
+	Real GetDataCoeff(const int &x, const int &y);
+
+	/// Get the frequency array
+	VectorXr GetFreqs();
+
+	/// Get the position array
+	Vector3Xr GetXYZ();
+
+	/// Get the position for a single datum
+	VectorXr GetSingleXYZ(const int &x);
+
+	/// Get array of transmitter orientations
+	Eigen::Matrix<ORIENTATION, Eigen::Dynamic, 1> GetTxOrien();
+
+	/// Get array of receiver orientations
+	Eigen::Matrix<ORIENTATION, Eigen::Dynamic, 1> GetRxOrien();
+
+	/// Get array of Tx Moments
+	VectorXr GetTxMom();
+
+	/// Get Tx/Rx Separation
+	Vector3Xr GetTxRxSep();
+
+	/// Get Scale Factor
+	VectorXr GetScaleFac();
+
+	protected:
+
+	// ====================  LIFECYCLE     =======================
+
+		/// Default protected constructor.
+		DataFEM (const std::string &name);
+
+		/// Default protected constructor.
+		~DataFEM ();
+
+		void Release();
+
+	// ====================  DATA MEMBERS  =========================
+
+	/// Number of frequencies
+	int nFreq;
+
+	/// Number of observation locations
+	int nObs;
+
+	/// Data cube containing the inphase and quadrature
+	MatrixXr FEMDataCube;
+
+	/// Data cube containing the uncertainties
+	MatrixXr FEMUncertainCube;
+
+	/// Array of frequencies
+	VectorXr freq;
+
+	/// Position vector, with z as height above the ground surface (pos)
+	Vector3Xr xyz;
+
+	/// Array of Tx orientations (x,y,z) for each freq
+	Eigen::Matrix<ORIENTATION,Eigen::Dynamic,1> TxOrientation;
+
+	/// Array of Rx orientations (x,y,z) for each freq
+	Eigen::Matrix<ORIENTATION,Eigen::Dynamic,1> RxOrientation;
+
+	/// Transmitter moments, one for each frequency
+	VectorXr TxMom;
+
+	/// Tx/Rx Separation in local, right hand system with x aligned with flight
+	Vector3Xr TxRxSep;
+
+	/// Scale factor as described in EM1DFM manual
+	VectorXr ScaleFac;
+
+
+	private:
+
+}; // -----  end of class  DataFEM  -----
+} // end of namespace Lemma
+#endif
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+

LemmaCore/include/datareader.h

@@ -0,0 +1,67 @@
+/* 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     03/01/2010
+  @version  $Id: datareader.h 193 2014-11-10 23:51:41Z tirons $
+ **/
+
+#ifndef  DATAREADER_H_INC
+#define  DATAREADER_H_INC
+
+#include "LemmaObject.h"
+#include "data.h"
+
+namespace Lemma {
+
+// ===================================================================
+//        Class:  DataReader
+/// \brief  Abstract class whose derived members read data files and
+/// converts them to Data Classes
+/// \details
+// ===================================================================
+class DataReader : public LemmaObject {
+
+    friend std::ostream &operator<<(std::ostream &stream,
+            const DataReader &ob);
+
+    public:
+
+        // ====================  LIFECYCLE     =======================
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        // ====================  ACCESS        =======================
+        virtual Data* GetData()=0;
+
+        // ====================  INQUIRY       =======================
+
+    protected:
+
+        // ====================  LIFECYCLE     =======================
+
+        /// Default protected constructor.
+        DataReader (const std::string &name);
+
+        /// Default protected constructor.
+        ~DataReader ();
+
+        // ====================  DATA MEMBERS  =========================
+
+    private:
+
+}; // -----  end of class  DataReader  -----
+
+}       // -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef DATAREADER_H_INC  -----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */

LemmaCore/include/datareaderfem.h

@@ -0,0 +1,67 @@
+/* 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   M. Andy Kass
+  @date     01/03/2013
+  @version  $Id$
+ **/
+
+#ifndef __DATAREADERFEM_H
+#define __DATAREADERFEM_H
+
+#include "datareader.h"
+#include "datafem.h"
+
+namespace Lemma {
+
+
+// ===================================================================
+//        Class:  DataReaderFem
+/// \brief
+/// \details
+// ===================================================================
+	class DataReaderFem : DataReader {
+
+	public:
+
+	// ====================  LIFECYCLE     =======================
+
+		static DataReaderFem* New();
+
+		void Delete();
+
+	// ====================  OPERATORS     =======================
+
+	// ====================  OPERATIONS    =======================
+
+	// ====================  ACCESS        =======================
+		Data* GetData();
+
+	// ====================  INQUIRY       =======================
+
+
+
+	protected:
+
+	// ====================  LIFECYCLE     =======================
+
+		/// Default protected constructor.
+		DataReaderFem (const std::string &name);
+
+		/// Default protected constructor.
+		~DataReaderFem ();
+
+		void Release();
+
+	// ====================  DATA MEMBERS  =========================
+
+	private:
+
+}; // -----  end of class  DataReaderFem  -----
+} // end of namespace Lemma
+#endif

LemmaCore/include/datareaderfemubc.h

@@ -0,0 +1,100 @@
+/* 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   M. Andy Kass
+  @date     01/03/2013
+  @version  $Id$
+ **/
+
+#ifndef __DATAREADERFEMUBC_H
+#define __DATAREADERFEMUBC_H
+
+#include "datareader.h"
+#include "datafem.h"
+
+namespace Lemma {
+
+
+// ===================================================================
+//        Class:  DataReaderFemUBC
+/// \brief  Reads UBC-format observation files
+/// \details This class reads UBC-format EM1DFM observation files and
+/// populates a DataFEM class.  Assumptions: the frequencies and coil
+/// geometries remain fixed throughout a survey.
+// ===================================================================
+	class DataReaderFemUBC : DataReader {
+
+		friend std::ostream &operator<<(std::ostream &stream,
+			const DataReaderFemUBC &ob);
+
+
+	public:
+
+	// ====================  LIFECYCLE     =======================
+
+		static DataReaderFemUBC* New();
+
+		void Delete();
+
+	// ====================  OPERATORS     =======================
+
+	// ====================  OPERATIONS    =======================
+
+		void ReadData(const std::string &datafile,int vbs = 0);
+
+	// ====================  ACCESS        =======================
+
+		///Attach the data object
+		void SetDataFEM(DataFEM* inputtemp);
+
+
+	// ====================  INQUIRY       =======================
+		/// Return the data object
+		DataFEM* GetData();
+
+	protected:
+
+	// ====================  LIFECYCLE     =======================
+
+		/// Default protected constructor.
+		DataReaderFemUBC (const std::string &name);
+
+		/// Default protected constructor.
+		~DataReaderFemUBC ();
+
+		void Release();
+
+		/// Load read data into data object
+		void SendData();
+
+	// ====================  DATA MEMBERS  =========================
+
+	DataFEM* InputData;
+
+	int nObs;
+	int nFreq;
+	MatrixXr DataMatrix;
+	MatrixXr Uncertainties;
+	Vector3Xr PositionVec;
+	VectorXr Freqs;
+	VectorXr TxMom;
+	Vector3Xr TxRxSep;
+	Eigen::Matrix<ORIENTATION,Eigen::Dynamic,1> TxOrientation;
+	Eigen::Matrix<ORIENTATION,Eigen::Dynamic,1> RxOrientation;
+	VectorXr ScaleFac;
+
+
+
+	private:
+
+}; // -----  end of class  DataReaderFemUBC  -----
+} // end of namespace Lemma
+#endif
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */

LemmaCore/include/datareadertem.h

@@ -0,0 +1,82 @@
+/* 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   M. Andy Kass
+  @date     12/28/2011
+  @version  $Id: datareadertem.h 87 2013-09-05 22:44:05Z tirons $
+ **/
+
+#ifndef __DATAREADERTEM_H
+#define __DATAREADERTEM_H
+
+#include "datareader.h"
+#include "datatem.h"
+
+namespace Lemma {
+// ===================================================================
+//        Class:  DataReaderTem
+/// \brief
+/// \details
+// ===================================================================
+class DataReaderTem : DataReader {
+
+	public:
+
+		// ====================  LIFECYCLE     =======================
+
+		static DataReaderTem* New();
+
+		void Delete();
+
+		// ====================  OPERATORS     =======================
+
+		// ====================  OPERATIONS    =======================
+
+		/// Read in the data file
+		void ReadData(const std::string &datafile);
+
+		// ====================  ACCESS        =======================
+
+		/// Attach the data object
+		void SetDataTEM(DataTEM* inputtemp);
+
+		/// Output the data object
+		DataTEM* GetData();
+
+		/// Return number of gates
+		int GetnGates();
+
+		/// Return number of soundings
+		int GetnObs();
+
+		// ====================  INQUIRY       =======================
+
+
+
+	protected:
+
+		// ====================  LIFECYCLE     =======================
+
+		/// Default protected constructor.
+		DataReaderTem (const std::string &name);
+
+		/// Default protected constructor.
+		~DataReaderTem ();
+
+		void Release();
+
+		// ====================  DATA MEMBERS  =========================
+
+		/// Input data
+		DataTEM* InputData;
+
+	private:
+
+}; // -----  end of class  Datareadertem  -----
+} // end of namespace Lemma
+#endif // __DATAREADERTEM_H

LemmaCore/include/datatem.h

@@ -0,0 +1,131 @@
+/* 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     03/23/2010
+  @version  $Id: datatem.h 193 2014-11-10 23:51:41Z tirons $
+ **/
+
+#ifndef  DATATEM_INC
+#define  DATATEM_INC
+
+#include "data.h"
+
+namespace Lemma {
+
+    // ===================================================================
+    //        Class:  DataTEM
+    /// \brief  Class for TEM data.
+    /// \details  A lot to do here. Just a placeholder.
+    // ===================================================================
+    class DataTEM : public Data {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+            const DataTEM &ob);
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+
+            /** Returns pointer to new object
+             */
+            static DataTEM* New();
+
+            /** @copybrief Data::Clone()
+             *  @copydetails Data::Clone()
+             */
+            DataTEM* Clone();
+
+            /**
+             * @copybrief LemmaObject::Delete()
+             * @copydetails LemmaObject::Delete()
+             */
+            void Delete();
+
+            // ====================  OPERATORS     =======================
+
+            // ====================  OPERATIONS    =======================
+
+            void Zero();
+
+            /** Data2 needs to be compatible with DataTEM, that is
+             *  to say that it needs to be able to be cast into the
+             *  form of DataTEM. It also needs to be aligned with
+             *  the calling class.
+             */
+            Real Norm(Data* Data2);
+
+            // ====================  ACCESS        =======================
+
+			/// Set data dimensions
+			void SetSize(const int &nObs,const int &nGates);
+
+			/// Input the data
+			void SetData(const MatrixXr &inputdata);
+
+			/// Input the positions
+			void SetPositions(const Vector3Xr &positions);
+
+			/// Return number of time gates
+			int GetnGates();
+
+			/// Return number of soundings
+			int GetnObs();
+
+			/// Return data matrix
+			MatrixXr GetData();
+
+			/// Return single data coefficient
+			Real GetDataCoeff(const int &x,const int &y);
+
+			/// Return time
+			VectorXr GetTimes();
+
+			/// Return positions
+			Vector3Xr GetPositions();
+
+            // ====================  INQUIRY       =======================
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /// Default protected constructor.
+            DataTEM (const std::string &name);
+
+            /// Default protected constructor.
+            ~DataTEM ();
+
+            /**
+             * @copybrief LemmaObject::Release()
+             * @copydetails LemmaObject::Release()
+             */
+            void Release();
+
+            // ====================  DATA MEMBERS  =========================
+
+			MatrixXr TEMDataCube;
+
+			VectorXr times;
+
+			Vector3Xr locations;
+
+			int nGates;
+
+			int nObs;
+
+    private:
+
+    }; // -----  end of class  DataTEM  -----
+
+}       // -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef DATATEM_INC  -----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */

LemmaCore/include/digitalfiltercostrans.h

@@ -0,0 +1,83 @@
+/* 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   M. Andy Kass
+  @date     02/07/2011
+  @version  $Id: digitalfiltercostrans.h 87 2013-09-05 22:44:05Z tirons $
+ **/
+
+#ifndef __DIGITALFILTERCOSTRANS_H
+#define __DIGITALFILTERCOSTRANS_H
+
+#include "digitalfilterintegrator.h"
+
+namespace Lemma {
+
+	// ===================================================================
+	//        Class:  DigitalFilterCosTrans
+	/** \brief Cosine Transform via digital filters
+	    \details Based on Andersons' Hankel transform, this calculates
+	 			the cosine transform of a discrete function
+				using a digital filter approach.  Filter weights are
+				hard-coded.
+				Calculates transform of the form:
+				\f[ \int_0^\infty f(x) \cos (x\omega)~dx
+				\f]
+    */
+
+	// ===================================================================
+	class DigitalFilterCosTrans : public DigitalFilterIntegrator<Real> {
+
+		friend std::ostream &operator<<(std::ostream &stream, const
+			DigitalFilterCosTrans &ob);
+
+		public:
+
+			// ====================  LIFECYCLE     =======================
+
+			static DigitalFilterCosTrans* New();
+
+			void Delete();
+
+			// ====================  OPERATORS     =======================
+
+			// ====================  OPERATIONS    =======================
+
+			// ====================  ACCESS        =======================
+
+			// ====================  INQUIRY       =======================
+
+		protected:
+
+			// ====================  LIFECYCLE     =======================
+
+			/// Default protected constructor.
+			DigitalFilterCosTrans (const std::string& name);
+
+			/// Default protected constructor.
+			~DigitalFilterCosTrans ();
+
+			void Release();
+
+			/// Set all the filter weights
+			void SetFilterWeights();
+
+			// ====================  DATA MEMBERS  =========================
+
+			//Eigen::Matrix<Real, 787, 1> FilterWeights;
+
+		private:
+
+    }; // -----  end of class  DigitalFilterCosTrans  -----
+
+} //end of namespace Lemma
+
+#endif // __DIGITALFILTERCOSTRANS_H
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */

LemmaCore/include/digitalfilterintegrator.h

@@ -0,0 +1,542 @@
+/* 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     02/07/2011
+  @version  $Id: digitalfilterintegrator.h 124 2014-02-07 04:26:26Z tirons $
+ **/
+
+#ifndef  DIGITALFILTERINTEGRATOR_INC
+#define  DIGITALFILTERINTEGRATOR_INC
+
+#include "integrator.h"
+#include "integrationkernel.h"
+
+namespace Lemma {
+
+    // ===================================================================
+    //  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
+               that reused a lot of code. The original fortran codes are
+               available at:
+        ftp://ftpext.usgs.gov/pub/cr/co/denver/musette/pub/anderson/
+               This is an abstract class. Concrete classes must define the
+               a function to make arguments.
+               Template specilizations are found in the implimentation file
+               digitalfilterintegrator.cpp. This was necessary to support
+               the design paradigm of Lemma.
+     */
+    // ===================================================================
+    template <typename Scalar>
+    class DigitalFilterIntegrator : public Integrator {
+
+        /** Prints out basic info about the class, Complex implimentation */
+
+        template <typename Scalar2>
+        friend std::ostream &operator<<(std::ostream &stream,
+                        const DigitalFilterIntegrator<Scalar2> &ob);
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+
+            // ====================  OPERATORS     =======================
+
+            // ====================  OPERATIONS    =======================
+
+            /** Sets the number of desired convolutions. From Anderson, where
+                this value is called NB:
+                NUMBER OF LAGGED CONVOLUTIONS DESIRED (NB.GE.1).  USE
+                NB=1 IF B=BMIN=BMAX (I.E.,NO LAGGING DESIRED).  USE
+                NB>1 IF B IS LAGGED IN (BMIN,BMAX), WHERE
+                BMIN=BMAX*DEXP(-.1D0*(NB-1)) DOES NOT UNDERFLOW THE DEXP
+                RANGE.  THE B-LAGGED SPACING IS .1D0 IN LOG-SPACE. FOR
+                CONVENIENCE IN SPLINE INTERPOLATION LATER, EACH B IN
+                (BMIN,BMAX) IS RETURNED IN ARRAY ARG(I),I=1,NB, WHERE
+                ARG(I+1)/ARG(I)=DEXP(.1D0) FOR ALL I.  IF BMAX>BMIN>0 IS
+                GIVEN, THEN AN EFFECTIVE VALUE OF NB IS DETERMINED AS
+                NB=DINT(10.*DLOG(BMAX/BMIN))+I, WHERE I>1 IS RECOMMENDED,
+                PARTICULARLY IF USING SUBSEQUENT SPLINE INTERPOLATION FOR
+                A DIFFERENT B-SPACING THAN USED IN THE DIGITAL FILTER. IF
+                SPLINE INTERPOLATION IS TO BE USED LATER, IT IS GENERALLY
+                BEST TO USE DLOG(ARG(I)) INSTEAD OF ARG(I) -VS- DANS(I),
+                FOR I=1,NB.
+            */
+            void SetNumConv(const int& i);
+
+            /** Evaluates related integrals */
+            void ComputeRelated(const Real& rho,
+                IntegrationKernel<Scalar>* Kernel);
+
+            /** Evaluates the integral
+            @param[in]tol  REQUESTED TRUNCATION TOLERANCE AT BOTH FILTER TAILS
+              FOR ADAPTIVE CONVOLUTION FOR ALL NB TRANSFORMS.  THE
+              TRUNCATION CRITERION IS ESTABLISHED DURING CONVOLUTION IN
+              A FIXED ABSCISSA RANGE (USING WEIGHTS 426-461) OF THE
+              COSINE FILTER AS THE MAXIMUM ABSOLUTE CONVOLVED PRODUCT
+              TIMES TOL.  THE CONVOLUTION SUMMATION IS TERMINATED
+              ON EITHER SIDE OF THE FIXED RANGE WHENEVER THE ABSOLUTE
+              PRODUCT .LE. THE TRUNCATION CRITERION.  IN GENERAL, A
+              DECREASING TOLERANCE WILL PRODUCE HIGHER ACCURACY SINCE
+              MORE FILTER WEIGHTS ARE USED (UNLESS EXPONENT UNDERFLOW
+              OCCURS IN THE TRANSFORM INPUT FUNCTION EVALUATION).
+              ONE MAY SET TOL=0.D0 TO OBTAIN MAXIMUM ACCURACY FOR ALL
+              NB DOUBLE-PRECISION COSINE TRANSFORMS IN DANS(NB).
+              HOWEVER, THE ACTUAL RELATIVE ERRORS CANNOT BE EXPECTED TO
+              BE SMALLER THAN ABOUT .1D-12 REGARDLESS OF THE TOLERANCE
+              VALUE USED, SINCE DOUBLE-PRECISION FILTER WEIGHTS AND A
+              DOUBLE-PRECISION FUNCTION ARE USED. IN ANY EVENT,
+              ONE SHOULD ALWAYS CHOOSE TOL<<DESIRED RELATIVE ERROR.
+           ** ACCURACY WARNING **  SOME HIGHLY OSCILLATORY FUNCTIONS
+              FUN(G) AND (OR) LIMITING CASES OF B NEAR MACHINE-ZERO
+              (OR INFINITY) SHOULD BE AVOIDED, OTHERWISE UNSATISFACTORY
+              RESULTS (E.G., RELATIVE & ABSOLUTE ERRORS>>TOL) MAY OCCUR.
+              @param[in] ntol  NUMBER OF CONSECUTIVE TIMES THE TRUNCATION CRITERION (TOL)
+              IS TO BE MET AT EITHER FILTER TAIL BEFORE FILTER
+              TRUNCATION OCCURS.  NTOL=1 SHOULD BE USED FOR INPUT
+              FUNCTIONS THAT DO NOT HAVE MANY ZEROS IN (0,INFINITY). FOR
+              OSCILLATORY FUNCTIONS WITH MANY ZEROS, NTOL>1 MAY BE USED
+              TO INSURE A PREMATURE CUTOFF DOES NOT OCCUR FOR TRUNCATION
+              (SEE USE OF ITOL,NTOL,TOL IN THE CODE BELOW).
+            @param[in] rho integration argument argument
+            */
+            void Compute(const Real& rho, const int& ntol, const Real& tol);
+
+            /** Attaches the integration kernel */
+            void AttachKernel(IntegrationKernel<Scalar> *Kernel);
+
+            /** Detaches the integration kernel */
+            void DetachKernel( );
+
+            // ====================  ACCESS        =======================
+
+            /** Returns the Vector of Abscissa arguments
+             */
+            VectorXr  GetAbscissaArguments();
+
+            Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic > GetAnswer();
+
+            /** Returns the number of evaluations of kernel */
+            int GetNumFun();
+            // ====================  INQUIRY       =======================
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /** Default protected constructor. */
+            DigitalFilterIntegrator (const std::string& name);
+
+            /** Default protected constructor. */
+            ~DigitalFilterIntegrator ();
+
+            // ====================  DATA MEMBERS  =========================
+
+            /** A rewrite of Anderson's Pseudo-subroutine. */
+            void StoreRetreive(const int& idx, const int& lag, const Real& y,
+                        Scalar& Zsum, const int& jrel, Scalar& C);
+
+            // ====================  OPERATIONS    ==============================
+            /** Sets the filter weights as prescribed by Anderson. This is called
+                automatically when the SetBesselOrder(int ) is called. This is
+                a protected function and cannot be called directly.
+             */
+            virtual void SetFilterWeights()=0;
+
+            /** Computes the absolute maximum of the scalar */
+            Scalar AbsMax(const Scalar& C, const Scalar& Cmax);
+
+            // ====================  DATA MEMBERS  ==============================
+
+            /** The hankel transform wavenumber embedded in the integral */
+            Real Lambda;
+
+            /** Number of times kernel was evaluated */
+            int NumFun;
+
+            /** Number of lagged convolutions
+                must be greater or equal to 1
+                It is set automatically in the @see Compute function so
+                that  \f$ \rho \exp\left( -.1*(\mathtt{NumConv} -1) \right) \f$
+                does not underflow the exponent range
+             */
+            int NumConv;
+
+            /** Number of related kernels */
+            int NumRel;
+
+            /** Used as base for filter abscissa generation */
+            Real ABSCISSA;
+
+            /** Also used in abscissa generation \f$ ABSE = \exp{.1} \f$ */
+            const Real ABSE;
+
+            /** Also used in abscissa generation \f$ ABSER = 1 / \exp{.1} \f$ */
+            const Real ABSER;
+
+            /** Counter for calculated */
+            int icount;
+
+            /** Index of special case low side convolution filter weights */
+            int ilow;
+
+            /** Index of special case right side convolution filter weights */
+            int ihi;
+
+            /** Kernel Calculator */
+            IntegrationKernel<Scalar> *IntKernel;
+
+            /** Holds answer, dimensions are NumConv, and NumberRelated. */
+            Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> Ans;
+
+            /** Filter weight coefficients.
+             */
+            VectorXr  FilterWeights;
+
+            /** Stored abscissa arguments
+             */
+            VectorXr  Arg;
+
+            /** Work from Anderson
+             */
+            Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> Work;
+
+            /// Key used internally
+            Eigen::Matrix<int, Eigen::Dynamic, 1> Key;
+
+        private:
+
+    }; // -----  end of class  DigitalFilterIntegrator  -----
+
+
+    /////////////////////////////////////////
+    /////////////////////////////////////////
+    //      Templated implimentation       //
+    /////////////////////////////////////////
+    /////////////////////////////////////////
+
+    template <typename Scalar>
+    std::ostream &operator<<(std::ostream &stream,
+			const DigitalFilterIntegrator<Scalar> &ob) {
+		stream << *(Integrator*)(&ob);
+		return stream;
+	}
+
+    // ====================  LIFECYCLE     =======================
+
+    template <typename Scalar>
+    DigitalFilterIntegrator<Scalar>::
+            DigitalFilterIntegrator(const std::string& name) :
+        Integrator(name), Lambda(0), NumFun(0), NumConv(0), NumRel(0),
+        ABSCISSA(0),
+        ABSE(1.10517091807564762),   //   exp(.1)
+        ABSER(0.904837418035959573), // 1/exp(.1)
+        ilow(0), ihi(0), IntKernel(NULL) {
+    }
+
+    template <typename Scalar>
+    DigitalFilterIntegrator<Scalar>::~DigitalFilterIntegrator( ) {
+    }
+
+    template <typename Scalar>
+    Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic >
+        DigitalFilterIntegrator<Scalar>::GetAnswer() {
+        return Ans;
+    }
+
+    // ====================  OPERATIONS    =======================
+
+    template <typename Scalar>
+    void DigitalFilterIntegrator<Scalar>::SetNumConv(const int& i) {
+        this->NumConv = i;
+    }
+
+    template <typename Scalar>
+    void DigitalFilterIntegrator<Scalar>::
+            AttachKernel(IntegrationKernel<Scalar> *ck) {
+		if (this->IntKernel == ck) return;
+        if (this->IntKernel != NULL) {
+			this->IntKernel->DetachFrom(this);
+		}
+		ck->AttachTo(this);
+		this->IntKernel = ck;
+	}
+
+
+    template <typename Scalar>
+	void DigitalFilterIntegrator<Scalar>::DetachKernel( ) {
+		if (this->IntKernel != NULL) {
+			this->IntKernel->DetachFrom(this);
+		}
+		this->IntKernel = NULL;
+	}
+
+//     template < >
+//     inline Complex DigitalFilterIntegrator<Complex>::AbsMax(const Complex& C,
+//         const Complex& Cmax) {
+// 		return Complex(std::max(std::abs(real(C)), std::real(Cmax)),
+// 					   std::max(std::abs(imag(C)), std::imag(Cmax)) );
+//     }
+//     template < >
+//     Real DigitalFilterIntegrator<Real>::AbsMax(const Real& C,
+//         const Real& Cmax) {
+//         return std::max(C, Cmax);
+//     }
+
+    template <typename Scalar>
+    VectorXr  DigitalFilterIntegrator<Scalar>::GetAbscissaArguments() {
+        return this->Arg;
+    }
+
+//     ///////////////////////////////////////////
+// 	// Computes the transform
+//
+//     template < >
+//     void DigitalFilterIntegrator<Real>::Compute(const Real& rho,
+//         const int& ntol, const Real& tol) {
+//
+// 		Real y1 = this->ABSCISSA/rho;
+// 		this->Key.setZero();
+//
+// 		// Check to make sure everything is set
+// 		if (rho<=0) {
+// 			throw std::runtime_error("In DigitalFilterIntegrator Argument rho < 0.");
+// 		}
+//
+// 		if (this->NumConv<1) {
+// 			throw std::runtime_error("In DigitalFilterIntegrator NumConv is less than 1.");
+// 		}
+//
+// 		if (this->IntKernel == NULL) {
+// 			throw std::runtime_error("In DigitalFilterIntegrator Unset Kernel Calculator");
+// 		}
+//
+// 		Arg = VectorXr::Zero(this->NumConv);
+// 		Real y = std::pow(rho*ABSER, this->NumConv-1);
+//
+// 		if (y <= 0) {
+// 			std::cerr << "Exponent Underflow Error";
+// 			throw std::underflow_error("Exponent underflow");
+// 		}
+//
+// 		this->Work.resize(Eigen::NoChange, this->IntKernel->GetNumRel());
+//
+//         // Main Loop
+// 		int itol = 0;
+// 		int none = 0;
+// 		this->NumFun = 0;
+// 		int idx = 0;
+// 		int istore = 0;
+// 		Real Sum(0.);
+// 		Real Cmax(0.);
+// 		Real C(0.);
+// 		Ans.resize(this->NumConv, this->IntKernel->GetNumRel());
+// 		Ans.setZero();
+//  		// 1010 Loop
+//  		for (int ilag=0; ilag < this->NumConv; ++ilag) {
+//   			istore = this->NumConv - 1 - ilag;
+//   			if (ilag > 0) y1 *= ABSE;
+//   			Arg(istore) = ABSCISSA/y1;
+//
+//  			// 1000 Loop
+//  			for (int irel=0; irel < this->IntKernel->GetNumRel(); ++irel) {
+// 				//this->SetBesselOrder(this->Ckernel->GetBesselOrder(irel));
+//   				none = 0;
+//   				itol = ntol;
+//   				Sum = Real(0);
+//   				Cmax = Real(0);
+//   				y = y1;
+// 				// Begin right side convolution at weight 298
+// 				// counting from 0
+//   				idx = ilow;
+//   				y *= ABSE;
+// 				// Code Block 20 in Anderson
+// 				do {
+//  					this->StoreRetreive(idx, ilag, y, Sum, irel, C);
+//                     Cmax = AbsMax(C, Cmax);
+// 					++idx;
+// 					y *= ABSE;
+// 				} while (idx <= ihi);
+// 				//if (real(Cmax) == 0 && imag(Cmax) == 0) none = 1;
+// 				if (Cmax == Real(0)) none = 1;
+// 				Cmax *= tol;
+// 				// Code Block 30 in Anderson
+// 				do {
+//  					this->StoreRetreive(idx, ilag, y, Sum, irel, C);
+// 					if (std::abs(C) <= Cmax) {
+// 						--itol;
+// 						if (itol < 0 || idx > FilterWeights.size()-1) break;
+// 					} else {
+// 						itol = ntol;
+// 					}
+// 					++idx;
+// 					y *= ABSE;
+// 				} while (idx < FilterWeights.size());
+// 				itol = ntol;
+// 				y = y1;
+// 				// Code Block 60 in Anderson
+// 				idx = ilow-1;
+// 				do {
+//  					this->StoreRetreive(idx, ilag, y, Sum, irel, C);
+// 					if (std::abs(C) <= Cmax &&  none == 0) {
+// 						--itol;
+// 						if (itol < 0 || idx < 0) break;
+// 					} else {
+// 						itol = ntol;
+// 					}
+// 					--idx;
+// 					y *= ABSER;
+// 				} while (idx>=0);
+//  				Ans(istore, irel) = Sum/Arg(istore);
+//   			}  // End of 1000 loop
+//   		}      // End of 1010 loop
+// 	}
+//
+//
+//     template < >
+// 	void DigitalFilterIntegrator<Complex>::Compute(const Real &rho,
+//             const int& ntol, const Real &tol) {
+//
+// 		Real y1 = this->ABSCISSA/rho;
+//
+// 		this->Key.setZero();
+//
+// 		// Check to make sure everything is set
+// 		if (rho<=0) {
+// 			throw std::runtime_error("In DigitalFilterIntegrator Argument rho < 0.");
+// 		}
+//
+// 		if (this->NumConv<1) {
+// 			throw std::runtime_error("In DigitalFilterIntegrator NumConv is less than 1.");
+// 		}
+//
+// 		if (this->IntKernel == NULL) {
+// 			throw std::runtime_error("In DigitalFilterIntegrator Unset Kernel Calculator");
+// 		}
+//
+// 		Arg = VectorXr::Zero(this->NumConv);
+// 		Real y = std::pow(rho*ABSER, this->NumConv-1);
+//
+// 		if (y <= 0) {
+// 			std::cerr << "Exponent Underflow Error";
+// 			throw std::underflow_error("Exponent underflow");
+// 		}
+//
+// 		this->Work.resize(Eigen::NoChange, this->IntKernel->GetNumRel());
+//
+//         // Main Loop
+// 		int itol = 0;
+// 		int none = 0;
+// 		this->NumFun = 0;
+// 		int idx = 0;
+// 		int istore = 0;
+// 		Complex Zsum(0.);
+// 		Complex Cmax(0.);
+// 		Complex C(0.);
+// 		Ans.resize(this->NumConv, this->IntKernel->GetNumRel());
+// 		Ans.setZero();
+//  		// 1010 Loop
+//  		for (int ilag=0; ilag < this->NumConv; ++ilag) {
+//   			istore = this->NumConv - 1 - ilag;
+//   			if (ilag > 0) y1 *= ABSE;
+//   			Arg(istore) = ABSCISSA/y1;
+//  			// 1000 Loop
+//  			for (int irel=0; irel < this->IntKernel->GetNumRel(); ++irel) {
+// 				//this->SetBesselOrder(this->Ckernel->GetBesselOrder(irel));
+//   				none = 0;
+//   				itol = ntol;
+//   				Zsum = Complex(0);
+//   				Cmax = Complex(0);
+//   				y = y1;
+// 				// Begin right side convolution at weight 298
+// 				// counting from 0
+//   				idx = ilow;
+//   				y *= ABSE;
+// 				// Code Block 20 in Anderson
+// 				do {
+//  					this->StoreRetreive(idx, ilag, y, Zsum, irel, C);
+//                     Cmax = AbsMax(C, Cmax);
+// 					++idx;
+// 					y *= ABSE;
+// 				} while (idx <= ihi);
+// 				//if (real(Cmax) == 0 && imag(Cmax) == 0) none = 1;
+// 				if (Cmax == Complex(0)) none = 1;
+// 				Cmax *= tol;
+// 				// Code Block 30 in Anderson
+// 				do {
+//  					this->StoreRetreive(idx, ilag, y, Zsum, irel, C);
+// 					if ( std::abs(real(C)) <= real(Cmax) &&
+// 						 std::abs(imag(C)) <= imag(Cmax) ) {
+// 						--itol;
+// 						if (itol < 0 || idx > FilterWeights.size()-1) break;
+// 					} else {
+// 						itol = ntol;
+// 					}
+// 					++idx;
+// 					y *= ABSE;
+// 				} while (idx < FilterWeights.size());
+// 				itol = ntol;
+// 				y = y1;
+// 				// Code Block 60 in Anderson
+// 				idx = ilow-1;
+// 				do {
+//  					this->StoreRetreive(idx, ilag, y, Zsum, irel, C);
+// 					if ( std::abs(real(C)) <= real(Cmax) &&
+// 						 std::abs(imag(C)) <= imag(Cmax) &&
+// 						 none == 0 ) {
+// 						--itol;
+// 						if (itol < 0 || idx < 0) break;
+// 					} else {
+// 						itol = ntol;
+// 					}
+// 					--idx;
+// 					y *= ABSER;
+// 				} while (idx>=0);
+//  				Ans(istore, irel) = Zsum/Arg(istore);
+//   			}  // End of 1000 loop
+//   		}      // End of 1010 loop
+// 	}
+
+    template <typename Scalar>
+    int DigitalFilterIntegrator<Scalar>::GetNumFun() {
+        return NumFun;
+    }
+
+    // generic rewrite of store-retreive 'pseudo-subroutine'
+    template <typename Scalar>
+    void DigitalFilterIntegrator<Scalar>::StoreRetreive(const int &idx,
+            const int& lag, const Real& y, Scalar& Sum,
+            const int& jrel, Scalar& C) {
+
+		int look = idx+lag;
+ 		int	iq = look/FilterWeights.size();
+ 		int	ir = look%FilterWeights.size();
+		int iroll = iq*(FilterWeights.size()-1);
+
+		if(this->Key(ir) <= iroll) {
+			this->Key(ir) = iroll + ir;
+			this->Lambda = y;
+ 			++this->NumFun;
+ 			for (int ir2=0; ir2<IntKernel->GetNumRel(); ++ir2) {
+ 			    this->Work(ir, ir2) = this->IntKernel->Argument(this->Lambda, ir2);
+ 			}
+		}
+
+		C = this->Work(ir, jrel) * this->FilterWeights(idx);
+		Sum += C;
+		return;
+
+	}
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef DIGITALFILTERINTEGRATOR_INC  -----

LemmaCore/include/digitalfiltersintrans.h

@@ -0,0 +1,81 @@
+/* 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   M. Andy Kass
+  @date     02/18/2011
+  @version  $Id: digitalfiltersintrans.h 87 2013-09-05 22:44:05Z tirons $
+ **/
+
+#ifndef __DIGITALFILTERSINTRANS_H
+#define __DIGITALFILTERSINTRANS_H
+
+#include "digitalfilterintegrator.h"
+
+namespace Lemma {
+
+	// ===================================================================
+	//        Class:  DigitalFilterSinTrans
+	/** \brief Sine Transform via digital filters
+	    \details Based on Andersons' Hankel transform, this calculates
+	 			the sine transform of a discrete function
+				using a digital filter approach.  Filter weights are
+				hard-coded.
+				Calculates transform of the form:
+				\f[ \int_0^\infty f(x) \sin (x\omega)~dx
+				\f]
+    */
+
+	// ===================================================================
+	class DigitalFilterSinTrans : public DigitalFilterIntegrator<Real> {
+
+		friend std::ostream &operator<<(std::ostream &stream, const
+			DigitalFilterSinTrans &ob);
+
+		public:
+
+			// ====================  LIFECYCLE     =======================
+
+			static DigitalFilterSinTrans* New();
+
+			void Delete();
+
+			// ====================  OPERATORS     =======================
+
+			// ====================  OPERATIONS    =======================
+
+			// ====================  ACCESS        =======================
+
+			// ====================  INQUIRY       =======================
+
+		protected:
+
+			// ====================  LIFECYCLE     =======================
+
+			/// Default protected constructor.
+			DigitalFilterSinTrans (const std::string& name);
+
+			/// Default protected constructor.
+			~DigitalFilterSinTrans ();
+
+			void Release();
+
+			/// Set all the filter weights
+			void SetFilterWeights();
+
+			// ====================  DATA MEMBERS  =========================
+
+			//Eigen::Matrix<Real, 787, 1> FilterWeights;
+
+		private:
+
+    }; // -----  end of class  DigitalFilterSinTrans  -----
+
+} //end of namespace Lemma
+
+#endif // __DIGITALFILTERSINTRANS_H
+

LemmaCore/include/dipolesource.h

@@ -0,0 +1,335 @@
+/* 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     12/02/2009
+  @version  $Id: dipolesource.h 203 2015-01-09 21:19:04Z tirons $
+ **/
+
+#ifndef __DIPOLESOURCE_H
+#define __DIPOLESOURCE_H
+
+#include "LemmaObject.h"
+#include "layeredearthem.h"
+//#include "kernelem1dmanager.h"
+
+
+#ifdef LEMMAUSEVTK
+#include "vtkActor.h"
+#include "vtkLineSource.h"
+#include "vtkSphereSource.h"
+#include "vtkPolyDataMapper.h"
+#include "vtkTubeFilter.h"
+#include "vtkRegularPolygonSource.h"
+#include "vtkProperty.h"
+#endif
+
+namespace Lemma {
+
+    class KernelEM1DManager;
+    class ReceiverPoints;
+    class HankelTransform;
+
+    // ==========================================================================
+    //        Class:  DipoleSource
+    /// \brief    Dipole sources form the backbone of Lemma.
+    /// \details  More complex sources are constructed from a superposition of
+    ///           dipoles.
+    // ==========================================================================
+    class DipoleSource : public LemmaObject {
+
+        public:
+
+            // ====================    FRIENDS     ======================
+
+            friend std::ostream &operator<<(std::ostream &stream,
+                        const DipoleSource &ob);
+
+
+            // ====================  LIFECYCLE     ======================
+
+            /**
+             *  Returns pointer to new DipoleSource. Location is
+             *  initialized to (0,0,0) type and polarization are
+             *  initialized  to nonworking values that will throw
+             *  exceptions if used.
+             */
+            static DipoleSource* New();
+
+
+            /** Returns a deep copy of the dipole. Used to make thread safe methods. Does not
+                copy attachments.
+             */
+            DipoleSource* Clone();
+
+            /**
+             * @copybrief LemmaObject::Delete()
+             * @copydetails LemmaObject::Delete()
+             */
+            void Delete();
+
+            // ====================  OPERATORS     ======================
+
+            // ====================  OPERATIONS    ======================
+
+            /** Determines if kernels have been loaded already, and if so if they can be reused
+             */
+            void SetKernels(const int& ifreq,  const FIELDCALCULATIONS&  Fields, ReceiverPoints* Receivers, const int& irec,
+                    LayeredEarthEM* Earth );
+
+            /** resets the kernels if they cannot be reused */
+            virtual void ReSetKernels(const int& ifreq,  const FIELDCALCULATIONS&  Fields, ReceiverPoints* Receivers, const int& irec,
+                    LayeredEarthEM* Earth );
+
+            /** Updates the receiver fields */
+            virtual void UpdateFields(const int& ifreq, HankelTransform* Hankel, const Real& wavef);
+
+            // ====================  ACCESS        ======================
+
+            /** Sets the position.
+             * @param [in] posin
+             */
+            void SetLocation(const Vector3r &posin);
+
+            /** Sets the location using three Real coordinate arguments.
+             *  @param[in] xp is the x coordinate of the dipole
+             *  @param[in] yp is the y coordinate of the dipole
+             *  @param[in] zp is the z coordinate of the dipole
+             */
+            void SetLocation(const Real &xp, const Real &yp, const Real &zp);
+
+            /** Sets the dipole direction (polarisation). This method
+             * replaced SetPolarisation(DipoleSourcePolarisation) and allows for general dipole
+             * directionality.
+             * @param[in] dir is the direction of the dipole. This will be normalised.
+             */
+            void SetPolarisation(const Vector3r &dir);
+
+            /** Sets the polarisation of the dipole. Conveneince method that calls
+             *  SetPolarisation(const Vector3r &dir), constructing the normalized Vector | <x, y, z> |
+             */
+            void SetPolarisation(const Real& x, const Real& y, const Real& z );
+
+            /// Sets the dipole polarisation
+            /// @param[in] pol is the enumerated polarisation
+            void SetPolarisation(const DipoleSourcePolarisation &pol);
+
+            /// Sets the dipole source type
+            /// @param[in] stype is one of the enerated values taking either
+            /// ELECTRICDIPOLE or MAGNETICDIPOLE
+            void SetType(const DipoleSourceType &stype);
+
+            /// Sets the dipole moment
+            void SetMoment(const Real &moment);
+
+            /// Sets the dipole phse
+            void SetPhase(const Real &phase);
+
+            /// Sets the polarity
+            void SetPolarity(const DipoleSourcePolarity& pol);
+
+            /// Sets number of frequencies
+            void SetNumberOfFrequencies(const int &nfreq);
+
+            /// Sets a specific frequency.
+            /// @param[in] ifreq is the frequency bin number
+            /// @param[in] freq is the frequency to set, in Hz
+            void SetFrequency(const int &ifreq, const Real &freq);
+
+            /// Sets the frequencies of the dipole.
+            /// @param[in] freqs is a vector of the frequencies. Also sets
+            /// number of frequencies
+            void SetFrequencies(const VectorXr& freqs);
+
+
+            // ====================  INQUIRY       ======================
+
+            /**  Accessor to polarisation vector.
+                 @return returns the unit polarisation vector.
+             */
+            Vector3r GetPolarisation();
+
+            /// Returns Vector3r position of the dipole
+            Vector3r GetLocation();
+
+            /// Returns a specific coordinate of the dipole
+            /// @param coordinate 0=x, 1=y, 2=z
+            Real  GetLocation(const int &coordinate);
+
+            /// Returns enumerated of DipoleSourceType
+            DipoleSourceType GetDipoleSourceType();
+
+            /// Returns the dipole type
+            DipoleSourceType GetType();
+
+            /// Returns pointer to KernelEM1DManager
+            KernelEM1DManager*  GetKernelManager();
+
+            // Returns enumerated DipoleSourcePolarization
+            //DipoleSourcePolarisation GetDipoleSourcePolarisation();
+
+            /// Returns the dipole moment
+            Real GetMoment();
+
+            /// Returns the angular frequency of the dipole
+            Real GetAngularFrequency(const int &ifreq);
+
+            /// Returns the frequency of the dipole (Hz)
+            Real GetFrequency(const int &ifreq);
+
+            /// Returns the frequency of the dipole (Hz)
+            VectorXr GetFrequencies( );
+
+            /// Returns the phase offset of the dipole
+            Real GetPhase();
+
+            /// Returns the number of frequencies
+            int GetNumberOfFrequencies();
+
+            #ifdef LEMMAUSEVTK
+            /// Returns an actor that can be placed into a vtk scene easily
+            /// Note that this function throws a pointer, it is the receivers
+            /// job to manage this memory!
+            vtkActor* GetVtkActor();
+            #endif
+
+        protected:
+
+            // ====================  LIFECYCLE     ======================
+
+            /// Default protected constructor.
+            DipoleSource (const std::string &name);
+
+            /// Default protected constructor.
+            ~DipoleSource ();
+
+            /**
+             * @copybrief LemmaObject::Release()
+             * @copydetails LemmaObject::Release()
+             */
+            void Release();
+
+            // ====================  DATA MEMBERS  ======================
+
+            /// Defines the type of source (magnetic or electric)
+            DipoleSourceType             Type;
+
+            // Polarization of the dipole, (x, y or z)
+            //DipoleSourcePolarisation     Polarisation;
+
+            // Dipole polarity
+            //DipoleSourcePolarity         Polarity;
+
+            /// Which receiver index should Kernels be configured for
+            int                          irec;
+            int                          lays;
+            int                          layr;
+
+            /// Phase offset of the dipole, referenced from 0
+            Real                         Phase;
+
+            /// Dipole Moment
+            Real                         Moment;
+
+            Real                         xxp;
+            Real                         yyp;
+            Real                         rho;
+            Real                         sp;
+            Real                         cp;
+            Real                         scp;
+            Real                         sps;
+            Real                         cps;
+            Real                         c2p;
+            Real                         kernelFreq;
+
+            FIELDCALCULATIONS            FieldsToCalculate;
+
+            VectorXcr                    f;
+            VectorXi                     ik;
+
+            /// Central location of the dipole
+            Vector3r                     Location;
+
+            /// Unit vector defining directionality of the dipole
+            Vector3r                     Phat;
+
+            /// Freqencies of the source, in Hz
+            VectorXr                     Freqs;
+
+            /// Storage of the EM1D kernels used by this dipole
+            KernelEM1DManager*          KernelManager;
+
+            /// Receiver points, keep track if these have changed
+            ReceiverPoints*             Receivers;
+
+            /// Layered Earth used by Kernels
+            LayeredEarthEM*             Earth;
+
+    }; // -----  end of class  DipoleSource  -----
+
+    /** If no dipole source has been specified, throw this error.
+    */
+    class NullDipoleSource : public std::runtime_error {
+        public:
+        /** Thrown when a DipoleSource pointer is NULL
+         */
+        NullDipoleSource ( );
+    };
+
+    /** Error class for assignment of a dipole source that did not connect properly.
+     */
+    class NonValidDipoleTypeAssignment  : public std::runtime_error {
+        public:
+            NonValidDipoleTypeAssignment(  );
+    };
+
+    /** Error class for a non-valid dipole type. Generally thrown if this was not
+     * set properly.
+     */
+    class NonValidDipoleType  : public std::runtime_error {
+        public:
+            /** Throws error. This is a deprecated function. Call the method with
+             *  the pointer address instead.
+             */
+            NonValidDipoleType( );
+            /** Throws error with information on the class throwing the error.
+            */
+            NonValidDipoleType( LemmaObject *ptr );
+    };
+
+    /** Error class for non valid dipole polarisation
+     */
+    class NonValidDipolePolarisation  : public std::runtime_error {
+        public:
+            NonValidDipolePolarisation( );
+    };
+
+    /** Error class for non valid dipole polarity
+     */
+    class NonValidDipolePolarity  : public std::runtime_error {
+        public:
+            NonValidDipolePolarity( );
+    };
+
+    /** Error class for non valid dipole polarisation
+     */
+    class NonValidDipolePolarisationAssignment  : public std::runtime_error {
+        public:
+            NonValidDipolePolarisationAssignment( );
+    };
+
+    /** Error class for non valid location coordinate.
+     */
+    class NonValidLocationCoordinate  : public std::runtime_error {
+        public:
+            NonValidLocationCoordinate( );
+    };
+
+}
+
+#endif // __DIPOLESOURCE_H

LemmaCore/include/earthmodel.h

@@ -0,0 +1,142 @@
+/* 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     03/23/2010
+  @version  $Id: earthmodel.h 198 2014-12-27 06:14:05Z tirons $
+ **/
+
+#ifndef  EARTHMODEL_INC
+#define  EARTHMODEL_INC
+
+#include "LemmaObject.h"
+
+namespace Lemma {
+
+    // ===================================================================
+    //        Class:  EarthModel
+    /// \brief abstract class for Earth models
+    /// \details
+    // ===================================================================
+    class EarthModel : public LemmaObject {
+
+        // ====================    FRIENDS     ===========================
+        friend std::ostream &operator<<(std::ostream &stream,
+                        const EarthModel &ob);
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+            #ifdef HAVE_YAMLCPP
+            /** YAML Serializing method
+             */
+            YAML::Node Serialize() const;
+            //static LayeredEarth* DeSerialize(const YAML::Node& node);
+            #endif
+
+            // ====================  OPERATORS     =======================
+
+            // ====================  OPERATIONS    =======================
+
+            // ====================  ACCESS        =======================
+
+            /** Sets the earth's magnetic field, in Tesla
+                @param[in] bfield contains the x,y, and z components of
+                the field. EarthModel::Inc, EarthModel::Dec, and
+                EarthModel::BMag are computed:
+                \f{eqnarray*}{ \mathrm{Inc} = &
+                \cos^{-1}( \mathbf{B} \cdot \hat{\mathbf{z}} / B )
+                \\ \mathrm{Dec} =& \cos^{-1}
+                         (\mathbf{B} \cdot \hat{\mathbf{x}} / B )
+                   \\           \mathrm{Mag} =& \Vert \mathbf{B} \Vert  \f}
+               @param[in] unit specifies the units of bfield.
+              */
+            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}
+            void SetMagneticFieldIncDecMag(const Real& inc, const Real&dec,
+                            const Real& Mag, const MAGUNITS &unit);
+
+            // ====================  INQUIRY       =======================
+
+            /// Gets the magnetic field of the earth, in T
+            Vector3r GetMagneticField( );
+
+            /// Gets the magnetic field of the earth, in T
+            Vector3r GetMagneticFieldInGauss(  );
+
+            /// Gets the magnetic field unit vector of the earth
+            Vector3r GetMagneticFieldUnitVector( );
+
+            /// Returns the magnitude of the magnetic field \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
+            Real GetMagneticFieldMagnitudeInGauss( );
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /// Default protected constructor.
+            EarthModel (const std::string& name);
+
+            #ifdef HAVE_YAMLCPP
+            /** Deserialize constructor */
+            EarthModel (const YAML::Node& node);
+            #endif
+
+            /// Default protected constructor.
+            ~EarthModel ();
+
+            // ====================  DATA MEMBERS  =========================
+
+            /// Magnetic field, in units of nT
+            Vector3r          BField;
+
+            /// Magnetic field unit vector \f$  \hat{\mathbf{B}_0} \f$
+            Vector3r          BFieldUnit;
+
+            /// Inclination of the magnetic field
+            Real              BInc;
+
+            /// Declination of the magnetic field
+            Real              BDec;
+
+            /// Declination of the magnetic field
+            Real              BMag;
+
+    }; // -----  end of class  EarthModel  -----
+
+    //////////////////////////////////////////////////////////////
+    // Error Classes
+
+    /** If the Earth class is NULL valued, throw this
+     */
+    class NullEarth : public std::runtime_error {
+            /** Thrown when an Earth pointer is NULL
+             */
+            public: NullEarth ();
+    };
+
+}       // -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef EARTHMODEL_INC  -----

LemmaCore/include/emearth1d.h

@@ -0,0 +1,232 @@
+/* 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     12/02/2009
+  @version  $Id: emearth1d.h 266 2015-04-01 03:24:00Z tirons $
+ **/
+
+#ifndef __EMEARTH1D_H
+#define __EMEARTH1D_H
+
+#include "dipolesource.h"
+#include "layeredearthem.h"
+#include "receiverpoints.h"
+#include "WireAntenna.h"
+#include "PolygonalWireAntenna.h"
+#include "kernelem1dspec.h"
+#include "kernelem1dmanager.h"
+#include "hankeltransformgaussianquadrature.h"
+#include "hankeltransformhankel2.h"
+#include "FHTKey.h"
+#include "FHTKey51.h"
+#include "FHTKey101.h"
+#include "QWEKey.h"
+#include "CubicSplineInterpolator.h"
+
+#ifdef HAVEBOOSTPROGRESS
+#include "boost/progress.hpp"
+#endif
+
+namespace Lemma {
+
+    // =======================================================================
+    //        Class:  EmEarth1D
+    /// \brief  Implimentation of 1D EM solution.
+    /// \details  We've done a lot of different things.
+    // =======================================================================
+    class EMEarth1D : public LemmaObject {
+
+		friend std::ostream &operator<<(std::ostream &stream,
+			const EMEarth1D &ob);
+
+        public:
+
+            //friend class KernelEm1D;
+
+            // ====================  LIFECYCLE     ===========================
+
+            /**
+             *  Returns pointer to new EMEarth1D. Location is
+             *  initialized to (0,0,0) type and polarization are
+             *  initialized  to nonworking values that will throw
+             *  exceptions if used.
+             */
+            static EMEarth1D* New();
+
+            /**
+             * @copybrief LemmaObject::Delete()
+             * @copydetails LemmaObject::Delete()
+             */
+            void Delete();
+
+            /** stream debugging info to std::out
+             */
+            void Query();
+
+            #ifdef HAVE_YAMLCPP
+            /** YAML Serializing method
+             */
+            YAML::Node Serialize() const;
+
+            //static EMEarth1D* DeSerialize(const YAML::Node& node);
+            #endif
+
+            // ====================  OPERATORS     ===========================
+
+            // ====================  OPERATIONS    ===========================
+
+            /// Calculates the field(s) due to an ungrounded dipole source
+            /// Calls FORTRAN library em1d (em1dnew.for)
+#ifdef COMPILE_FORTRAN
+            void MakeCalc();
+#endif
+
+            /** C++ wrapper for em1dnew.for, serial */
+            void MakeCalc3();
+
+            /** Calculates the field(s) due to a wire antennae */
+            void CalculateWireAntennaFields(bool progressbar=false);
+
+            // ====================  ACCESS        ===========================
+
+            /** Attaches an antennae */
+            void AttachWireAntenna(WireAntenna *antennae);
+
+            /** Attaches a dipole for calculation */
+            void AttachDipoleSource(DipoleSource *dipole);
+
+            /** Attaches a layered earth model for calculation */
+            void AttachLayeredEarthEM(LayeredEarthEM *Earth);
+
+            /** Attaches a set of receiver points for calculation */
+            void AttachReceiverPoints(ReceiverPoints *Receivers);
+
+            /** Sets the fields that are calcultated, E,H or BOTH */
+            void SetFieldsToCalculate(const FIELDCALCULATIONS &calc);
+
+            /** Sets the method to use to evaluate the Hankel integral,
+             */
+            void SetHankelTransformMethod(const HANKELTRANSFORMTYPE &type);
+
+            // ====================  INQUIRY       ===========================
+
+        protected:
+
+            // ====================  LIFECYCLE     ===========================
+
+            /** Default protected constructor. */
+            EMEarth1D (const std::string& name);
+
+            #ifdef HAVE_YAMLCPP
+            /** Default protected constructor. */
+			EMEarth1D (const YAML::Node& node);
+            #endif
+
+            /** Default protected constructor. */
+            ~EMEarth1D ();
+
+            /**
+             * @copybrief LemmaObject::Release()
+             * @copydetails LemmaObject::Release()
+             */
+            void Release();
+
+            // ====================  OPERATIONS    ===========================
+
+            /** Used internally, this is the innermost loop of the MakeCalc3,
+             *  and CalculateWireAntennaField routines.
+             */
+            void SolveSingleTxRxPair(const int &irec,
+                    HankelTransform *Hankel,
+                    const Real &wavef, const int &ifreq,
+                    DipoleSource *tDipole);
+
+            /** Used internally, this is the innermost loop of the MakeCalc3,
+             *  and CalculateWireAntennaField routines.
+             */
+            void SolveLaggedTxRxPair(const int &irec, Hankel2* Hankel,
+                    const Real &wavef, const int &ifreq,
+                    PolygonalWireAntenna* antenna);
+
+            /** Removes all connections */
+            void DetachAll();
+
+            // ====================  DATA MEMBERS  ===========================
+
+            /** Computes field due to dipole */
+            DipoleSource*        Dipole;
+
+            /** Earth model (Cole-cole) */
+            LayeredEarthEM*      Earth;
+
+            /** Receiver points */
+            ReceiverPoints*      Receivers;
+
+            /** Wire antennae tx */
+            WireAntenna*         Antenna;
+
+            /** What fields are wanted */
+            FIELDCALCULATIONS    FieldsToCalculate;
+
+            /** The type of Hankel transform to use, default to digital
+             *  filtering
+             */
+            HANKELTRANSFORMTYPE  HankelType;
+
+            /** Counter for number of caclulations made
+             */
+            int icalcinner;
+
+            /** Counter for number of caclulations made
+             */
+            int icalc;
+
+    }; // -----  end of class  EMEarth1D  -----
+
+    /////////////////////////////////////////
+    // Exception classes
+
+    /** If a Receivers Class is NULL valued, throw this.
+     */
+    class NullReceivers : public std::runtime_error {
+            /** Thrown when Receivers pointer is NULL
+             */
+            public: NullReceivers();
+    };
+
+    /** If an Antenna is NULL valued, throw this error.
+     */
+    class NullAntenna : public std::runtime_error {
+            /** Thrown when an antenna pointer is NULL
+             */
+            public: NullAntenna();
+    };
+
+    /** If an Instrument is NULL valued, throw this error.
+     */
+    class NullInstrument : public std::runtime_error {
+            /** thrown when an instrument pointer is NULL.
+             *  @param[in] ptr is a pointer to the class throwing the exception.
+             */
+            public: NullInstrument(LemmaObject* ptr);
+    };
+
+    /** If a dipole source is specified, but a method calling a wire antenna is
+     * called, throw this.
+     */
+    class DipoleSourceSpecifiedForWireAntennaCalc : public std::runtime_error {
+            /** Thrown when a dipole source is specified when a wire antenna is
+             * expected
+             */
+            public: DipoleSourceSpecifiedForWireAntennaCalc();
+    };
+
+} // Namespace Lemma
+
+#endif // __EMEARTH1D_H

LemmaCore/include/emearth3d.h

@@ -0,0 +1,78 @@
+/* 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     10/28/2010
+  @version  $Id: emearth3d.h 193 2014-11-10 23:51:41Z tirons $
+ **/
+
+
+#ifndef  EMEARTH3D_INC
+#define  EMEARTH3D_INC
+
+#include "LemmaObject.h"
+
+namespace Lemma {
+
+
+    // ===================================================================
+    //  Class:  EMEarth3D
+    /**
+      @class
+      \brief   Impliments a 3D EM solution to a general conductivity
+               structure.
+      \details Calculations are made on a rectilinear grid. General 3D
+               conductivity is supported, but not magnetic permeability.
+     */
+    // ===================================================================
+    class EMEarth3D : public LemmaObject {
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+
+            /** Returns a pointer to a new object of type EMEarth3D.
+             * It allocates all necessary memory.
+             */
+            static EMEarth3D* New();
+
+            /** Deletes this object. Delete also disconnects any
+             * attachments to this object.
+             */
+            void Delete();
+
+            // ====================  OPERATORS     =======================
+
+            // ====================  OPERATIONS    =======================
+
+            // ====================  ACCESS        =======================
+
+            // ====================  INQUIRY       =======================
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /// Default protected constructor.
+            EMEarth3D (const std::string& name);
+
+            /// Default protected constructor.
+            ~EMEarth3D ();
+
+            /// Frees all memory
+            void Release();
+
+            // ====================  DATA MEMBERS  =========================
+
+        private:
+
+    }; // -----  end of class  EMEarth3D  -----
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef EMEARTH3D_INC  -----

LemmaCore/include/filter.h

@@ -0,0 +1,62 @@
+/* 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     07/20/2010
+  @version  $Id: filter.h 193 2014-11-10 23:51:41Z tirons $
+ **/
+
+#include "LemmaObject.h"
+
+namespace Lemma {
+
+
+    // ===================================================================
+    //  Class:  Filter
+    /**
+      @class  Filter
+      \brief  Abstract class for filtering.
+      \details Derived classes include fourier domain and time domain filters.
+     */
+    // ===================================================================
+
+    class Filter : public LemmaObject {
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+
+            // ====================  OPERATORS     =======================
+
+            // ====================  OPERATIONS    =======================
+
+            // ====================  ACCESS        =======================
+
+            // ====================  INQUIRY       =======================
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /// Default protected constructor.
+            Filter (const std::string& name);
+
+            /// Default protected constructor.
+            ~Filter ();
+
+            // ====================  DATA MEMBERS  =========================
+
+        private:
+
+    }; // -----  end of class  Filter  -----
+
+
+}		// -----  end of Lemma  name  -----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */

LemmaCore/include/gaussianquadrature.h

@@ -0,0 +1,139 @@
+/* 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     10/07/2010
+  @version  $Id: gaussianquadrature.h 193 2014-11-10 23:51:41Z tirons $
+ **/
+
+#ifndef __gaussianquadrature_h
+#define __gaussianquadrature_h
+
+#include "LemmaObject.h"
+
+namespace Lemma {
+
+
+	// ===================================================================
+	//        Class:  gaussianquadrature
+	/// \brief Numerical integration via Legendre-Gauss Quadrature.
+	/// \details Returns integration result, weights, and abscissae.  This
+	/// script computes the Legendre-Gauss nodes and weights on an interval
+	/// [a,b] with truncation order N.  This class is heavily derived from
+	/// lgwt.m by Greg von Winckel (2/25/2004).
+	// ===================================================================
+	class gaussianquadrature {
+
+		public:
+
+			friend std::ostream &operator<<(std::ostream &stream,
+						const gaussianquadrature &ob);
+
+			// ====================  LIFECYCLE     =======================
+
+			static gaussianquadrature* New();
+
+			void Delete();
+
+			// ====================  OPERATORS     =======================
+
+			// ====================  OPERATIONS    =======================
+			/// Perform Gaussian Quadrature Integration
+			void Integrate();
+
+			/// Calculate abscissae and weights
+			void CalcAW();
+
+			// ====================  ACCESS        =======================
+			/// Set number of points and limits
+			void SetFreqs(const int& nfreq, const Real& a, const Real& b);
+
+			/// Eigen Vector of function values to be integrated over
+			void SetFunc(const VectorXr& fx);
+
+			// ====================  INQUIRY       =======================
+			/// Returns Eigen Vector of Abscissae
+			VectorXr GetAbscissae();
+
+			/// Returns Eigen Vector of Weights
+			VectorXr GetWeights();
+
+			/// Returns integration result
+			Real GetResult();
+
+
+		protected:
+
+			// ====================  LIFECYCLE     =======================
+
+			/// Default protected constructor.
+			gaussianquadrature ();
+
+			/// Default protected constructor.
+			~gaussianquadrature ();
+
+
+
+			// ====================  DATA MEMBERS  =========================
+			/// Interval
+			Real dx;
+
+			/// Machine precision
+			Real machineeps;
+
+			/// Bookkeeping variable
+			int N;
+
+			/// Bookkeeping variable
+			int N1;
+
+			/// Bookkeeping variable
+			int N2;
+
+			/// Lower bound
+			Real a;
+
+			/// Upper bound
+			Real b;
+
+			/// Placeholder vector
+			VectorXr ytemp;
+
+			/// Abscissae
+			VectorXr xu;
+
+			/// Intermediate Abscissae vector
+			VectorXr y;
+
+			/// Intermediate Abscissae vector
+			VectorXr y0;
+
+			/// Legendre-Gauss Vandermonde Matrix
+			MatrixXr L;
+
+			/// Derivative of LGVM
+			VectorXr Lp;
+
+			/// Intermediate Matrix
+			VectorXr Ltemp;
+
+			/// Weights Vector
+			VectorXr wgq;
+
+			///Function to integrate
+			VectorXr funcx;
+
+			/// Integration result
+			Real intres;
+
+		private:
+
+	}; // -----  end of class  gaussianquadrature  -----
+} // end of namespace Lemma
+#endif // __gaussianquadrature_h
+

LemmaCore/include/grid.h

@@ -0,0 +1,64 @@
+/* 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     10/25/2009
+  @version  $Id: grid.h 193 2014-11-10 23:51:41Z tirons $
+ **/
+
+#ifndef __GRID_H
+#define __GRID_H
+
+#include "LemmaObject.h"
+
+namespace Lemma {
+
+// ===============================================================================
+//        Class:  Grid
+/// \brief Abstract base class for grids.
+/// \details Grids define values in space, they may either be an integral part
+/// of models, or simply the output of a forward modelling procedure.
+// ===============================================================================
+
+class Grid : public LemmaObject {
+
+    friend std::ostream &operator<<(std::ostream &stream,
+            const Grid &ob);
+
+    public:
+
+        // ====================  LIFECYCLE     ===================================
+
+        // ====================  OPERATORS     ===================================
+
+        // ====================  OPERATIONS    ===================================
+
+        // ====================  ACCESS        ===================================
+
+        // ====================  INQUIRY       ===================================
+
+    protected:
+
+        // ====================  LIFECYCLE     ===================================
+
+        /// Default protected constructor.
+        Grid (const std::string &name);
+
+        /// Default protected constructor.
+        ~Grid ();
+
+        // ====================  DATA MEMBERS  ===================================
+
+    private:
+
+}; // -----  end of class  Grid  -----
+
+} // namespace Lemma
+
+#endif // __GRID_H
+

LemmaCore/include/hankeltransform.h

@@ -0,0 +1,90 @@
+/* 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     01/28/2010
+  @version  $Id: hankeltransform.h 270 2015-08-24 15:45:41Z tirons $
+ **/
+
+#ifndef __hankeltransform_h
+#define __hankeltransform_h
+
+#include "LemmaObject.h"
+#include "kernelem1dbase.h"
+#include "kernelem1dspec.h"
+#include "kernelem1dmanager.h"
+
+namespace Lemma {
+
+        // ===================================================================
+        //        Class:  HankelTransform
+        /// \brief  Pure abstract class for hankel transforms
+        /// \details
+        // ===================================================================
+        class HankelTransform : public LemmaObject {
+
+            public:
+
+                /// Prints out basic info about the class
+                friend std::ostream &operator<<(std::ostream &stream,
+                        const HankelTransform &ob);
+
+                // ====================  LIFECYCLE     =======================
+
+                //static HankelTransform* New();
+
+                //void Delete();
+
+                // ====================  OPERATORS     =======================
+
+                // ====================  OPERATIONS    =======================
+
+                /// @todo this is actually a deprecated function. Only Chave
+                ///   uses this.
+                /// Performs numerical integration using Gaussian quadrature
+                /// ikk:   type of kernel depending on source and receiver couple
+                /// imode: a switch for TE(0) and TM(1) mode
+                /// itype: order of Bessel function
+                /// rho is argument to integral
+                /// wavef is the propogation constant of free space
+                /// = omega * sqrt( EP*AMU )  amu = 4 pi e-7  ep = 8.85e-12
+                virtual Complex Zgauss(const int &ikk, const EMMODE &imode,
+                            const int &itype, const Real &rho,
+                            const Real &wavef, KernelEm1DBase *Kernel)=0;
+
+                /// Computes related kernels, if applicable, otherwise this is
+                /// just a dummy function.
+                virtual void ComputeRelated(const Real& rho, KernelEm1DBase* Kernel);
+
+                virtual void ComputeRelated(const Real& rho, std::vector< KernelEm1DBase* > KernelVec);
+
+                virtual void ComputeRelated(const Real& rho, KernelEM1DManager* KernelManager);
+
+                // ====================  ACCESS        =======================
+
+                // ====================  INQUIRY       =======================
+
+                // ====================  DATA MEMBERS  =======================
+
+            protected:
+
+                // ====================  LIFECYCLE     =======================
+
+                /// Default protected constructor.
+                HankelTransform (const std::string &name);
+
+                /// Default protected constructor.
+                ~HankelTransform ();
+
+            private:
+
+    }; // -----  end of class  HankelTransform  -----
+
+}
+
+#endif // __hankeltransform_h

LemmaCore/include/hankeltransformgaussianquadrature.h

@@ -0,0 +1,349 @@
+/* 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     01/02/2010
+  @version  $Id: hankeltransformgaussianquadrature.h 199 2014-12-29 19:25:20Z tirons $
+ **/
+
+#ifndef  _HANKELTRANSFORMGAUSSIANQUADRATURE_h_INC
+#define  _HANKELTRANSFORMGAUSSIANQUADRATURE_h_INC
+
+#include "hankeltransform.h"
+#include "kernelem1dbase.h"
+
+#ifdef HAVEBOOSTCYLBESSEL
+#include "boost/math/special_functions.hpp"
+#endif
+
+namespace Lemma {
+
+
+	// =======================================================================
+	//        Class:  HankelTransformGaussianQuadrature
+	/// \brief  Calculates hankel transform using gaussian quadrature.
+	/// \details  Accurate but slow, this is a port of Alan Chave's public domain
+    /// fortran code
+	// =======================================================================
+	class HankelTransformGaussianQuadrature : public HankelTransform {
+
+		friend std::ostream &operator<<(std::ostream &stream,
+				const HankelTransformGaussianQuadrature &ob);
+
+		public:
+
+			// ====================  LIFECYCLE     ===========================
+
+            /**
+             *  Returns pointer to new HankelTransformGaussianQuadrature.
+             *  Location is
+             *  initialized to (0,0,0) type and polarization are
+             *  initialized  to nonworking values that will throw
+             *  exceptions if used.
+             */
+			static HankelTransformGaussianQuadrature* New();
+
+            /**
+             * @copybrief LemmaObject::Delete()
+             * @copydetails LemmaObject::Delete()
+             */
+            void Delete();
+
+			// ====================  OPERATORS     ===========================
+
+			// ====================  OPERATIONS    ===========================
+
+			/// Performs numerical integration using Gaussian quadrature
+			/// ikk:   type of kernel depending on source and receiver couple
+			/// imode: a switch for TE(0) and TM(1) mode
+			/// itype: order of Bessel function
+			/// rho is argument to integral
+			/// wavef is the propogation constant of free space
+			/// = omega * sqrt( EP*AMU )  amu = 4 pi e-7  ep = 8.85e-12
+            //template <EMMODE T>
+			Complex Zgauss(const int &ikk, const EMMODE &imode,
+							const int &itype, const Real &rho,
+							const Real &wavef, KernelEm1DBase *Kernel);
+
+			// ====================  ACCESS        ============================
+
+			// ====================  INQUIRY       ============================
+
+			// ====================  DATA MEMBERS  ============================
+
+		protected:
+
+			// ====================  LIFECYCLE     ============================
+
+			/// Default protected constructor.
+			HankelTransformGaussianQuadrature (const std::string &name);
+
+            /// Default protected constructor.
+			~HankelTransformGaussianQuadrature ();
+
+            /**
+             * @copybrief LemmaObject::Release()
+             * @copydetails LemmaObject::Release()
+             */
+            void Release();
+
+			// ====================  OPERATIONS    ============================
+
+			/// Modified by Yoonho Song to branch cut, June, 1996
+			/// Separate Gaussian quarature integral by two interval
+			/// first:  integal from 0 to wavenumber of free space
+			/// second: integral from wavenunmber of free space to infinity
+			///         for large arguments, it uses continued fraction also
+			/// It is recommended to use nl = 1 to 6, nu =7
+			/// PERFORMS AUTOMATIC CALCULATION OF BESSEL TRANSFORM TO SPECIFIED
+			/// RELATIVportisheadE AND ABSOLUTE ERROR
+			///
+			/// ARGUMENT LIST:
+			///
+			/// BESR,BESI-REAL AND IMAGINARY PARTS RETURNED BY BESAUX
+			/// iorder-ORDER OF THE BESSEL FUNCTION
+			/// NL-LOWER LIMIT FOR GAUSS ORDER TO START COMPUTATION
+			/// NU-UPPER LIMIT FOR GAUSS ORDER
+			/// NU,NL=1,...7 SELECTS 3,7,15,31,63,127,AND 255 POINT GAUSS
+			/// QUADRATURE BETWEEN THE ZERO CROSSINGS OF THE BESSEL FUNCTION
+			/// R-ARGUMENT OF THE BESSEL FUNCTION
+			/// RERR,AERR-RELATIVE AND ABSOLUTE ERROR FOR TERMINATION
+			/// BESAUX TERMINATES WHEN INCREASING THE GAUSS ORDER DOES NOT
+			/// CHANGE THE RESULT BY MORE THAN RERR OR WHEN THE ABSOLUTE ERROR
+			/// IS LESS THAN AERR OR WHEN A GAUSS ORDER OF NU IS REACHED.
+			/// NPCS-NUMBER OF PIECES INTO WHICH EACH PARTIAL INTEGRAND
+			/// IS DIVIDED,
+			/// ORDINARILY SET TO ONE. FOR VERY SMALL VALUES OF R WHERE
+			/// THE KERNEL FUNCTION IS APPRECIABLE ONLY OVER THE FIRST FEW
+			/// LOOPS OF THE BESSEL FUNCTION, NPCS MAY BE INCREASED TO ACHIEVE
+			/// REASONABLE ACCURACY.
+			/// NEW  IF NEW=1, THE INTEGRANDS ARE COMPUTED AND SAVED AT EACH
+			/// GAUSS
+			/// ORDER. IF NEW=2, PREVIOUSLY COMPUTED INTEGRANDS ARE USED. NOTE
+			/// THAT ORDER,R, AND NPCS MUST NOT BE CHANGED WHEN SETTING NEW=2.
+			/// IERR-ERROR PARAMETER
+			/// IERR=0--NORMAL RETURN
+			/// IERR=1--RESULT NOT ACCURATE TO RERR DUE TO TOO LOW A GAUSS
+			///  ORDER OR CONVERGENCE NOT ACHIEVED IN BESTRX
+            //template <EMMODE T>
+			void Besautn(Real &besr, Real &besi, const int &iorder,
+							const int &nl, const int &nu, const Real &rho,
+							const Real &rerr, const Real &aerr,
+							const int &npcs, int &inew, const Real &aorb,
+							KernelEm1DBase *Kernel);
+
+			/// COMPUTES BESSEL TRANSFORM OF SPECIFIED ORDER DEFINED AS
+			/// INTEGRAL(FUNCT(X)*J-SUB-ORDER(X*R)*DX) FROM X=0 TO INFINITY
+			/// COMPUTATION IS ACHIEVED BY INTEGRATION BETWEEN THE ASYMPTOTIC
+			/// ZERO CROSSINGS OF THE BESSEL FUNCTION USING GAUSS QUADRATURE.
+			/// THE RESULTING SERIES OF PARTIAL INTEGRANDS IS SUMMED BY
+			/// CALCULATING THE PADE APPROXIMANTS TO SPEED UP CONVERGENCE.
+			/// ARGUMENT LIST:
+			/// BESR,BESI  REAL AND IMAGINARY PARTS RETURNED BY BESTRN
+			/// iorder  ORDER OF THE BESSEL FUNCTIONC  NG  NUMBER OF GAUSS
+			/// POINTS TO USE IN THE QUADRATURE ROUTINE.
+			/// NG=1 THROUGH 7 SELECTS 3,7,15,31,63,126,AND 255 TERMS.
+			///   R     ARGUMENT OF THE BESSEL FUNCTION
+			///   RERR,AERR  SPECIFIED RELATIVE AND ABSOLUTE ERROR FOR THE
+			///           CALCULATION.  THE INTEGRATION
+			///  TERMINATES WHEN AN ADDITIONAL TERM DOES NOT CHANGE THE
+			///  RESULT BY MORE THAN RERR*RESULT+AERR
+			///  NPCS  NUMBER OF PIECES INTO WHICH EACH PARTIAL I
+			///        NTEGRAND IS DIVIDED,
+			///        ORDINARILY SET TO ONE. FOR VERY SMALL VALUES OF RANGE
+			///        WHERE THE KERNEL FUNCTION IS APPRECIABLE ONLY OVER THE
+			///        FIRST FEW LOOPS OF THE BESSEL FUNCTION, NPCS MAY BE
+			///        INCREASED TO ACHIEVE REASONABLE ACCURACY. NOTE THAT
+			///        NPCS AFFECTS ONLY THE PADE
+			///        SUM PORTION OF THE INTEGRATION, OVER X(NSUM) TO INFINITY.
+			/// XSUM  VECTOR OF VALUES OF THE KERNEL ARGUMENT OF FUNCT FOR WHICH
+			/// EXPLICIT CALCULATION OF THE INTEGRAL IS DESIRED, SO THAT THE
+			/// INTEGRAL OVER 0 TO XSUM(NSUM) IS ADDED TO THE INTEGRAL OVER
+			/// XSUM(NSUM) TO INFINITY WITH THE PADE METHOD INVOKED ONLY FOR
+			/// THE LATTER. THIS ALLOWS THE PADE SUMMATION METHOD TO BE
+			/// OVERRIDDEN AND SOME TYPES OF SINGULARITIES TO BE HANDLED.
+			/// NSUM  NUMBER OF VALUES IN XSUM, MAY BE ZERO.
+			/// NEW   DETERMINES METHOD OF KERNEL CALCULATION
+			/// NEW=0 MEANS  CALCULATE BUT DO NOT SAVE INTEGRANDS
+			/// NEW=1 MEANS CALCULATE KERNEL BY CALLING FUNCT-SAVE KERNEL
+			///       TIMES BESSEL FUNCTION
+			/// NEW=2 MEANS USE SAVED KERNELS TIMES BESSEL FUNCTIONS IN
+			///       COMMON /BESINT/. NOTE THAT ORDER,R,NPCS,XSUM, AND
+			///       NSUM MAY NOT BE CHANGED WHEN SETTING NEW=2.
+			/// IERR  ERROR PARAMETER
+			///       0 NORMAL RETURN-INTEGRAL CONVERGED
+			///       1 MEANS NO CONVERGENCE AFTER NSTOP TERMS IN THE PADE SUM
+			///
+			/// SUBROUTINES REQUIRED:
+			/// BESQUD,PADECF,CF,ZEROJ,DOT,JBESS
+			///  A.CHAVE IGPP/UCSD
+			/// NTERM IS MAXIMUM NUMBER OF BESSEL FUNCTION LOOPS STORED IF
+			/// NEW.NE.0
+			/// NSTOP IS MAXIMUM Number of Pade terms
+            //template <EMMODE T>
+ 			void Bestrn( Real &BESR, Real &BESI, const int &iorder,
+ 					const int &NG, const Real &R,
+ 					const Real &RERR, const Real &AERR, const int &npcs,
+ 					VectorXi &XSUM, int &NSUM, int &NEW,
+ 					int &IERR, int &NCNTRL, const Real &AORB,
+					KernelEm1DBase *Kernel);
+
+			/// CALCULATES THE INTEGRAL OF F(X)*J-SUB-N(X*R) OVER THE
+			/// INTERVAL A TO B AT A SPECIFIED GAUSS ORDER THE RESULT IS
+			/// OBTAINED USING A SEQUENCE OF 1, 3, 7, 15, 31, 63, 127, AND 255
+			/// POINT INTERLACING GAUSS FORMULAE SO THAT NO INTEGRAND
+			/// EVALUATIONS ARE WASTED. THE KERNEL FUNCTIONS MAY BE
+			/// SAVED SO THAT BESSEL TRANSFORMS OF SIMILAR KERNELS ARE COMPUTED
+			/// WITHOUT NEW EVALUATION OF THE KERNEL.  DETAILS ON THE FORMULAE
+			/// ARE GIVEN IN 'THE OPTIMUM ADDITION OF POINTS TO QUADRATURE
+			/// FORMULAE' BY T.N.L. PATTERSON, MATHS.COMP. 22,847-856 (1968).
+			/// GAUSS WEIGHTS TAKEN FROM COMM. A.C.M. 16,694-699 (1973)
+			/// ARGUMENT LIST:
+			/// A      LOWER LIMIT OF INTEGRATION
+			/// B      UPPER LIMIT OF INTEGRATION
+			/// BESR,BESI RETURNED INTEGRAL VALUE REAL AND IMAGINARY PARTS
+			/// NG NUMBER OF POINTS IN THE GAUSS FORMULA.  NG=1,...7
+			///        SELECTS 3,7,15,31,63,127,AND 255 POINT QUADRATURE.
+			///  NEW SELECTS METHOD OF KERNEL EVALUATION
+			///    NEW=0 CALCULATES KERNELS BY CALLING F - NOTHING SAVED
+			///    NEW=1 CALCULATES KERNELS BY CALLING F AND SAVES KERNEL TIMES
+			///           BESSEL FUNCTION IN COMMON /BESINT/
+			///    NEW=2 USES SAVED KERNEL TIMES BESSEL FUNCTIONS IN
+			///           COMMON /BESINT/
+			/// iorder ORDER OF THE BESSEL FUNCTION
+			/// R    ARGUMENT OF THE BESSEL FUNCTION
+			/// F     F(X) IS THE EXTERNAL INTEGRAND SUBROUTINE
+			/// A.CHAVE IGPP/UCSDC
+			/// MAXIMUM NUMBER OF BESSEL FUNCTION LOOPS THAT CAN BE SAVED
+            //template <EMMODE T>
+			void Besqud(const Real &A, const Real &B, Real &BESR, Real &BESI,
+							const int &NG, const int &NEW, const int &iorder,
+							const Real &R, KernelEm1DBase *Kernel);
+
+			/// COMPUTES SUM(S(I)),I=1,...N BY COMPUTATION OF PADE APPROXIMANT
+			/// USING CONTINUED FRACTION EXPANSION.  FUNCTION IS DESIGNED TO BE
+			/// CALLED SEQUENTIALLY AS N IS INCREMENTED FROM 1 TO ITS FINAL
+			/// VALUE.  THE NTH CONTINUED FRACTION COEFFICIENT IS CALCULATED AND
+			/// STORED AND THE NTH CONVERGENT RETURNED.  IT IS UP TO THE USER TO
+			/// STOP THE CALCULATION WHEN THE DESIRED ACCURACY IS ACHIEVED.
+			/// ALGORITHM FROM HANGGI ET AL., Z.NATURFORSCH. 33A,402-417 (1977)
+			/// IN THEIR NOTATION, VECTORS CFCOR,CFCOI ARE LOWER CASE D,
+			/// VECTORS DR, DI ARE UPPER CASE D, VECTORS XR,XI ARE X, AND
+			/// VECTORS SR,SI ARE S
+			/// A.CHAVE IGPP/UCSD
+			void Padecf(Real &SUMR, Real &SUMI, const int &N);
+
+			/// EVALUATES A COMPLEX CONTINUED FRACTION BY RECURSIVE DIVISION
+			/// STARTING AT THE BOTTOM, AS USED BY PADECF
+			/// RESR,RESI ARE REAL AND IMAGINARY PARTS RETURNED
+			/// CFCOR,CFCOI ARE REAL AND IMAGINARY VECTORS OF CONTINUED FRACTION
+			/// COEFFICIENTS
+			void CF(        Real& RESR, Real &RESI,
+							Eigen::Matrix<Real, 100, 1> &CFCOR,
+							Eigen::Matrix<Real, 100, 1> &CFCOI,
+							const int &N);
+
+
+			/// COMPUTES ZERO OF BESSEL FUNCTION OF THE FIRST KIND FROM
+			/// MCMAHON'S ASYMPTOTIC EXPANSION
+			/// NZERO-NUMBER OF THE ZERO
+			/// iorder-ORDER OF THE BESSEL FUNCTION (0 OR 1)
+			Real ZeroJ(const int &ZERO, const int &IORDER);
+
+			/// COMPUTES BESSEL FUNCTION OF ORDER "ORDER" AND ARGUMENT X BY
+			/// CALLING NBS ROUTINES J0X AND J1X (REAL*8 BUT APPROXIMATELY
+			/// REAL*4 ACCURACY).
+			/// FOR MORE ACCURACY JBESS COULD BE CHANGED TO CALL, FOR EXAMPLE,
+			/// THE IMSL ROUTINES MMBSJ0,MMBSJ1 << SEE C// BELOW >>
+			Real Jbess(const Real &X, const int &IORDER);
+
+			/// COMPUTES DOT PRODUCT OF TWO D.P. VECTORS WITH NONUNIT
+			/// INCREMENTING ALLOWED. REPLACEMENT FOR BLAS SUBROUTINE SDOT.
+			/// Currently does no checking, kind of stupid.
+			/// The fortran version will wrap around if (inc*N) > X1.size()
+			/// but not in a nice way.
+			Real _dot(const int&N,
+				const Eigen::Matrix<Real, Eigen::Dynamic, Eigen::Dynamic> &X1,
+							const int &INC1,
+				const Eigen::Matrix<Real, Eigen::Dynamic, Eigen::Dynamic> &X2,
+				const int &INC2);
+
+			// ====================  DATA MEMBERS  ============================
+
+            static const Real PI2;
+			static const Real X01P;
+			static const Real XMAX;
+			static const Real XSMALL;
+			static const Real J0_X01;
+			static const Real J0_X02;
+			static const Real J0_X11;
+			static const Real J0_X12;
+			static const Real FUDGE;
+			static const Real FUDGEX;
+			static const Real TWOPI1;
+			static const Real TWOPI2;
+			static const Real RTPI2;
+			static const Real XMIN;
+			static const Real J1_X01;
+			static const Real J1_X02;
+			static const Real J1_X11;
+			static const Real J1_X12;
+
+			/// Highest gauss order used, Was NG
+			int HighestGaussOrder;
+
+			/// Total number of partial integrals on last call, was NI
+			int NumberPartialIntegrals;
+
+			/// Total number of function calls, was NF
+			int NumberFunctionEvals;
+
+			int          np;
+			int          nps;
+
+            /////////////////////////////////////////////////////////////
+			// Eigen members
+
+            // Shared constant values
+			static const VectorXr  WT;
+			static const VectorXr  WA;
+
+			Eigen::Matrix<int,  100, 1>    Nk;
+			//Eigen::Matrix<Real, 255, 100>  karg;
+			//Eigen::Matrix<Real, 510, 100>  kern;
+			Eigen::Matrix<Real, Eigen::Dynamic, Eigen::Dynamic>  karg;
+			Eigen::Matrix<Real, Eigen::Dynamic, Eigen::Dynamic>  kern;
+
+			// Was Besval COMMON block
+			Eigen::Matrix<Real, 100, 1> Xr;
+			Eigen::Matrix<Real, 100, 1> Xi;
+			Eigen::Matrix<Real, 100, 1> Dr;
+			Eigen::Matrix<Real, 100, 1> Di;
+			Eigen::Matrix<Real, 100, 1> Sr;
+			Eigen::Matrix<Real, 100, 1> Si;
+			Eigen::Matrix<Real, 100, 1> Cfcor;
+			Eigen::Matrix<Real, 100, 1> Cfcoi;
+
+		private:
+
+	}; // -----  end of class  HankelTransformGaussianQuadrature  -----
+
+    //////////////////////////////////////////////////////////////
+    // Exception Classes
+
+    /** If the lower integration limit is greater than the upper limit, throw this
+     * error.
+     */
+    class LowerGaussLimitGreaterThanUpperGaussLimit :
+        public std::runtime_error {
+        /** Thrown when the LowerGaussLimit is greater than the upper limit.
+         */
+        public: LowerGaussLimitGreaterThanUpperGaussLimit();
+    };
+
+}	   // -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef _HANKELTRANSFORMGAUSSIANQUADRATURE_h_INC  -----

LemmaCore/include/hankeltransformhankel2.h

@@ -0,0 +1,246 @@
+/* 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     06/26/2009
+  @version  $Id: hankeltransformhankel2.h 201 2015-01-03 00:07:47Z tirons $
+ **/
+
+#ifndef __HANKEL2_H
+#define __HANKEL2_H
+
+#include "hankeltransform.h"
+#include "kernelem1dbase.h"
+#include "kernelem1dspec.h"
+#include "CubicSplineInterpolator.h"
+
+namespace Lemma {
+
+// ==========================================================================
+//        Class:  Hankel2
+/** \brief   Computes the Hankel transform of orders 0 and 1 using lagged
+             and related convolutions.
+    \details A rewrite of work by Anderson who wrote a FORTRAN program
+             that he released while working at the USGS.
+             The  transform evaluates an integral of the form:
+             \f[ \int_0^\infty K(\lambda) J_I (\lambda r) ~ d \lambda
+             \f]
+             Where \f$ K(\lambda) \f$ is some kernel function. The value
+             \f$ J_I \f$ is the Bessel function of order
+             \f$I, I \in \{0,1\} \f$
+             The kernel function is unique for each source and is computed
+             in the class CalculateKernel. The value \f$r\f$ is the radial
+             distance away from the centre of the grid \f$ r=\sqrt{x^2 + y^2} \f$
+             The Hankel transform is useful as it allows a double fourier
+             transform to be written as a single integral:
+             \f[ \mathop {\int \!\!\! \int}_{\!\!\!\!\!-\infty}^{\,\,\infty}
+             F(k_x^2 + k_y^2)
+                 e^{\imath (k_x x + k_y y)} dk_x \, dk_y = 2 \pi
+                 \int_0^\infty K(\lambda) J_I (\lambda r) ~ d \lambda
+             \f]
+             This can only be done where there is radial symmetry. Hence
+             its application to 1D solutions here.
+ */
+// ==========================================================================
+
+class Hankel2 : public HankelTransform {
+
+    friend std::ostream &operator<<(std::ostream &stream, const Hankel2 &ob);
+
+    public:
+
+        // ====================  LIFECYCLE     ==============================
+        /**
+         *  Returns pointer to new Hankel2. Location is
+         *  initialized to (0,0,0) type and polarization are
+         *  initialized  to nonworking values that will throw
+         *  exceptions if used.
+         */
+        static Hankel2 *New();
+
+        /**
+         * @copybrief LemmaObject::Delete()
+         * @copydetails LemmaObject::Delete()
+         */
+        void Delete();
+
+        // ====================  OPERATORS     ==============================
+
+        // ====================  OPERATIONS    ==============================
+
+        /// Sets the number of convolutions
+        void SetNumConv(const int &i);
+
+        /// Computes the hankel transform with arguments
+        /// @param rho [input] rho is the hankel transform argument
+        /// @param ntol [input] ntol is
+        /// @param tol [input] tol is
+        void Compute(const Real &rho, const int& ntol, const Real &tol);
+
+        /// Computes the related
+        void ComputeRelated(const Real &rho, KernelEm1DBase* Kernel);
+
+        /// Computes the related
+        void ComputeRelated(const Real &rho,  std::vector< KernelEm1DBase* > KernelVec);
+
+        /// Computes the related
+        void ComputeRelated(const Real &rho,  KernelEM1DManager* Manager);
+
+        /// Computes the related and lagged convolutions
+        void ComputeLaggedRelated(const Real &rho, const int& nlag,  KernelEM1DManager* Manager);
+
+        // ====================  ACCESS        ==============================
+
+        /// Returns the answer
+        Eigen::Matrix<Complex, Eigen::Dynamic, Eigen::Dynamic>  GetAnswer();
+
+        /// Returns the arguments for lagged convolutions
+        VectorXr GetArg() {return Arg;};
+
+        /// Returns the value of Abscissa stepping
+        Real GetABSER( ) { return ABSER; };
+
+        /// Sets the lagged kernel index so that the proper value is returned
+        void SetLaggedArg(const Real& rho);
+
+
+        // ====================  INQUIRY       ==============================
+
+        /// Calculates Hankel Transform using filtering.
+        /// ikk:   type of kernel depending on source and receiver couple
+        /// imode: a switch for TE(0) and TM(1) mode
+        /// itype: order of Bessel function
+        /// rho is argument to integral
+        /// wavef is the propogation constant of free space
+        /// = omega * sqrt( EP*AMU )  amu = 4 pi e-7  ep = 8.85e-12
+        Complex Zgauss(const int &ikk, const EMMODE &imode,
+                        const int &itype, const Real &rho,
+                        const Real &wavef, KernelEm1DBase *Kernel);
+
+    protected:
+
+        // ====================  LIFECYCLE     ==============================
+
+        /** A rewrite of Anderson's Pseudo-subroutine. */
+        inline void StoreRetreive(const int &idx, const int &lag,
+                        Complex &Zsum, const int &irel, Complex &C, const Real& rho0) {
+
+            int look = idx+lag;
+    		int	iq = look/801;
+    		int	ir = look%801;
+    		int iroll = iq*800;
+
+    		if(this->Key[ir] <= iroll) {
+			    this->Key[ir] = iroll + ir;
+ 	    		++this->NumFun;
+                Manager->ComputeReflectionCoeffs(this->Lambda, idx, rho0);
+ 			    for (unsigned int ir2=0; ir2<this->kernelVec.size(); ++ir2) {
+ 			        this->Zwork(ir, ir2) = this->kernelVec[ir2]->RelBesselArg(this->Lambda);
+ 			    }
+		    }
+
+		    C = this->Zwork(ir, irel) * this->FilterWeights(this->BesselOrder, idx);
+		    Zsum += C;
+		    return;
+	    }
+
+        /// Default protected constructor
+        Hankel2(const std::string& name);
+
+        /// Default protected destructor
+        ~Hankel2();
+
+        /**
+         * @copybrief LemmaObject::Release()
+         * @copydetails LemmaObject::Release()
+         */
+        void Release();
+
+        // ====================  OPERATIONS    ==============================
+
+        void DeleteSplines();
+
+        // ====================  DATA MEMBERS  ==============================
+
+        /// The hankel transform wavenumber embedded in the integral
+        Real Lambda;
+
+        /// Number of times a kernel was evaluated
+        int NumFun;
+
+        /// Number of lagged convolutions
+        /// must be greater or equal to 1
+        /// It is set automatically in the @see Compute function so
+        /// that  \f$ \rho \exp\left( -.1*(\mathtt{NumConv} -1) \right) \f$
+        /// does not underflow the exponent range
+        int NumConv;
+
+        /// Number of related kernels
+        int NumRel;
+
+        /** Bessel transform order to use */
+        int BesselOrder;
+
+        /** Lag argument */
+        int iLag;
+
+        /* Should results be cached? Useful for repeated calculations of few receiver points */
+        // turned out to have only marginal benefits in best case, and awful consequences in many
+        //bool cacheResults;
+
+        /** Related Kernel Manager */
+        KernelEM1DManager*          Manager;
+
+        /// Used as base for filter abscissa generation
+        static const Real ABSCISSA;
+
+        /// Also used in abscissa generation \f$ ABSE = \exp{.1} \f$
+        static const Real ABSE;
+
+        /// Also used in abscissa generation \f$ ABSER = 1 / \exp{.1} \f$
+        static const Real ABSER;
+
+        /// Counter for calculated
+        int icount;
+
+        /// Kernel Calculator
+        std::vector <KernelEm1DBase*> kernelVec;
+
+        /// Spines for lagged convolutions (real part)
+        std::vector <CubicSplineInterpolator*> splineVecReal;
+
+        /// Spines for lagged convolutions (imaginary part)
+        std::vector <CubicSplineInterpolator*> splineVecImag;
+
+        /// Key used internally
+        Eigen::Matrix<int, 801, 1> Key;
+        //int  Key[801];
+        //Eigen::Matrix<int, Eigen::Dynamic, 1> Key;
+
+        /// Filter weight coefficients. Set for either \f$J_0\f$ or \f$J_1\f$
+        /// internally by protected function SetFilterWeights.
+        /// Fixed sized will yield better performance. (not necessarily)
+        //Eigen::Matrix<Real, 801, 1> FilterWeights;
+        static const Eigen::Matrix<Real, 2, 801> FilterWeights;
+        //static const Eigen::Matrix<Real, Eigen::Dynamic, Eigen::Dynamic> FilterWeights;
+
+        /// Zwork from Anderson
+        Eigen::Matrix<Complex, 801, Eigen::Dynamic> Zwork;
+        //Eigen::Matrix<Complex, Eigen::Dynamic, Eigen::Dynamic> Zwork;
+
+        /// Holds answer, dimensions are NumConv, and NumberRelated.
+        Eigen::Matrix<Complex, Eigen::Dynamic, Eigen::Dynamic> Zans;
+
+        /// Holds the arguments for lagged convolutions
+        VectorXr Arg;
+
+}; // -----  end of class  HankelTransform  -----
+
+}
+
+#endif // __HANKEL2_h

LemmaCore/include/helper.h

@@ -0,0 +1,277 @@
+/* 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/02/2014 02:49:55 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
+ */
+
+#pragma once
+
+#ifndef  HELPER_INC
+#define  HELPER_INC
+
+#include "lemma.h"
+
+#ifdef HAVE_YAMLCPP
+#include "yaml-cpp/yaml.h"
+#endif
+
+namespace Lemma {
+
+    template <class T>
+    inline std::string to_string (const T& t) {
+        std::stringstream ss;
+        ss << t;
+        return ss.str();
+    }
+
+
+    // handy little way to convert enums, saves repeated code useful for YAML serializing
+    std::string enum2String(const FREQUENCYUNITS& Units);
+    std::string enum2String(const TIMEUNITS& Units);
+    std::string enum2String(const MAGUNITS& Units);
+    std::string enum2String(const TEMPUNITS& Units);
+    std::string enum2String(const FEMCOILORIENTATION& Units);
+    std::string enum2String(const ORIENTATION& Units);
+    std::string enum2String(const FIELDCOMPONENT& Comp);
+    std::string enum2String(const HANKELTRANSFORMTYPE& Htype);
+    std::string enum2String(const FIELDCALCULATIONS& Htype);
+
+    // other way around is a template, where template argument lets us know
+    // which specialisation to use.
+    template <typename T>
+    T string2Enum( const std::string& str );
+
+    // Handy little class that indents a stream.
+    // Based on solution provided here, todo may need to add to some managing class which keeps
+    // track of nesting levels? But perhaps not. A Lemma class will contain pointers to other Lemma
+    // classes. But those are not specifically listed out.
+    // http://stackoverflow.com/questions/9599807/how-to-add-indention-to-the-stream-operator
+    class IndentingOStreambuf : public std::streambuf {
+        std::streambuf*     myDest;
+        bool                myIsAtStartOfLine;
+        std::string         myIndent;
+        std::ostream*       myOwner;
+    protected:
+        virtual int         overflow( int ch )
+        {
+            if ( myIsAtStartOfLine && ch != '\n' ) {
+                myDest->sputn( myIndent.data(), myIndent.size() );
+            }
+            myIsAtStartOfLine = ch == '\n';
+            return myDest->sputc( ch );
+        }
+    public:
+        explicit            IndentingOStreambuf(
+                                std::streambuf* dest, int indent = 4 )
+            : myDest( dest )
+            , myIsAtStartOfLine( true )
+            , myIndent( indent, ' ' )
+            , myOwner( NULL )
+        {
+        }
+        explicit            IndentingOStreambuf(
+                                std::ostream& dest, int indent = 4 )
+            : myDest( dest.rdbuf() )
+            , myIsAtStartOfLine( true )
+            , myIndent( indent, ' ' )
+            , myOwner( &dest )
+        {
+            myOwner->rdbuf( this );
+        }
+        virtual             ~IndentingOStreambuf()
+        {
+            if ( myOwner != NULL ) {
+                myOwner->rdbuf( myDest );
+            }
+        }
+    };
+
+
+} // end namespace Lemma
+
+#ifdef HAVE_YAMLCPP
+
+///////////////////////////////////////////////////////
+// YAML Serializing helper functions. Can we move this into helper.h
+namespace YAML {
+
+template<>
+struct convert<Lemma::Complex> {
+  static Node encode(const Lemma::Complex& rhs) {
+    Node node;
+    node["real"] = rhs.real();
+    node["imag"] = rhs.imag();
+
+    // No labels
+    //node.push_back(rhs.real());
+    //node.push_back(rhs.imag());
+
+    node.SetTag( "Complex" ); // too verbose?
+    return node;
+  }
+
+  static bool decode(const Node& node, Lemma::Complex& rhs) {
+    // Disabled due to overly verbose output. Just believe...
+    if( node.Tag() != "Complex" ) {
+        return false;
+    }
+    rhs = Lemma::Complex( node["real"].as<Lemma::Real>(), node["imag"].as<Lemma::Real>()  );
+    // no label style
+    //rhs = Lemma::Complex( node[0].as<Lemma::Real>(), node[1].as<Lemma::Real>()  );
+    return true;
+  }
+
+};
+
+template<>
+struct convert<Lemma::Vector3Xr> {
+  static Node encode(const Lemma::Vector3Xr& rhs) {
+    Node node;
+    node["size"] = rhs.cols();
+    //node["rows"] = rhs.rows(); // == 3
+    for (int ic=0; ic<rhs.cols(); ++ic) {
+        node[ic].push_back( rhs(0, ic) );
+        node[ic].push_back( rhs(1, ic) );
+        node[ic].push_back( rhs(2, ic) );
+    }
+    node.SetTag( "Vector3Xr" );
+    return node;
+  }
+
+  static bool decode(const Node& node, Lemma::Vector3Xr& rhs) {
+    if( node.Tag() != "Vector3Xr" ) {
+        return false;
+    }
+    rhs.resize( Eigen::NoChange, node["size"].as<int>() );
+    for (unsigned int ic=0; ic<node.size(); ++ic) {
+        int ir=0;
+        for(YAML::const_iterator it=node[ic].begin();it!=node[ic].end();++it) {
+            rhs(ir, ic) = it->as<Lemma::Real>();
+            ++ir;
+        }
+    }
+    return true;
+  }
+};
+
+template<>
+struct convert<Lemma::VectorXr> {
+  static Node encode(const Lemma::VectorXr& rhs) {
+    Node node;
+    node["size"] = rhs.size();
+    for (int ic=0; ic<rhs.size(); ++ic) {
+        node["data"].push_back( rhs(ic) );
+    }
+    node.SetTag( "VectorXr" );
+    return node;
+  }
+
+  static bool decode(const Node& node, Lemma::VectorXr& rhs) {
+    if( node.Tag() != "VectorXr" ) {
+        return false;
+    }
+    rhs.resize( node["size"].as<int>() );
+    int ir=0;
+    for(YAML::const_iterator it=node["data"].begin(); it!=node["data"].end(); ++it) {
+        rhs(ir) = it->as<Lemma::Real>();
+        ++ir;
+    }
+    return true;
+  }
+};
+
+template<>
+struct convert<Lemma::VectorXcr> {
+  static Node encode(const Lemma::VectorXcr& rhs) {
+    Node node;
+    node["size"] = rhs.size();
+    for (int ic=0; ic<rhs.size(); ++ic) {
+        node["data"].push_back( rhs(ic) );
+    }
+    node.SetTag( "VectorXcr" );
+    return node;
+  }
+
+  static bool decode(const Node& node, Lemma::VectorXcr& rhs) {
+    if( node.Tag() != "VectorXcr" ) {
+        return false;
+    }
+    rhs.resize( node["size"].as<int>() );
+    int ir=0;
+    for(YAML::const_iterator it=node["data"].begin(); it!=node["data"].end(); ++it) {
+        rhs(ir) = it->as<Lemma::Complex>();
+        ++ir;
+    }
+    return true;
+  }
+};
+
+
+template<>
+struct convert<Lemma::VectorXi> {
+  static Node encode(const Lemma::VectorXi& rhs) {
+    Node node;
+    node["size"] = rhs.size();
+    for (int ic=0; ic<rhs.size(); ++ic) {
+        node["data"].push_back( rhs(ic) );
+    }
+    node.SetTag( "VectorXi" );
+    return node;
+  }
+
+  static bool decode(const Node& node, Lemma::VectorXi& rhs) {
+    if( node.Tag() != "VectorXi" ) {
+        return false;
+    }
+    rhs.resize( node["size"].as<int>() );
+    int ir=0;
+    for(YAML::const_iterator it=node["data"].begin(); it!=node["data"].end(); ++it) {
+        rhs(ir) = it->as<int>();
+        ++ir;
+    }
+    return true;
+  }
+};
+
+template<>
+struct convert<Lemma::Vector3r> {
+  static Node encode(const Lemma::Vector3r& rhs) {
+    Node node;
+    for (int ic=0; ic<rhs.size(); ++ic) {
+        node[0].push_back( rhs(ic) );
+    }
+    node.SetTag( "Vector3r" );
+    return node;
+  }
+
+  static bool decode(const Node& node, Lemma::Vector3r& rhs) {
+    if( node.Tag() != "Vector3r" ) {
+        return false;
+    }
+    int ir=0;
+    for(YAML::const_iterator it=node[0].begin(); it!=node[0].end(); ++it) {
+        rhs(ir) = it->as<Lemma::Real>();
+        ++ir;
+    }
+    return true;
+  }
+};
+
+}
+#endif //HAVE_YAMLCPP
+
+#endif   // ----- #ifndef HELPER_INC  -----
+

LemmaCore/include/instrument.h

@@ -0,0 +1,62 @@
+/* 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     02/05/2010
+  @version  $Id: instrument.h 193 2014-11-10 23:51:41Z tirons $
+ **/
+
+#ifndef __INSTRUMENT_H
+#define __INSTRUMENT_H
+
+#include "LemmaObject.h"
+
+namespace Lemma {
+
+	// =======================================================================
+	//        Class:  Instrument
+	/// \brief    Abstract class for instruments
+	/// \details
+	// =======================================================================
+	class Instrument : public LemmaObject {
+
+		friend std::ostream &operator<<(std::ostream &stream,
+			const Instrument &ob);
+
+		public:
+
+			// ====================  LIFECYCLE     ===========================
+
+			// ====================  OPERATORS     ===========================
+
+			// ====================  OPERATIONS    ===========================
+            //virtual void ForwardModelOnOctreeMesh()=0;
+
+			// ====================  ACCESS        ===========================
+
+			// ====================  INQUIRY       ===========================
+
+			// ====================  DATA MEMBERS  ===========================
+
+		protected:
+
+			// ====================  LIFECYCLE     ===========================
+
+			/// Default protected constructor.
+			Instrument (const std::string &name);
+
+			/// Default protected constructor.
+			~Instrument ();
+
+		private:
+
+	}; // -----  end of class  Instrument  -----
+
+}		// -----  end of Lemma  name  -----
+
+#endif // __INSTRUMENT_H

LemmaCore/include/instrumentfem.h

@@ -0,0 +1,144 @@
+/* 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   M. Andy Kass
+  @date     01/14/2013
+  @version  $Id$
+ **/
+
+#ifndef __INSTRUMENTFEM_H
+#define __INSTRUMENTFEM_H
+
+#include "instrument.h"
+#include "emearth1d.h"
+#include "WireAntenna.h"
+#include "PolygonalWireAntenna.h"
+#include "receiverpoints.h"
+#include "dipolesource.h"
+#include "layeredearthem.h"
+#include "datafem.h"
+
+namespace Lemma {
+
+// ===================================================================
+//        Class:  InstrumentFem
+/// \brief
+/// \details
+// ===================================================================
+	class InstrumentFem : public Instrument {
+		friend std::ostream &operator<<(std::ostream &stream,
+			const InstrumentFem &ob);
+
+
+	public:
+
+	// ====================  LIFECYCLE     =======================
+
+		static InstrumentFem* New();
+
+		void Delete();
+
+	// ====================  OPERATORS     =======================
+
+	// ====================  OPERATIONS    =======================
+
+		/// Make the forward model calculation
+		void MakeCalculation();
+
+		/// Forward model from a vector of inputs
+		void ForwardModelProfile();
+
+	// ====================  ACCESS        =======================
+	//
+		/// Set layered earth model
+		void EMEarthModel(LayeredEarthEM* Earth);
+
+		/// Set dipole source
+		void SetDipoleSource(DipoleSource* dipolesource);
+
+		/// Set Field Points
+		void SetReceiverPoints(ReceiverPoints* receiver);
+
+		/// Copy parameters from data object
+		void AlignWithData(DataFEM* inpdata);
+
+		/// Set a data object for output
+		void SetOutputData(DataFEM* outputdata);
+
+
+
+	// ====================  INQUIRY       =======================
+
+
+	protected:
+
+	// ====================  LIFECYCLE     =======================
+
+		/// Default protected constructor.
+		InstrumentFem (const std::string &name);
+
+		/// Default protected constructor.
+		~InstrumentFem ();
+
+		void Release();
+
+	// ====================  DATA MEMBERS  =========================
+
+	LayeredEarthEM* EarthModel;
+
+	DipoleSource* Dipole;
+
+	ReceiverPoints* Receiver;
+
+	DataFEM* InputData;
+
+	DataFEM* OutputData;
+
+	/// Vector of dipole sources - may be superceded by boost
+	std::vector<DipoleSource*> Transmitters;
+
+	/// Vector of receivers - may be superceded by boost
+	/// not necessary--one set of receivers for all dipoles,
+	/// except the number of frequencies is built into the receiver
+	std::vector<ReceiverPoints*> Receivers;
+
+	/// Vector of Earth Models - may be superceded by boost
+	//std::vector<LayeredEarthEM*> EarthModels;
+
+	/// Number of frequencies
+	int nFreq;
+
+	/// Number of observation locations
+	int nObs;
+
+	/// Array of frequencies
+	VectorXr freq;
+
+	/// Position vector, with z as height above the ground surface (pos)
+	Vector3Xr xyz;
+
+	/// Array of Tx orientations (x,y,z) for each freq
+	Eigen::Matrix<ORIENTATION,Eigen::Dynamic,1> TxOrientation;
+
+	/// Array of Rx orientations (x,y,z) for each freq
+	Eigen::Matrix<ORIENTATION,Eigen::Dynamic,1> RxOrientation;
+
+	/// Transmitter moments, one for each frequency
+	VectorXr TxMom;
+
+	/// Tx/Rx Separation in local, right hand system with x aligned with flight
+	Vector3Xr TxRxSep;
+
+	/// Scale factor as described in EM1DFM manual
+	VectorXr ScaleFac;
+
+	private:
+
+}; // -----  end of class  InstrumentFem  -----
+} // end of namespace Lemma
+#endif

LemmaCore/include/instrumenttem.h

@@ -0,0 +1,213 @@
+/* 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   M. Andy Kass
+  @date     02/10/2011
+  @version  $Id: instrumenttem.h 201 2015-01-03 00:07:47Z tirons $
+ **/
+
+#ifndef __INSTRUMENTTEM_H
+#define __INSTRUMENTTEM_H
+
+#include "instrument.h"
+#include "emearth1d.h"
+#include "WireAntenna.h"
+#include "PolygonalWireAntenna.h"
+#include "receiverpoints.h"
+#include "dipolesource.h"
+#include "layeredearthem.h"
+#include "digitalfiltercostrans.h"
+#include "digitalfiltersintrans.h"
+#include "temintegrationkernel.h"
+#include "CubicSplineInterpolator.h"
+
+namespace Lemma {
+
+enum ReceiverType { INDUCTIVE, MAGNETOMETER, ELECTRIC };
+
+// ===================================================================
+//        Class:  InstrumentTem
+/// \brief  TEM Instrument Class
+/// \details Provides utility to forward model TEM data in Lemma.
+// ===================================================================
+class InstrumentTem : public Instrument {
+
+	friend std::ostream &operator<<(std::ostream &stream,
+		const InstrumentTem &ob);
+
+	public:
+
+	// ====================  LIFECYCLE     =======================
+
+		static InstrumentTem* New();
+
+		void Delete();
+
+	// ====================  OPERATORS     =======================
+
+	// ====================  OPERATIONS    =======================
+
+		/// Perform the forward model calculation
+		void MakeDirectCalculation( const HANKELTRANSFORMTYPE& hType );
+
+        /** Perform the forward model calculation, use lagged convolutions to
+         *  speed up the calculations
+         */
+		void MakeLaggedCalculation( const HANKELTRANSFORMTYPE& hType );
+
+	// ====================  ACCESS        =======================
+
+		/** Sets pulse parameters as a linearly segmented graph, so
+         *  for example a triangle wave needs three points in Amps and
+         *  times, a trapazoidal needs for. The pulse is assumed (defaults) to be
+         *  bipolar, only the positive polarity should be specified.
+         *  @param[in] Amp is the waveform current in Amps
+         *  @param[in] times are the abscissa values of the waveform
+         *  @param[in] bipolar specifies whether or not the pulse is bipolar
+         */
+		void SetPulse( const VectorXr& Amp, const VectorXr& times, bool bipolar=true );
+
+		/// Sets layered earth model
+		void EMEarthModel(LayeredEarthEM* Earth);
+
+		/// Sets transmitter parameters
+		void SetTransmitLoop(WireAntenna *antennae);
+
+		/// Sets dipole source parameters
+		void SetDipoleSource(DipoleSource* dipolesource);
+
+		/// Sets receiver points and parameters
+		void SetReceiver(ReceiverPoints* Receivers);
+
+        /** Sets the type of receiver/measurement
+         */
+        void SetReceiverType( const ReceiverType& rtype  );
+
+		/// Return calculated data
+		MatrixXr GetMeasurements();
+
+		/**
+            Set time gates, assumes gates widths are delta (instantaneous)
+            @param[in] times gate centres units are in seconds
+         */
+
+		void SetTimes(const VectorXr &times);
+
+        /** Sets time gates centres and widths, both in seconds. The window is assumed to be
+         *  a simple boxcar. Simpson's rule is used to integrate the response
+         * @param[in] times gate centres units are in seconds
+         * @param[in] widths gate widths units are in seconds
+         */
+        void SetTimeGates(const VectorXr &centres, const VectorXr& widths);
+
+		/// Get number of times
+		int GetNumberOfTimes();
+
+        /** Sets reference time for time gate to pulse time offset.
+         */
+        void SetReferenceTime(const Real& RefTime);
+
+		/// Attach EMEarth1D
+		//void AttachEMEarth1D(EMEarth1D *EMEarth);
+
+	// ====================  INQUIRY       =======================
+
+
+
+	protected:
+
+	// ====================  LIFECYCLE     =======================
+
+		/// Default protected constructor.
+		InstrumentTem (const std::string &name);
+
+		/// Default protected constructor.
+		~InstrumentTem ();
+
+		void Release();
+
+    // ====================  OPERATIONS    =======================
+
+        /**
+         *  Converts impulse B response (step db/dt) into inductive db/dt
+         *  response for general waveform.
+         */
+        void FoldAndConvolve( CubicSplineInterpolator* Spline );
+
+        /** Convolves the transmitter waveform(s), takes the impulse response
+            and uses simpson's rule to evaluate the integral.
+            @param[in] Spline is the Cubic Spline object representing the solution.
+            @param[in] t is the evaluation time.
+         */
+        Real ConvolveWaveform( CubicSplineInterpolator* Spline, const Real& t );
+
+        /** Subtracts previous waveform(s) from current impulse response, and re-splines.
+         */
+        void SubtractPrevious( CubicSplineInterpolator* Spline );
+
+
+	// ====================  DATA MEMBERS  =========================
+
+		//EMEarth1D* EmEarth;
+
+		WireAntenna* Antenna;
+
+		ReceiverPoints* Receiver;
+
+		LayeredEarthEM* EarthMod;
+
+		DipoleSource* Dipole;
+
+        bool     bipolarWaveform;
+
+        /** Number of previous pules to model */
+        int      NPreviousPulse;
+
+        /** Reference time (relative to pulse abscissa) for time gates */
+        Real     RefTime;
+
+        /** Pulse period, if bimodal 1/2 repitition period */
+        Real     PulseT;
+
+        /** Transmitter repitition frequency */
+        Real     TxFreq;
+
+        /** Receiver type */
+        ReceiverType  RType;
+
+        MatrixXr ModelledData;
+
+        /** Centre of time gate */
+		VectorXr TimeGates;
+
+        /** Width of time gates */
+        VectorXr GateWidths;
+
+        /** Pulse waveform */
+        VectorXr Waveform;
+
+        /** Current Amplitude of pulse */
+        VectorXr  TxAmp;
+
+        /** Current -delta of pulse */
+        VectorXr  TxDelta;
+
+        /** Current derivative of pulse */
+        VectorXr  TxDiff;
+
+        /** times associated with TxAmp segments */
+        VectorXr  TxAbs;
+
+	private:
+
+}; // -----  end of class  InstrumentTem  -----
+
+} // End of namespace Lemma
+
+#endif // __TEMINSTRUMENT_H
+

LemmaCore/include/integrationkernel.h

@@ -0,0 +1,92 @@
+/* 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     02/07/2011
+  @version  $Id: integrationkernel.h 193 2014-11-10 23:51:41Z tirons $
+ **/
+
+#ifndef  INTEGRATIONKERNEL_INC
+#define  INTEGRATIONKERNEL_INC
+
+#include "LemmaObject.h"
+
+namespace Lemma {
+
+    // ===================================================================
+    //  Class:  IntegrationKernel
+    /**
+      @class
+      \brief    Abstract class that computes arguments for numerical
+                integrators.
+      \details  Needs to provide Argument function, as well as be able to
+                set necessary integration parameters.
+     */
+    // ===================================================================
+    template <typename T>
+    class IntegrationKernel : public LemmaObject {
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+
+
+            // ====================  OPERATORS     =======================
+
+            // ====================  OPERATIONS    =======================
+
+            /** Returns the argument of a function at a given argument. Also
+             *  capable or returning related function values.
+             */
+            //template <typename T>
+            virtual T Argument(const Real& x, const int& iRelated)=0;
+
+            // ====================  ACCESS        =======================
+
+            // ====================  INQUIRY       =======================
+
+            virtual int GetNumRel()=0;
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /// Default protected constructor.
+            IntegrationKernel (const std::string& name);
+
+            /// Default protected constructor.
+            ~IntegrationKernel ();
+
+            // ====================  DATA MEMBERS  =========================
+
+        private:
+
+    }; // -----  end of class  IntegrationKernel  -----
+
+    template <typename T>
+    IntegrationKernel<T>::IntegrationKernel(const std::string& name) :
+        LemmaObject(name) {
+    }
+
+    template<typename T>
+    IntegrationKernel<T>::~IntegrationKernel( ) {
+    }
+
+//     template <typename T>
+//     T IntegrationKernel<T>::Argument(const Real& x, const int& iRelated) {
+//         return 11.;
+//     }
+//
+//     template <typename T>
+//     int IntegrationKernel<T>::GetNumRel( ) {
+//         return 0;
+//     }
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef INTEGRATIONKERNEL_INC  -----

LemmaCore/include/integrator.h

@@ -0,0 +1,66 @@
+/* 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     02/07/2011
+  @version  $Id: integrator.h 193 2014-11-10 23:51:41Z tirons $
+ **/
+
+#ifndef  INTEGRATOR_INC
+#define  INTEGRATOR_INC
+
+#include "LemmaObject.h"
+
+namespace Lemma {
+
+    // ===================================================================
+    //  Class:  Integrator
+    /**
+      @class
+      \brief
+      \details
+     */
+    // ===================================================================
+    class Integrator : public LemmaObject {
+
+        /// Prints out basic info about the class
+        friend std::ostream &operator<<(std::ostream &stream,
+                        const Integrator &ob);
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+
+            // ====================  OPERATORS     =======================
+
+            // ====================  OPERATIONS    =======================
+
+            // ====================  ACCESS        =======================
+
+            // ====================  INQUIRY       =======================
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /// Default protected constructor.
+            Integrator (const std::string& name);
+
+            /// Default protected constructor.
+            ~Integrator ();
+
+            // ====================  DATA MEMBERS  =========================
+
+        private:
+
+    }; // -----  end of class  Integrator  -----
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef INTEGRATOR_INC  -----
+

LemmaCore/include/inversesolver.h

@@ -0,0 +1,118 @@
+/* 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     07/14/2010
+  @version  $Id: inversesolver.h 193 2014-11-10 23:51:41Z tirons $
+ **/
+
+#ifndef  INVERSESOLVER_H_INC
+#define  INVERSESOLVER_H_INC
+
+#include "LemmaObject.h"
+#include "data.h"
+#include "instrument.h"
+#include "octreegrid.h"
+
+namespace Lemma {
+
+
+    // ===================================================================
+    //  Class:  InverseSolver
+    /**
+      @class  InverseSolver
+      \brief   Abstract class for inverse problem solver.
+      \details General solution of inverse problems.
+     */
+    // ===================================================================
+    class InverseSolver : public LemmaObject {
+
+        friend  std::ostream &operator<<(std::ostream &stream,
+                const InverseSolver &ob);
+
+        friend class OctreeGrid;
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+
+            // ====================  OPERATORS     =======================
+
+            // ====================  OPERATIONS    =======================
+
+            // ====================  ACCESS        =======================
+
+            /** @brief Sets the obsered data, any instance of Data.
+             *  @details This may either be field data, or forward modelled
+             *  data.
+             *  @param[in] ObsData a pointer to the observed data class.
+             */
+            void SetObservedData(Data* ObsData);
+
+            /** @brief Sets the instument that is used to create the data.
+             *  @details This is used for all forward modelling.
+             *  @param[in] inst is a pointer to the instrument class.
+             */
+            void SetInstrument(Instrument* inst);
+
+            /** @brief Returns the predicted data.
+             *  @return a pointer to the predicted data.
+             */
+            Data* GetPredictedData();
+
+            // ====================  INQUIRY       =======================
+
+            /** Returns the number of iterations it took to converge to a
+             *  solution.
+             */
+            virtual int NumberOfIterations()=0;
+
+            /** Returns true if the inversion converged successfully.
+             */
+            virtual bool Success()=0;
+
+            /** Returns a vector of \f$ \phi_M \f$
+             */
+            virtual VectorXr GetPhiMVector()=0;
+
+            /** Returns a vector of \f$ \phi_D \f$
+             */
+            virtual VectorXr GetPhiDVector()=0;
+
+        protected:
+
+            // ====================  OPERATIONS    =======================
+
+            /// Used as a callback function from iterating mesh.
+            virtual void FillInG(const Vector3r& pos, const Vector3r& step)=0;
+
+            // ====================  LIFECYCLE     =======================
+
+            /// Default protected constructor.
+            InverseSolver (const std::string &name);
+
+            /// Default protected constructor.
+            ~InverseSolver ();
+
+            // ====================  DATA MEMBERS  =========================
+
+            /// The Observed Data
+            Data* ObservedData;
+
+            /// The Predicted Data
+            Data* PredictedData;
+
+            /// Instrument that makes the data
+            Instrument*            ModelInstrument;
+
+        private:
+
+    }; // -----  end of class  InverseSolver  -----
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef INVERSESOLVER_H_INC  -----

LemmaCore/include/inversesolvertem1d.h

@@ -0,0 +1,146 @@
+/* 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   M. Andy Kass
+  @date     03/23/2011
+  @version  $Id: inversesolvertem1d.h 201 2015-01-03 00:07:47Z tirons $
+ **/
+
+#ifndef _INVERSESOLVERTEM1D__H
+#define _INVERSESOLVERTEM1D__H
+
+#include "inversesolver.h"
+#include "layeredearthem.h"
+#include "WireAntenna.h"
+#include "dipolesource.h"
+#include "receiverpoints.h"
+#include "instrumenttem.h"
+#include "cg.h"
+
+namespace Lemma {
+	// ===================================================================
+	//        Class:  InverseSolverTEM1D
+	/// \brief  Inversion for 1D TEM data
+	/// \details
+	// ===================================================================
+	class InverseSolverTEM1D : public InverseSolver {
+
+		friend std::ostream &operator<<(std::ostream &stream,
+			const InverseSolverTEM1D &ob);
+
+		public:
+
+		// ====================  LIFECYCLE     =======================
+
+		static InverseSolverTEM1D* New();
+
+		void Delete();
+
+		// ====================  OPERATORS     =======================
+
+		// ====================  OPERATIONS    =======================
+
+		/// Perform the inverse calculation
+		void Calculate();
+
+		// ====================  ACCESS        =======================
+
+		/// Attach starting model
+		void AttachStartMod(LayeredEarthEM* inpstartmod);
+
+		/// Attach recovered model
+		void AttachRecMod(LayeredEarthEM* inprecmod);
+
+		/// Attach wire antenna source
+		void AttachWireAntenna(WireAntenna* inpwireantenna);
+
+		/// Attach dipole source
+		void AttachDipoleSource(DipoleSource* inpdipsource);
+
+		/// Attach receiver points
+		void AttachReceiver(ReceiverPoints* inpreceiver);
+
+		/// Set the time gates
+		void SetTimes(VectorXr &inptimes);
+
+		/// Show forward modelled data
+		void ShowSoln();
+
+		/// Write recovered model to file
+		void WriteSoln(const std::string &filename);
+
+		/// Set free parameter indices: layer, conductivity
+		void SetFreeParams(const VectorXi &layers, const VectorXi &cond);
+
+		/// Attach measured data for misfit comparison
+		void AttachMeasuredData(const MatrixXr &data);
+
+		// ====================  INQUIRY       =======================
+		/// Report number of iterations
+		int NumberOfIterations();
+
+		/// Report success/failure
+		bool Success();
+
+		/// Return phi m vector
+		VectorXr GetPhiMVector();
+
+		/// Return phi d vector
+		VectorXr GetPhiDVector();
+
+
+		protected:
+
+		/// Some crap trevor uses
+		void FillInG(const Vector3r& pos, const Vector3r& step);
+
+		/// Calculate Jacobian
+		MatrixXr CalcJac(LayeredEarthEM* m0);
+
+		// ====================  LIFECYCLE     =======================
+
+		/// Default protected constructor.
+		InverseSolverTEM1D (const std::string &name);
+
+		/// Default protected constructor.
+		~InverseSolverTEM1D ();
+
+        void Release();
+
+		// ====================  DATA MEMBERS  =========================
+
+		WireAntenna* Antenna;
+
+		DipoleSource* Dipole;
+
+		ReceiverPoints* Receiver;
+
+		LayeredEarthEM* StartingMod;
+
+		LayeredEarthEM* RecoveredMod;
+
+		InstrumentTem *InstrumentFor;
+
+		MatrixXr MeasuredData;
+
+		VectorXr Times;
+
+		/// Vector of indices for which layer conductivities are solved for
+		VectorXi SCondIndex;
+
+		/// Vecor of indices for which layer thicknesses are solved for
+		VectorXi SThickIndex;
+
+		/// Temporary vector for returning linearised step
+		VectorXr RecModStep;
+
+		private:
+
+}; // -----  end of class  InverseSolverTEM1D  -----
+} // End of namespace Lemma
+#endif // _INVERSESOLVERTEM1D__H

LemmaCore/include/kernel.h

@@ -0,0 +1,85 @@
+/* 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     01/29/2010
+  @version  $Id: kernel.h 193 2014-11-10 23:51:41Z tirons $
+ **/
+
+#ifndef __kernel_h
+#define __kernel_h
+
+#ifdef LEMMAUSEVTK
+#include "vtkImplicitFunction.h"
+#endif
+
+#include "LemmaObject.h"
+#include "receivercubes.h"
+
+namespace Lemma {
+
+        // ==================================================================
+        //        Class:  Kernel
+        /// \brief Pure abstract class for some kind of kernel function.
+        /// \details Provides a consistent interface to kernel functions.
+        // ==================================================================
+        class Kernel : public LemmaObject {
+
+            /// Prints out basic info about the class
+            friend std::ostream &operator<<(std::ostream &stream,
+                        const Kernel &ob);
+
+            public:
+
+                // ====================  LIFECYCLE     ======================
+
+                //static Kernel* New();
+
+                virtual void Delete()=0;
+
+                // ====================  OPERATORS     ======================
+
+                // ====================  OPERATIONS    ======================
+
+                // ====================  ACCESS        ======================
+
+                // ====================  INQUIRY       ======================
+
+                virtual VectorXcr ComputeSensitivity()=0;
+
+                #ifdef LEMMAUSEVTK
+                virtual VectorXcr ComputeSensitivity(vtkImplicitFunction* Impl)=0;
+                #endif
+
+                /** computes sensitivity for same value */
+                virtual VectorXcr ComputeSensitivity(const Real& fval)=0;
+
+                /** Computes sensitivity for array of values */
+                virtual VectorXcr ComputeSensitivity(const VectorXr& fval)=0;
+
+                virtual void SetFieldCubes(ReceiverCubes* pts)=0;
+
+                // ====================  DATA MEMBERS  ======================
+
+            protected:
+
+                // ====================  LIFECYCLE     ======================
+
+                /// Default protected constructor.
+                Kernel (const std::string& name);
+
+                /// Default protected constructor.
+                ~Kernel ();
+
+        private:
+
+    }; // -----  end of class  Kernel  -----
+
+}
+
+#endif // __kernel_h

LemmaCore/include/kernelem1dbase.h

@@ -0,0 +1,111 @@
+/* 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     05/18/2012
+  @version  $Id: kernelem1dbase.h 193 2014-11-10 23:51:41Z tirons $
+ **/
+
+#ifndef  KERNELEM1DBASE_INC
+#define  KERNELEM1DBASE_INC
+
+#include "LemmaObject.h"
+
+namespace Lemma {
+
+    // Transverse electric or magnetic mode
+    enum EMMODE {TM, TE, NONE};
+
+    // ===================================================================
+    //  Class:  KernelEm1DBase
+    /**
+      @class
+      \brief   Pure virtual base class of KernelEm1D
+      \details Defines interface for HankelTransform classes
+     */
+    // ===================================================================
+    class KernelEm1DBase : public LemmaObject {
+
+        friend class KernelEM1DManager;
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+
+            // ====================  OPERATORS     =======================
+
+            // ====================  OPERATIONS    =======================
+
+            /** Returns the Complex bessel argument to be evaluated for a given
+			 * lambda value
+             */
+            virtual Complex BesselArg(const Real& lambda)=0;
+
+            /** Returns the complex bessel argument. Same as above, but does not
+             *  call reflection coefficient calculation in KernelEM1DReflBase.
+             *  @param[in] lambda is the hankel wave value.
+             */
+            virtual Complex RelBesselArg(const Real& lambda)=0;
+
+            // ====================  ACCESS        =======================
+            virtual void SetIk(const int& ik)=0;
+
+            virtual void SetMode(const EMMODE& mode)=0;
+
+            int GetManagerIndex() {
+                return this->managerIdx;
+            }
+
+            // ====================  INQUIRY       =======================
+            virtual int GetNumRel()=0;
+
+            virtual int GetBesselOrder()=0;
+
+            virtual Complex GetZm()=0;
+
+            virtual Complex GetYm()=0;
+
+            virtual Complex GetZs()=0;
+
+            virtual Complex GetKs()=0;
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /// Default protected constructor.
+            KernelEm1DBase (const std::string& name) : LemmaObject(name)
+            {
+            }
+
+            /// Default protected constructor.
+            ~KernelEm1DBase () {
+                if (this->NumberOfReferences > 0)
+                    throw DeleteObjectWithReferences( this );
+            }
+
+            void Release() {
+                delete this;
+            }
+
+            // ====================  OPERATIONS    =======================
+
+
+            // ====================  DATA MEMBERS  =========================
+
+            /** Where does this kernel live on the vector managed by the manager */
+            int  managerIdx;
+
+        private:
+
+    }; // -----  end of class  KernelEm1DBase  -----
+
+} // namespace Lemma
+
+#endif   // ----- #ifndef KERNELEM1DBASE_INC  -----

LemmaCore/include/kernelem1dmanager.h

@@ -0,0 +1,217 @@
+/* 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     06/26/2012
+  @version   0.0
+ **/
+
+#ifndef  KERNELEM1DMANAGER_INC
+#define  KERNELEM1DMANAGER_INC
+
+//#include "dipolesource.h"
+//#include "kernelem1dreflbase.h"
+#include "kernelem1dbase.h"
+#include "kernelem1dspec.h"
+
+namespace Lemma {
+
+    class DipoleSource;
+    class KernelEM1DReflBase;
+
+    // ===================================================================
+    //  Class:  KernelEM1DManager
+    /**
+      @class
+      \brief
+      \details
+     */
+    // ===================================================================
+    class KernelEM1DManager : public LemmaObject {
+
+        public:
+
+            friend std::ostream &operator<<(std::ostream &stream,
+                        const KernelEM1DManager &ob);
+
+            // ====================  LIFECYCLE     =======================
+
+            /** Returns a pointer to a new object of type KernelEM1DManager.
+             * It allocates all necessary memory.
+             */
+            static KernelEM1DManager* New();
+
+            /** Deletes this object. Delete also disconnects any
+             * attachments to this object.
+             */
+            void Delete();
+
+            // ====================  OPERATORS     =======================
+
+            // ====================  OPERATIONS    =======================
+
+            template<EMMODE Mode, int Ikernel, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
+            int AddKernel( );
+            /*
+            {
+
+                KernelEm1DSpec<Mode, Ikernel, Isource, Irecv>* NewKern =
+                    KernelEm1DSpec<Mode, Ikernel, Isource, Irecv>::New();
+                KernelVec.push_back( NewKern );
+                NewKern->managerIdx = KernelVec.size()-1;
+                switch (Mode) {
+                    case TE:
+                        if (TEReflBase == NULL) {
+                            TEReflBase = KernelEM1DReflSpec<TE, Isource, Irecv>::New();
+                            TEReflBase->Initialise(Earth);
+                            TEReflBase->SetUpSource(Dipole, ifreq);
+                            TEReflBase->SetUpReceiver( rx_z );
+                        }
+                        NewKern->SetReflBase(TEReflBase);
+                        break;
+                    case TM:
+                        if (TMReflBase == NULL) {
+                            TMReflBase = KernelEM1DReflSpec<TM, Isource, Irecv>::New();
+                            TMReflBase->Initialise(Earth);
+                            TMReflBase->SetUpSource(Dipole, ifreq);
+                            TMReflBase->SetUpReceiver( rx_z );
+                        }
+                        NewKern->SetReflBase(TMReflBase);
+                        break;
+                }
+                return static_cast<int>(KernelVec.size()-1);
+            }
+            */
+
+            void ResetSource(const int& ifreq);
+
+            /** For use in related Kernel calculations. This function calles
+             * ComputeReflectionCoeffs on TEReflBase and TMReflBase, if they
+             * exist. After this has been called, KernelEM1DBase::RelBesselArg() may be safely
+             * called. This method stores solutions of the same idx. rho0 is the intial lambda argument
+             */
+            void ComputeReflectionCoeffs(const Real& lambda, const int& idx, const Real& rho0);
+
+            /** Clears the vector of kernels */
+            void ClearVec() {
+                for (unsigned int ik=0; ik<this->KernelVec.size(); ++ik) {
+                    this->KernelVec[ik]->Delete();
+                }
+                KernelVec.clear();
+            }
+
+            // ====================  ACCESS        =======================
+
+            /** Sets the LayeredEarthEM class that will be used by the kernels.
+             */
+            void SetEarth( LayeredEarthEM*   Earth);
+
+            /** Sets the source of the kernels */
+            void SetDipoleSource( DipoleSource*   Dipole, const int& ifreq, const Real& rx_zin);
+
+            /** Returns pointer to specified kernel indice. Indices are assigned in the same
+                order as they are created by AddKernel.
+             */
+            KernelEm1DBase*    GetKernel(const unsigned int& ik);
+
+            /** Returns pointer to connected dipole.
+             */
+            DipoleSource*    GetDipole( );
+
+            inline std::vector<KernelEm1DBase*>  GetSTLVector() {
+                return KernelVec;
+            }
+
+            // ====================  INQUIRY       =======================
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /** Default protected constructor. */
+            KernelEM1DManager (const std::string& name);
+
+            /** Default protected constructor. */
+            ~KernelEM1DManager ();
+
+            /**
+             * @copybrief LemmaObject::Release()
+             * @copydetails LemmaObject::Release()
+             */
+            void Release();
+
+            // ====================  DATA MEMBERS  =========================
+
+            /** List of KernelEm1D instances */
+            std::vector<KernelEm1DBase*>           KernelVec;
+
+            /** Reflection base used for TE mode */
+            KernelEM1DReflBase*                    TEReflBase;
+
+            /** Reflection base used for TM mode */
+            KernelEM1DReflBase*                    TMReflBase;
+
+            /** EmEarth Class */
+            LayeredEarthEM*                        Earth;
+
+            /** EM dipole souce */
+            DipoleSource*                          Dipole;
+
+            /** Frequency index for the sources */
+            int                                    ifreq;
+
+            /** Receiver height */
+            Real                                   rx_z;
+
+        private:
+
+    }; // -----  end of class  KernelEM1DManager  -----
+
+    // template methods
+    template<EMMODE Mode, int Ikernel, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
+    int KernelEM1DManager::AddKernel( ) {
+
+        KernelEm1DSpec<Mode, Ikernel, Isource, Irecv>* NewKern =
+                    KernelEm1DSpec<Mode, Ikernel, Isource, Irecv>::New();
+        KernelVec.push_back( NewKern );
+        NewKern->managerIdx = KernelVec.size()-1;
+        switch (Mode) {
+            case TE:
+                if (TEReflBase == NULL) {
+                    TEReflBase = KernelEM1DReflSpec<TE, Isource, Irecv>::New();
+                    TEReflBase->Initialise(Earth);
+                    TEReflBase->SetUpSource(Dipole, ifreq);
+                    TEReflBase->SetUpReceiver( rx_z );
+                }
+                NewKern->SetReflBase(TEReflBase);
+                break;
+            case TM:
+                if (TMReflBase == NULL) {
+                    TMReflBase = KernelEM1DReflSpec<TM, Isource, Irecv>::New();
+                    TMReflBase->Initialise(Earth);
+                    TMReflBase->SetUpSource(Dipole, ifreq);
+                    TMReflBase->SetUpReceiver( rx_z );
+                }
+                NewKern->SetReflBase(TMReflBase);
+                break;
+        }
+        return static_cast<int>(KernelVec.size()-1);
+     }
+
+
+//     /** Clears the vector of kernels */
+//     void ClearVec() {
+//         for (unsigned int ik=0; ik<this->KernelVec.size(); ++ik) {
+//             this->KernelVec[ik]->Delete();
+//         }
+//         KernelVec.clear();
+//     }
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef KERNELEM1DMANAGER_INC  -----

LemmaCore/include/kernelem1dreflbase.h

@@ -0,0 +1,253 @@
+/* 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     05/18/2012
+  @version  $Id: kernelem1dreflbase.h 193 2014-11-10 23:51:41Z tirons $
+ **/
+
+#ifndef  KERNELEM1DREFLBASE_INC
+#define  KERNELEM1DREFLBASE_INC
+
+#include "dipolesource.h"
+#include "kernelem1dbase.h"
+#include "layeredearthem.h"
+//#include "kernelem1dspec.h"
+
+namespace Lemma {
+
+    //class DipoleSource;
+
+    enum DIPOLE_LOCATION { INAIR, INGROUND };
+
+    // forward declaration for friend
+    template<EMMODE Mode, int Ikernel, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
+    class KernelEm1DSpec;
+
+
+    // ===================================================================
+    //  Class:  KernelEM1DReflBase
+    /**
+      @class
+      \brief   Abstract class defining EM1DRefl class.
+      \details Derived classes are template specialized for optimal performance.
+     */
+    // ===================================================================
+    class KernelEM1DReflBase : public LemmaObject {
+
+        template<EMMODE Mode, int Ikernel, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
+        friend class KernelEm1DSpec;
+        friend class KernelEM1DManager;
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+
+            // ====================  OPERATORS     =======================
+
+            // ====================  OPERATIONS    =======================
+
+            void Initialise(LayeredEarthEM* EarthIn) {
+
+                nlay = EarthIn->GetNumberOfLayers();
+                zh = VectorXcr::Zero(nlay);
+                yh = VectorXcr::Zero(nlay);
+                u = VectorXcr::Zero(nlay);
+                cf = VectorXcr::Zero(nlay);    // nlay -1 (lay 0 empty)
+                rtu = VectorXcr::Zero(nlay);   // nlay -1 Interfaces only
+                rtd = VectorXcr::Zero(nlay);   // nlay -1 Interfaces only
+                kk = VectorXcr::Zero(nlay);
+                Zyu = VectorXcr::Zero(nlay);
+                Zyd = VectorXcr::Zero(nlay);
+                Zyi = VectorXcr::Zero(nlay);
+                th = VectorXcr::Zero(nlay);
+
+                // Don't attach Earth, because this is performance critical.
+                // Everying is internal, it's OK relax Frankie
+                //if (Earth != NULL) {
+                //    Earth->DetachFrom(this);
+                //    Earth = NULL;
+                //}
+                //EarthIn->AttachTo(this);
+                Earth = EarthIn;
+
+                LayerThickness.resize(nlay);
+                for (int ilay=0; ilay<nlay; ++ilay) {
+                    LayerThickness(ilay) =  Earth->GetLayerThickness(ilay);
+                }
+
+                LayerDepth.resize(nlay);
+                for (int ilay=0; ilay<nlay; ++ilay) {
+                    LayerDepth(ilay) =  Earth->GetLayerDepth(ilay);
+                }
+
+            }
+
+            void SetUpSource(DipoleSource *Dipole, const int &ifreq) {
+
+                zh(0) = Complex(0, Dipole->GetAngularFrequency(ifreq)*MU0);
+                yh(0) = Complex(0, Dipole->GetAngularFrequency(ifreq)*EPSILON0);
+                kk(0) = -zh(0) * yh(0);
+
+                Earth->EvaluateColeColeModel(Dipole->GetAngularFrequency(ifreq));
+
+                for (int ilay=1; ilay<Earth->GetNumberOfLayers(); ++ilay) {
+                    zh(ilay) = zh(0) * Earth->GetLayerSusceptibility(ilay);
+                    yh(ilay) = Earth->GetLayerConductivity(ilay) +
+                            yh(0)*Earth->GetLayerPermitivity(ilay);
+                    kk(ilay)   = -zh(ilay)*yh(ilay);
+                }
+
+                tx_z = Dipole->GetLocation(2);
+                lays = 0;
+                Real Depth(0);
+                for (int ilay=1; ilay<nlay; ++ilay) {
+                    if (tx_z > Depth) {
+                        lays = ilay;
+                    }
+                    Depth += LayerThickness(ilay);
+                }
+            }
+
+            void SetUpReceiver(const Real &rz) {
+                rx_z = rz;
+                Real Depth(0.);
+                layr = 0;
+                for (int ilay=1; ilay<Earth->GetNumberOfLayers(); ++ilay) {
+                    if (rx_z > Depth) {
+                        layr = ilay;
+                    }
+                    Depth += LayerThickness(ilay);
+                }
+            }
+
+            // ====================  ACCESS        =======================
+            Complex GetYm() {
+                return yh(layr);
+            }
+
+            Complex GetZm() {
+                return zh(layr);
+            }
+
+            Complex GetZs() {
+                return zh(lays);
+            }
+
+            Complex GetKs() {
+                return kk(lays);
+            }
+
+            // ====================  INQUIRY       =======================
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /// Default protected constructor.
+            KernelEM1DReflBase (const std::string& name) : LemmaObject(name)
+            {
+            }
+
+            /// Default protected constructor.
+            ~KernelEM1DReflBase () {
+                if (this->NumberOfReferences > 0)
+                    throw DeleteObjectWithReferences( this );
+            }
+
+            void Release() {
+                delete this;
+            }
+
+            // ====================  OPERATIONS    =======================
+
+            /** Computes reflection coefficients. Depending on the
+             * specialisation, this will either be TM or TE mode.
+             */
+            virtual void ComputeReflectionCoeffs(const Real& lambda)=0;
+
+            /** Precomputes expensive calculations that are reused by insances
+             * of KernelEM1DSpec in the calculation of Related potentials.
+             */
+            virtual void PreComputePotentialTerms()=0;
+
+            // ====================  DATA MEMBERS  =========================
+
+			/// Bessel order, only 0 or 1 supported
+			int id; // Needs to be dim nRel, or separate
+
+            /// Layer the source is in
+			int lays;
+
+			/// Layer the receiver is in
+			int layr;
+
+			/// Number of Layers
+			int nlay;
+
+            /// Number of Related kernels to be computed
+            int nRelated;
+
+            /// Used in related kernel precompute calls
+            int relIud;
+
+			/// Receiver z position
+			Real rx_z;
+
+			/// Transmitter z position
+			Real tx_z;
+
+            /// bessel arg squared
+            Real rams;
+
+            /** Related part of con term */
+            Complex  relCon;
+
+            Complex  relenukadz;
+
+            Complex  relexp_pbs1;
+
+            Complex  relexp_pbs2;
+
+            Complex  rel_a;
+
+			/// TM or TE mode
+			EMMODE mode;
+
+            /// Pointer to layered earth
+            LayeredEarthEM *Earth;
+
+			Complex       uk;
+			Complex       um;
+			VectorXcr     cf;  // nlay
+			VectorXcr      u;  // nlay
+			VectorXcr     yh;  // nlay
+			VectorXcr     zh;  // nlay
+			VectorXcr     kk;  // nlay
+			VectorXcr    Zyu;  //(nlay); //Zyu.setZero();
+			VectorXcr    Zyd;  //(nlay); //Zyd.setZero();
+			VectorXcr    Zyi;  //(nlay); //Zyi.setZero();
+			VectorXcr     th;  //(nlay);
+			VectorXr     LayerThickness;
+			VectorXr     LayerDepth;
+
+			/// Reflection/Transmission coeffients for upgoing waves in a
+			/// layered earth model
+			VectorXcr    rtu;
+
+			/// Reflection/Transmission coeffients for downgoing waves in
+			/// a layered earth model
+			VectorXcr    rtd;
+
+        private:
+
+    }; // -----  end of class  KernelEM1DReflBase  -----
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef KERNELEM1DREFLBASE_INC  -----

LemmaCore/include/kernelem1dreflspec.h

@@ -0,0 +1,373 @@
+/* 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     05/18/2012
+  @version  $Id: kernelem1dreflspec.h 123 2014-02-05 23:47:20Z tirons $
+ **/
+
+#ifndef  KERNELEM1DREFLSPEC_INC
+#define  KERNELEM1DREFLSPEC_INC
+
+#include "dipolesource.h"
+#include "kernelem1dreflbase.h"
+#include "layeredearthem.h"
+
+// #include<unordered_map> // for caching results
+
+namespace Lemma {
+
+    // forward declare
+    //struct cache;
+    // Simple container to hold reflection results
+    struct  cache {
+        Real                       rho0;
+        Real                       lambda[805];
+        Real                       rams[805];
+        Complex                    uk[805];
+        Complex                    um[805];
+        Real                       zh0i[805];
+        VectorXcr                  Rtd[805];
+        VectorXcr                  Rtu[805];
+        VectorXcr                  u[805];
+        VectorXcr                  cf[805];
+        VectorXcr                  kk[805];
+        const Real                 epsilon;
+        //bool                       nc;
+        cache( ) : epsilon (std::numeric_limits<Real>::epsilon() ) { // TODO reset to precision of Real
+            //Rtd = VectorXcr::Zero(805);
+            //Rtu = VectorXcr::Zero(805);
+        }
+    };
+
+    // forward declaration for friend
+    template<EMMODE Mode, int Ikernel, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
+    class KernelEm1DSpec;
+
+    // ===================================================================
+    //  Class:  KernelEM1DReflSpec
+    /**
+      @class
+      \brief   Specialized version of KernelEM1DReflBase
+      \details Through use of template specialisations, this KernelEm1D
+               class delivers much better performance.
+     */
+    // ===================================================================
+    template<EMMODE Mode, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
+    class KernelEM1DReflSpec : public KernelEM1DReflBase {
+
+        public:
+
+            template<EMMODE Mode2, int Ikernel2, DIPOLE_LOCATION Isource2, DIPOLE_LOCATION Irecv2>
+            friend class KernelEm1DSpec;
+            friend class KernelEM1DManager;
+
+            // ====================  LIFECYCLE     =======================
+
+            static KernelEM1DReflSpec* New() {
+                KernelEM1DReflSpec<Mode, Isource, Irecv>*  Obj =
+                    new KernelEM1DReflSpec<Mode, Isource, Irecv>("KernelEM1DReflSpec<>");
+                Obj->AttachTo(Obj);
+                return Obj;
+            }
+
+            void Delete() {
+                this->DetachFrom(this);
+            }
+
+            // ====================  OPERATORS     =======================
+
+            // ====================  OPERATIONS    =======================
+
+            // ====================  ACCESS        =======================
+
+            // ====================  INQUIRY       =======================
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /// Default protected constructor.
+            KernelEM1DReflSpec (const std::string& name) : KernelEM1DReflBase(name)
+            {
+            }
+
+            /// Default protected constructor.
+            ~KernelEM1DReflSpec () {
+                if (this->NumberOfReferences > 0)
+                    throw DeleteObjectWithReferences( this );
+            }
+
+            void Release() {
+                delete this;
+            }
+
+            // ====================  OPERATIONS    =======================
+
+            /** Computes reflection coefficients. Depending on the
+             * specialisation, this will either be TM or TE mode.
+             */
+            void ComputeReflectionCoeffs(const Real &lambda);
+
+            /* Computes reflection coefficients. Depending on the
+             * specialisation, this will either be TM or TE mode. This method
+             * stores previous results in a struct. For a given index, and
+             * lambda, the result will be the same. Turned out to be of limited utility.
+             */
+            //void ComputeReflectionCoeffs(const Real &lambda, const int& idx);
+
+            /** Precomputes expensive calculations that are reused by insances
+             * of KernelEM1DSpec in the calculation of Related potentials. This
+             * method is specialised based on template parameters
+             */
+            void PreComputePotentialTerms();
+
+            /*
+             * Sets the cache in CACHE to use. Somewhat expensive, avoid calling in tight loops
+             */
+            //void SetTCache(const Real& rho0);
+
+            // ====================  DATA MEMBERS  =========================
+
+        private:
+
+            //** Storage container for reused results */
+            //static std::unordered_map<Real, cache> CACHE;
+
+            //** Currenly used cache */
+            //cache* tcache;
+            //#pragma omp threadprivate(tcache)
+
+    }; // -----  end of class  KernelEM1DReflSpec  -----
+
+    //template<EMMODE Mode, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
+    //std::unordered_map<Real, cache> KernelEM1DReflSpec<Mode, Isource, Irecv>::CACHE;
+
+    //template<EMMODE Mode, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
+    //cache*  KernelEM1DReflSpec<Mode, Isource, Irecv>::tcache;
+
+    ///////////////////////////////////////////////
+    // Declarations of specialisations
+
+    template<>
+    void KernelEM1DReflSpec<TM, INAIR, INAIR>::ComputeReflectionCoeffs(const Real& lambda);
+
+    template<>
+    void KernelEM1DReflSpec<TE, INAIR, INAIR>::ComputeReflectionCoeffs(const Real& lambda);
+
+    template<>
+    void KernelEM1DReflSpec<TM, INAIR, INGROUND>::ComputeReflectionCoeffs(const Real& lambda);
+
+    template<>
+    void KernelEM1DReflSpec<TE, INAIR, INGROUND>::ComputeReflectionCoeffs(const Real& lambda);
+
+    template<>
+    void KernelEM1DReflSpec<TM, INAIR, INAIR>::PreComputePotentialTerms( );
+
+    template<>
+    void KernelEM1DReflSpec<TE, INAIR, INAIR>::PreComputePotentialTerms( );
+
+    template<>
+    void KernelEM1DReflSpec<TM, INAIR, INGROUND>::PreComputePotentialTerms( );
+
+    template<>
+    void KernelEM1DReflSpec<TE, INAIR, INGROUND>::PreComputePotentialTerms( );
+
+    ///////////////////////////////////////////////
+    // Default mode definitions
+
+/*
+    template<EMMODE Mode, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
+    void KernelEM1DReflSpec<Mode, Isource, Irecv>::SetTCache(const Real& rho0) {
+       #ifdef LEMMAUSEOMP
+        #pragma omp critical
+        #endif
+        {
+        this->tcache = &this->CACHE[rho0];
+        }
+    }
+*/
+
+/*
+    template<EMMODE Mode, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
+    void KernelEM1DReflSpec<Mode, Isource, Irecv>::ComputeReflectionCoeffs(const Real& lambda, const int& idx) {
+
+        if ( (std::abs(this->tcache->lambda[idx]-lambda) <= this->tcache->epsilon) &&
+            this->tcache->u[idx].size() > 0  && std::abs(this->kk(0) - this->tcache->kk[idx](0)) <= this->tcache->epsilon ) {
+            //std::cout << "USING CACHED RESULTS !!!!!!" << std::endl;
+            // load all the values we need
+            this->u   = this->tcache->u[idx];
+            this->rams = this->tcache->rams[idx];
+            this->cf = this->tcache->cf[idx];
+            //this->kk = this->tcache->kk[idx];
+            this->uk = this->tcache->uk[idx];
+            this->um = this->tcache->um[idx];
+            this->rtd = this->tcache->Rtd[idx];
+            this->rtu = this->tcache->Rtu[idx];
+
+        } else { // else do the work
+        }
+
+        ComputeReflectionCoeffs(lambda);
+
+        //#pragma omp critical
+        //{
+        //std::cout << idx << "\t" << lambda << "\t" << rtd.transpose() << std::endl;
+        //}
+        // store the results
+        this->tcache->u[idx]      = this->u;
+        this->tcache->cf[idx]     = this->cf;
+        this->tcache->kk[idx]     = this->kk;
+        this->tcache->uk[idx]     = this->uk;
+        this->tcache->um[idx]     = this->um;
+        this->tcache->Rtd[idx]    = this->rtd;
+        this->tcache->Rtu[idx]    = this->rtu;
+        this->tcache->zh0i[idx]    = std::imag(this->zh[0]);
+        this->tcache->lambda[idx] = lambda;
+        this->tcache->rams[idx]   = rams;
+
+        }
+
+        return;
+    }
+*/
+
+    template<EMMODE Mode, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
+    void KernelEM1DReflSpec<Mode, Isource, Irecv>::ComputeReflectionCoeffs(const Real& lambda) {
+        static bool called = false;
+        if (!called) {
+            std::cout << "unspecialised Reflection function KernelEM1DReflSpec<"
+                      << Mode << ", " << Isource << ", "
+                      << Irecv << " >::ComputeReflectionCoeffs( const Real& lambda ) --> SLOW PERFORMANCE EXPECTED\n";
+            called = true;
+        }
+
+        rams = lambda*lambda;
+        //////////////////////////////////////////
+        // Compute TEM stuff
+
+        // This call to sqrt takes ~ 15% of execution time
+        u  = (rams-kk.array()).sqrt();
+        uk = u(lays);
+        um = u(layr);
+
+        switch (Mode) {
+
+            // TM mode
+            case (TM):
+                Zyu(1) = -u(0)/yh(0);
+                Zyi    =  u.array() / yh.array();
+                break;
+
+            // TE mode
+            case (TE):
+                Zyu(1) = -u(0)/zh(0);
+                Zyi    =  u.array() / zh.array();
+                break;
+
+            default:
+                throw 11; //IllegalMode(this);
+        }
+
+        Zyd.tail<1>() = Zyi.tail<1>();
+
+        for (int ilay=1; ilay<nlay-1; ++ilay) {
+            cf(ilay) =
+                std::exp(-(Real)(2.)*u(ilay)*LayerThickness(ilay));
+            th(ilay) = ((Real)(1.)-cf(ilay)) / ((Real)(1.)+cf(ilay));
+        }
+
+        // Can't use blocks, b/c recursive
+        for (int N=1; N<lays; ++N){
+            Zyu(N+1)=Zyi(N)*(Zyu(N)-Zyi(N)*th(N)) /
+                            (Zyi(N)-Zyu(N)*th(N)) ;
+        }
+
+        int ne = nlay-2;
+        for (int N=ne; N >=lays+1; --N) {
+            Zyd(N) = Zyi(N)*(Zyd(N+1)+Zyi(N)*th(N)) /
+                            (Zyi(N)+Zyd(N+1)*th(N)) ;
+        }
+
+        rtd(nlay-1) = 0;
+
+        if (layr < lays) {
+            // Receiver above source layer
+            int ls = layr;
+            if (ls == 0) {
+                ls = layr+1;
+            }
+            for (int N=ls; N<=lays; ++N) {
+                rtu(N)= (Zyi(N)+Zyu(N)) /
+                        (Zyi(N)-Zyu(N)) ;
+            }
+            if (lays < nlay-1) {
+                rtd(lays) = (Zyi(lays)-Zyd(lays+1)) /
+                            (Zyi(lays)+Zyd(lays+1)) ;
+            }
+        } else {
+            // RECEIVER IN OR BELOW THE SOURCE LAYER
+            if (lays == layr) {  // Rx In source Layer
+                if (layr == 0) {
+                    rtd(0) = (Zyu(1)+Zyd(1)) /
+                             (Zyu(1)-Zyd(1)) ;
+                } else if (layr == nlay-1) {
+                    rtu(nlay-1) = (Zyi(nlay-1)+Zyu(nlay-1)) /
+                                  (Zyi(nlay-1)-Zyu(nlay-1)) ;
+                } else {
+                    rtu(layr) = (Zyi(layr)+Zyu(layr)) /
+                                (Zyi(layr)-Zyu(layr)) ;
+                    rtd(layr) = (Zyi(layr)-Zyd(layr+1)) /
+                                (Zyi(layr)+Zyd(layr+1)) ;
+                }
+            } else { // receiver below source layer
+                if (lays == 0) {
+                    rtd(0) = (Zyu(1)+Zyd(1)) /
+                             (Zyu(1)-Zyd(1)) ;
+                } else {
+                    rtu(lays) = (Zyi(lays)+Zyu(lays)) /
+                                (Zyi(lays)-Zyu(lays)) ;
+                }
+                int le = layr;
+                if (le == nlay-1) --le;
+                int ls = lays;
+                if (lays == 0   ) ++ls;
+
+                // TODO use blocks to vectorize maybe?
+                // This works but gives same to slightly worse
+                // performance as loop.
+//                 int nn = le-ls+1;
+//                 rtd.segment(ls, nn) =
+//                      (Zyi.segment(ls  , nn).array() -
+//                       Zyd.segment(ls+1, nn).array()).array() /
+//                      (Zyi.segment(ls  , nn).array() +
+//                       Zyd.segment(ls+1, nn).array()).array() ;
+                for (int N=ls; N<=le; ++N) {
+                    rtd(N) = (Zyi(N)-Zyd(N+1)) /
+                             (Zyi(N)+Zyd(N+1)) ;
+                }
+            }
+        } // End in or below source layer
+        return;
+    }
+
+    template<EMMODE Mode, DIPOLE_LOCATION Isource, DIPOLE_LOCATION Irecv>
+    void KernelEM1DReflSpec<Mode, Isource, Irecv>::PreComputePotentialTerms( ) {
+        static bool called = false;
+        if (!called) {
+            std::cerr << "unspecialised function KernelEM1DReflSpec<"
+                      << Mode << ", " << Isource << ", "
+                      << Irecv << " >::PreComputePotentialTerms\n";
+            called = true;
+        }
+    }
+
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef KERNELEM1DREFLSPEC_INC  -----

LemmaCore/include/layeredearth.h

@@ -0,0 +1,166 @@
+/* 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     06/24/2009
+  @version   0.0
+ **/
+
+#ifndef __LAYEREDEARTH_H
+#define __LAYEREDEARTH_H
+
+#include "earthmodel.h"
+
+namespace Lemma {
+
+	const int MAXLAYERS	= 10;
+
+	// =======================================================================
+	//        Class:  LayeredEarth
+	/// Abstract 1D layered earth.
+	// =======================================================================
+	class LayeredEarth : public EarthModel {
+
+		public:
+
+			// ====================    FRIENDS     ===========================
+			/** Recursively prints out information about this class
+             */
+            friend std::ostream &operator<<(std::ostream &stream,
+						const LayeredEarth &ob);
+
+			// ====================  LIFECYCLE     ===========================
+
+			// ====================  OPERATORS     ===========================
+
+			// ====================  OPERATIONS    ===========================
+
+			// ====================  ACCESS        ===========================
+
+			/** Sets the number of layers and resizes all model parameters to
+			 *  be the correct size, finally initialises all values to free
+			 *  space.
+             */
+			virtual void SetNumberOfLayers(const int& nlay)=0;
+
+			/** Sets the thickness of the layers
+             */
+			void SetLayerThickness(const VectorXr &thick);
+
+			// ====================  INQUIRY       ===========================
+
+			/** Returns the number of layers in the model */
+			int GetNumberOfLayers( );
+
+			/** Returns the number of layers in the model, excluding the air
+			 * layer
+             */
+			int GetNumberOfNonAirLayers( );
+
+			/** Returns the layer that a depth is in.
+			 * @param[in] depth is the depth you desire to know the layer of
+			 * @return the indice of the layer that depth is in.
+             */
+			int GetLayerAtThisDepth(const Real& depth);
+
+			/** Returns the thickness of a layer
+             *  @param[in] lay is the layer indice
+             *  @return the thickness of a layer
+             */
+			Real GetLayerThickness(const int & lay);
+
+			/** Returns the depth of the bottom interface of a layer
+             *  @param[in] lay is the layer indice
+             *  @return the depth of the bottom interface of a layer
+             */
+			Real GetLayerDepth(const int & lay);
+
+            #ifdef HAVE_YAMLCPP
+            /** YAML Serializing method
+             */
+            YAML::Node Serialize() const;
+            //static LayeredEarth* DeSerialize(const YAML::Node& node);
+            #endif
+
+		protected:
+
+			// ====================  LIFECYCLE     ===========================
+
+			/** Default protected constructor. */
+			LayeredEarth (const std::string& name);
+
+            #ifdef HAVE_YAMLCPP
+            /** Default protected constructor. */
+			LayeredEarth (const YAML::Node& node);
+            #endif
+
+			/** Default protected constructor. */
+			~LayeredEarth ();
+
+			// ====================  DATA MEMBERS  ===========================
+
+			/** Number of layers in the model, including the air layer,
+			 * and counting from 0
+             */
+			int               NumberOfLayers;
+
+			/** Number of interfaces in the model. Equal to NumberOfLayers - 1
+			 */
+            int               NumberOfInterfaces;
+
+			/** Vector of layer thicknesses */
+			VectorXr          LayerThickness;
+
+	}; // -----  end of class  LayeredEarth  -----
+
+
+    ///////////////////////////////////////////////////////////////////
+    // Error classes
+
+    /** If a model with less than two layers is specified, throw error. Not set up
+     * for whole space solutions.
+     */
+    class EarthModelWithLessThanTwoLayers : public std::runtime_error {
+        public:
+            EarthModelWithLessThanTwoLayers( );
+    };
+
+    /** If a solver has a max number of layers, and this is exceeded, throw this
+     * error.
+     */
+    class EarthModelWithMoreThanMaxLayers : public std::runtime_error {
+        public:
+            /** Thrown when an Earth model with more than the maximum number of
+             *  Layers is given
+             */
+            EarthModelWithMoreThanMaxLayers( );
+    };
+
+    /** If the model parameters have different lengths than the earth model, throw
+     * this error.
+     */
+    class EarthModelParametersDoNotMatchNumberOfLayers : public std::runtime_error {
+        public:
+            /** Thrown when the parameters do not match the number of Layers
+             */
+            EarthModelParametersDoNotMatchNumberOfLayers ( );
+    };
+
+    /** If a request if made for a non-valid earth model parameter, throw this
+     * error.
+     */
+    class RequestForNonValidEarthModelParameter : public std::runtime_error {
+        public:
+            /** Thrown when a request is made for a non-valid earth parameter
+             */
+            RequestForNonValidEarthModelParameter ( );
+    };
+
+} // namespace Lemma
+
+#endif // __LAYEREDEARTH_H

LemmaCore/include/layeredearthem.h

@@ -0,0 +1,314 @@
+/* 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     06/24/2009
+  @version   0.0
+ **/
+
+#ifndef __LAYEREDEARTHEM_H
+#define __LAYEREDEARTHEM_H
+
+#include "layeredearth.h"
+#include <iomanip>
+
+namespace Lemma {
+
+    // =======================================================================
+    //        Class:  LayeredEarthEM
+    /// \brief  1D layered earth. Attributes include all aspects of
+    /// Cole-Cole model.
+    /// \details   Primarily used for EM calculations.
+    // =======================================================================
+    class LayeredEarthEM : public LayeredEarth {
+
+        public:
+
+            // ====================    FRIENDS     ===========================
+
+            /** Recursively streams information about this class */
+            friend std::ostream &operator<<(std::ostream &stream,
+                        const LayeredEarthEM &ob);
+
+            // ====================  LIFECYCLE     ===========================
+
+            /**
+             *  Public constructor. Creates a new instance of the class and
+             *  assigns a reference to the thrown pointer.
+             */
+            static LayeredEarthEM* New();
+
+            /**
+             * @copybrief LemmaObject::Delete()
+             * @copydetails LemmaObject::Delete()
+             */
+            void Delete();
+
+            #ifdef HAVE_YAMLCPP
+            /** YAML Serializing method
+             */
+            YAML::Node Serialize() const;
+
+
+            //static LayeredEarthEM* DeSerialize(const YAML::Node& node);
+            #endif
+
+            /** @return a deep copy
+             */
+			LayeredEarthEM* Clone();
+
+            // ====================  OPERATORS     ===========================
+
+            // ====================  OPERATIONS    ===========================
+
+            /** Evaluates the cole-cole model for suceptability and
+             * permeability.
+             * @param[in] omega is the frequency in Hz
+             */
+            void EvaluateColeColeModel(const Real& omega);
+
+            // ====================  ACCESS        ===========================
+
+            /** Sets the number of layers and resizes all model parameters to
+             *  be the correct size, finally initialises all values to free
+             *  space.
+             *  @param[in] nlay is the number of layers
+             */
+            virtual void SetNumberOfLayers(const int& nlay);
+
+            /** Sets Complex Conductivity of the layers
+             *  @param[in] sigma is a vector of the conducivity of the layers
+             */
+            void SetLayerConductivity(const VectorXcr &sigma);
+
+            /** Sets Complex Conductivity of a single layer
+             *  @param[in] sigma is  the conducivity of the layer
+             *  @param[in] ilay is  the layer index
+             */
+            void SetLayerConductivity(const int& ilay, const Complex &sigma);
+
+            /* Sets Complex resitivity of the layers
+             *  @param[in] ohm is a vector of the resistivity of the layers
+                Singularity at 0 resistivity in air. Need to reformaulat things a bit
+             */
+            //void SetLayerResistivity(const VectorXcr &ohm);
+
+            /** Sets the thickness of the layers
+             *  @param[in] thick is a vector of the thicknesses of the layers.
+             *  Must be two less than the total number of Layers as the top and
+             *  bottom layers are assumed infinite.
+             */
+            void SetLayerThickness(const VectorXr &thick);
+
+            /** Sets the High frequency susceptibility
+             */
+            void SetLayerHighFreqSusceptibility(const VectorXr& sushi);
+
+            /** Sets the Low frequency susceptibility
+             */
+            void SetLayerLowFreqSusceptibility(const VectorXr& sushi);
+
+            /** Sets the Layer breath susceptibility
+             */
+            void SetLayerBreathSusceptibility(const VectorXr& susbr);
+
+            /** Sets the Layer tau susceptibility
+             */
+            void SetLayerTauSusceptibility(const VectorXr& susta);
+
+            /** Sets the High frequency permitivity
+             */
+            void SetLayerHighFreqPermitivity(const VectorXr& sushi);
+
+            /** Sets the Low frequency permitivity
+             */
+            void SetLayerLowFreqPermitivity(const VectorXr& sushi);
+
+            /** Sets the Layer breath permitivity
+             */
+            void SetLayerBreathPermitivity(const VectorXr& oerbr);
+
+            /** Sets the Layer breath permitivity
+             */
+            void SetLayerTauPermitivity(const VectorXr& oerbr);
+
+            // ====================  INQUIRY       ===========================
+
+            /** Returns the thickness of a layer
+                @return a VectorXcr of the layer conductivities.
+             */
+            VectorXcr GetLayerConductivity( );
+
+            /** Returns the conductivity of a layer
+             *  @param[in] ilay is the layer indice of interest
+             *  @return the complex valued conductivity of the layer of
+             *  interest.
+             */
+            Complex GetLayerConductivity(const int &ilay);
+
+            /** Returns the susceptibility of a layer
+             *  @param[in] ilay is the layer indice of interest.
+             *  @return a Complex value of the electrical susceptibility of the
+             *  probes layer.
+             */
+            Complex GetLayerSusceptibility(const int &ilay);
+
+            /** Returns the Susceptibility of Cole-Cole model
+             *  @return a VectorXcr of the suceptibilities of the model.
+             */
+            VectorXcr GetLayerSusceptibility( );
+
+            /** Returns the low freq susceptibility of a layer
+             */
+            Real GetLayerLowFreqSusceptibility(const int &ilay);
+
+            /** Returns the low freq susceptibility of a layer
+             */
+            VectorXr GetLayerLowFreqSusceptibility( );
+
+            /** Returns the low freq susceptibility of a layer
+             */
+            Real GetLayerHighFreqSusceptibility(const int &ilay);
+
+            /** Returns the low freq susceptibility of a layer
+             */
+            VectorXr GetLayerHighFreqSusceptibility( );
+
+            /** Returns the low freq susceptibility of a layer
+             */
+            Real GetLayerTauSusceptibility(const int &ilay);
+
+            /** Returns the low freq susceptibility of a layer
+             */
+            VectorXr GetLayerTauSusceptibility( );
+
+            /** Returns the low freq susceptibility of a layer
+             */
+            Real GetLayerBreathSusceptibility(const int &ilay);
+
+            /** Returns the low freq susceptibility of a layer
+             */
+            VectorXr GetLayerBreathSusceptibility( );
+
+            /** Returns the Relative Permitivity of the cole cole model
+             */
+            VectorXcr GetLayerPermitivity( );
+
+            /** Returns the conductivity of a layer
+             *  @param[in] ilay is the layer indice of interest.
+             *  @return a Complex value of the electrical permitivity of the
+             *  probed layer.
+             */
+            Complex GetLayerPermitivity(const int &ilay);
+
+            /** Low Freq permivitity
+             */
+            VectorXr  GetLayerLowFreqPermitivity( );
+
+            /** Returns the low freq susceptibility of a layer
+             */
+            Real GetLayerLowFreqPermitivity(const int &ilay);
+
+            /** Returns the low freq susceptibility of a layer
+             */
+            Real GetLayerHighFreqPermitivity(const int &ilay);
+
+            /** Returns the low freq susceptibility of a layer
+             */
+            VectorXr GetLayerHighFreqPermitivity( );
+
+            /** Returns the low freq susceptibility of a layer
+             */
+            Real GetLayerTauPermitivity(const int &ilay);
+
+            /** Returns the low freq susceptibility of a layer
+             */
+            VectorXr GetLayerTauPermitivity( );
+
+            /** Returns the low freq susceptibility of a layer
+             */
+            Real GetLayerBreathPermitivity(const int &ilay);
+
+            /** Returns the low freq susceptibility of a layer
+             */
+            VectorXr GetLayerBreathPermitivity( );
+
+        protected:
+
+            // ====================  LIFECYCLE     ===========================
+
+            /** Default protected constructor. */
+            LayeredEarthEM (const std::string &name);
+
+            #ifdef HAVE_YAMLCPP
+            /** Default protected constructor. */
+			LayeredEarthEM (const YAML::Node& node);
+            #endif
+
+            /** Default protected constructor. */
+            ~LayeredEarthEM ();
+
+            /**
+             * @copybrief LemmaObject::Release()
+             * @copydetails LemmaObject::Release()
+             */
+            void Release();
+
+            // ====================  DATA MEMBERS  ===========================
+
+            /** Vector of layer Conductivity */
+            VectorXcr         LayerConductivity;
+
+            /** Vector of layer Susceptibility (chi)
+             *  This is calculated using the Cole-Cole model
+             *  \f[ sus(i) = sush(i)
+             *   + \frac{(susl(i)-sush(i))}  {(1+(jw * sustau(i))^{susalp(i)})} \f]
+             */
+            VectorXcr         LayerSusceptibility;
+
+            /** Vector of low frequency susceptibility, for use in Cole-Cole
+              model */
+            VectorXr          LayerLowFreqSusceptibility;
+
+            /** Vector of high frequency susceptibility, for use in Cole-Cole
+             model */
+            VectorXr          LayerHighFreqSusceptibility;
+
+            /** Vector of relaxation time constants, for use in Cole-Cole model
+             */
+            VectorXr          LayerTauSusceptibility;
+
+            /** Vector relaxation breath, for use in Cole-Cole model
+             */
+            VectorXr          LayerBreathSusceptibility;
+
+            /** Vector of Layer Permitivity (epsilon)
+             *  Calculated using the Cole-Cole model
+             *  \f[ epr(i) = eprh(i)
+             *     + \frac{ (eprl(i)-eprh(i))}  { (1+(jw*eprtau(i))^{epralp(i)})} \f]
+             */
+            VectorXcr         LayerPermitivity;
+
+            /** Low frequency permitivity for each layer */
+            VectorXr          LayerLowFreqPermitivity;
+
+            /** High frequency permitivity for each layer */
+            VectorXr          LayerHighFreqPermitivity;
+
+            /** Decay time constant for each layer */
+            VectorXr          LayerTauPermitivity;
+
+            /** Relaxation breath for each layer */
+            VectorXr          LayerBreathPermitivity;
+
+    }; // -----  end of class  LayeredEarthEM  -----
+
+
+} // namespace Lemma
+
+#endif // __LAYEREDEARTHEM_H

LemmaCore/include/lemma.h

@@ -0,0 +1,333 @@
+/* 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     06/19/2009 09:12:20 AM  The Birth of Lemma!
+  @version  $Id: lemma.h 203 2015-01-09 21:19:04Z tirons $
+ **/
+
+/** \mainpage Lemma is an ElectroMagnetics Modelling API
+    \image html lemma.png
+
+    \authors Trevor Irons and M. Andrew Kass and others
+
+    Lemma is a recursive acronym that stands for <B>L</B>emma is an
+    <B>E</B>lectro<B>M</B>agnetics <B>M</B>odelling <B>A</B>PI.
+    Lemma is a cross-platform library delivering an expressive API that
+    can be used to easily create versatile programs.
+    We are building a powerful, flexible,
+    expresive framework that allows for the straightforward creation of
+    geophysical EM applications. Lemma is not itself a program, instead
+    it is a collection of building blocks to make applications.
+    We chose this name because:
+
+    - In mathematics a Lemma is a proven proposition which is used as a
+    stepping stone to a larger result rather than as a statement in-and-of
+    itself.
+    - In addition to the electromagnetic modelling, some other facilities are
+    provided such as numerical optimization and inversion capabilities. These
+    tools are also considered stepping stones to final products.
+
+    We feel that this is a partucularily approprate name, as Lemma's
+    API can be leveraged create powerful applications such as forward
+    modelling and inverting frequency and time-domain
+    surveys of arbitrary survey design, SNMR surveys, CSAMT and more.
+
+    \section Motivation
+    Why another Geophysical EM project? For starters, there
+    aren't that many quality open source packages out there. Those that do
+    exist are generally specialized to perform a single task and extending
+    them is a major undertaking. Lemma's approach is much different, by
+    providing a set of general tools users can easily assemble applications
+    that suite their needs.
+
+    While most geophysical EM modeling packages are concerned with forward
+    modeling <B>DATA</B> between specific transmitters and receivers located
+    on the surface of the earth; Lemma is fundamentally concerned with
+    modelling <B>FIELDS</B> due to sources, the field values can be calculated
+    everywhere within the domain. This allows for solving multiphysics EM
+    problems. Tradional EM data may be forward modelled using the Lemma::Instrument
+    classes.
+
+    \section Capabilities Capabilities
+    In the long term, we have many goals for this software project. Due to its
+    design, Lemma can be built upon and extended easily. The initial aim is to
+    provide flexible 1D and 3D EM modelling in the time and frequency domains.
+    The project is still in beta, but we have made a lot of progress already.
+    We will release our first non-beta release as soon as the following are
+    supported.
+
+    \subsection FDM Frequency-domain forward modelling
+    Lemma was initially called EMMODFD: Electromagnetic Modelling in the Frequency
+    Domain. As such this is the most mature area of Lemma.
+
+    \par 1D
+    Frequency domain solutions to electrical and magnetic dipoles can be computed
+    quasi-analytically in 1D. Calculations can be made in or above the layered
+    media, and complex electrical conductivity and magnetic susceptibility are
+    supported according to the Cole-Cole model. Sources may be embdedded in the
+    media or in the resisitive air layer. Lemma can also can compute fields due
+    to arbitrarily shaped ungrounded wire loops, topography of the loops is also
+    supported. Two separate approaches to solving the Hankel transform, one
+    based on Anderson's digitial filtering technique, and another based on Gaussian
+    quadrature.
+
+    \par 3D
+    A fast 3D solver that can modify the 1D results based
+    on arbitrary electrical conductivity model is nearing completion.
+
+    \par future work
+    We are also planning on supporting grounded wires in the near future.
+
+    \subsection TDM Time-domain forward modelling
+	A 1D time-domain solution has been implemented that utilises both a
+	dipole source as well as a wire loop.  Currently, only one receiver is
+	modelled at a time, but will be generalised.  In addition, utilities
+	to read in data files for modelling have been implemented.
+    We would like to offer 3D time domain support, but this will not be
+    provided before our first stable release.
+
+    \subsection DataFormats Data Formats
+    The EM community is plagued with myriad data formats. Often each equiptment
+    manufacturer provides their own data format and interoperability is a
+    constant struggle. We are working on a flexible data format based on the XML
+    format that can be adapted to many types of data. The template for this
+    format will be publically released and we hope it catches on in the community.
+    At the least, it will provide a mechanism to compare datasets and datatypes
+    within Lemma.
+
+    \section Modules Modules
+    Due to Lemma's design, it is easy to extend the platform. In some cases this
+    extension results in adding functionality that is not directly related to
+    ElectroMagnetics. The following modules utilise parts of Lemma to provide
+    their functionality.
+
+    \subsection Merlin Merlin.
+    This module provides nuclear magnetic resonance functionality.
+
+
+    \section Tutorials
+        - \ref Tutorial - Basic intruduction to Lemma, including aquiring and
+          compiling the code, class structure, and building your own
+          applications.
+        - \ref Extending Tutorial on how to extend Lemma.
+
+
+    \section Development Development and design
+    Ths package is primarily being developed by the Center for Gravity,
+    Electrical, and Magnetic Studies (CGEM) at the Colorado School of Mines (CSM), the United
+    States Geological Survey (USGS), and Broken Spoke Development, LLC. It draws on work by
+    many others including Ki Ha Lee, and Walt Anderson. All new work and
+    interfaces are written entirely in C++. Several small external projects are
+    included, which are written in standard C, and FORTRAN 77. We adapt a
+    modern, test driven, object oriented, C++ framework.
+
+    \section Legalities
+
+    \subsection Copyrights
+    The following copyrights apply to the source.
+    Most of the code was developed either by Trevor
+    Copyright (C) 2008-2010 Trevor Irons <tirons@mines.edu> or
+    M. Andrew Kass Copyright (C) 2010 <mkass@numericalgeo.com>.
+
+    The 1D EM solver was derived (but updated heavily) from a fortran
+    programme written by Ki Ha Lee in 1984. We have communicated with Ki Ha,
+    and he assured us that this code is in the public domian.
+
+    A Gaussian quadrature hankel transform originally written by Alan Chave was
+    ported to C++. This code is in the public domain, and was published in Geophysics.
+
+    A digital filtering approach to the Hankel transform written by Walt
+    Anderson was also rewritten for Lemma. The origional fortran code is also in
+    the public domain. Using this Hankel transform works
+    arround the copyright issue mentioned above, but may not produce accurate
+    results for high frequencies.
+
+    Please note that Ki Ha Lee and Walt Anderson had no part in this work, and
+    the above should not be interpreted as any sort of endorsement by those
+    parties.
+
+    \subsection License
+
+    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/.
+
+    \section Contributing Suggestions and contributions
+        We welcome contributions and suggestions. Feel free to email the development
+        team at info@lemmasoftware.org.
+        Under the terms of the MPL, if you modify a Lemma file, you are obligated to
+        share those contributions back with the community.
+
+    \section Useful Useful links
+        - Home page https://lemmasoftware.org
+        - SVN repository https://svn.lemmasoftware.org
+        - Broken Spoke Develpment http://numericalgeo.com
+        - CGEM at the Coloroado School of Mines http://geophysics.mines.edu/cgem/
+**/
+
+#pragma once
+
+#ifndef __LEMMA_H
+#define __LEMMA_H
+
+    // Include some basic stuff that will always be needed
+    #include <iostream>
+    #include <iomanip>
+    #include <complex>
+    #include <fstream>
+    #include <string>
+    #include <vector>
+    #include <stdexcept>
+    #include <sstream>
+
+    #include <Eigen/Core>
+    #include <cstddef>
+    #include <Eigen/StdVector>
+    #include <Eigen/Sparse>
+    #include <unsupported/Eigen/FFT>
+    //#include <unsupported/Eigen/SparseExtra>
+    #include <Eigen/Geometry>
+
+    /** \brief The only namespace used by Lemma
+     *
+     *  \details The rational behind this namespace is that built-in
+     *  types should be used wherever possible, but not
+     *  not built-in names. This allows for code that is better
+     *  enacsulated and easier to modify. The typedefs and constants
+     *  specified here are defined so that
+     *  precision/inplimentation can easily be changed.
+     *  All floating precision types should be typedefed in this file
+     *  and should not be used natively within any code.
+     *  Lemma uses
+     *  the Eigen Matrix/Vector/Linear Algebra library.
+     *  <http://eigen.tuxfamily.org> and a lot of the namespece typedefs
+     *  are specifying Eigen types.
+     */
+    namespace Lemma {
+
+        /// Real defines precision for the whole API, default is double
+#ifdef  LEMMA_SINGLE_PRECISION
+        typedef float Real;
+#else      // -----      LEMMA_SINGLE_PRECISION  -----
+        typedef double Real;
+#endif     // -----  not LEMMA_SINGLE_PRECISION  -----
+
+        /// Complex version of Real.
+        typedef std::complex<Real> Complex;
+
+        /// A 3 component Eigen vector of Reals
+        typedef Eigen::Matrix<Real, 3, 1> Vector3r;
+
+        /// A 3 X Dynamic Component Eigen matrix of Reals
+        typedef Eigen::Matrix<Real, 3, Eigen::Dynamic> Vector3Xr;
+
+        /// Variable length Eigen vector of Reals
+        typedef Eigen::Matrix<Real, Eigen::Dynamic, 1> VectorXr;
+
+        /// Variable length Eigen vector of integers (int)
+        typedef Eigen::Matrix<int, Eigen::Dynamic, 1> VectorXi;
+
+        /// Variable length Eigen vector of Complexes
+        typedef Eigen::Matrix<Complex, Eigen::Dynamic, 1> VectorXcr;
+
+        /// A 3 Component Eigen vector of Complexes
+        typedef Eigen::Matrix<Complex, 3, 1> Vector3cr;
+
+        /// A 3 X Dynamic Component Eigen matrix of Complexes
+        typedef Eigen::Matrix<Complex, 3, Eigen::Dynamic> Vector3Xcr;
+
+        /// Variable length Eigen Matrix of Reals
+        typedef Eigen::Matrix<Real, Eigen::Dynamic, Eigen::Dynamic> MatrixXr;
+
+        /// Variable length Eigen Matrix of ints
+        typedef Eigen::Matrix<int, Eigen::Dynamic, Eigen::Dynamic> MatrixXi;
+
+        /// Variable length Eigen vector of Complexes
+        typedef Eigen::Matrix<Complex, Eigen::Dynamic, Eigen::Dynamic> MatrixXcr;
+
+        ////////////////////////////////////////
+        // Constants used across the programmes
+
+        /// Restating the obvious, this is pi
+        const Real PI = 4.0*atan(1.0);
+
+        /// Permitivity of Free Space
+        //const Real EPSILON0 = 8.854187817e-12;
+        const Real EPSILON0 = 8.854187817e-12;
+
+        /// Permeability of free space
+        const Real MU0 = 4.*PI*1e-7;
+
+        /// 1/4 of \f$ \pi\f$
+        const Real QPI = .25/PI;
+
+        /// Some functions will convert units from SI (standard) to Gauss
+        /// This is because NMR calculations are much more natural in Gauss
+        enum MAGUNITS  {TESLA, NANOTESLA, GAUSS};
+
+        /// Unit of temperature entered
+        enum TEMPUNITS {CELCIUS, KELVIN};
+
+        /// Unit of time entered
+        enum TIMEUNITS {SEC, MILLISEC, MICROSEC, NANOSEC, PICOSEC};
+
+        /// Unit of time entered
+        enum FREQUENCYUNITS {HZ, KHZ, MHZ, GHZ};
+
+		/// FEM coil relative orientations
+		enum FEMCOILORIENTATION {COAXIAL, COPLANAR};
+
+		/// General orientation relative to coordinate system
+		enum ORIENTATION {X, Y, Z, NX, NY, NZ};
+
+        /// Type of field
+        enum FIELDTYPE         {HFIELDREAL, HFIELDIMAG, EFIELDREAL, EFIELDIMAG};
+
+        /// Compenent of vector field
+        enum FIELDCOMPONENT    {XCOMPONENT=0, YCOMPONENT=1, ZCOMPONENT=2};
+
+        /// Spatial component of vector
+        enum SPATIALCOORDINANT  {XCOORD=0, YCOORD=1, ZCOORD=2};
+
+        /** Evaluation method for Hankel integrals.
+         *  ANDERSON801     Walt Anderson's 801 point filter
+         *  CHAVE           Alan Chave's gaussian quadrature integration method
+         *  FHTKEY201       Key's 201 point filter
+         *  FHTKEY201       Key's 101 point filter
+         *  FHTKEY51        Key's 51 point filter
+         *  QWEKEY          Key's Gaussian quadrature integration method
+         */
+        enum HANKELTRANSFORMTYPE { ANDERSON801, CHAVE, FHTKEY201, FHTKEY101, FHTKEY51, QWEKEY };
+
+        /** Enum is OK because these are the only physically possible sources.
+         @param NOSOURCETYPE is default.
+         @param ELECTRICDIPOLE is an electric dipole
+         @param MAGNETICDIPOLE is a magnetic dipole
+        */
+        enum DipoleSourceType {NOSOURCETYPE, GROUNDEDELECTRICDIPOLE, UNGROUNDEDELECTRICDIPOLE, MAGNETICDIPOLE};
+
+        /// Only three polarizations are supported. They may be summed to
+        /// approximate others
+        /// @param NOPOLARISATION is uninitialized, default value
+        /// @param XPOLARISATION is a dipole oriented in the x direction
+        /// @param YPOLARISATION is a dipole oriented in the y direction
+        /// @param ZPOLARISATION is a dipole oriented in the z direction
+        enum DipoleSourcePolarisation {NOPOLARISATION, XPOLARISATION,
+            YPOLARISATION,  ZPOLARISATION};
+
+        /// The polarity may be either negative or positinve
+        enum DipoleSourcePolarity {NEGATIVE, POSITIVE};
+
+        /** The fields to make calculations on
+        */
+        enum FIELDCALCULATIONS {E, H, BOTH};
+
+    }
+
+#endif // __Lemma_H

LemmaCore/include/modelreader.h

@@ -0,0 +1,73 @@
+/* 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   M. Andy Kass
+  @date     02/18/2011
+  @version  $Id: modelreader.h 201 2015-01-03 00:07:47Z tirons $
+ **/
+
+#ifndef __MODELREADER_H
+#define __MODELREADER_H
+
+#include "LemmaObject.h"
+#include "layeredearthem.h"
+#include "PolygonalWireAntenna.h"
+#include "receiverpoints.h"
+
+namespace Lemma {
+
+// ===================================================================
+//        Class:  ModelReader
+/// \brief Model and instrument reader for forward modelling.
+/// \details This is an abstract class.
+// ===================================================================
+class ModelReader : public LemmaObject {
+
+	friend std::ostream &operator<<(std::ostream &stream,
+		const ModelReader &ob);
+
+	public:
+
+		// ====================  LIFECYCLE     =======================
+
+		static ModelReader* New();
+
+		void Delete();
+
+		// ====================  OPERATORS     =======================
+
+		// ====================  OPERATIONS    =======================
+
+		// ====================  ACCESS        =======================
+
+		// ====================  INQUIRY       =======================
+
+
+
+	protected:
+
+		// ====================  LIFECYCLE     =======================
+
+		/// Default protected constructor.
+		ModelReader (const std::string &name);
+
+		/// Default protected constructor.
+		~ModelReader ();
+        /**
+        * @copybrief LemmaObject::Release()
+        * @copydetails LemmaObject::Release()
+        */
+		void Release();
+		// ====================  DATA MEMBERS  =========================
+
+	private:
+
+}; // -----  end of class  ModelReader  -----
+} // end of namespace lemma
+#endif // __MODELREADER_H
+

LemmaCore/include/modelreaderfem1d.h

@@ -0,0 +1,68 @@
+/* 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   M. Andy Kass
+  @date     01/03/2013
+  @version  $Id$
+ **/
+
+#ifndef __MODELREADERFEM1D_H
+#define __MODELREADERFEM1D_H
+
+#include "modelreader.h"
+
+namespace Lemma {
+
+
+// ===================================================================
+//        Class:  ModelReaderFem1D
+/// \brief
+/// \details
+// ===================================================================
+	class ModelReaderFem1D : public ModelReader {
+
+		friend std::ostream &operator<<(std::ostream &stream,
+			const ModelReaderFem1D &ob);
+
+	public:
+
+	// ====================  LIFECYCLE     =======================
+
+	static ModelReaderFem1D* New();
+
+	void Delete();
+
+	// ====================  OPERATORS     =======================
+
+	// ====================  OPERATIONS    =======================
+
+	// ====================  ACCESS        =======================
+
+	// ====================  INQUIRY       =======================
+
+
+
+	protected:
+
+	// ====================  LIFECYCLE     =======================
+
+	/// Default protected constructor.
+	ModelReaderFem1D (const std::string &name);
+
+	/// Default protected constructor.
+	~ModelReaderFem1D ();
+
+	void Release();
+
+	// ====================  DATA MEMBERS  =========================
+
+	private:
+
+}; // -----  end of class  ModelReaderFem1D  -----
+} // end of namespace Lemma
+#endif // __MODELREADERFEM1D_H

LemmaCore/include/modelreadertem1d.h

@@ -0,0 +1,83 @@
+/* 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   M. Andy Kass
+  @date     02/19/2011
+  @version  $Id: modelreadertem1d.h 87 2013-09-05 22:44:05Z tirons $
+ **/
+
+#ifndef __MODELREADERTEM1D_H
+#define __MODELREADERTEM1D_H
+
+#include "modelreader.h"
+
+namespace Lemma {
+
+// ===================================================================
+//        Class:  ModelReaderTem1D
+/// \brief Model reader class for forward modelling 1D TEM data
+/// \details This is a mostly abstract class.
+// ===================================================================
+class ModelReaderTem1D : public ModelReader {
+
+	friend std::ostream &operator<<(std::ostream &stream,
+		const ModelReaderTem1D &ob);
+
+	public:
+
+		// ====================  LIFECYCLE     =======================
+
+		static ModelReaderTem1D* New();
+
+		void Delete();
+
+		// ====================  OPERATORS     =======================
+
+		// ====================  OPERATIONS    =======================
+
+		//void ReadParameters(/* Pass file name */);
+
+		// ====================  ACCESS        =======================
+
+		// ====================  INQUIRY       =======================
+
+
+	protected:
+
+		// ====================  LIFECYCLE     =======================
+
+		/// Default protected constructor.
+		ModelReaderTem1D (const std::string &name);
+
+		/// Default protected constructor.
+		~ModelReaderTem1D ();
+
+		void Release();
+
+		/// Read in the Earth Model file and attach
+		//void ReadModel();
+
+		/// Read in the instrument parameters and attach
+		//void ReadInstrument();
+
+		/// Read in the waveform file (future)
+		//void ReadWaveform();
+
+		// ====================  DATA MEMBERS  =========================
+
+		//std::string modelfile;
+
+		//std::string instrumentfile;
+
+		//std::string waveformfile;
+
+	private:
+
+}; // -----  end of class  ModelReaderTem1D  -----
+} // end of namespace lemma
+#endif // __MODELREADERTEM1D_H

LemmaCore/include/modelreadertem1dubc.h

@@ -0,0 +1,116 @@
+/* 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   M. Andy Kass
+  @date     02/19/2011
+  @version  $Id: modelreadertem1dubc.h 87 2013-09-05 22:44:05Z tirons $
+ **/
+
+#ifndef __MODELREADERTEM1DUBC_H
+#define __MODELREADERTEM1DUBC_H
+
+#include "modelreadertem1d.h"
+
+namespace Lemma {
+
+// ===================================================================
+//        Class:  ModelReaderTem1DUBC
+/// \brief Model reader class for forward modelling 1D TEM data
+/// \details Reads UBC 1D TEM forward model format
+// ===================================================================
+class ModelReaderTem1DUBC : public ModelReaderTem1D {
+
+	friend std::ostream &operator<<(std::ostream &stream,
+		const ModelReaderTem1DUBC &ob);
+
+	public:
+
+		// ====================  LIFECYCLE     =======================
+
+		static ModelReaderTem1DUBC* New();
+
+		void Delete();
+
+		// ====================  OPERATORS     =======================
+
+		// ====================  OPERATIONS    =======================
+
+		void ReadParameters(const std::string &params);
+
+		// ====================  ACCESS        =======================
+
+		/// Attaches a LayeredEarthEM object
+		void SetEMEarth1D(LayeredEarthEM* earth);
+
+		/// Attaches a WireAntenna object
+		void SetTransmitter(WireAntenna *antennae);
+
+		/// Attaches a ReceiverPoints object
+		void SetReceiver(ReceiverPoints* receiver);
+
+		VectorXr GetTimes();
+
+		// ====================  INQUIRY       =======================
+
+
+	protected:
+
+		// ====================  LIFECYCLE     =======================
+
+		/// Default protected constructor.
+		ModelReaderTem1DUBC (const std::string &name);
+
+		/// Default protected constructor.
+		~ModelReaderTem1DUBC ();
+
+		void Release();
+
+		/// Read in the Earth Model file and attach
+		void ReadModel();
+
+		/// Read in the instrument parameters and attach
+		void ReadInstrument();
+
+		/// Read in the waveform file (future)
+		void ReadWaveform();
+
+		// ====================  DATA MEMBERS  =========================
+
+		std::string modelfile;
+
+		std::string instrumentfile;
+
+		std::string waveformfile;
+
+		WireAntenna* Trans;
+
+		ReceiverPoints* Receivers;
+
+		LayeredEarthEM* EarthMod;
+
+		/// Simulated noise flag
+		bool addednoise;
+
+		/// Simulated noise percentage
+		Real noisepercent;
+
+		/// Baseline threshold percentage
+		Real noisethresh;
+
+		/// Seed for random number generator
+		Real noiseseed;
+
+		VectorXr receivermoment;
+
+		VectorXr modtimes;
+
+	private:
+
+}; // -----  end of class  ModelReaderTem1DUBC  -----
+} // end of namespace lemma
+#endif // __MODELREADERTEM1DUBC_H

LemmaCore/include/modules.h

@@ -0,0 +1,25 @@
+/* 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     11/26/2010
+  @version  $Id: modules.h 87 2013-09-05 22:44:05Z tirons $
+ **/
+
+/**
+      \defgroup Merlin Merlin
+      @brief    Merlin is a nuclear magnetic resonance module.
+      @details  Much of Merlin focuses on surface, or earth's field NMR (SNMR)
+       but many of the algorithms may be extended to general NMR.
+
+     \defgroup Wavelet Wavelet
+      @brief    A wavlet transfer module.
+      @details  Provides multidimensional wavelet transforms and solver routines.
+ */
+
+

LemmaCore/include/octreegrid.h

@@ -0,0 +1,352 @@
+/* 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     03/19/2010
+  @version  $Id: octreegrid.h 193 2014-11-10 23:51:41Z tirons $
+ **/
+
+#ifndef  OCTREEGRID_INC
+#define  OCTREEGRID_INC
+
+// This class depends on VTK!
+
+#ifdef  LEMMAUSEVTK
+#include "grid.h"
+#include "vtkHyperOctree.h"        // In Filtering
+#include "vtkHyperOctreeCursor.h"
+#include "vtkHyperOctreeSampleFunction.h"
+#include "vtkImplicitFunction.h"
+#include "vtkCell.h"
+#include "vtkGenericCell.h"
+
+#ifdef  LEMMA_SINGLE_PRECISION
+#include "vtkFloatArray.h"
+#else      // -----  not LEMMA_SINGLE_PRECISION  -----
+#include "vtkDoubleArray.h"
+#endif     // -----  not LEMMA_SINGLE_PRECISION  -----
+
+#include "kernel.h"
+#include "receiverpoints.h"
+#include "receivercubes.h"
+#include "layeredearth.h"
+//#include "layeredearthnmr.h"
+#include "inversesolver.h"
+
+#include "FastDelegate.h"
+#include "FastDelegateBind.h"
+
+namespace Lemma {
+
+    // forward declaration
+    class InverseSolver ;
+
+    // ===================================================================
+    //        Class:  OctreeGrid
+    /** An Octree class, builds off VtkHyperOctree so this class can
+        only be used when compiled with VTK libs.
+        An Octree is a heirarchial 3D mesh with rectangular cells containing
+        either 0 or 8 children.
+     */
+    // ===================================================================
+    class OctreeGrid : public Grid {
+
+        friend class InverseSolver;
+        //friend class SNMRInversion1D;        // From Merlin Module
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const OctreeGrid &ob);
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+
+            /**
+             * new grid octreee
+             */
+            static OctreeGrid* New();
+
+            /**
+             * @copybrief LemmaObject::Delete()
+             * @copydetails LemmaObject::Delete()
+             */
+            void Delete();
+
+            // ====================  OPERATORS     =======================
+
+
+            // ====================  ACCESS        =======================
+
+            /** Sets the kernel function to be used to make the mesh.
+             *  @param[in] kern is a kernel that is used to generate a mesh.
+             */
+            void SetKernel(Kernel* kern);
+
+            /// Sets a 1D model associated with this kernel.
+            /// @param[in] model1d is a pointer to a LayeredEarth model that
+            /// will be used to pre-subdivide leaves that overlap several
+            /// layers.
+            void SetLayeredEarth(LayeredEarth* model1d);
+
+            /** Sets the size of the mesh
+                @param[in] size is the size of the mesh. The mesh must start at
+                [0,0,0] and goes to [sizex, sizey, sizez].
+             */
+            void SetSize(const Vector3r& size);
+
+            /** Sets the origin of the mesh
+                @param[in] origin is the origin of the mesh.
+             */
+            void SetOrigin(const Vector3r& origin);
+
+            /** Sets the minimum depth to model. This must be greater than 0.
+                @param[in] depth is the new minimum depth.
+             */
+            void SetMinimumDepth(const Real& depth);
+
+            /** Fills in the leaf data with the kernel sensitivity
+             */
+            void FillMeshWithKernel();
+
+            /** Fills in the leaf data with the kernel sensitivity
+             */
+            void FillMeshWithKernel(vtkImplicitFunction* Impl);
+
+            /** Sets the size of the mesh
+             */
+            void SetSize(const Real &x, const Real &y, const Real &z);
+
+            /** Generates mesh to specified tolerance.
+             *  @param[in] tol is the kernel tolerance.
+             */
+            void GenerateMesh(const Real &tol);
+
+
+            /** Generates a mesh to specified tolerance, but initially splits
+             *  based on implicit function.
+             *  @param[in] tol is the kernel tolerance.
+             *  @param[in] Impl is the implicit dataset used for initial
+             *  subdivision
+             *  @param[in] impltol is the tolerance for the initial model based
+             *  subdividing.
+             */
+            void GenerateMesh(const Real& tol, vtkImplicitFunction* Impl,
+                              const Real& impltol);
+
+            /** Generates an Octree mesh using a pre-sampled input Octree Dataset.
+                Speeds up repeated kernel calculations when the underlying model in
+                the above ImplicitFunction needs to be called often or is complex.
+             */
+            void GenerateMesh(const Real& tol, vtkImplicitFunction* Impl,
+                    vtkHyperOctreeSampleFunction* OctSamp);
+
+            /** Evaluates the kernel on the mesh. In some cases this is the same thing
+                as generate mesh, but if more that one calculation are needed on a
+                mesh you can use this method. It interfaces with the kernels by
+                calling
+             */
+            Complex EvaluateKernelOnMesh();
+
+            /** Returns a receiver cube class that represents the same Geometry as the
+                HyperOctree. This is useful as it can be passed directly to em1dearth,
+                and currently, an Octree cannot. But this requires storage of all the
+                cell volumes and locations. In the future, you should be able to pass
+                around this class just like a ReceiverCubes.
+             */
+            void ReceiverCubeRepresentation();
+
+            /** Returns the receiver cube class. */
+            ReceiverCubes* GetReceiverCubes();
+
+            /** returns the kernel sum from generation */
+            Complex GetKernelSum();
+
+            /** Accessor to underlying vtkClass.
+             *  @return a vtkHyperOctree that can be used for visualization.
+             */
+            vtkHyperOctree* GetVtkHyperOctree( );
+
+            /** Traverse the data structure and call a function at each leaf
+             */
+            void TraverseAndCall(InverseSolver* Inverse);
+
+            /** Traverse the data structure and call a function at each leaf
+             */
+            void TraverseAndCall( vtkImplicitFunction* Impl );
+
+            /**
+             */
+            void TraverseLeaves(vtkImplicitFunction* Impl);
+
+            /**
+             */
+            void FollowExistingTree(vtkHyperOctree* Leader, vtkHyperOctreeCursor* LeaderCursor,
+                    vtkImplicitFunction* Impl);
+
+            // ====================  OPERATIONS    =======================
+
+            /** Binds any derived member function of a derived class of
+                LayeredEarth to SampleScalarFromLayeredEarthFD. This function is then
+                used to sample the Octree mesh for that parameter. The member function
+                needs to be of the type GetLayerXXX(const int Layer& lay).
+                @param[in] earth is a pointer to a derived class of LayeredEarth
+                @param[in] fcnptr is a function pointer to a member function. It
+                should be called like &LayeredEarthNMR::GetLayerPorosity
+                @param[in] name is a std::string identifier.
+             */
+            template <class Derived>
+            void SampleScalarFromLayeredEarth(LayeredEarth* earth,
+                    Real (Derived::*fcnptr)(const int& id), const std::string &name) {
+
+                SampleScalarFromLayeredEarthFD.bind(static_cast<Derived*>(earth), fcnptr);
+                GetLayerInt.bind(earth, &LayeredEarth::GetLayerAtThisDepth);
+                // TODO, don't use KernelArray, instead create new Array, and set it
+                // in there. Then delete?
+                this->KernelArray->SetName(name.c_str());
+                this->KernelArray->SetNumberOfTuples(Octree->GetNumberOfLeaves());
+                SampleScalar();
+                this->Octree->GetLeafData()->SetScalars( KernelArray );
+                this->Octree->GetLeafData()->AddArray( KernelArray );
+            }
+
+            /** Sends cursor to root
+             */
+            void CursorToRoot();
+
+            // ====================  INQUIRY       =======================
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /** Default protected constructor. */
+            OctreeGrid (const std::string &name);
+
+            /** Default protected constructor. */
+            ~OctreeGrid ();
+
+            /**
+             * @copybrief LemmaObject::Release()
+             * @copydetails LemmaObject::Release()
+             */
+            void Release();
+
+            // ====================  OPERATIONS    =======================
+
+            /** Used internally. The leaf data is saved and then set as the vtk leaf
+             *  data.
+             */
+            void SetLeafDataFromGridCreation();
+
+            /** Return position of leaf, returns centre location
+             */
+            void GetPosition( Real* p );
+
+            /** Used to fill leaf data with a scalar value from a layered earth
+             *  model
+             */
+            fastdelegate::FastDelegate1< const int&, Real > SampleScalarFromLayeredEarthFD;
+
+            /** Used to get the Layer of delagated model.
+             */
+            fastdelegate::FastDelegate1< const Real&, int >  GetLayerInt;
+
+            /** Recursively determines the mesh to use
+             */
+            void EvaluateKids( );
+
+            /** Recursively determines the mesh to use
+                @param[in] kval is the current leaf kernel value
+                           which may be reused in analysis.
+             */
+            void EvaluateKids( Complex kval );
+
+            /** Same as above, but uses an implict function.
+             */
+            void EvaluateKids (vtkImplicitFunction* Impl);
+
+            /** Same as above, but lets function value be passed directly
+             */
+            void EvaluateKids (const Real& fval, vtkImplicitFunction* Impl);
+
+            /** Same as above but is passed a static fval to reuse. Useful when underlying model is smooth
+             */
+            void EvaluateKidsStatic(const Real& fval);
+
+            /** Same as above, but lets function value be passed directly
+             */
+            void SampleFunction(vtkImplicitFunction* Impl);
+
+            /** Recursively determines the mesh to use
+             */
+            void FillGrid( );
+
+            /** Recursively determines the mesh to use
+             */
+            void FillGrid(vtkImplicitFunction* Impl);
+
+            /** Used internally to build a receiver cube representation
+             */
+            void AssembleReceiverCubes( );
+
+            /** Samples a scalar from a LayeredEarth object. Used internally and calls
+             *  SampleScalarFromLayeredEarthFD, which can be set using
+             *  SampleScalarFromLayeredEarth.
+             */
+            void SampleScalar();
+
+
+
+            // Returns ReceiverPoints for the Octree.
+            //void ComputeFieldOnOctree( WireAntenna* loop );
+
+            // ====================  DATA MEMBERS  =========================
+
+        private:
+
+            Vector3r                Size;
+            Vector3r                Origin;
+            Vector3r                step;
+            Vector3r                cpos;
+
+            int                     level;
+            int                     maxlevel;
+            int                     index;
+            int                     counter;
+
+            Real                    cvol;
+            Real                    tvol;
+            Real                    tol;
+            Complex                 KernelSum;
+
+            Eigen::Matrix<Real, 8, 3> Posadd;
+
+            std::vector<Real>       leafdata;
+            std::vector<vtkIdType>  leafids;
+
+            Kernel                 *SenseKernel;
+            ReceiverCubes          *Cubes;
+            LayeredEarth           *Model1D;
+
+            vtkHyperOctree               *Octree;
+            vtkHyperOctreeCursor         *Cursor;
+            vtkHyperOctreeSampleFunction *OctSamp;
+
+            #ifdef  LEMMA_SINGLE_PRECISION
+            vtkFloatArray          *KernelArray;
+            #else      // -----  not LEMMA_SINGLE_PRECISION  -----
+            vtkDoubleArray         *KernelArray;
+            #endif     // -----  not LEMMA_SINGLE_PRECISION  -----
+            vtkDataArray           *SampleArray;
+
+    }; // -----  end of class  OctreeGrid  -----
+
+}       // -----  end of Lemma  name  -----
+
+#endif     // -----  not LEMMAUSEVTK  -----
+#endif   // ----- #ifndef OCTREEGRID_INC  -----

LemmaCore/include/pulse.h

@@ -0,0 +1,62 @@
+/* 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     02/05/2010
+  @version  $Id: pulse.h 193 2014-11-10 23:51:41Z tirons $
+ **/
+
+#ifndef  _PULSE_H_INC
+#define  _PULSE_H_INC
+
+#include "LemmaObject.h"
+
+namespace Lemma {
+
+    // =======================================================================
+    //        Class:  Pulse
+    /// \brief Pure abstract class defining interace to some sort of pulse.
+    /// \details
+    // =======================================================================
+    class Pulse : public LemmaObject {
+
+        public:
+
+            /** Recursively prints information about this object
+             */
+            friend std::ostream &operator<<(std::ostream &stream,
+                    const Pulse &ob);
+
+            // ====================  LIFECYCLE     ===========================
+
+            // ====================  OPERATORS     ===========================
+
+            // ====================  OPERATIONS    ===========================
+
+            // ====================  ACCESS        ===========================
+
+            // ====================  INQUIRY       ===========================
+
+            // ====================  DATA MEMBERS  ===========================
+
+        protected:
+
+            // ====================  LIFECYCLE     ===========================
+
+            /// Default protected constructor.
+            Pulse (const std::string &name);
+
+            /// Default protected constructor.
+            ~Pulse ();
+
+    }; // -----  end of class  Pulse  -----
+
+}       // -----  end of Lemma  name  -----
+
+
+#endif   // ----- #ifndef _PULSE_H_INC  -----

LemmaCore/include/quasinewtonbfgs.h

@@ -0,0 +1,111 @@
+/* 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  -----

LemmaCore/include/receivercubes.h

@@ -0,0 +1,169 @@
+/* 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     06/17/2010
+  @version  $Id: receivercubes.h 193 2014-11-10 23:51:41Z tirons $
+ **/
+
+#ifndef  RECEIVERCUBES_INC
+#define  RECEIVERCUBES_INC
+
+#include "receiverpoints.h"
+
+namespace Lemma {
+
+
+    // ===================================================================
+    //        Class:  ReceiverCubes
+    /** This class builds on Reciver points, but supports a cube around
+     * each point. It is a direct descendent and may be used wherever
+     * ReceiverPoints is used
+     */
+    // ===================================================================
+    class ReceiverCubes : public ReceiverPoints {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+                const ReceiverCubes &ob);
+
+        friend class EmDipEarth1D;
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+
+            /**
+             *  Returns pointer to new DipoleSource. Location is
+             *  initialized to (0,0,0) type and polarization are
+             *  initialized  to nonworking values that will throw
+             *  exceptions if used.
+             */
+            static ReceiverCubes* New();
+
+            /**
+             * @copybrief LemmaObject::Delete()
+             * @copydetails LemmaObject::Delete()
+             */
+            void Delete();
+
+            // ====================  OPERATORS     =======================
+
+            // ====================  OPERATIONS    =======================
+
+            /** Sets the number of reciver cubes.
+             *  This method also resizes all the dynamic vectors in the class
+             *  to support this size.
+             *  @param[in] nrec is the number of cubes in the class.
+             */
+            void SetNumberOfReceivers(const int &nrec);
+
+            /** Sets the length of the x dimension of a single cube.
+             * @param[in] i is the cube number.
+             * @param[in] lx is the length of this cube, in this dimension.
+             */
+            void SetLengthX(const int &i, const Real &lx);
+
+            /** Sets the length of the y dimension of a single cube.
+             * @param[in] i is the cube number.
+             * @param[in] ly is the length of this cube, in this dimension.
+             */
+            void SetLengthY(const int &i, const Real &ly);
+
+            /** Sets the length of the z dimension of a single cube.
+             * @param[in] i is the cube number.
+             * @param[in] lz is the length of this cube, in this dimension.
+             */
+            void SetLengthZ(const int &i, const Real &lz);
+
+            /** Sets the lengths of all three dimensions of a single cube.
+             * @param[in] i is the cube number.
+             * @param[in] lx is the length of this cube, in this dimension.
+             * @param[in] ly is the length of this cube, in this dimension.
+             * @param[in] lz is the length of this cube, in this dimension.
+             */
+            void SetLength(const int &i, const Real& lx, const Real& ly,
+                            const Real &lz);
+
+            /** Sets the length of the x dimension of a single cube.
+             * @param[in] i is the cube number.
+             * @param[in] V is a vector of lenths.
+             */
+            void SetLength(const int &i, const Vector3r &V);
+
+
+            /** Gets the x dimension of cube i
+              * @param[in] i is the cube in quesion
+              * @return The legth of the x dimension of cube i
+              */
+            Real GetLengthX(const int &i);
+
+            /** Gets the y dimension of cube i
+              * @param[in] i is the cube in quesion
+              * @return The length of the y dimension of cube i
+              */
+            Real GetLengthY(const int &i);
+
+            /** Gets the z dimension of cube i
+              * @param[in] i is the cube in quesion
+              * @return The length of the z dimension of cube i
+              */
+            Real GetLengthZ(const int &i);
+
+            /** Gets the z dimension of cube i
+              * @param[in] i is the cube in quesion
+              * @return A vector of the lengths of the cube
+              */
+            Vector3r GetLength(const int& i);
+
+            /** Returns the volume of a cube
+              * @param[in] i is the cube of interest
+              * @return is the volume
+              */
+            Real GetVolume(const int&i);
+
+            /** Returns the volume of all the receiver cubes.
+              */
+            Real GetVolumeSum();
+
+            // ====================  ACCESS        =======================
+
+            // ====================  INQUIRY       =======================
+
+            // Returns the volume of a cube.
+            //Real GetCubeVolume(const int&i);
+            //VectorXr GetCubeVolumes();
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /// Default protected constructor.
+            ReceiverCubes (const std::string &name);
+
+            /// Default protected constructor.
+            ~ReceiverCubes ();
+
+            /**
+             * @copybrief LemmaObject::Release()
+             * @copydetails LemmaObject::Release()
+             */
+            void Release();
+
+            // ====================  DATA MEMBERS  =========================
+
+            /// Dimension of each cube stored here, first indice is x, second y, and
+            /// third z
+            Vector3Xr Lengths;
+
+        private:
+
+    }; // -----  end of class  ReceiverCubes  -----
+
+}       // -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef RECEIVERCUBES_INC  -----

LemmaCore/include/receiverpoints.h

@@ -0,0 +1,281 @@
+/* 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     12/02/2009
+  @version  $Id: receiverpoints.h 199 2014-12-29 19:25:20Z tirons $
+ **/
+
+#ifndef __RECEIVERPOINTS_H
+#define __RECEIVERPOINTS_H
+
+#ifdef LEMMAUSEVTK
+#include "vtkPointData.h"
+#include "vtkFieldData.h"
+#include "vtkGlyph3D.h"
+#include "vtkArrowSource.h"
+#include "vtkActor.h"
+#include "vtkPolyDataMapper.h"
+#include "vtkPoints.h"
+#include "vtkPolyData.h"
+#include "vtkDoubleArray.h"
+#include "vtkDataObject.h"
+#endif
+
+#include "LemmaObject.h"
+#include "dipolesource.h"
+
+#ifdef HAVE_YAMLCPP
+#include "yaml-cpp/yaml.h"
+#endif
+
+namespace Lemma {
+
+    // =======================================================================
+    //        Class:  ReceiverPoints
+    /// \brief  Points in the subsurface to make EM calculations,
+    ///  more general than the grids.
+    // =======================================================================
+    class ReceiverPoints : public LemmaObject {
+
+        public:
+
+            // ====================    FRIENDS     ===========================
+
+            /** Stream operator printing out information about this class.
+             */
+            friend std::ostream &operator<<(std::ostream &stream,
+                        const ReceiverPoints &ob);
+
+            friend class EMEarth1D;
+            friend class DipoleSource;
+
+            // ====================  LIFECYCLE     ===========================
+
+            /**
+             *  Returns pointer to new DipoleSource. Location is
+             *  initialized to (0,0,0) type and polarization are
+             *  initialized  to nonworking values that will throw
+             *  exceptions if used.
+             */
+            static ReceiverPoints* New();
+
+
+            /**
+             * @copybrief LemmaObject::Delete()
+             * @copydetails LemmaObject::Delete()
+             */
+            void Delete();
+
+            // ====================  OPERATORS     ===========================
+
+            // ====================  OPERATIONS    ===========================
+
+            // ====================  ACCESS        ===========================
+
+            /// Sets the number of receivers
+            virtual void SetNumberOfReceivers(const int &nrec);
+
+            /// Returns the location of a single receiver as an Eigen Vector
+            void SetLocation(const int& nrec, const Vector3r& loc);
+
+            /// Returns the location of a single receiver as an Eigen Vector
+            void SetLocation(const int& nrec, const Real& xp, const Real& yp,
+                            const Real& zp);
+
+            // ====================  INQUIRY       ===========================
+
+            /// Returns the number of receiverpoints.
+            int GetNumberOfReceivers();
+
+            /// Returns all the receiver locations as a 3 X matrix
+            Vector3Xr GetLocations();
+
+            /// Returns all the receiver locations as a general matrix, useful for python wrapper
+            MatrixXr GetLocationsMat();
+
+            /// Returns the E field for all locations
+            /// nfreq is the freqency desired
+            Vector3Xcr GetEfield(const int &nfreq);
+
+            /// Returns the E field for all locations
+            /// nfreq is the freqency desired, cast to general dynamic matrix, for python interoperability
+            MatrixXcr GetEfieldMat(const int &nfreq);
+
+            /// Returns the H field for all locations
+            /// nfreq is the freqency desired, cast to general dynamic matrix, for python interoperability
+            MatrixXcr GetHfieldMat(const int &nfreq);
+
+            /// Returns the H field for all locations
+            /// nfreq is the freqency desired
+            Vector3Xcr GetHfield(const int &nfreq);
+
+            /// Returns all of the computed H fields. Every frequency
+            std::vector<Vector3Xcr> GetHfield( );
+
+            /// Returns all of the computed E fields. Every frequency
+            std::vector<Vector3Xcr> GetEfield( );
+
+            /// Returns the E field of a single receiver as an Eigen Vector
+            /// nfreq is the freqency desired
+            Vector3cr GetEfield(const int &nfreq, const int& loc);
+
+            /// Returns the H field of a single receiver as an Eigen Vector
+            /// nfreq is the freqency desired
+            Vector3cr GetHfield(const int &nfreq, const int& loc);
+
+            /// Returns the B field of a single receiver as an Eigen Vector
+            /// nfreq is the freqency desired
+            Vector3cr GetBfield(const int &nfreq, const int& loc);
+
+            #ifdef LEMMAUSEVTK
+            /// Returns vtk Glyph actor that can be placed into scenes
+            vtkActor* GetVtkGlyphActor(const FIELDTYPE &ftype,
+                const Real& clip, const Real &scale,
+                const int &nfreq);
+
+            /// Returns a vtk Data Object that can easily be plotted
+            vtkDataObject * GetVtkDataObject(const FIELDTYPE &ftype,
+                const int& nbin,
+                const int& start, const int& end,
+                const FIELDCOMPONENT& fcomp,
+                const SPATIALCOORDINANT& scord);
+
+            /// Returns a vtk Data Object that can easily be plotted
+            vtkDataObject * GetVtkDataObjectFreq(const FIELDTYPE &ftype,
+                const int& nrec,
+                const int& fstart, const int& fend,
+                const FIELDCOMPONENT& fcomp,
+                const VectorXr& Freqs);
+            #endif
+
+            /// Returns the location of a single receiver as an Eigen Vector
+            Vector3r GetLocation(const int& loc);
+
+            /// Returns the x component of the location
+            Real GetLocationX(const int& loc);
+
+            /// Returns the y component of the location
+            Real GetLocationY(const int& loc);
+
+            /// Returns the z component of the location
+            Real GetLocationZ(const int& loc);
+
+            /// Resets fields
+            void ClearFields();
+
+            /// Sets the mask variable to true for this point.
+            void MaskPoint(const int& i);
+
+            /// Turns the mask off for this point.
+            void UnMaskPoint(const int& i);
+
+            /// Removes making on all points
+            void UnMaskAllPoints();
+
+            /// Returns the mask for this point
+            int GetMask(const int& i);
+
+            #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 ReceiverPoints* DeSerialize(const YAML::Node& node);
+            #endif
+
+        protected:
+
+            // ====================  LIFECYCLE     ===========================
+
+            /// Default protected constructor.
+            ReceiverPoints (const std::string& name);
+
+            #ifdef HAVE_YAMLCPP
+            /// Default protected constructor.
+            ReceiverPoints (const YAML::Node& node);
+            #endif
+
+            /// Default protected constructor.
+            ~ReceiverPoints ();
+
+            /**
+             * @copybrief LemmaObject::Release()
+             * @copydetails LemmaObject::Release()
+             */
+            void Release();
+
+            // ====================  OPERATIONS    ===========================
+
+            /// Sets the number of H bins. These bins are often frequencies.
+            void SetNumberOfBinsH(const int& nbins);
+
+            /// Sets the number of E bins. These bins are often frequencies.
+            void SetNumberOfBinsE(const int& nbins);
+
+            /** Internal function that resizes the EField data structure */
+            void ResizeEField();
+
+            /** Internal function that resizes the HField data structure */
+            void ResizeHField();
+
+            /// Sets the value of the E field
+            void SetEfield(const int &nfreq, const int& loc,
+                const Complex &ex, const Complex &ey, const Complex &ez);
+
+            /// Sets the value of the H field
+            void SetHfield(const int &nfreq, const int& loc,
+                const Complex &hx, const Complex &hy, const Complex &hz);
+
+            /// Appends the value of the E field. This method is not
+            /// thread safe.
+            void AppendEfield(const int&nfreq, const int& loc,
+                const Complex &ex, const Complex &ey, const Complex &ez);
+
+            /// Appends the value of the H field. This method is not
+            /// thread safe.
+            void AppendHfield(const int &nfreq, const int& loc,
+                const Complex &hx, const Complex &hy, const Complex &hz);
+
+            // ====================  DATA MEMBERS  ===========================
+
+            /// Number of receivers
+            int                         NumberOfReceivers;
+
+            /// Number of fields
+            int                         NumberOfBinsE;
+
+            /// Number of fields
+            int                         NumberOfBinsH;
+
+            /// Used to mask this point so no computation is made at
+            /// this point.
+            VectorXi                    Mask;
+
+            /// Locations of receivers
+            Vector3Xr                   Locations;
+
+        private:
+
+            // NOTE, these are not serialized in output!
+
+            /// Electric field at receiver locations
+            std::vector<Vector3Xcr>     Efield;
+
+            /// H field at receiver locations
+            std::vector<Vector3Xcr>     Hfield;
+
+    }; // -----  end of class  ReceiverPoints  -----
+}
+
+#endif // __RECEIVERPOINTS

LemmaCore/include/rectilineargrid.h

@@ -0,0 +1,237 @@
+/* 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     10/28/2010
+  @version  $Id: rectilineargrid.h 193 2014-11-10 23:51:41Z tirons $
+ **/
+
+#ifndef  RECTILINEARGRID_INC
+#define  RECTILINEARGRID_INC
+
+#include "grid.h"
+
+namespace Lemma {
+
+    // ===================================================================
+    //  Class:  RectilinearGrid
+    /**
+      @class
+      \brief   Impliments a rectilinear grid.
+      \details A rectilinear grid can vary regularily in space but must be
+               constant variation across each dimension. In this way three
+               vectors can define the entire grid, and each cell is right
+               aligned with all its neighbours.
+     */
+    // ===================================================================
+    class RectilinearGrid : public Grid {
+
+        friend std::ostream &operator<<(std::ostream &stream,
+			const RectilinearGrid &ob);
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+
+            /** Returns a pointer to a new object of type RectilinearGrid.
+             * It allocates all necessary memory.
+             */
+            static RectilinearGrid* New();
+
+            /**
+             *  @copybrief   LemmaObject::Delete()
+             *  @copydetails LemmaObject::Delete()
+             */
+            void Delete();
+
+            // ====================  OPERATORS     =======================
+
+            // ====================  OPERATIONS    =======================
+
+            /**
+             *  Sets the dimensions in x, y and z
+             *  @param[in] nx is the number of cells in x
+             *  @param[in] ny is the number of cells in y
+             *  @param[in] nz is the number of cells in z
+             */
+            void SetDimensions (const int &nx, const int &ny, const int &nz);
+
+            /**
+             *  Sets the offset in x, y and z. This sets the corner position of the top SW corner.
+             *  @param[in] ox is the number of cells in x
+             *  @param[in] oy is the number of cells in y
+             *  @param[in] oz is the number of cells in z
+             */
+            void SetOffset (const Real &ox, const Real &oy, const Real &oz);
+
+            /**
+             *  Sets the spacing in x, y and z
+             *  @param[in] dx is a Vector of cell spacing in x, must be same
+             *  size ad nx
+             *  @param[in] dy is a Vector of cell spacing in x, must be same
+             *  size ad ny
+             *  @param[in] dz is a Vector of cell spacing in x, must be same
+             *  size ad nz
+             */
+            void SetSpacing (const VectorXr &dx, const VectorXr &dy,
+                const VectorXr &dz);
+
+
+            // ====================  ACCESS        =======================
+
+            /** Returns the number of cells in x
+             *  @return number of cells in x
+             */
+            int GetNx();
+
+            /** Returns the number of cells in y
+             *  @return number of cells in y
+             */
+            int GetNy();
+
+            /** Returns the number of cells in z
+             *  @return number of cells in z
+             */
+            int GetNz();
+
+            /** Returns the offset of cells in x
+             *  @return offset of cells in x
+             */
+            Real GetOx();
+
+            /** Returns the number of cells in y
+             *  @return number of cells in y
+             */
+            Real GetOy();
+
+            /** Returns the offset of cells in z
+             *  @return offset of cells in z
+             */
+            Real GetOz();
+
+            /** Returns Spacing Vector
+             *  @return dx
+             */
+            VectorXr GetDx();
+
+            /** Returns a spacing
+             *  @return dx[ix]
+             */
+            Real GetDx(const int& ix);
+
+            /** Returns Spacing Vector
+             *  @return dy
+             */
+            VectorXr GetDy();
+
+            /** Returns a spacing
+             *  @return dy[iy]
+             */
+            Real GetDy(const int& iy);
+
+            /** Returns Spacing Vector
+             *  @return dz
+             */
+            VectorXr GetDz();
+
+            /** Returns Spacing Vector
+             *  @return dz[iz]
+             */
+            Real GetDz(const int& iz);
+
+            // ====================  INQUIRY       =======================
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /// Default protected constructor.
+            RectilinearGrid (const std::string &name);
+
+            /// Default protected constructor.
+            ~RectilinearGrid ();
+
+            /**
+             *  @copybrief   LemmaObject::Release()
+             *  @copydetails LemmaObject::Release()
+             */
+            void Release();
+
+            // ====================  DATA MEMBERS  =========================
+
+            /// Number of cells in the x dimension
+            int nx;
+
+            /// Number of cells in the y dimension
+            int ny;
+
+            /// Number of cells in the z dimension
+            int nz;
+
+            /// Grid offset in x dimension
+            Real ox;
+
+            /// Grid offset in y dimension
+            Real oy;
+
+            /// Grid offset in z dimension
+            Real oz;
+
+            /// Cell spacing in the x dimension
+            VectorXr dx;
+
+            /// Cell spacing in the y dimension
+            VectorXr dy;
+
+            /// Cell spacing in the z dimension
+            VectorXr dz;
+
+/*          @todo find a good way to store models that works with portions threadprivate
+            /// Container holding Vectors of Real data at centre of cell.
+            std::vector<VectorXr>   RealCellData;
+
+            /// Container holding names of Real data
+            std::vector<std::string> RealCellDataNames;
+
+            /// Container holding Vectors of Real data on edges.
+            std::vector<VectorXr>   RealEdgeData;
+
+            /// Container holding names of Real data on edges
+            std::vector<std::string> RealEdgeDataNames;
+
+            /// Container holding Vectors of Complex data on edges.
+            std::vector<VectorXcr>   ComplexEdgeData;
+
+            /// Container holding names of Real data on edges
+            std::vector<std::string> ComplexEdgeDataNames;
+
+            /// Container holding Vectors of Real properties.
+            std::vector<VectorXr>   RealCellProperties;
+
+            /// Container holding names of Real cell properties
+            std::vector<std::string> RealCellPropertyNames;
+
+            /// Container holding Vectors of Real data.
+            std::vector<VectorXcr>   ComplexCellData;
+
+            /// Container holding names of Real data
+            std::vector<std::string> ComplexCellDataNames;
+
+            /// Container holding Vectors of Complex properties.
+            std::vector<VectorXcr>   ComplexCellProperties;
+
+            /// Container holding names of Real cell properties
+            std::vector<std::string> ComplexCellPropertyNames;
+*/
+        private:
+
+    }; // -----  end of class  RectilinearGrid  -----
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef RECTILINEARGRID_INC  -----

LemmaCore/include/sintransintegrationkernel.h

@@ -0,0 +1,97 @@
+/* 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     02/08/2011
+  @version  $Id: sintransintegrationkernel.h 87 2013-09-05 22:44:05Z tirons $
+ **/
+
+#ifndef  SINTRANSINTEGRATIONKERNEL_INC
+#define  SINTRANSINTEGRATIONKERNEL_INC
+
+#include "integrationkernel.h"
+
+namespace Lemma {
+
+    // ===================================================================
+    //  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.
+     */
+    // ===================================================================
+    class SinTransIntegrationKernel : public IntegrationKernel<Real> {
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+
+            /** Returns a pointer to a new object of type SinTransIntegrationKernel.
+             * It allocates all necessary memory.
+             */
+            static SinTransIntegrationKernel* New();
+
+            /** Deletes this object. Delete also disconnects any
+             * attachments to this object.
+             */
+            void Delete();
+
+            // ====================  OPERATORS     =======================
+
+            Real Argument(const Real&x, const int& iRelated);
+
+            int GetNumRel();
+
+            /// Sets the value 'A' used in test cases
+            void SetA(const Real& A);
+
+            /** Sets the integral to evaluate (1, 2, 3)
+             */
+            void SetIntegral(const int& i);
+
+            /** Returns the analytical answer at A and B */
+            Real GetAnalytical(const Real& B);
+            // ====================  OPERATIONS    =======================
+
+            // ====================  ACCESS        =======================
+
+            // ====================  INQUIRY       =======================
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /** Deletes this object. Delete also disconnects any
+             * attachments to this object.
+             */
+            void Release();
+
+            /// Default protected constructor.
+            SinTransIntegrationKernel (const std::string& name);
+
+            /// Default protected constructor.
+            ~SinTransIntegrationKernel ();
+
+            // ====================  DATA MEMBERS  =========================
+
+            /** Value used in test cases  */
+            Real A;
+
+            /** Test integral to evaluate */
+            int Integral;
+
+        private:
+
+    }; // -----  end of class  SinTransIntegrationKernel  -----
+
+
+}		// -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef SINTRANSINTEGRATIONKERNEL_INC  -----

LemmaCore/include/temintegrationkernel.h

@@ -0,0 +1,103 @@
+/* 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   M. Andy Kass
+  @date     02/10/2011
+  @version  $Id: temintegrationkernel.h 190 2014-10-16 23:02:09Z tirons $
+ **/
+
+#ifndef __TEMINTEGRATIONKERNEL_H
+#define __TEMINTEGRATIONKERNEL_H
+
+#include "integrationkernel.h"
+#include "emearth1d.h"
+
+namespace Lemma {
+
+
+// ===================================================================
+//        Class:  TemIntegrationKernel
+/// \brief  Integration kernel for calculation of TEM data
+/// \details Calculates the integration kernel for the sine transform
+// ===================================================================
+
+class TemIntegrationKernel : public IntegrationKernel<Real>{
+
+	//friend std::ostream &operator<<(std::ostream &stream,
+	//	const TemIntegrationKernel &ob);
+
+	public:
+
+	// ====================  LIFECYCLE     =======================
+
+		static TemIntegrationKernel* New();
+
+		void Delete();
+
+	// ====================  OPERATORS     =======================
+
+	// ====================  OPERATIONS    =======================
+
+	// ====================  ACCESS        =======================
+
+		/// Calculates the integration argument.  Passed a frequency.
+		Real Argument(const Real&x, const int& iRelated);
+
+		int GetNumRel();
+
+		/// Attach EMEarth1D object to TemIntegrationKernel
+		void SetEMEarth1D(EMEarth1D* earth);
+
+		/// Attach Transmitter object
+		void SetTransmitter(WireAntenna *antennae);
+
+		/// Attach Dipole object
+		void SetDipole(DipoleSource* dipolesource);
+
+		/// Attach Receiver object
+		void SetReceiver(ReceiverPoints *receiver);
+
+        /**
+         *   @param[in] comp is the component to integrate
+         */
+        void SetComponent(const FIELDCOMPONENT& comp);
+	// ====================  INQUIRY       =======================
+
+
+
+	protected:
+
+	// ====================  LIFECYCLE     =======================
+
+		/// Default protected constructor.
+		TemIntegrationKernel (const std::string& name);
+
+		/// Default protected constructor.
+		~TemIntegrationKernel ();
+
+		void Release();
+
+	// ====================  DATA MEMBERS  =========================
+
+        FIELDCOMPONENT  component;
+
+		EMEarth1D* EmEarthInt;
+
+		WireAntenna* Trans;
+
+		DipoleSource* DipoleS;
+
+		ReceiverPoints* Receivers;
+
+	private:
+
+}; // -----  end of class  TemIntegrationKernel  -----
+
+} // End of namespace Lemma
+
+#endif // __TEMINTEGRATIONKERNEL_H

LemmaCore/include/timer.h

@@ -0,0 +1,82 @@
+/* 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     01/27/2010
+  @version  $Id: timer.h 87 2013-09-05 22:44:05Z tirons $
+ **/
+
+#ifndef  TIMER_H_INC
+#define  TIMER_H_INC
+
+#include <iostream>
+#include <fstream>
+#include <ctime>
+#ifdef LEMMAUSEOMP
+#include "omp.h"
+#endif
+
+#include "lemma.h"
+
+namespace Lemma {
+
+/** \brief Simple timer class.
+  * \details Can be used either with multithreaded applications, using
+  * OpenMP defined functions, or using system wall time. System wall time
+  * is not good for parallel programs as it reports cpu core execution time.
+  */
+class jsw_timer {
+
+    public:
+
+        /**
+          * Constructor that automatically starts the timer.
+          */
+        jsw_timer(): start ( std::clock() ), elapsed ( 0.0 ) {
+
+        }
+
+        /** begins the timer.
+          */
+        void begin() {
+            #ifdef LEMMAUSEOMP
+            start =  omp_get_wtime();
+            #else
+            start = std::clock();
+            #endif
+            elapsed = 0.0;
+        }
+
+        /** Ends the timer.
+          * @return the time that the stopwatch ended at.
+          */
+        Real end() {
+
+            #ifdef LEMMAUSEOMP
+            elapsed = static_cast<Real> (omp_get_wtime()) - start;
+            return elapsed;
+            #else
+            elapsed = static_cast<Real> ( std::clock() ) - start;
+            return elapsed /= CLOCKS_PER_SEC;
+            #endif
+
+        }
+
+        /**
+          * @return the elapsed time between start and end.
+          */
+        Real last() const { return elapsed; }
+
+    private:
+        std::clock_t start;
+        Real    elapsed;
+};
+
+}       // -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef TIMER_H_INC  -----

LemmaCore/include/windowfilter.h

@@ -0,0 +1,130 @@
+/* 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     07/20/2010
+  @version  $Id: windowfilter.h 193 2014-11-10 23:51:41Z tirons $
+ **/
+
+#ifndef  WINDOWFILTER_INC
+#define  WINDOWFILTER_INC
+#include "filter.h"
+
+namespace Lemma {
+    /** Types of filter window that are supported.
+     */
+    enum WINDOWTYPE { HAMMING, /*!< A hamming window */
+                      HANNING, /*!< A hanning window */
+                      RECTANGULAR /*!< Rectangular window */
+                    };
+
+    // ===================================================================
+    //  Class:  WindowFilter
+    /**
+      @class   WindowFilter
+      \brief   Fourier domain window filter.
+      \details Current types are Hamming and Hanning. Others to be added.
+     */
+    // ===================================================================
+    class WindowFilter : public Filter {
+
+        public:
+
+            // ====================  LIFECYCLE     =======================
+
+            /**
+             * Returns a pointer to a new object of type WindowFilter.
+             * It allocates all necessary memory.
+             */
+            static WindowFilter* New();
+
+            /**
+             * @copybrief LemmaObject::Delete()
+             * @copydetails LemmaObject::Delete()
+             */
+            void Delete();
+
+            // ====================  OPERATORS     =======================
+
+            // ====================  OPERATIONS    =======================
+
+            /// Sets the bandwith of the window.
+            /// @param[in] width Bandwidth in Hz
+            void SetBandwidth(const Real& width);
+
+            /// Sets the sampling rate of an input time domain signal.
+            /// @param[in] dt is the sampling rate, in seconds.
+            void SetSamplingInterval(const Real& dt);
+
+            /// Specifies the length of the time series to apply filter to.
+            void SetNumberOfSamples(const int& nt);
+
+            /// Sets the type of window to compute.
+            void SetWindowType(const WINDOWTYPE& type);
+
+            /** Returns the number of frequency bins for whole data record.
+             *  this is different then the length of the filter. This is
+             *  simply the length of the real to complex FFT, or
+             *  Nw = Nt%2 ? (Nt-1)/2+1 : (Nt)/2+1;
+             *  @return the number of frequency bins.
+             */
+            int GetNumberOfFrequencyBins();
+
+            // ====================  ACCESS        =======================
+
+            // ====================  INQUIRY       =======================
+
+            /// Returns a Vector of the filter coefficients.
+            VectorXr GetFilterCoefficients( );
+
+        protected:
+
+            // ====================  LIFECYCLE     =======================
+
+            /// Default protected constructor.
+            WindowFilter (const std::string& name);
+
+            /// Default protected constructor.
+            ~WindowFilter ();
+
+            /**
+             * @copybrief LemmaObject::Release()
+             * @copydetails LemmaObject::Release()
+             */
+            void Release();
+
+            // ====================  DATA MEMBERS  =========================
+
+            /// Width of the window
+            int         Width;
+
+            /// Length of time series
+            int         Nt;
+
+            /// Length of the frequency series representation
+            int         Nw;
+
+            /// Sampling rate of a time domain signal
+            Real        SamplingRate;
+
+            /// Bandwith of filter
+            Real        Bandwidth;
+
+            /// The filter coefficients
+            VectorXr    Coefficients;
+
+            /// The type of filter to use
+            WINDOWTYPE  Type;
+
+        private:
+
+    }; // -----  end of class  WindowFilter  -----
+
+}       // -----  end of Lemma  name  -----
+
+#endif   // ----- #ifndef WINDOWFILTER_INC  -----

LemmaCore/lemma.h

@@ -1,23 +0,0 @@
-/* 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/16/2016 04:40:33 PM
- * @version   $Id$
- * @author    Trevor Irons (ti)
- * @email     tirons@egi.utah.edu
- * @copyright Copyright (c) 2016, University of Utah
- * @copyright Copyright (c) 2016, Trevor Irons & Lemma Software, LLC
- */
-
-#include "yaml-cpp/yaml.h"
-
-float thingy();
-

LemmaCore/src/AEMSurvey.cpp

@@ -0,0 +1,111 @@
+/* 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/24/2013 04:09:04 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@xri-geo.com
+ * @copyright Copyright (c) 2013, XRI Geophysics, LLC
+ * @copyright Copyright (c) 2013, Trevor Irons
+ */
+
+#include "AEMSurvey.h"
+
+namespace Lemma {
+
+// ====================  FRIEND METHODS  =====================
+
+std::ostream &operator<<(std::ostream &stream, const AEMSurvey &ob) {
+
+    stream << *(LemmaObject*)(&ob);
+
+    return stream;
+}
+
+// ====================  LIFECYCLE     =======================
+
+//--------------------------------------------------------------------------------------
+//       Class:  AEMSurvey
+//      Method:  AEMSurvey
+// Description:  constructor (protected)
+//--------------------------------------------------------------------------------------
+AEMSurvey::AEMSurvey (const std::string& name) : LemmaObject(name) {
+
+}  // -----  end of method AEMSurvey::AEMSurvey  (constructor)  -----
+
+
+//--------------------------------------------------------------------------------------
+//       Class:  AEMSurvey
+//      Method:  New()
+// Description:  public constructor
+//--------------------------------------------------------------------------------------
+AEMSurvey* AEMSurvey::New() {
+    AEMSurvey*  Obj = new AEMSurvey("AEMSurvey");
+    Obj->AttachTo(Obj);
+    return Obj;
+}
+
+//--------------------------------------------------------------------------------------
+//       Class:  AEMSurvey
+//      Method:  ~AEMSurvey
+// Description:  destructor (protected)
+//--------------------------------------------------------------------------------------
+AEMSurvey::~AEMSurvey () {
+
+    for (unsigned int isc=0; isc<Sources.size(); ++isc) Sources[isc]->Delete();
+
+}  // -----  end of method AEMSurvey::~AEMSurvey  (destructor)  -----
+
+//--------------------------------------------------------------------------------------
+//       Class:  AEMSurvey
+//      Method:  Delete
+// Description:  public destructor
+//--------------------------------------------------------------------------------------
+void AEMSurvey::Delete() {
+    this->DetachFrom(this);
+}
+
+//--------------------------------------------------------------------------------------
+//       Class:  AEMSurvey
+//      Method:  Release
+// Description:  destructor (protected)
+//--------------------------------------------------------------------------------------
+void AEMSurvey::Release() {
+    delete this;
+}
+
+//--------------------------------------------------------------------------------------
+//       Class:  AEMSurvey
+//      Method:  GetSource
+//--------------------------------------------------------------------------------------
+DipoleSource* AEMSurvey::GetSource ( const int& isource ) {
+    return Sources[isource] ;
+}		// -----  end of method AEMSurvey::GetSource  -----
+
+//--------------------------------------------------------------------------------------
+//       Class:  AEMSurvey
+//      Method:  GetFrequencies
+//--------------------------------------------------------------------------------------
+VectorXr AEMSurvey::GetFrequencies (  ) {
+    return Freqs;
+}		// -----  end of method AEMSurvey::GetFrequencies  -----
+
+
+//--------------------------------------------------------------------------------------
+//       Class:  AEMSurvey
+//      Method:  GetNumberOfSources
+//--------------------------------------------------------------------------------------
+int AEMSurvey::GetNumberOfSources (  ) {
+    return  static_cast<int>(Sources.size());
+}		// -----  end of method AEMSurvey::GetNumberOfSources  -----
+
+
+}		// -----  end of Lemma  name  -----

LemmaCore/src/AEMSurveyReader.cpp

@@ -0,0 +1,169 @@
+/* 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/24/2013 04:36:14 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@xri-geo.com
+ * @copyright Copyright (c) 2013, XRI Geophysics, LLC
+ * @copyright Copyright (c) 2013, Trevor Irons
+ */
+
+#include "AEMSurveyReader.h"
+
+namespace Lemma {
+
+    // ====================  FRIEND METHODS  =====================
+
+    std::ostream &operator<<(std::ostream &stream, const AEMSurveyReader &ob) {
+
+        stream << *(LemmaObject*)(&ob);
+
+        return stream;
+    }
+
+    // ====================  LIFECYCLE     =======================
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  AEMSurveyReader
+    //      Method:  AEMSurveyReader
+    // Description:  constructor (protected)
+    //--------------------------------------------------------------------------------------
+    AEMSurveyReader::AEMSurveyReader (const std::string& name) :
+        LemmaObject(name), Survey(NULL) {
+
+    }  // -----  end of method AEMSurveyReader::AEMSurveyReader  (constructor)  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  AEMSurveyReader
+    //      Method:  New()
+    // Description:  public constructor
+    //--------------------------------------------------------------------------------------
+    AEMSurveyReader* AEMSurveyReader::New() {
+        AEMSurveyReader*  Obj = new AEMSurveyReader("AEMSurveyReader");
+        Obj->AttachTo(Obj);
+        return Obj;
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  AEMSurveyReader
+    //      Method:  ~AEMSurveyReader
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
+    AEMSurveyReader::~AEMSurveyReader () {
+        if (Survey) Survey->Delete();
+    }  // -----  end of method AEMSurveyReader::~AEMSurveyReader  (destructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  AEMSurveyReader
+    //      Method:  Delete
+    // Description:  public destructor
+    //--------------------------------------------------------------------------------------
+    void AEMSurveyReader::Delete() {
+        this->DetachFrom(this);
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  AEMSurveyReader
+    //      Method:  Release
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
+    void AEMSurveyReader::Release() {
+        delete this;
+    }
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  AEMSurveyReader
+    //      Method:  GetSurvey
+    //--------------------------------------------------------------------------------------
+    AEMSurvey* AEMSurveyReader::GetSurvey (  ) {
+        return Survey;
+    }		// -----  end of method AEMSurveyReader::GetSurvey  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  AEMSurveyReader
+    //      Method:  ReadASCIIAEMFile
+    //--------------------------------------------------------------------------------------
+    void AEMSurveyReader::ReadASCIIAEMFile (  const std::string& fname ) {
+
+        if (Survey) Survey->Delete();
+        Survey = AEMSurvey::New();
+        ASCIIParser* Parser = ASCIIParser::New();
+        Parser->SetCommentString("//");
+        Parser->Open(fname);
+
+        // Sanity check
+        std::vector<int> ivals = Parser->ReadInts(1);
+        std::vector<Real> freqs;
+        for (int isc=0; isc<ivals[0]; ++isc) {
+            Real df = Parser->ReadReals(1)[0]; // frequency Hz
+            bool unique = true;
+            for (unsigned int ifreq=0; ifreq<freqs.size(); ++ifreq) {
+                if (df - freqs[ifreq] < 1e-2) {
+                    unique = false;
+                }
+            }
+            if (unique) freqs.push_back(df);
+            std::string DT = Parser->ReadStrings(1)[0];
+            if (DT == "MD" || DT == "ED") {
+            } else {
+                std::cerr << "In AEMSurveyReader::ReadASCIIAEMFile. The source type: "
+                          << DT << " is not supported.\n";
+                std::exit(EXIT_FAILURE);
+            }
+            Parser->ReadReals(4); // position and moment
+        }
+
+        Survey->Freqs = VectorXr::Map(&freqs[0], freqs.size());
+
+        // OK, now get cracking, those sources at every location
+        int nb = Parser->ReadInts(1)[0];  // number of locations
+        for (int ib=0; ib<nb; ++ib) {
+            std::vector<Real> rvals = Parser->ReadReals(6); // position and moment
+            int bp = Parser->GetFileLocation(  );
+            Parser->JumpToLocation( 0 );
+            //std::vector<int> ivals = Parser->ReadInts(1);   // number of frequencies
+            int nf = Parser->ReadInts(1)[0];   // number of frequencies
+            for (int isc=0; isc<nf; ++isc) {
+                Survey->Sources.push_back(DipoleSource::New());
+                int cnt = Survey->Sources.size() - 1; //
+                // and now set it
+                Survey->Sources[cnt]->SetNumberOfFrequencies(1);
+                Survey->Sources[cnt]->SetFrequency(0, Parser->ReadReals(1)[0]);
+                std::string DT = Parser->ReadStrings(1)[0];
+                if (DT == "MD") {
+                     Survey->Sources[cnt]->SetType(MAGNETICDIPOLE);
+                } else if (DT == "ED") {
+                     Survey->Sources[cnt]->SetType(UNGROUNDEDELECTRICDIPOLE);
+                } else {
+                    std::cerr << "In AEMSurveyReader::ReadASCIIAEMFile. The source type: "
+                              << DT << " is not supported.\n";
+                    std::exit(EXIT_FAILURE);
+                }
+                std::vector<Real> irvals = Parser->ReadReals(4); // position and moment
+                Survey->Sources[cnt]->SetMoment(irvals[3]);
+                Survey->Sources[cnt]->SetLocation(rvals[0] + irvals[0], rvals[1] + irvals[1],
+                                                     rvals[2] + irvals[2]);
+                Survey->Sources[cnt]->SetPolarisation(rvals[3], rvals[4], rvals[5]);
+            }
+            Parser->JumpToLocation(bp);
+        }
+
+        Parser->Delete();
+
+        return ;
+    }		// -----  end of method AEMSurveyReader::ReadASCIIAEMFile  -----
+
+
+}		// -----  end of Lemma  name  -----

LemmaCore/src/ASCIIParser.cpp

@@ -0,0 +1,216 @@
+/* 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/23/2013 02:33:41 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@xri-geo.com
+ * @copyright Copyright (c) 2013, XRI Geophysics, LLC
+ * @copyright Copyright (c) 2013, Trevor Irons
+ */
+
+#include "ASCIIParser.h"
+
+namespace Lemma {
+
+
+    // ====================  FRIEND METHODS  =====================
+
+    std::ostream &operator<<(std::ostream &stream, const ASCIIParser &ob) {
+
+        stream << *(LemmaObject*)(&ob);
+
+        return stream;
+    }
+
+    // ====================  LIFECYCLE     =======================
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ASCIIParser
+    //      Method:  ASCIIParser
+    // Description:  constructor (protected)
+    //--------------------------------------------------------------------------------------
+    ASCIIParser::ASCIIParser (const std::string& name) : LemmaObject(name),
+            CommentString("//"), BufferSize(255) {
+
+    }  // -----  end of method ASCIIParser::ASCIIParser  (constructor)  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ASCIIParser
+    //      Method:  New()
+    // Description:  public constructor
+    //--------------------------------------------------------------------------------------
+    ASCIIParser* ASCIIParser::New() {
+        ASCIIParser*  Obj = new ASCIIParser("ASCIIParser");
+        Obj->AttachTo(Obj);
+        return Obj;
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ASCIIParser
+    //      Method:  ~ASCIIParser
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
+    ASCIIParser::~ASCIIParser () {
+
+    }  // -----  end of method ASCIIParser::~ASCIIParser  (destructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ASCIIParser
+    //      Method:  Delete
+    // Description:  public destructor
+    //--------------------------------------------------------------------------------------
+    void ASCIIParser::Delete() {
+        this->DetachFrom(this);
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ASCIIParser
+    //      Method:  Release
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
+    void ASCIIParser::Release() {
+        delete this;
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ASCIIParser
+    //      Method:  Open
+    //--------------------------------------------------------------------------------------
+    void ASCIIParser::Open ( const std::string& fname ) {
+        input.open(fname.c_str(), std::ios::in);
+        if (input.fail()) {
+           throw  GenericFileIOError(this, fname);
+        }
+        return ;
+    }		// -----  end of method ASCIIParser::Open  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ASCIIParser
+    //      Method:  Close
+    //--------------------------------------------------------------------------------------
+    void ASCIIParser::Close (  ) {
+        input.close();
+        return ;
+    }		// -----  end of method ASCIIParser::Close  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ASCIIParser
+    //      Method:  ReadReals
+    //--------------------------------------------------------------------------------------
+    std::vector<Real> ASCIIParser::ReadReals ( const int& nr ) {
+        std::string buf;
+        char *dump = new char[BufferSize];
+        std::vector<Real> vals(0);
+        while (input >> buf) {
+            if (buf.substr(0, CommentString.size()) == CommentString) {
+                input.getline(dump, BufferSize);
+            } else {
+                vals.push_back( atof(buf.c_str() ));
+            }
+            if (static_cast<int>(vals.size()) == nr) {
+                delete [] dump;
+                return vals;
+            }
+        }
+        delete [] dump;
+        return vals;
+    }		// -----  end of method ASCIIParser::ReadReals  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ASCIIParser
+    //      Method:  ReadInts
+    //--------------------------------------------------------------------------------------
+    std::vector<int> ASCIIParser::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  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ASCIIParser
+    //      Method:  ReadStings
+    //--------------------------------------------------------------------------------------
+    std::vector<std::string> ASCIIParser::ReadStrings ( const int& nr ) {
+        std::string buf;
+        char *dump = new char[BufferSize];
+        std::vector<std::string> vals(0);
+        while (input >> buf) {
+            if (buf.substr(0, CommentString.size()) == CommentString) {
+                input.getline(dump, BufferSize);
+            } else {
+                vals.push_back( buf );
+            }
+            if (static_cast<int>(vals.size()) == nr) {
+                delete [] dump;
+                return vals;
+            }
+
+        }
+        delete [] dump;
+        return vals;
+    }		// -----  end of method ASCIIParser::ReadInts  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ASCIIParser
+    //      Method:  SetCommentString
+    //--------------------------------------------------------------------------------------
+    void ASCIIParser::SetCommentString ( const std::string& key ) {
+        CommentString = key;
+    }		// -----  end of method ASCIIParser::SetCommentString  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ASCIIParser
+    //      Method:  SetBufferSize
+    //--------------------------------------------------------------------------------------
+    void ASCIIParser::SetBufferSize ( const int& size ) {
+        BufferSize = size;
+    }		// -----  end of method ASCIIParser::SetCommentString  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ASCIIParser
+    //      Method:  GetFileLocation
+    //--------------------------------------------------------------------------------------
+    int ASCIIParser::GetFileLocation (  ) {
+        return input.tellg();
+    }		// -----  end of method ASCIIParser::GetFileLocation  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ASCIIParser
+    //      Method:  JumpToLocation
+    //--------------------------------------------------------------------------------------
+    void ASCIIParser::JumpToLocation ( const int& loc ) {
+        input.seekg( loc );
+        return ;
+    }		// -----  end of method ASCIIParser::JumpToLocation  -----
+
+
+}		// -----  end of Lemma  name  -----
+
+

LemmaCore/src/CubicSplineInterpolator.cpp

@@ -0,0 +1,335 @@
+/* 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/07/2014 12:50:52 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@xri-geo.com
+ * @copyright Copyright (c) 2014, XRI GeophysiSpline, LLC
+ * @copyright Copyright (c) 2014, Trevor Irons
+ */
+
+#include "CubicSplineInterpolator.h"
+
+#include<iostream>
+#include<fstream>
+#include<vector>
+#include<algorithm>
+#include<cmath>
+
+namespace Lemma {
+
+    // ====================  FRIEND METHODS  =====================
+
+    std::ostream &operator<<(std::ostream &stream, const CubicSplineInterpolator &ob) {
+
+        stream << *(LemmaObject*)(&ob);
+
+        return stream;
+    }
+
+    // ====================  LIFECYCLE     =======================
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CubicSplineInterpolator
+    //      Method:  CubicSplineInterpolator
+    // Description:  constructor (protected)
+    //--------------------------------------------------------------------------------------
+    CubicSplineInterpolator::CubicSplineInterpolator (const std::string& name) : LemmaObject(name) {
+
+    }  // -----  end of method CubicSplineInterpolator::CubicSplineInterpolator  (constructor)  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CubicSplineInterpolator
+    //      Method:  New()
+    // Description:  public constructor
+    //--------------------------------------------------------------------------------------
+    CubicSplineInterpolator* CubicSplineInterpolator::New() {
+        CubicSplineInterpolator*  Obj = new CubicSplineInterpolator("CubicSplineInterpolator");
+        Obj->AttachTo(Obj);
+        return Obj;
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CubicSplineInterpolator
+    //      Method:  ~CubicSplineInterpolator
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
+    CubicSplineInterpolator::~CubicSplineInterpolator () {
+
+    }  // -----  end of method CubicSplineInterpolator::~CubicSplineInterpolator  (destructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CubicSplineInterpolator
+    //      Method:  Delete
+    // Description:  public destructor
+    //--------------------------------------------------------------------------------------
+    void CubicSplineInterpolator::Delete() {
+        this->DetachFrom(this);
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CubicSplineInterpolator
+    //      Method:  Release
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
+    void CubicSplineInterpolator::Release() {
+        delete this;
+    }
+
+    // ====================  OPERATIONS    =======================
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CubicSplineInterpolator
+    //      Method:  SetKnots
+    //--------------------------------------------------------------------------------------
+    void CubicSplineInterpolator::SetKnots ( const VectorXr& x, const VectorXr& y ) {
+
+        int n = x.size()-1;
+
+        Spline = SplineSet(n);
+
+        Spline.a = y;
+        Spline.x = x;
+        VectorXr h = VectorXr::Zero(n);
+        for(int i=0; i<n; ++i)
+            h(i) = Spline.x(i+1)-Spline.x(i);
+
+        VectorXr alpha(n-1);
+        for(int i=1; i<n-1; ++i)
+            alpha(i) =  3.*(Spline.a[i+1]-Spline.a[i])/h[i] - 3.*(Spline.a[i]-Spline.a[i-1])/h[i-1] ;
+
+        VectorXr l = VectorXr::Zero(n+1);
+        VectorXr mu  = VectorXr::Zero(n+1);
+        VectorXr z = VectorXr::Zero(n+1);
+        l[0] = 1;
+        mu[0] = 0;
+        z[0] = 0;
+
+        for(int i = 1; i < n-1; ++i) {
+            l[i] = 2 *(Spline.x[i+1]-Spline.x[i-1])-h[i-1]*mu[i-1];
+            mu[i] = h[i]/l[i];
+            z[i] = (alpha[i]-h[i-1]*z[i-1])/l[i];
+        }
+        l[n] = 1;
+        z[n] = 0;
+
+        for(int j = n-1; j >= 0; --j) {
+            Spline.c[j] = z[j] - mu[j] * Spline.c[j+1];
+            Spline.b[j] = (Spline.a[j+1]-Spline.a[j])/h[j]-h[j]*(Spline.c[j+1]+2*Spline.c[j])/3;
+            Spline.d[j] = (Spline.c[j+1]-Spline.c[j])/3/h[j];
+        }
+        // On OSX, this causes a strange bug 'sometimes', alignment?
+        //Spline.c = Spline.c.head(n);
+
+        return;
+    }		// -----  end of method CubicSplineInterpolator::SetKnots  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CubicSplineInterplator
+    //      Method:  ResetKnotOrdinate
+    //--------------------------------------------------------------------------------------
+    void CubicSplineInterpolator::ResetKnotOrdinate ( const VectorXr& y ) {
+        VectorXr x = Spline.x;
+        SetKnots(x, y);
+        return ;
+    }		// -----  end of method CubicSplineInterplator::ResetKnotOrdinate  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CubicSplineInterpolator
+    //      Method:  InterpolateOrderedSet
+    //--------------------------------------------------------------------------------------
+    VectorXr CubicSplineInterpolator::InterpolateOrderedSet ( const VectorXr& x ) {
+        VectorXr y = VectorXr::Zero(x.size());
+        int ii = 0;
+        for (int iy=0; iy<y.size(); ++iy) {
+            y[iy] = Interpolate(x[iy], ii);
+        }
+        return y;
+    }		// -----  end of method CubicSplineInterpolator::InterpolateOrderedSet  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CubicSplineInterpolator
+    //      Method:  Interpolate
+    //--------------------------------------------------------------------------------------
+    Real CubicSplineInterpolator::Interpolate ( const Real& x, int& i) {
+        // O(n) search, could do bisection, but if these are sorted, then this is quick
+        while(Spline.x[i] < x && i<Spline.x.size()) {
+            ++i;
+        }
+        --i;
+
+        //if ( x > Spline.x[i] ) {
+        //    throw std::runtime_error("CubicSplineInterpolator::Interpolate ATTEMPT TO INTERPOLATE PAST LAST KNOT");
+        //}
+
+        return Spline.a[i] + Spline.b[i]*(x-Spline.x[i]) + Spline.c[i]*((x-Spline.x[i])*(x-Spline.x[i])) +
+               Spline.d[i]*((x-Spline.x[i])*(x-Spline.x[i])*(x-Spline.x[i]) );
+    }		// -----  end of method CubicSplineInterpolator::Interpolate  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CubicSplineInterpolator
+    //      Method:  Interpolate
+    //--------------------------------------------------------------------------------------
+    Real CubicSplineInterpolator::Interpolate ( const Real& x ) {
+        int ii(0);
+        return Interpolate(x, ii);
+    }
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CubicSplineInterpolator
+    //      Method:  Integrate
+    //--------------------------------------------------------------------------------------
+    Real CubicSplineInterpolator::Integrate ( const Real& x0, const Real& x1, const int& n ) {
+
+        assert(n > 0);
+        // force n to be even?
+        //n += (n % 2);
+
+        Real S = Interpolate(x0) + Interpolate(x1);
+        Real h = (x1 - x0) / Real(n);
+
+        int ik = 0;
+        for (int i=1; i<n; i+=2) {
+            S += 4. * Interpolate(x0 + (Real)(i)*h, ik);
+        }
+
+        ik = 0;
+        for (int i=2; i<n-1; i+=2) {
+            S += 2. * Interpolate(x0 + (Real)(i)*h, ik);
+        }
+
+        return  S * h / 3.;
+    }
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CubicSplineInterpolator
+    //      Method:  Integrate
+    //--------------------------------------------------------------------------------------
+    Real CubicSplineInterpolator::Integrate ( const Real& x0, const Real& x1 ) {
+
+
+        int i0 = Interval(x0);
+        int i1 = Interval(x1);
+
+        Real h0 = x0 - Spline.x(i0);
+        if (mflag == -1) h0 = 0;
+        Real h1 = x1 - Spline.x(i1);
+
+        Real cubint = (((Spline.d(i1)*h1/4.0 + Spline.c(i1) )*h1/3.0 +
+                         Spline.b(i1) )*h1/2.0 + Spline.a(i1) )*h1
+                    - (((Spline.d(i0)*h0/4.0 + Spline.c(i0) )*h0/3.0 +
+                         Spline.b(i0) )*h0/2.0 + Spline.a(i0) )*h0;
+
+        // Include integrals over intervening intervals.
+        if (i1 > i0) {
+            for (int i=i0; i<i1-1; ++i) {
+                Real h = Spline.x(i+1) - Spline.x(i);
+                cubint +=  (((Spline.d(i)*h/4.0 + Spline.c(i) )*h/3.0 +
+                              Spline.b(i))*h/2.0 + Spline.a(i) )*h;
+            }
+        }
+        return cubint;
+    }		// -----  end of method CubicSplineInterpolator::Integrate  -----
+
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CubicSplineInterpolator
+    //      Method:  Interval
+    //--------------------------------------------------------------------------------------
+    int CubicSplineInterpolator::Interval ( const Real& x ) {
+
+        std::cerr << "ENTERING CubicSplineInterpolator::Inverval. Known bugs here"  << std::endl;
+        int nx = Spline.x.size() - 2; // TODO check if this is correct or just -1
+        // when x not in range
+        if (x <= Spline.x(0) || nx <= 1 ) {
+            mflag = -1;
+            return 1;
+        }
+
+        if (x >= Spline.x(nx)) {
+            mflag = 1;
+            return nx;
+        }
+
+        mflag = 0;
+        if (ilo >= nx) ilo = nx-1;
+        int ihi = ilo+1;
+
+        // if x is already in the interval
+        if ( x<Spline.x(ihi) && x >= Spline.x(ilo) ) {
+            //std::cout << "TRIVIAL INTERVAL " << Spline.x(ilo) << "\t" << x << "\t" << Spline.x(ihi) << std::endl;
+            return ilo;
+        }
+
+        if (x <= Spline.x(ilo)) { // decrease ilo to capture
+            int istep = 1;
+            for (int ix=1; ix<nx; ++ix) {
+                ihi = ilo;
+                ilo = ihi - istep;
+                ilo = std::max(1, ilo);
+                if (x >= Spline.x(ilo) || ilo == 1) break;
+                istep *= 2;
+            }
+        } else if (x >= Spline.x(ihi)) { // increase ihi to capture
+            int istep = 1;
+            for (int ix=1; ix<nx; ++ix) {
+                ilo = ihi;
+                ihi = ilo + istep;
+                ihi = std::min(ihi, nx);
+                if (x <= Spline.x(ihi) || ihi == nx) break;
+                istep *= 2;
+            }
+        }
+
+        // Now Spline.x(ilo) <= x < Spline.x(ihi) --> Narrow the interval.
+        //std::cout << "WIDE INTERVAL " << Spline.x(ilo) << "\t" << x << "\t" << Spline.x(ihi) << std::endl;
+        for (int ix=1; ix<nx; ++ix) {
+            int middle = (ilo+ihi) / 2;
+            if (middle == ilo) break;
+            if (x < Spline.x(middle)) {
+                ihi = middle;
+            } else {
+                ilo = middle;
+            }
+        }
+        assert ( Spline.x(ilo) < x && x < Spline.x(ihi) );
+        return ilo;
+    }		// -----  end of method CubicSplineInterpolator::Inverval  -----
+
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CubicSplineInterplator
+    //      Method:  GetAbscissa
+    //--------------------------------------------------------------------------------------
+    VectorXr CubicSplineInterpolator::GetKnotAbscissa (  ) {
+        return Spline.x;
+    }		// -----  end of method CubicSplineInterplator::get_GetAbscissa  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  CubicSplineInterpolator
+    //      Method:  GetKnotOrdinate
+    //--------------------------------------------------------------------------------------
+    VectorXr CubicSplineInterpolator::GetKnotOrdinate (  ) {
+        return Spline.a;
+    }		// -----  end of method CubicSplineInterpolator::GetKnotOrdinate  -----
+
+
+}		// -----  end of Lemma  name  -----

LemmaCore/src/DCIPElectrode.cpp

@@ -0,0 +1,165 @@
+/* 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/10/2014 10:53:53 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 "DCIPElectrode.h"
+
+namespace Lemma {
+
+
+
+    // ====================  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);
+        return stream;
+    }
+#endif
+
+    // ====================  LIFECYCLE     =======================
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DCIPElectrode
+    //      Method:  DCIPElectrode
+    // Description:  constructor (protected)
+    //--------------------------------------------------------------------------------------
+    DCIPElectrode::DCIPElectrode (const std::string& name) : LemmaObject(name), Node_ID(-1), Label(std::string("None")) {
+
+    }  // -----  end of method DCIPElectrode::DCIPElectrode  (constructor)  -----
+
+#ifdef HAVE_YAMLCPP
+    //--------------------------------------------------------------------------------------
+    //       Class:  DCIPElectrode
+    //      Method:  DCIPElectrode
+    // Description:  DeSerializing constructor (protected)
+    //--------------------------------------------------------------------------------------
+    DCIPElectrode::DCIPElectrode (const YAML::Node& node) : LemmaObject(node) {
+        if (node.Tag() != this->Name) {
+            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;
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DCIPElectrode
+    //      Method:  ~DCIPElectrode
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
+    DCIPElectrode::~DCIPElectrode () {
+
+    }  // -----  end of method DCIPElectrode::~DCIPElectrode  (destructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       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 );
+        // FILL IN CLASS SPECIFICS HERE
+        node["Location"] = Location;
+        node["Node_ID"] = Node_ID;
+        node["Label"] = Label;
+        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 ;
+    }		// -----  end of method DCIPElectrode::DeSerialize  -----
+#endif
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DCIPElectrode
+    //      Method:  SetLocation
+    //--------------------------------------------------------------------------------------
+    void DCIPElectrode::SetLocation ( const Vector3r& loc ) {
+        Location = loc;
+        return ;
+    }		// -----  end of method DCIPElectrode::SetLocation  -----
+
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DCIPElectrode
+    //      Method:  SetTag
+    //--------------------------------------------------------------------------------------
+    void DCIPElectrode::SetLabel ( const std::string& inLabel  ) {
+        Label = inLabel;
+        return ;
+    }		// -----  end of method DCIPElectrode::SetTag  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DCIPElectrode
+    //      Method:  get_Label
+    //--------------------------------------------------------------------------------------
+    std::string DCIPElectrode::GetLabel (  ) {
+        return Label;
+    }		// -----  end of method DCIPElectrode::get_Label  -----
+
+
+}		// -----  end of Lemma  name  -----
+

LemmaCore/src/DCSurvey.cpp

@@ -0,0 +1,377 @@
+/* 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/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
+ */
+
+#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);
+        return stream;
+    }
+    #endif
+
+    // ====================  LIFECYCLE     =======================
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DCSurvey
+    //      Method:  DCSurvey
+    // Description:  constructor (protected)
+    //--------------------------------------------------------------------------------------
+    DCSurvey::DCSurvey (const std::string& name) : LemmaObject(name) {
+
+    }  // -----  end of method DCSurvey::DCSurvey  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DCSurvey
+    //      Method:  DCSurvey
+    // Description:  DeSerializing constructor (protected)
+    //--------------------------------------------------------------------------------------
+    #ifdef HAVE_YAMLCPP
+    DCSurvey::DCSurvey (const YAML::Node& node) : LemmaObject(node) {
+
+        if (node.Tag() != "DCSurvey") {
+            throw std::runtime_error("DCSurvey->DeSerialize cannot deserialize non-DCSurvey");
+        }
+
+        std::map<YAML::Node, int>  eMap;
+        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);
+        }
+
+        //std::cout << "J-0\n" << node["Injections"]["J-0"] << std::endl;
+        int ij = 0 ;
+        for(YAML::const_iterator it=node["Injections"].begin(); it!=node["Injections"].end(); ++it) {
+
+            //std::cout << "it->first" << it->first << std::endl;
+
+            A_Electrodes.push_back( ElectrodeLabelMap[ it->second["A"]["Label"].as<std::string>() ].second );
+            B_Electrodes.push_back( ElectrodeLabelMap[ it->second["B"]["Label"].as<std::string>() ].second );
+            J_Electrodes.push_back( it->second["J"].as<Real>() );
+            //std::string Jstr = it->first.as<std::string>(); // J-1
+
+            M_Electrodes.push_back( std::vector<int>() );
+            N_Electrodes.push_back( std::vector<int>() );
+
+            for (int ii=0; ii<it->second["Measurements"]["Number"].as<int>(); ++ii) {
+                std::string Mstr = std::string("V-") + to_string(ii);
+                //std::cout << "measurements" << it->second["Measurements"][Mstr]["M"]["Label"] << std::endl;
+                M_Electrodes[ij].push_back( ElectrodeLabelMap[ it->second["Measurements"][Mstr]["M"]["Label"].as<std::string>() ].second );
+                N_Electrodes[ij].push_back( ElectrodeLabelMap[ it->second["Measurements"][Mstr]["N"]["Label"].as<std::string>() ].second );
+            }
+            ++ ij;
+        }
+
+    }  // -----  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;
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DCSurvey
+    //      Method:  ~DCSurvey
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
+    DCSurvey::~DCSurvey () {
+
+    }  // -----  end of method DCSurvey::~DCSurvey  (destructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       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["NumberOfElectrodes"] = Electrodes.size();
+
+        // All the electrodes
+        for (std::map<std::string, std::pair<DCIPElectrode*, int> >::const_iterator it  = ElectrodeLabelMap.begin();
+                                                                                    it != ElectrodeLabelMap.end(); ++it) {
+            node["Electrodes"][ it->first ] = it->second.first->Serialize();
+        }
+
+        // Injections and Measurements
+        for (unsigned int ic=0; ic<A_Electrodes.size(); ++ic) {
+            std::string strLab = std::string("J-") + to_string(ic);
+            node["Injections"][strLab]["A"] = node["Electrodes"][ OrderedElectrodeLabels[ A_Electrodes[ic] ] ];
+            node["Injections"][strLab]["B"] = node["Electrodes"][ OrderedElectrodeLabels[ B_Electrodes[ic] ] ];
+            node["Injections"][strLab]["J"] = J_Electrodes[ic];
+            node["Injections"][strLab]["Measurements"]["Number"] = M_Electrodes[ic].size();
+            for (unsigned int iv=0; iv<M_Electrodes[ic].size(); ++iv) {
+                node["Injections"][strLab]["Measurements"][std::string("V-") + to_string(iv)]["M"] =
+                    node["Electrodes"][ OrderedElectrodeLabels[M_Electrodes[ic][iv]] ];
+                node["Injections"][strLab]["Measurements"][std::string("V-") + to_string(iv)]["N"] =
+                    node["Electrodes"][ OrderedElectrodeLabels[N_Electrodes[ic][iv]] ];
+            }
+        }
+
+        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 ;
+    }		// -----  end of method DCSurvey::DeSerialize  -----
+    #endif
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DCSurvey
+    //      Method:  PoundElectrode
+    //--------------------------------------------------------------------------------------
+    int DCSurvey::PoundElectrode ( 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);
+            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);
+            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();
+            Electrode->SetLocation( loc );
+        Electrodes.push_back(Electrode);
+        if (tag != "NULL") {
+            OrderedElectrodeLabels.push_back(tag);
+            ElectrodeLabelMap[tag] = std::pair<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);
+            Electrode->SetLabel( std::string("E") + to_string(Electrodes.size()-1) );
+        }
+        Electrode->AttachTo(this);
+        return  Electrode;
+    }		// -----  end of method DCSurvey::PoundElectrode  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DCSurvey
+    //      Method:  PoundElectrode
+    //--------------------------------------------------------------------------------------
+#ifdef LEMMAUSEVTK
+    DCIPElectrode* DCSurvey::PoundElectrode( const int& nodeID, vtkDataSet* Mesh, const std::string& tag ) {
+        DCIPElectrode* Electrode = DCIPElectrode::New();
+        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);
+            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);
+            Electrode->SetLabel( std::string("E") + to_string(Electrodes.size()-1) );
+        }
+        Electrode->AttachTo(this);
+        return Electrode;
+    }		// -----  end of method DCSurvey::PoundElectrode  -----
+#endif
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DCSurvey
+    //      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();
+        A_Electrodes.clear();
+        B_Electrodes.clear();
+        M_Electrodes.clear();
+        N_Electrodes.clear();
+
+        return ;
+    }		// -----  end of method DCSurvey::PullElectrodes  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DCSurvey
+    //      Method:  AddInjection
+    //--------------------------------------------------------------------------------------
+    int DCSurvey::AddInjection ( DCIPElectrode* A, DCIPElectrode* B, const Real& J ) {
+        bool fA = false;
+        bool fB = false;
+        for (unsigned int i=0; i<Electrodes.size(); ++i) {
+            if (Electrodes[i] == A) {
+                A_Electrodes.push_back(i);
+                M_Electrodes.push_back( std::vector<int>() );
+                N_Electrodes.push_back( std::vector<int>() );
+                fA = true;
+            }
+            if (Electrodes[i] == B) {
+                B_Electrodes.push_back(i);
+                fB = true;
+            }
+            if (fA == true && fB == true) break;
+        }
+        if (!fA) {
+            throw std::runtime_error( "Injection point A not found" );
+        }
+        if (!fB) {
+            throw std::runtime_error( "Injection point B not found" );
+        }
+        J_Electrodes.push_back(J);
+        return A_Electrodes.size()-1; // we want index
+    }		// -----  end of method DCSurvey::AddInjection  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DCSurvey
+    //      Method:  AddMeasurement
+    //--------------------------------------------------------------------------------------
+    void DCSurvey::AddMeasurement ( const int& iJ, DCIPElectrode* M, DCIPElectrode* N  ) {
+        bool fM = false;
+        bool fN = false;
+        for (unsigned int i=0; i<Electrodes.size(); ++i) {
+            if (Electrodes[i] == M) {
+                M_Electrodes[iJ].push_back(i);
+                fM = true;
+            }
+            if (Electrodes[i] == N) {
+                N_Electrodes[iJ].push_back(i);
+                fN = true;
+            }
+            if (fM == true && fN == true) break;
+        }
+        if (!fM) {
+            throw std::runtime_error( "Injection point M not found" );
+        }
+        if (!fN) {
+            throw std::runtime_error( "Injection point N not found" );
+        }
+        return ;
+    }		// -----  end of method DCSurvey::AddMeasurement  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DCSurvey
+    //      Method:  AddMeasurement
+    //--------------------------------------------------------------------------------------
+
+    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];
+
+        if (Mp.first == NULL) {
+            throw std::runtime_error( "Injection point M not found" );
+        }
+        if (Np.first == NULL) {
+            throw std::runtime_error( "Injection point N not found" );
+        }
+
+        M_Electrodes[iJ].push_back( Mp.second );
+        N_Electrodes[iJ].push_back( Np.second );
+
+        return ;
+    }		// -----  end of method DCSurvey::AddMeasurement  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DCSurvey
+    //      Method:  GetA
+    //--------------------------------------------------------------------------------------
+    void DCSurvey::GetA (const int& iA, int& iB, Real& J ) {
+        iB = Electrodes[A_Electrodes[iA]]->GetNodeID();
+        J = J_Electrodes[iA];
+        return ;
+    }		// -----  end of method DCSurvey::GetA  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  DCSurvey
+    //      Method:  GetB
+    //--------------------------------------------------------------------------------------
+    void DCSurvey::GetB (const int& iA, int& iB, Real& J ) {
+        iB = Electrodes[B_Electrodes[iA]]->GetNodeID();
+        J = -J_Electrodes[iA];
+        return ;
+    }		// -----  end of method DCSurvey::GetA  -----
+
+
+}		// -----  end of Lemma  name  -----
+

LemmaCore/src/FHTKey.cpp

@@ -0,0 +1,359 @@
+/* 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/11/2014 03:42:53 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 "FHTKey.h"
+
+namespace Lemma {
+
+    // ====================  FRIEND METHODS  =====================
+
+    std::ostream &operator<<(std::ostream &stream, const FHTKey &ob) {
+
+        stream << *(HankelTransform*)(&ob);
+
+        return stream;
+    }
+
+
+    // ====================  STATIC CONST MEMBERS     ============
+
+    const Eigen::Matrix<Real, 201, 3>  FHTKey::WT201 =
+        ( Eigen::Matrix<Real, 201, 3>()   <<
+        // Base                   J0                      J1
+          4.1185887075357082e-06, 1.5020099209519960e-03, 4.7827871332506182e-10
+        , 4.6623077830484039e-06,-1.0381698214761684e-02,-2.9784175503440788e-09
+        , 5.2778064058937756e-06, 3.6840860097595164e-02, 9.7723832770897220e-09
+        , 5.9745606155328603e-06,-8.9903380392274704e-02,-2.2382340996085809e-08
+        , 6.7632974390298035e-06, 1.7082286536833860e-01, 4.0446774329470848e-08
+        , 7.6561600412698171e-06,-2.7115749656836280e-01,-6.1734815854553919e-08
+        , 8.6668946776271221e-06, 3.7649328091859574e-01, 8.3293912185608189e-08
+        , 9.8110623273521872e-06,-4.7220778569122657e-01,-1.0249453502284080e-07
+        , 1.1106278265924788e-05, 5.4778211089647089e-01, 1.1780779749909977e-07
+        , 1.2572483264760042e-05,-5.9823516853035097e-01,-1.2870061460834850e-07
+        , 1.4232250593579901e-05, 6.2345791612185331e-01, 1.3559243438349901e-07
+        , 1.6111133551969887e-05,-6.2650436648257724e-01,-1.3921010821521872e-07
+        , 1.8238058880617237e-05, 6.1197225351173345e-01, 1.4065745722769670e-07
+        , 2.0645772109076137e-05,-5.8470173866140451e-01,-1.4074881908375281e-07
+        , 2.3371341696506312e-05, 5.4911055789616858e-01, 1.4051720878600928e-07
+        , 2.6456729726989950e-05,-5.0878861684860843e-01,-1.4040746687777830e-07
+        , 2.9949437945688260e-05, 4.6652106345430200e-01, 1.4127886061686993e-07
+        , 3.3903239082024059e-05,-4.2426478870289325e-01,-1.4315595655055356e-07
+        , 3.8379004719130766e-05, 3.8339538911933357e-01, 1.4689283208027915e-07
+        , 4.3445642455208216e-05,-3.4472344791723936e-01,-1.5210916706348747e-07
+        , 4.9181156785051293e-05, 3.0876891466890510e-01, 1.5989801550138741e-07
+        , 5.5673850034776868e-05,-2.7570439368364807e-01,-1.6940918407911260e-07
+        , 6.3023681838995322e-05, 2.4562331000974616e-01, 1.8227089415749844e-07
+        , 7.1343808090545215e-05,-2.1839207265400126e-01,-1.9695856878603369e-07
+        , 8.0762323056016586e-05, 1.9393194321380827e-01, 2.1603952427106760e-07
+        , 9.1424231478173270e-05,-1.7198162962644575e-01,-2.3691320619292838e-07
+        , 1.0349368102719458e-04, 1.5242270280410272e-01, 2.6369843208466607e-07
+        , 1.1715648947091054e-04,-1.3494945901825492e-01,-2.9202021404039016e-07
+        , 1.3262300547161834e-04, 1.1946763189654602e-01, 3.2852445086324662e-07
+        , 1.5013134705348249e-04,-1.0565870880444576e-01,-3.6589094553627693e-07
+        , 1.6995106759902750e-04, 9.3482355548033913e-02, 4.1487501036863030e-07
+        , 1.9238730581535294e-04,-8.2612525279836244e-02,-4.6327136995173986e-07
+        , 2.1778548356175115e-04, 7.3077763526174969e-02, 5.2852697369750518e-07
+        , 2.4653662386513240e-04,-6.4536481281701225e-02,-5.9034983719954077e-07
+        , 2.7908337099788406e-04, 5.7096310621587334e-02, 6.7710211611560898e-07
+        , 3.1592680530155527e-04,-5.0384859605213800e-02,-7.5512942807901028e-07
+        , 3.5763415767542709e-04, 4.4599557396733047e-02, 8.7062473466409799e-07
+        , 4.0484754250000483e-04,-3.9316995063444334e-02,-9.6788530918130449e-07
+        , 4.5829384344501882e-04, 3.4838544754296139e-02, 1.1222658353725904e-06
+        , 5.1879590436097246e-04,-3.0664946477420088e-02,-1.2417228058919743e-06
+        , 5.8728519754599128e-04, 2.7221072240291456e-02, 1.4493467036899140e-06
+        , 6.6481616442494776e-04,-2.3901586108434601e-02,-1.5932456559208080e-06
+        , 7.5258244942583781e-04, 2.1281566646364738e-02, 1.8747045814274419e-06
+        , 8.5193527698548301e-04,-1.8612484595521447e-02,-2.0433320340041385e-06
+        , 9.6440425461164468e-04, 1.6655386303461400e-02, 2.4285695351967146e-06
+        , 1.0917209222795108e-03,-1.4472420076504743e-02,-2.6179926456520528e-06
+        , 1.2358454107222641e-03, 1.3057747649606617e-02, 3.1511729661391781e-06
+        , 1.3989966190390965e-03,-1.1226286001060300e-02,-3.3492412032881268e-06
+        , 1.5836863762264436e-03, 1.0266818557930830e-02, 4.0964186613549959e-06
+        , 1.7927581125735061e-03,-8.6738022421653585e-03,-4.2758275751239154e-06
+        , 2.0294306362957340e-03, 8.1103368670848164e-03, 5.3371197552207799e-06
+        , 2.2973476893787268e-03,-6.6573628142085938e-03,-5.4435423773626499e-06
+        , 2.6006340455800008e-03, 6.4551189810889585e-03, 6.9725766921672099e-06
+        , 2.9439590142573526e-03,-5.0524015117839084e-03,-6.9045562968161745e-06
+        , 3.3326083277104117e-03, 5.1989014270506263e-03, 9.1397025436977438e-06
+        , 3.7725655187922052e-03,-3.7597430078747883e-03,-8.7148373033635960e-06
+        , 4.2706040416570154e-03, 4.2640545165292636e-03, 1.2029590806160379e-05
+        , 4.8343915539089625e-03,-2.6994965688974474e-03,-1.0927976968519436e-05
+        , 5.4726079656493079e-03, 3.5928000560587229e-03, 1.5912526719455299e-05
+        , 6.1950790728715292e-03,-1.8061291289989019e-03,-1.3582559661331659e-05
+        , 7.0129278325854246e-03, 3.1436470898586703e-03, 2.1176226828087565e-05
+        , 7.9387456086585442e-03,-1.0244200001620755e-03,-1.6678205993448338e-05
+        , 8.9867860248264830e-03, 2.8888297674091743e-03, 2.8384979250408712e-05
+        , 1.0173184409377162e-02,-3.0605070741955765e-04,-2.0132088397797457e-05
+        , 1.1516206210016314e-02, 2.8125907445050334e-03, 3.8372045311188108e-05
+        , 1.3036528203437736e-02, 3.9337862066047565e-04,-2.3702184335455945e-05
+        , 1.4757556829019875e-02, 2.9102041487017727e-03, 5.2385308850007940e-05
+        , 1.6705788547622769e-02, 1.1170884769911178e-03,-2.6854373943701261e-05
+        , 1.8911217773465227e-02, 3.1876763415953362e-03, 7.2318581557902158e-05
+        , 2.1407798659484324e-02, 1.9097806429850762e-03,-2.8535361884516687e-05
+        , 2.4233967845691123e-02, 3.6621020321465411e-03, 1.0108123118106823e-04
+        , 2.7433236218606032e-02, 2.8203783587849949e-03,-2.6788477540644352e-05
+        , 3.1054858792331431e-02, 4.3626885599390430e-03, 1.4319185407094621e-04
+        , 3.5154593024557458e-02, 3.9050024915686802e-03,-1.8108424211338017e-05
+        , 3.9795557242315927e-02, 5.3324923486866077e-03, 2.0573561552327273e-04
+        , 4.5049202393557801e-02, 5.2303399394270488e-03, 3.6361648565843316e-06
+        , 5.0996412085361466e-02, 6.6309348458396984e-03, 2.9991264692859609e-04
+        , 5.7728747844643331e-02, 6.8775540687037451e-03, 4.8993332079278846e-05
+        , 6.5349858773045680e-02, 8.3371689988226087e-03, 4.4354733854670903e-04
+        , 7.3977077298642363e-02, 8.9468564745410102e-03, 1.3589101811995494e-04
+        , 8.3743225592195963e-02, 1.0554326601376745e-02, 6.6515823521273764e-04
+        , 9.4798660459030126e-02, 1.1562765604509096e-02, 2.9451991608624389e-04
+        , 1.0731358818908403e-01, 1.3414536265660639e-02, 1.0105553806271136e-03
+        , 1.2148068500391276e-01, 1.4879837399735491e-02, 5.7533964792254050e-04
+        , 1.3751806344428075e-01, 1.7084241336519569e-02, 1.5535077418254303e-03
+        , 1.5567263036799733e-01, 1.9088092654441269e-02, 1.0621193133794828e-03
+        , 1.7622388825676111e-01, 2.1768513715084332e-02, 2.4128970258747457e-03
+        , 1.9948823835583873e-01, 2.4416120601223806e-02, 1.8929698186109245e-03
+        , 2.2582385189647586e-01, 2.7711234465350204e-02, 3.7800177772191607e-03
+        , 2.5563618439697788e-01, 3.1127164234404547e-02, 3.2937343278959356e-03
+        , 2.8938421793905067e-01, 3.5184140220277452e-02, 5.9612179800391544e-03
+        , 3.2758752752368947e-01, 3.9497913113638941e-02, 5.6295935320552241e-03
+        , 3.7083428029819565e-01, 4.4449762157204989e-02, 9.4422526803168080e-03
+        , 4.1979029080811425e-01, 4.9758433269983887e-02, 9.4810228247137925e-03
+        , 4.7520927168614446e-01, 5.5667457114992429e-02, 1.4979159139973408e-02
+        , 5.3794443759467447e-01, 6.1949790434151823e-02, 1.5745093424331037e-02
+        , 6.0896164107289685e-01, 6.8682064905571841e-02, 2.3708966370000140e-02
+        , 6.8935424252422239e-01, 7.5616743950118387e-02, 2.5740590762136872e-02
+        , 7.8035994327803426e-01, 8.2584983563572259e-02, 3.7232782843117498e-02
+        , 8.8337984088275090e-01, 8.9193635262987042e-02, 4.1225008900614292e-02
+        , 1.0000000000000000e+00, 9.4874686942005279e-02, 5.7507103212277359e-02
+        , 1.1320158709991752e+00, 9.8891681869094042e-02, 6.4044642846235691e-02
+        , 1.2814599321940212e+00, 1.0004294654495730e-01, 8.6091796551857253e-02
+        , 1.4506329812931589e+00, 9.7016844329802857e-02, 9.4717139804457451e-02
+        , 1.6421395578187052e+00, 8.7789596149914384e-02, 1.2172497389177185e-01
+        , 1.8589280418463421e+00, 7.0509767592855419e-02, 1.2853597000398900e-01
+        , 2.1043360464154781e+00, 4.2778853484849347e-02, 1.5450777327408322e-01
+        , 2.3821418024579781e+00, 3.5584532926218175e-03, 1.4755964090969320e-01
+        , 2.6966223273530128e+00,-4.7210453264879347e-02, 1.5621399202016978e-01
+        , 3.0526192726543444e+00,-1.0489787743225988e-01, 1.1147620703185755e-01
+        , 3.4556134647626755e+00,-1.6020950407348281e-01, 7.7489831356083380e-02
+        , 3.9118092861497971e+00,-1.9459781573132096e-01,-2.7628266850147711e-02
+        , 4.4282301962435247e+00,-1.8490774599542381e-01,-1.0198730178317840e-01
+        , 5.0128268625854631e+00,-1.0754165020025190e-01,-2.2039889971111640e-01
+        , 5.6745995670177445e+00, 3.6037727487476613e-02,-2.1185762869925318e-01
+        , 6.4237367714291338e+00, 1.9759013047489976e-01,-1.6052415083152241e-01
+        , 7.2717719763787807e+00, 2.6132313321851336e-01, 9.1649025798681089e-02
+        , 8.2317612875478190e+00, 1.1713996822458939e-01, 2.3792823877700942e-01
+        , 9.3184844237807365e+00,-1.8758779281301441e-01, 2.6075777853738125e-01
+        , 1.0548672261378394e+01,-3.0238114997462151e-01,-1.5662188259001042e-01
+        , 1.1941264417849103e+01, 4.8163135684567732e-02,-2.8932081756330175e-01
+        , 1.3517700840802913e+01, 3.6399529664885466e-01, 1.3148519116247689e-02
+        , 1.5302251891207787e+01,-1.4910233461562913e-01, 4.2691302759079564e-01
+        , 1.7322392002874359e+01,-2.6373490348543854e-01,-4.0005050006489040e-01
+        , 1.9609222670922968e+01, 4.0362661807718703e-01, 1.1513789407450359e-01
+        , 2.2197951281441636e+01,-3.1409794650104578e-01, 9.3748244358717620e-02
+        , 2.5128433154258410e+01, 1.8179369405131079e-01,-1.6037231301955096e-01
+        , 2.8445785143962375e+01,-9.0738718042631769e-02, 1.5071857939129532e-01
+        , 3.2201080245997971e+01, 4.2946487545160242e-02,-1.2120369075996129e-01
+        , 3.6452133901787732e+01,-2.0586135807067835e-02, 9.4110656079982341e-02
+        , 4.1264394108610787e+01, 1.0392667161913182e-02,-7.3742238434584328e-02
+        , 4.6711949038112273e+01,-5.6117848068723023e-03, 5.9038567576124905e-02
+        , 5.2878667676447755e+01, 3.2402025511569896e-03,-4.8288117528475852e-02
+        , 5.9859491047029913e+01,-1.9858724388273777e-03, 4.0197054299576880e-02
+        , 6.7761893895170928e+01, 1.2807317326135252e-03,-3.3919787720641081e-02
+        , 7.6707539338295589e+01,-8.6253791756068252e-04, 2.8918247156763971e-02
+        , 8.6834151956244213e+01, 6.0296590782143555e-04,-2.4845271759013743e-02
+        , 9.8297638159222487e+01,-4.3548936996943465e-04, 2.1470449751150148e-02
+        , 1.1127448647797397e+02, 3.2375891570874245e-04,-1.8635828020057092e-02
+        , 1.2596448473034971e+02,-2.4698212240059978e-04, 1.6229579362363859e-02
+        , 1.4259379589698909e+02, 1.9279062274925971e-04,-1.4170085406786529e-02
+        , 1.6141844006140866e+02,-1.5357911509105972e-04, 1.2396084121011890e-02
+        , 1.8272823602144376e+02, 1.2453787849367440e-04,-1.0860414401084047e-02
+        , 2.0685126325595743e+02,-1.0255126402954421e-04, 9.5259444245356633e-03
+        , 2.3415891294197226e+02, 8.5558482209476271e-05,-8.3628577447233381e-03
+        , 2.6507160578622688e+02,-7.2170928476334345e-05, 7.3468029551253195e-03
+        , 3.0006526470124555e+02, 6.1436863283080017e-05,-6.4576043210966359e-03
+        , 3.3967864197737873e+02,-5.2693349406473615e-05, 5.6783439955994880e-03
+        , 3.8452161375783919e+02, 4.5471255142623729e-05,-4.9946949167265437e-03
+        , 4.3528456951608860e+02,-3.9433284158653591e-05, 4.3944258108608806e-03
+        , 4.9274904109325632e+02, 3.4332971164795619e-05,-3.8670264019660858e-03
+        , 5.5779973493719069e+02,-2.9987212220165472e-05, 3.4034180355556670e-03
+        , 6.3143815278803334e+02, 2.6257657435614391e-05,-2.9957260668529964e-03
+        , 7.1479801051045558e+02,-2.3037978256349448e-05, 2.6370977166248776e-03
+        , 8.0916269245647072e+02, 2.0245071331016652e-05,-2.3215540117372982e-03
+        , 9.1598501008114988e+02,-1.7812925644382519e-05, 2.0438677474690805e-03
+        , 1.0369095690092008e+03, 1.5688305607849465e-05,-1.7994616759226389e-03
+        , 1.1737980889093292e+03,-1.3827679492110470e-05, 1.5843226896713463e-03
+        , 1.3287580659938624e+03, 1.2195005442258958e-05,-1.3949288614414647e-03
+        , 1.5041752194232211e+03,-1.0760110818279243e-05, 1.2281869708886250e-03
+        , 1.7027502211507524e+03, 9.4974857670959145e-06,-1.0813786997088304e-03
+        , 1.9275402746900081e+03,-8.3853711343938338e-06, 9.5211407460757294e-04
+        , 2.1820061829391980e+03, 7.4050612540713192e-06,-8.3829103020448140e-04
+        , 2.4700656297055034e+03,-6.5403682860228500e-06, 7.3806018220987763e-04
+        , 2.7961534952362003e+03, 5.7772102413267325e-06,-6.4979406671247244e-04
+        , 3.1652901343571971e+03,-5.1032933218796731e-06, 5.7206022901230412e-04
+        , 3.5831586684094545e+03, 4.5078641320869195e-06,-5.0359764543483573e-04
+        , 4.0561924809477755e+03,-3.9815111951817114e-06, 4.4329604122300101e-04
+        , 4.5916742642604040e+03, 3.5159993210292339e-06,-3.9017773206623073e-04
+        , 5.1978481416012310e+03,-3.1041249680128287e-06, 3.4338166974098888e-04
+        , 5.8840465913361650e+03, 2.7395854235553632e-06,-3.0214941633163506e-04
+        , 6.6608341270911405e+03,-2.4168587823583312e-06, 2.6581280850704716e-04
+        , 7.5401699459601114e+03, 2.1310948134441218e-06,-2.3378310479588391e-04
+        , 8.5355920488578286e+03,-1.8780185742021288e-06, 2.0554143583887405e-04
+        , 9.6624256676814348e+03, 1.6538488252707735e-06,-1.8063040107732216e-04
+        , 1.0938019208165191e+04,-1.4552318768651144e-06, 1.5864667598176302e-04
+        , 1.2382011340936813e+04, 1.2791890865306748e-06,-1.3923451235168759e-04
+        , 1.4016633352832258e+04,-1.1230741959148155e-06, 1.2208003098625932e-04
+        , 1.5867051413382505e+04, 9.8453630538596172e-07,-1.0690622166177854e-04
+        , 1.7961754025908867e+04,-8.6148574493190796e-07, 9.3468580362568137e-05
+        , 2.0332990628312182e+04, 7.5206242699701732e-07,-8.1551328581234316e-05
+        , 2.3017268096126892e+04,-6.5460810334682633e-07, 7.0964174631531072e-05
+        , 2.6055912791858576e+04, 5.6764451596029765e-07,-6.1539592468666665e-05
+        , 2.9495706813754354e+04,-4.8985884555184997e-07, 5.3130609116145443e-05
+        , 3.3389608239508460e+04, 4.2009674106879252e-07,-4.5609105983126460e-05
+        , 3.7797566453568354e+04,-3.5736212641225517e-07, 3.8864648584181207e-05
+        , 4.2787445110585410e+04, 3.0082215969939671e-07,-3.2803856352344075e-05
+        , 4.8436066944688770e+04,-2.4981510481639669e-07, 2.7350296775876261e-05
+        , 5.4830396510166145e+04, 2.0385823466866512e-07,-2.2444816150805301e-05
+        , 6.2068879062685897e+04,-1.6265189071584773e-07, 1.8046076281584239e-05
+        , 7.0262956194088882e+04, 1.2607416700611311e-07,-1.4130826937491561e-05
+        , 7.9538781555028458e+04,-9.4158417913450858e-08, 1.0693106849359383e-05
+        , 9.0039163080228551e+04, 6.7043911217063425e-08,-7.7412053314530284e-06
+        , 1.0192576161830177e+05,-4.4891090827293947e-08, 5.2910576443698300e-06
+        , 1.1538157981559623e+05, 2.7761325666544702e-08,-3.3552268362550323e-06
+        , 1.3061377957221285e+05,-1.5480404355710375e-08, 1.9282956206367452e-06
+        , 1.4785687144693290e+05, 7.5327300141098751e-09,-9.7253712572058755e-07
+        , 1.6737632511421290e+05,-3.0524770418657847e-09, 4.1100807632959352e-07
+        , 1.8947265645880660e+05, 9.5877856096830783e-10,-1.3553176263207053e-07
+        , 2.1448605423174356e+05,-2.0575286298055636e-10, 3.0748587523233524e-08
+        , 2.4280161749832361e+05, 2.2414416956474645e-11,-3.5668195345476294e-09 ).finished();
+
+    // ====================  LIFECYCLE     =======================
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey
+    //      Method:  FHTKey
+    // Description:  constructor (protected)
+    //--------------------------------------------------------------------------------------
+    FHTKey::FHTKey (const std::string& name) : HankelTransform(name) {
+
+    }  // -----  end of method FHTKey::FHTKey  (constructor)  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey
+    //      Method:  New()
+    // Description:  public constructor
+    //--------------------------------------------------------------------------------------
+    FHTKey* FHTKey::New() {
+        FHTKey*  Obj = new FHTKey("FHTKey");
+        Obj->AttachTo(Obj);
+        return Obj;
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey
+    //      Method:  ~FHTKey
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
+    FHTKey::~FHTKey () {
+
+    }  // -----  end of method FHTKey::~FHTKey  (destructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey
+    //      Method:  Delete
+    // Description:  public destructor
+    //--------------------------------------------------------------------------------------
+    void FHTKey::Delete() {
+        this->DetachFrom(this);
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey
+    //      Method:  Release
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
+    void FHTKey::Release() {
+        delete this;
+    }
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey
+    //      Method:  Zgauss
+    //--------------------------------------------------------------------------------------
+    Complex FHTKey::Zgauss ( const int &ikk, const EMMODE &imode,
+                            const int &itype, const Real &rho,
+                            const Real &wavef, KernelEm1DBase *Kernel ) {
+ 		return Zans(0, Kernel->GetManagerIndex());
+    }		// -----  end of method FHTKey::ComputeRelated  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey
+    //      Method:  ComputeRelated
+    //--------------------------------------------------------------------------------------
+    void FHTKey::ComputeRelated ( const Real& rho, KernelEm1DBase* Kernel ) {
+        return ;
+    }		// -----  end of method FHTKey::ComputeRelated  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey
+    //      Method:  ComputeRelated
+    //--------------------------------------------------------------------------------------
+    void FHTKey::ComputeRelated ( const Real& rho, std::vector< KernelEm1DBase* > KernelVec ) {
+        return ;
+    }		// -----  end of method FHTKey::ComputeRelated  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey
+    //      Method:  ComputeRelated
+    //--------------------------------------------------------------------------------------
+    void FHTKey::ComputeRelated ( const Real& rho, KernelEM1DManager* KernelManager ) {
+
+        //kernelVec = KernelManager->GetSTLVector();
+        int nrel = (int)(KernelManager->GetSTLVector().size());
+        Eigen::Matrix<Complex, 201, Eigen::Dynamic > Zwork;
+        // TODO, if we want to allow lagged, then 1 below should be nlag
+        Zans= Eigen::Matrix<Complex, Eigen::Dynamic, Eigen::Dynamic>::Zero(1, nrel);
+        Zwork.resize(201, nrel);
+        VectorXr lambda = WT201.col(0).array()/rho;
+        int NumFun = 0;
+        int idx = 0;
+
+        // Get Kernel values
+        for (int ir=0; ir<lambda.size(); ++ir) {
+            // irelated loop
+            ++NumFun;
+            KernelManager->ComputeReflectionCoeffs(lambda(ir), idx, rho);
+            for (int ir2=0; ir2<nrel; ++ir2) {
+                // Zwork* needed due to sign convention of filter weights
+ 			    Zwork(ir, ir2) = std::conj(KernelManager->GetSTLVector()[ir2]->RelBesselArg(lambda(ir)));
+            }
+
+        }
+
+        // We diverge slightly from Key here, each kernel is evaluated seperately, whereby instead
+        // they prefer to sum them. The reason is that all those terms have been removed from the kernels
+        // in the interests of making them as generic and reusable as possible. This approach requires slightly
+        // more multiplies, but the same number of kernel evaluations, which is the expensive part.
+        // Inner product and scale
+        for (int ir2=0; ir2<nrel; ++ir2) {
+            Zans(0, ir2) = Zwork.col(ir2).dot(WT201.col(KernelManager->GetSTLVector()[ir2]->GetBesselOrder() + 1))/rho;
+        }
+
+        return ;
+    }		// -----  end of method FHTKey::ComputeRelated  -----
+
+}		// -----  end of Lemma  name  -----

LemmaCore/src/FHTKey101.cpp

@@ -0,0 +1,259 @@
+/* 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/11/2014 03:42:53 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 "FHTKey101.h"
+
+namespace Lemma {
+
+    // ====================  FRIEND METHODS  =====================
+
+    std::ostream &operator<<(std::ostream &stream, const FHTKey101 &ob) {
+
+        stream << *(HankelTransform*)(&ob);
+
+        return stream;
+    }
+
+
+    // ====================  STATIC CONST MEMBERS     ============
+
+    const Eigen::Matrix<Real, 101, 3>  FHTKey101::WT101 =
+        ( Eigen::Matrix<Real, 101, 3>()   <<
+       // Base                   J0                      J1
+       5.5308437014783363e-04,   5.1818808036862153e-02,   4.1746363961646286e-06,
+       6.4259236035555788e-04,  -2.9258492652779172e-01,  -2.5993370843637242e-05,
+       7.4658580837667996e-04,   8.7289913080159265e-01,   9.2506838353721647e-05,
+       8.6740895730700251e-04,  -1.8525183961240297e+00,  -2.4318740269846489e-04,
+       1.0077854290485113e-03,   3.2096055660873608e+00,   5.2276050788732404e-04,
+       1.1708796207911744e-03,  -4.9248158048315069e+00,  -9.5803859755432658e-04,
+       1.3603680375478939e-03,   7.0219167445719828e+00,   1.5308357107396591e-03,
+       1.5805221687362171e-03,  -9.4781099645811544e+00,  -2.1584605764249656e-03,
+       1.8363047770289071e-03,   1.2098564895534539e+01,   2.7161344302423967e-03,
+       2.1334817700377098e-03,  -1.4476661837664896e+01,  -3.0845361397036195e-03,
+       2.4787521766663585e-03,   1.6146079632847474e+01,   3.2133980102756368e-03,
+       2.8798991580882430e-03,  -1.6810370923047440e+01,  -3.1305779240645847e-03,
+       3.3459654574712720e-03,   1.6506202923977266e+01,   2.9239120736637542e-03,
+       3.8874572434761303e-03,  -1.5534747212675301e+01,  -2.6680602560576316e-03,
+       4.5165809426126703e-03,   1.4267433361428399e+01,   2.4131379039476304e-03,
+       5.2475183991813838e-03,  -1.2939053370802849e+01,  -2.1549566068119440e-03,
+       6.0967465655156379e-03,   1.1628520257389562e+01,   1.9058200916563901e-03,
+       7.0834089290521185e-03,  -1.0325503688577493e+01,  -1.6533122444456158e-03,
+       8.2297470490200302e-03,   9.0574401975545840e+00,   1.4391633836110848e-03,
+       9.5616019305435132e-03,  -7.8759096646654951e+00,  -1.2363666069459527e-03,
+       1.1108996538242306e-02,   6.8446506699312666e+00,   1.0907227256323094e-03,
+       1.2906812580479873e-02,  -5.9542991234257840e+00,  -9.2712769282234358e-04,
+       1.4995576820477703e-02,   5.1830565431894602e+00,   8.2888526218099687e-04,
+       1.7422374639493515e-02,  -4.4805481279340267e+00,  -6.7675613963809832e-04,
+       2.0241911445804391e-02,   3.8608298760715378e+00,   6.3558641899842260e-04,
+       2.3517745856009110e-02,  -3.3125736597743227e+00,  -4.8591507683128695e-04,
+       2.7323722447292573e-02,   2.8648088091590589e+00,   5.1892328126100203e-04,
+       3.1745636378067953e-02,  -2.4710577422247479e+00,  -3.3190335155472070e-04,
+       3.6883167401240015e-02,   2.1450315408533416e+00,   4.6189809360776176e-04,
+       4.2852126867040180e-02,  -1.8334353019592327e+00,  -1.8326476919948130e-04,
+       4.9787068367863944e-02,   1.5850020809005190e+00,   4.7669939315323097e-04,
+       5.7844320874838456e-02,  -1.3468969891769780e+00,  -1.7380345519175726e-05,
+       6.7205512739749784e-02,   1.1802299801807625e+00,   5.9009214750893949e-04,
+       7.8081666001153169e-02,  -9.9988174688478793e-01,   2.1645139320505843e-04,
+       9.0717953289412512e-02,   8.8503813256539254e-01,   8.5203135609860704e-04,
+       1.0539922456186433e-01,  -7.3165077099639619e-01,   5.9560990889710838e-04,
+       1.2245642825298191e-01,   6.5909386165012596e-01,   1.3651107378683781e-03,
+       1.4227407158651359e-01,  -5.3038429622108840e-01,   1.2606987195022564e-03,
+       1.6529888822158656e-01,   5.0119791866928076e-01,   2.3131990435032663e-03,
+       1.9204990862075413e-01,  -3.8269840749371159e-01,   2.4572002938857678e-03,
+       2.2313016014842982e-01,   3.8622329595139565e-01,   4.0408430887840449e-03,
+       2.5924026064589156e-01,  -2.6413330193320073e-01,   4.6278078809669602e-03,
+       3.0119421191220208e-01,   3.0353632730294311e-01,   7.1437051276295131e-03,
+       3.4993774911115533e-01,  -1.7255655176111537e-01,   8.5723466849983495e-03,
+       4.0656965974059917e-01,   2.5119774955173280e-01,   1.2684763573137947e-02,
+       4.7236655274101469e-01,  -9.8536724013140092e-02,   1.5643387012124067e-02,
+       5.4881163609402650e-01,   2.1755876398162183e-01,   2.2480928663078600e-02,
+       6.3762815162177333e-01,  -3.4268716744688760e-02,   2.8124131719595692e-02,
+       7.4081822068171788e-01,   1.9925218957836366e-01,   3.9373999883133115e-02,
+       8.6070797642505781e-01,   1.8319735495994052e-02,   4.9445586323210833e-02,
+       1.0000000000000000e+00,   1.8963099219918259e-01,   6.7326587032714463e-02,
+       1.1618342427282831e+00,   5.7228135568732394e-02,   8.3541701874077570e-02,
+       1.3498588075760032e+00,   1.7266316834158107e-01,   1.0961776964853986e-01,
+       1.5683121854901687e+00,   6.8141322181604499e-02,   1.3118216481048459e-01,
+       1.8221188003905089e+00,   1.2468074033081850e-01,   1.6144181878027153e-01,
+       2.1170000166126748e+00,   2.1678852838804014e-02,   1.7704476632134886e-01,
+       2.4596031111569494e+00,   1.1114005126278175e-02,   1.9032654055463888e-01,
+       2.8576511180631639e+00,  -1.0424806190544497e-01,   1.6333927603825021e-01,
+       3.3201169227365472e+00,  -1.6473681128667569e-01,   1.1034442879456068e-01,
+       3.8574255306969740e+00,  -2.3603153458714107e-01,  -1.1282682226217962e-02,
+       4.4816890703380645e+00,  -2.2093965064386309e-01,  -1.4579378661401318e-01,
+       5.2069798271798486e+00,  -7.5633542915308175e-02,  -2.7560051939484942e-01,
+       6.0496474644129448e+00,   1.3358180223826097e-01,  -2.3333751023296440e-01,
+       7.0286875805892928e+00,   3.3949946683489907e-01,  -5.9615109981928909e-03,
+       8.1661699125676499e+00,   1.2815187347111337e-01,   3.2380356528743487e-01,
+       9.4877358363585262e+00,  -2.2988301163130145e-01,   2.1970582679149839e-01,
+       1.1023176380641601e+01,  -3.3425750283830036e-01,  -2.8302631898505476e-01,
+       1.2807103782663029e+01,   4.4350537603751145e-01,  -2.2706962776315812e-01,
+       1.4879731724872830e+01,  -8.8943820418669634e-02,   4.7351258711649669e-01,
+       1.7287781840567639e+01,  -1.8646079800862164e-01,  -3.5417866045339608e-01,
+       2.0085536923187668e+01,   2.4494657419883456e-01,   1.6582378621661517e-01,
+       2.3336064580942711e+01,  -2.0169045144304532e-01,  -5.1221107687420810e-02,
+       2.7112638920657883e+01,   1.4661206655803793e-01,   3.5484710794282063e-03,
+       3.1500392308747923e+01,  -1.0564640256629308e-01,   1.1614894738175324e-02,
+       3.6598234443677974e+01,   7.8487036158411266e-02,  -1.4776256489774963e-02,
+       4.2521082000062783e+01,  -6.0533748554794195e-02,   1.4194293010344678e-02,
+       4.9402449105530167e+01,   4.8243702864613026e-02,  -1.2609914713728791e-02,
+       5.7397457045446188e+01,  -3.9347085461672239e-02,   1.0854082569077052e-02,
+       6.6686331040925154e+01,   3.2489421068688185e-02,  -9.2082270347668624e-03,
+       7.7478462925260828e+01,  -2.6982535264609676e-02,   7.7880648968821110e-03,
+       9.0017131300521811e+01,   2.2530196869950080e-02,  -6.6089268276601255e-03,
+       1.0458498557711414e+02,  -1.8947601435977172e-02,   5.6159700146012417e-03,
+       1.2151041751873485e+02,   1.6017457455233256e-02,  -4.7432063636330263e-03,
+       1.4117496392147686e+02,  -1.3519422964231352e-02,   3.9609893136500528e-03,
+       1.6402190729990167e+02,   1.1318328695851308e-02,  -3.2753768787828126e-03,
+       1.9056626845862999e+02,  -9.3839154851987506e-03,   2.6945716306237466e-03,
+       2.2140641620418697e+02,   7.7256174599644543e-03,  -2.2042319512562145e-03,
+       2.5723755590577474e+02,  -6.3199190181430056e-03,   1.7733135127602079e-03,
+       2.9886740096706029e+02,   5.0986473606509210e-03,  -1.3773733375919272e-03,
+       3.4723438047873447e+02,  -3.9929354358609528e-03,   1.0137885881408651e-03,
+       4.0342879349273511e+02,   2.9783618569305080e-03,  -6.9751488719640639e-04,
+       4.6871738678241655e+02,  -2.0802747552777045e-03,   4.4545125438205673e-04,
+       5.4457191012592898e+02,   1.3429398653973710e-03,  -2.6373575275283686e-04,
+       6.3270229281225352e+02,  -7.9345560431147465e-04,   1.4519595835116970e-04,
+       7.3509518924197266e+02,   4.2530878973518046e-04,  -7.4640168948626184e-05,
+       8.5405876252615155e+02,  -2.0457624610548748e-04,   3.5826939350044606e-05,
+       9.9227471560502534e+02,   8.6750842046621606e-05,  -1.5854604622793124e-05,
+       1.1528587427833875e+03,  -3.1406113278782205e-05,   6.2412989356183992e-06,
+       1.3394307643944169e+03,   9.1385289919391839e-06,  -2.0349222128793154e-06,
+       1.5561965278371533e+03,  -1.8949818224609619e-06,   4.8072849734177625e-07,
+       1.8080424144560632e+03,   2.0794387557779629e-07,  -6.0462736574031818e-08).finished();
+
+    // ====================  LIFECYCLE     =======================
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey101
+    //      Method:  FHTKey101
+    // Description:  constructor (protected)
+    //--------------------------------------------------------------------------------------
+    FHTKey101::FHTKey101 (const std::string& name) : HankelTransform(name) {
+
+    }  // -----  end of method FHTKey101::FHTKey101  (constructor)  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey101
+    //      Method:  New()
+    // Description:  public constructor
+    //--------------------------------------------------------------------------------------
+    FHTKey101* FHTKey101::New() {
+        FHTKey101*  Obj = new FHTKey101("FHTKey101");
+        Obj->AttachTo(Obj);
+        return Obj;
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey101
+    //      Method:  ~FHTKey101
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
+    FHTKey101::~FHTKey101 () {
+
+    }  // -----  end of method FHTKey101::~FHTKey101  (destructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey101
+    //      Method:  Delete
+    // Description:  public destructor
+    //--------------------------------------------------------------------------------------
+    void FHTKey101::Delete() {
+        this->DetachFrom(this);
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey101
+    //      Method:  Release
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
+    void FHTKey101::Release() {
+        delete this;
+    }
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey101
+    //      Method:  Zgauss
+    //--------------------------------------------------------------------------------------
+    Complex FHTKey101::Zgauss ( const int &ikk, const EMMODE &imode,
+                            const int &itype, const Real &rho,
+                            const Real &wavef, KernelEm1DBase *Kernel ) {
+ 		return Zans(0, Kernel->GetManagerIndex());
+    }		// -----  end of method FHTKey101::ComputeRelated  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey101
+    //      Method:  ComputeRelated
+    //--------------------------------------------------------------------------------------
+    void FHTKey101::ComputeRelated ( const Real& rho, KernelEm1DBase* Kernel ) {
+        return ;
+    }		// -----  end of method FHTKey101::ComputeRelated  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey101
+    //      Method:  ComputeRelated
+    //--------------------------------------------------------------------------------------
+    void FHTKey101::ComputeRelated ( const Real& rho, std::vector< KernelEm1DBase* > KernelVec ) {
+        return ;
+    }		// -----  end of method FHTKey101::ComputeRelated  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey101
+    //      Method:  ComputeRelated
+    //--------------------------------------------------------------------------------------
+    void FHTKey101::ComputeRelated ( const Real& rho, KernelEM1DManager* KernelManager ) {
+
+        //kernelVec = KernelManager->GetSTLVector();
+        int nrel = (int)(KernelManager->GetSTLVector().size());
+        Eigen::Matrix<Complex, 101, Eigen::Dynamic > Zwork;
+        // TODO, if we want to allow lagged, then 1 below should be nlag
+        Zans= Eigen::Matrix<Complex, Eigen::Dynamic, Eigen::Dynamic>::Zero(1, nrel);
+        Zwork.resize(101, nrel);
+        VectorXr lambda = WT101.col(0).array()/rho;
+        int NumFun = 0;
+        int idx = 0;
+
+        // Get Kernel values
+        for (int ir=0; ir<lambda.size(); ++ir) {
+            // irelated loop
+            ++NumFun;
+            KernelManager->ComputeReflectionCoeffs(lambda(ir), idx, rho);
+            for (int ir2=0; ir2<nrel; ++ir2) {
+                // Zwork* needed due to sign convention of filter weights
+ 			    Zwork(ir, ir2) = std::conj(KernelManager->GetSTLVector()[ir2]->RelBesselArg(lambda(ir)));
+            }
+
+        }
+
+        // We diverge slightly from Key here, each kernel is evaluated seperately, whereby instead
+        // they prefer to sum them. The reason is that all those terms have been removed from the kernels
+        // in the interests of making them as generic and reusable as possible. This approach requires slightly
+        // more multiplies, but the same number of kernel evaluations, which is the expensive part.
+        // Inner product and scale
+        for (int ir2=0; ir2<nrel; ++ir2) {
+            Zans(0, ir2) = Zwork.col(ir2).dot(WT101.col(KernelManager->GetSTLVector()[ir2]->GetBesselOrder() + 1))/rho;
+        }
+
+        return ;
+    }		// -----  end of method FHTKey101::ComputeRelated  -----
+
+}		// -----  end of Lemma  name  -----