Moved around some more files and working toward FDEM1D module ported.

Modules/FDEM1D/include/FDEM1D

 #include "LayeredEarthEM.h"
 #include "FieldPoints.h"
+#include "WireAntenna.h"
+#include "DipoleSource.h"
+
+// internal
+//#include "KernelEM1DManager.h"
+//#include "KernelEM1DSpec.h"
+//#include "KernelEM1DReflSpec.h"
 
 /* vim: set tabstop=4 expandtab: */
 /* vim: set filetype=cpp: */

Modules/FDEM1D/include/hankeltransformhankel2.h → Modules/FDEM1D/include/FHTAnderson801.h

   @version  $Id: hankeltransformhankel2.h 201 2015-01-03 00:07:47Z tirons $
  **/
 
-#ifndef __HANKEL2_H
-#define __HANKEL2_H
+#ifndef __FHTANDERSON801_H
+#define __FHTANDERSON801_H
 
-#include "hankeltransform.h"
 #include "KernelEM1DBase.h"
 #include "KernelEM1DSpec.h"
 #include "CubicSplineInterpolator.h"
+#include "HankelTransform.h"
 
 namespace Lemma {
 
 // ==========================================================================
-//        Class:  Hankel2
+//        Class:  FHTAnderson801
 /** \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.
+             that he released while working at the USGS:
+             Anderson, W. L., 1989, A hybrid fast hankel transform algorithm for
+             electromagnetic modeling: Geophysics, 54, 263-266.
+
+             This function does not provide the Hybrid functionality however, merely the
+             digital filter implimentation.
+
              The  transform evaluates an integral of the form:
              \f[ \int_0^\infty K(\lambda) J_I (\lambda r) ~ d \lambda
              \f]
              \f]
              This can only be done where there is radial symmetry. Hence
              its application to 1D solutions here.
+    \note In previous versions of Lemma, this class was called HankelTransformHankel2,
+        which more closely follows Anderson's procedural routine names, but was non-descriptive
+        regarding where the algorithm is derived from.
  */
 // ==========================================================================
 
-class Hankel2 : public HankelTransform {
+class FHTAnderson801 : public HankelTransform {
+
+    friend std::ostream &operator<<(std::ostream &stream, const FHTAnderson801 &ob);
 
-    friend std::ostream &operator<<(std::ostream &stream, const Hankel2 &ob);
+    struct ctor_key {};
 
     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.
+         *  Returns shared_ptr to new FHTAnderson801.
          */
-        static Hankel2 *New();
+        static std::shared_ptr<FHTAnderson801> NewSP();
 
         /**
-         * @copybrief LemmaObject::Delete()
-         * @copydetails LemmaObject::Delete()
+         *  Returns unique_ptr to new FHTAnderson801.
          */
-        void Delete();
+        static std::unique_ptr<FHTAnderson801> NewUP();
+
+        /// Default locked constructor
+        FHTAnderson801( const ctor_key& );
+
+        /** Locked deserializing constructor. */
+		FHTAnderson801 ( const YAML::Node& node, const ctor_key& );
+
+        /// Default destructor
+        ~FHTAnderson801();
+
+        /**
+         *   YAML Serializing method
+         */
+        YAML::Node Serialize() const;
+
+        /**
+         *   Constructs an object from a YAML::Node.
+         */
+        static std::shared_ptr< FHTAnderson801 > DeSerialize(const YAML::Node& node);
 
         // ====================  OPERATORS     ==============================
 
         void Compute(const Real &rho, const int& ntol, const Real &tol);
 
         /// Computes the related
-        void ComputeRelated(const Real &rho, KernelEm1DBase* Kernel);
+        void ComputeRelated(const Real &rho, std::shared_ptr<KernelEM1DBase> Kernel);
 
         /// Computes the related
-        void ComputeRelated(const Real &rho,  std::vector< KernelEm1DBase* > KernelVec);
+        void ComputeRelated(const Real &rho,  std::vector< std::shared_ptr<KernelEM1DBase> > KernelVec);
 
         /// Computes the related
-        void ComputeRelated(const Real &rho,  KernelEM1DManager* Manager);
+        void ComputeRelated(const Real &rho,  std::shared_ptr<KernelEM1DManager> Manager);
 
         /// Computes the related and lagged convolutions
-        void ComputeLaggedRelated(const Real &rho, const int& nlag,  KernelEM1DManager* Manager);
+        void ComputeLaggedRelated(const Real &rho, const int& nlag,  std::shared_ptr<KernelEM1DManager> Manager);
 
         // ====================  ACCESS        ==============================
 
         /// Sets the lagged kernel index so that the proper value is returned
         void SetLaggedArg(const Real& rho);
 
-
         // ====================  INQUIRY       ==============================
 
         /// Calculates Hankel Transform using filtering.
         /// = 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);
+                        const Real &wavef, std::shared_ptr<KernelEM1DBase> Kernel);
+
+        /** Returns the name of the underlying class, similiar to Python's type */
+        virtual inline std::string GetName() const {
+            return CName;
+        }
 
     protected:
 
+    private:
+
         // ====================  LIFECYCLE     ==============================
 
-        /** A rewrite of Anderson's Pseudo-subroutine. */
+        /** A rewrite of Anderson's "Pseudo-subroutine" computed GOTO madness. */
         inline void StoreRetreive(const int &idx, const int &lag,
                         Complex &Zsum, const int &irel, Complex &C, const Real& rho0) {
 
 		    return;
 	    }
 
-        /// Default protected constructor
-        Hankel2(const std::string& name);
-
-        /// Default protected destructor
-        ~Hankel2();
-
-        /**
-         * @copybrief LemmaObject::Release()
-         * @copydetails LemmaObject::Release()
-         */
-        void Release();
-
         // ====================  OPERATIONS    ==============================
 
         void DeleteSplines();
         //bool cacheResults;
 
         /** Related Kernel Manager */
-        KernelEM1DManager*          Manager;
+        std::shared_ptr<KernelEM1DManager>     Manager;
 
         /// Used as base for filter abscissa generation
         static const Real ABSCISSA;
         int icount;
 
         /// Kernel Calculator
-        std::vector <KernelEm1DBase*> kernelVec;
+        std::vector < std::shared_ptr<KernelEM1DBase> > kernelVec;
 
         /// Spines for lagged convolutions (real part)
-        std::vector <CubicSplineInterpolator*> splineVecReal;
+        std::vector <std::shared_ptr<CubicSplineInterpolator> > splineVecReal;
 
         /// Spines for lagged convolutions (imaginary part)
-        std::vector <CubicSplineInterpolator*> splineVecImag;
+        std::vector < std::shared_ptr<CubicSplineInterpolator> > splineVecImag;
 
         /// Key used internally
         Eigen::Matrix<int, 801, 1> Key;
         /// Holds the arguments for lagged convolutions
         VectorXr Arg;
 
-}; // -----  end of class  HankelTransform  -----
+        /** ASCII string representation of the class name */
+        static constexpr auto CName = "FHTAnderson801";
+
+}; // -----  end of class  FHTAnderson801  -----
 
 }
 
-#endif // __HANKEL2_h
+#endif // __FHTAnderson801_h

Modules/FDEM1D/include/hankeltransform.h → Modules/FDEM1D/include/HankelTransform.h

   @file
   @author   Trevor Irons
   @date     01/28/2010
-  @version  $Id: hankeltransform.h 270 2015-08-24 15:45:41Z tirons $
  **/
 
 #ifndef __hankeltransform_h
 
 namespace Lemma {
 
-
         class KernelEM1DBase;
 
         // ===================================================================
         //        Class:  HankelTransform
-        /// \brief  Pure abstract class for hankel transforms
+        /// \brief   Abstract class for hankel transforms
         /// \details
         // ===================================================================
         class HankelTransform : public LemmaObject {
 
                 // ====================  LIFECYCLE     =======================
 
-                //static HankelTransform* New();
-
-                //void Delete();
-
                 // ====================  OPERATORS     =======================
 
                 // ====================  OPERATIONS    =======================
 
                 /// 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::shared_ptr<KernelEM1DBase> Kernel);
 
                 virtual void ComputeRelated(const Real& rho, std::vector< std::shared_ptr<KernelEM1DBase> > KernelVec);
 
                 // ====================  ACCESS        =======================
 
                 // ====================  INQUIRY       =======================
+                /** Returns the name of the underlying class, similiar to Python's type */
+                virtual inline std::string GetName() const {
+                    return CName;
+                }
 
                 // ====================  DATA MEMBERS  =======================
 
                 // ====================  LIFECYCLE     =======================
 
                 /// Default protected constructor.
-                HankelTransform (const std::string &name);
+                HankelTransform ( );
 
                 /// Default protected constructor.
-                ~HankelTransform ();
+                ~HankelTransform ( );
 
             private:
 
+                /** ASCII string representation of the class name */
+                static constexpr auto CName = "HankelTransform";
+
     }; // -----  end of class  HankelTransform  -----
 
 }

Modules/FDEM1D/src/CMakeLists.txt

 set (FDEM1DSOURCE
 	${FDEM1DSOURCE}
 
-	#${CMAKE_CURRENT_SOURCE_DIR}/AEMSurvey.cpp
-	#${CMAKE_CURRENT_SOURCE_DIR}/AEMSurveyReader.cpp
+
 
 	${CMAKE_CURRENT_SOURCE_DIR}/LayeredEarthEM.cpp
 	
 	${CMAKE_CURRENT_SOURCE_DIR}/KernelEM1DSpec.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/KernelEM1DReflSpec.cpp
 
+	${CMAKE_CURRENT_SOURCE_DIR}/HankelTransform.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/FHTAnderson801.cpp
 
+	#${CMAKE_CURRENT_SOURCE_DIR}/AEMSurvey.cpp
+	#${CMAKE_CURRENT_SOURCE_DIR}/AEMSurveyReader.cpp
 	#${CMAKE_CURRENT_SOURCE_DIR}/UngroundedElectricDipole.cpp
 	PARENT_SCOPE
 )

Modules/FDEM1D/src/DipoleSource.cpp

 //#include "MagneticDipole.h"
 
 #include "FieldPoints.h"
-#include "hankeltransform.h"
+#include "HankelTransform.h"
 
 namespace Lemma {
 

Modules/FDEM1D/src/hankeltransformhankel2.cpp → Modules/FDEM1D/src/FHTAnderson801.cpp

   @version  $Id: hankeltransformhankel2.cpp 202 2015-01-06 20:53:21Z tirons $
  **/
 
-#include "hankeltransformhankel2.h"
+#include "FHTAnderson801.h"
 
 namespace Lemma {
 
-	std::ostream &operator<<(std::ostream &stream,
-			const Hankel2 &ob) {
-
-		stream << *(HankelTransform*)(&ob);
-		return stream;
-	}
+    std::ostream &operator << (std::ostream &stream, const FHTAnderson801 &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        return stream;
+    }
 
-    // Initialise static const members
-    const Eigen::Matrix<Real, 2, 801>  Hankel2::FilterWeights =
+    // Initialise static const members, this could be done by preprocessor in
+    // slightly higher precision?
+    const Eigen::Matrix<Real, 2, 801>  FHTAnderson801::FilterWeights =
         ( Eigen::Matrix<Real, 2, 801>()   <<
 					2.103562053838982e-29, -1.264469361608894e-14,
 					4.615731256788567e-14, -2.798703374257668e-14,
 					// 800
 					7.214920505613761e-28).finished();
 
-    const Real Hankel2::ABSCISSA = 0.7059431685223780;     //
-	const Real Hankel2::ABSE = 1.10517091807564762;        // exp(.1)
-	const Real Hankel2::ABSER = 0.904837418035959573;      // 1/exp(.1)
-    //std::unordered_map<Real, int> Hankel2::RHO0 = {};
+    const Real FHTAnderson801::ABSCISSA = 0.7059431685223780;     //
+	const Real FHTAnderson801::ABSE = 1.10517091807564762;        // exp(.1)
+	const Real FHTAnderson801::ABSER = 0.904837418035959573;      // 1/exp(.1)
 
 	// ====================  LIFECYCLE     ==============================
-	Hankel2::Hankel2(const std::string&name) : HankelTransform(name),
+	FHTAnderson801::FHTAnderson801(const ctor_key& ) : HankelTransform( ),
 			             Lambda(0), NumFun(0),
 						 NumConv(0), NumRel(0),
-						 BesselOrder(-1),  Manager(NULL) {
+						 BesselOrder(-1),  Manager(nullptr) {
 	}
 
-	Hankel2::~Hankel2() {
-		//if (!this->kernelVec.empty()) {
-		//	this->Ckernel->DetachFrom(this);
-		//}
-
-        DeleteSplines();
-
-        if (Manager != NULL) {
-            Manager->DetachFrom(this);
-        }
-
-        if (this->NumberOfReferences != 0)
-            throw DeleteObjectWithReferences( this );
+    FHTAnderson801::FHTAnderson801( const YAML::Node& node, const ctor_key& ) : HankelTransform( ) {
+        Lambda = node["Lambda"].as<Real>();
+        NumFun = node["NumFun"].as<int>();
+		NumConv = node["NumConv"].as<int>();
+        NumRel = node["NumRel"].as<int>( );
+		BesselOrder = node["BesselOrder"].as<int>( );
+        //Manager = KernelEM1DManager::DeSerialize(node["Manager"]);
 	}
 
-	Hankel2* Hankel2::New() {
-		Hankel2* Obj = new Hankel2("Hankel2");
-        Obj->AttachTo(Obj);
-        return Obj;
+	FHTAnderson801::~FHTAnderson801() {
 	}
 
-	void Hankel2::Delete() {
-        this->DetachFrom(this);
-	}
+	std::shared_ptr<FHTAnderson801> FHTAnderson801::NewSP() {
+	    return std::make_shared<FHTAnderson801>( ctor_key() );
+    }
 
-    void Hankel2::Release() {
-        delete this;
+    std::unique_ptr<FHTAnderson801> FHTAnderson801::NewUP() {
+	    return std::make_unique<FHTAnderson801>( ctor_key() );
     }
 
-    void Hankel2::DeleteSplines() {
-        for (unsigned int ii=0; ii<splineVecReal.size(); ++ii){
-            splineVecReal[ii]->Delete();
+    std::shared_ptr<FHTAnderson801> FHTAnderson801::DeSerialize( const YAML::Node& node ) {
+        if (node.Tag() != "FHTAnderson801") {
+            throw  DeSerializeTypeMismatch( "FHTAnderson801", node.Tag());
         }
-        splineVecReal.clear();
+        return std::make_shared<FHTAnderson801> ( node, ctor_key() );
+    }
 
-        for (unsigned int ii=0; ii<splineVecImag.size(); ++ii){
-            splineVecImag[ii]->Delete();
-        }
+    YAML::Node FHTAnderson801::Serialize() const {
+        YAML::Node node = HankelTransform::Serialize();
+        node.SetTag( GetName() );
+        node["Lambda"] = Lambda;
+        node["NumFun"] = NumFun;
+        node["NumConv"] = NumConv;
+        node["NumRel"] = NumRel;
+        node["BesselOrder"] = BesselOrder;
+        node["Manager"] = Manager->Serialize();
+        return node;
+    }
+
+    void FHTAnderson801::DeleteSplines() {
+        splineVecReal.clear();
         splineVecImag.clear();
     }
 
 	// ====================  OPERATIONS    ==============================
 
-    void Hankel2::ComputeRelated(const Real& rho, KernelEm1DBase* Kernel) {
+    void FHTAnderson801::ComputeRelated(const Real& rho, std::shared_ptr<KernelEM1DBase> Kernel) {
         //this->AttachKernel(Kernel);
         this->SetNumConv(1);
         icount = 0;
 #endif
     }
 
-    void Hankel2::ComputeRelated(const Real& rho,  std::vector< KernelEm1DBase*> KernelVecIn ) {
+    void FHTAnderson801::ComputeRelated(const Real& rho,  std::vector< std::shared_ptr<KernelEM1DBase> > KernelVecIn ) {
         icount = 0;
         this->kernelVec = KernelVecIn;
         this->SetNumConv(1);
 #endif
     }
 
-    void Hankel2::ComputeRelated(const Real& rho,  KernelEM1DManager* KernelManager) {
+    void FHTAnderson801::ComputeRelated(const Real& rho,  std::shared_ptr<KernelEM1DManager> KernelManager) {
         icount = 0;
-        if (Manager != NULL) {
-            Manager->DetachFrom(this);
-        }
-        KernelManager->AttachTo(this);
         Manager = KernelManager;
         this->kernelVec = KernelManager->GetSTLVector();
         this->SetNumConv(1);
 #endif
     }
 
-    void Hankel2::ComputeLaggedRelated(const Real& rho, const int& nlag, KernelEM1DManager* KernelManager) {
+    void FHTAnderson801::ComputeLaggedRelated(const Real& rho, const int& nlag, std::shared_ptr<KernelEM1DManager> KernelManager) {
         icount = 0;
-        if (Manager != NULL) {
-            Manager->DetachFrom(this);
-        }
-        KernelManager->AttachTo(this);
         Manager = KernelManager;
         this->kernelVec = KernelManager->GetSTLVector();
         this->SetNumConv(nlag);
         //std::cout << "Arg\n" << Arg << std::endl;
         //std::cout << "Zans\n" << Zans.col(0) << std::endl;
         for (int ii=0; ii<Zans.cols(); ++ii) {
-            CubicSplineInterpolator *Spline = CubicSplineInterpolator::New();
+            auto Spline = CubicSplineInterpolator::NewSP();
             Spline->SetKnots( Arg, Zans.col(ii).real() );
             splineVecReal.push_back(Spline);
 
-            CubicSplineInterpolator *SplineI = CubicSplineInterpolator::New();
+            auto SplineI = CubicSplineInterpolator::NewSP();
             SplineI->SetKnots( Arg, Zans.col(ii).imag() );
             splineVecImag.push_back(SplineI);
         }
 
     }
 
-    void Hankel2::SetLaggedArg(const Real& rho) {
+    void FHTAnderson801::SetLaggedArg(const Real& rho) {
         for (int i=0; i<Zans.cols(); ++ i) {
             Zans(0, i) = Complex( splineVecReal[i]->Interpolate(rho),
                                   splineVecImag[i]->Interpolate(rho) );
         }
     }
 
-	Complex Hankel2::Zgauss(const int &ikk, const EMMODE &imode,
+	Complex FHTAnderson801::Zgauss(const int &ikk, const EMMODE &imode,
 						const int &itype, const Real &rho,
 						const Real &wavef, KernelEm1DBase *Kernel) {
 
 
 	}
 
-	void Hankel2::SetNumConv(const int &i) {
+	void FHTAnderson801::SetNumConv(const int &i) {
 		this->NumConv = i;
 	}
 
-	Eigen::Matrix<Complex, Eigen::Dynamic, Eigen::Dynamic> Hankel2::GetAnswer() {
+	Eigen::Matrix<Complex, Eigen::Dynamic, Eigen::Dynamic> FHTAnderson801::GetAnswer() {
 		return this->Zans;
 	}
 
 	///////////////////////////////////////////
 	// Computes the transform
-	void Hankel2::Compute(const Real &rho, const int& ntol, const Real &tol) {
+	void FHTAnderson801::Compute(const Real &rho, const int& ntol, const Real &tol) {
 
 		Real y1 = this->ABSCISSA/rho;
 		//this->Key.setZero(801);
 		}
 
 		if (this->NumConv<1) {
-			throw std::runtime_error("In Hankel2 NumConv is less than 1.");
+			throw std::runtime_error("In FHTAnderson801 NumConv is less than 1.");
 		}
 
         if (this->kernelVec.empty()) {
-			throw std::runtime_error("In Hankel2 Unset Kernel Calculator");
+			throw std::runtime_error("In FHTAnderson801 Unset Kernel Calculator");
 		}
         #endif
 		//if (rho<=1e-5) {

Modules/FDEM1D/src/HankelTransform.cpp

+/* This file is part of Lemma, a geophysical modelling and inversion API */
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+  @file
+  @author   Trevor Irons
+  @date     01/02/2010
+  @version  $Id: hankeltransform.cpp 193 2014-11-10 23:51:41Z tirons $
+ **/
+
+#include "HankelTransform.h"
+
+namespace Lemma {
+
+    std::ostream &operator << (std::ostream &stream, const HankelTransform &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        return stream;
+    }
+
+	HankelTransform::HankelTransform( ) : LemmaObject( )	{
+	}
+
+	HankelTransform::~HankelTransform( ) {
+	}
+
+    void HankelTransform::ComputeRelated(const Real& rho, std::shared_ptr<KernelEM1DBase> Kernel) {
+    }
+
+    void HankelTransform::ComputeRelated(const Real& rho, std::vector< std::shared_ptr<KernelEM1DBase> > KernelVec) {
+    }
+
+    void HankelTransform::ComputeRelated(const Real& rho, std::shared_ptr<KernelEM1DManager> KernelManager) {
+    }
+}

Modules/FDEM1D/src/hankeltransform.cpp

-/* This file is part of Lemma, a geophysical modelling and inversion API */
-
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/**
-  @file
-  @author   Trevor Irons
-  @date     01/02/2010
-  @version  $Id: hankeltransform.cpp 193 2014-11-10 23:51:41Z tirons $
- **/
-
-#include "hankeltransform.h"
-
-namespace Lemma {
-
-	std::ostream &operator<<(std::ostream &stream,
-			const HankelTransform &ob) {
-		stream << *(LemmaObject*)(&ob);
-		return stream;
-	}
-
-	HankelTransform::HankelTransform(const std::string &name) :
-	   LemmaObject(name)	{
-	}
-
-	HankelTransform::~HankelTransform() {
-	}
-
-    void HankelTransform::ComputeRelated(const Real& rho, KernelEm1DBase *Kernel) {
-    }
-
-    void HankelTransform::ComputeRelated(const Real& rho, std::vector< KernelEm1DBase* > KernelVec) {
-    }
-
-    void HankelTransform::ComputeRelated(const Real& rho, KernelEM1DManager*  KernelManager) {
-    }
-}

Modules/FDEM1D/testing/GetNameCheck.h

         TS_ASSERT_EQUALS( Obj->GetName(), std::string("FieldPoints") );
     }
 
+    void testDipoleSource( void )
+    {
+        auto Obj = DipoleSource::NewSP();
+        TS_ASSERT_EQUALS( Obj->GetName(), std::string("DipoleSource") );
+    }
+
+    void testWireAntenna( void )
+    {
+        auto Obj = WireAntenna::NewSP();
+        TS_ASSERT_EQUALS( Obj->GetName(), std::string("WireAntenna") );
+    }
+
+//     void testKernelEM1DManager( void )
+//     {
+//         auto Obj = KernelEM1DManager::NewSP();
+//         TS_ASSERT_EQUALS( Obj->GetName(), std::string("KernelEM1DManager") );
+//     }
+//
+//     void testKernelEM1DSpec( void )
+//     {
+//         auto Obj = KernelEM1DSpec::NewSP();
+//         TS_ASSERT_EQUALS( Obj->GetName(), std::string("KernelEM1DSpec") );
+//     }
+//
+//     void testKernelEM1DReflSpec( void )
+//     {
+//         auto Obj = KernelEM1DReflSpec::NewSP();
+//         TS_ASSERT_EQUALS( Obj->GetName(), std::string("KernelEM1DReflSpec") );
+//     }
+
 };
 

vim/c.vim

 
 " Lemma types
 highlight leType ctermfg=Yellow guifg=Yellow
-syn keyword leType HankelTransform KernelEm1D KernelEM1DManager DipoleSource EarthModel LayeredEarth LayeredEarthEM TEMSurvey TEMSurveyLine TEMSurveyLineRecord TEMInductiveReceiver PolygonalWireAntenna TEMTransmitter TEMReceiver Instrument InstrumentTem LemmaObject FieldPoints DCIPElectrode TEMSurveyData TEMSurveyLineData TEMSurveyLineRecordData  ASCIIParser CubicSplineInterpolator RectilinearGrid GridReader RectilinearGridReader RectilinearGridVTKExporter Filter WindowFilter DEMParticle DEMGrain Data DataReader 
+syn keyword leType HankelTransform FHTAnderson801 KernelEM1D KernelEM1DSpec KernelEM1DBase KernelEM1DManager DipoleSource EarthModel LayeredEarth LayeredEarthEM TEMSurvey TEMSurveyLine TEMSurveyLineRecord TEMInductiveReceiver WireAntenna PolygonalWireAntenna TEMTransmitter TEMReceiver Instrument InstrumentTem LemmaObject FieldPoints DCIPElectrode TEMSurveyData TEMSurveyLineData TEMSurveyLineRecordData  ASCIIParser CubicSplineInterpolator RectilinearGrid GridReader RectilinearGridReader RectilinearGridVTKExporter Filter WindowFilter DEMParticle DEMGrain Data DataReader 
 
 " Deprecated Lemma Types
 highlight dleType ctermfg=Blue guifg=Blue