Added Key hankel class and polygonal wire antenna.

Modules/FDEM1D/examples/CMakeLists.txt

 add_executable( FieldPoints FieldPoints.cpp  )
 target_link_libraries(  FieldPoints  "lemmacore" "fdem1d")
 
+add_executable( PolygonalWireAntenna PolygonalWireAntenna.cpp  )
+target_link_libraries(  PolygonalWireAntenna  "lemmacore" "fdem1d")
+
 INSTALL_TARGETS( "/share/FEM1D/"
 	LayeredEarthEM 
 	FieldPoints
+	PolygonalWireAntenna
 )

Modules/FDEM1D/examples/PolygonalWireAntenna.cpp

+/* This file is part of Lemma, a geophysical modelling and inversion API.
+ * More information is available at http://lemmasoftware.org
+ */
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+/**
+ * @file
+ * @date      11/07/2016 12:01:34 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 <FDEM1D>
+using namespace Lemma;
+
+int main() {
+
+    auto wire = PolygonalWireAntenna::NewSP();
+        wire->SetNumberOfPoints(5);
+        wire->SetPoint(0, 0, 0, 0);
+        wire->SetPoint(1, 1, 0, 0);
+        wire->SetPoint(2, 1, 1, 0);
+        wire->SetPoint(3, 0, 1, 0);
+        wire->SetPoint(4, 0, 0, 0);
+    std::cout << *wire << std::endl;
+
+    auto wire2 = wire->Clone();
+    std::cout << *wire2 << std::endl;
+}

Modules/FDEM1D/include/FDEM1D

 #include "LayeredEarthEM.h"
+
 #include "FieldPoints.h"
+
 #include "WireAntenna.h"
+#include "PolygonalWireAntenna.h"
+
 #include "DipoleSource.h"
 
 // internal

Modules/FDEM1D/include/FHTKey.h → Modules/FDEM1D/include/FHTKey201.h

 /**
  * @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
+ * @email     Trevor.Irons@lemmasoftware.org
  * @copyright Copyright (c) 2014, Trevor Irons
  */
 
 
-#ifndef  FHTKEY_INC
-#define  FHTKEY_INC
+#ifndef  FHTKEY201_INC
+#define  FHTKEY201_INC
 
-#include "hankeltransform.h"
+#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
+      \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:
                 %------------------------------------------------------------------%
                 % http://software.seg.org/disclaimer.txt before use.               %
                 %------------------------------------------------------------------%
      */
-    class FHTKey : public HankelTransform {
+    class FHTKey201 : public HankelTransform {
 
-        friend std::ostream &operator<<(std::ostream &stream,
-                const FHTKey &ob);
+        friend std::ostream &operator<<(std::ostream &stream, const FHTKey201 &ob);
+
+        struct ctor_key {};
 
         public:
 
         // ====================  LIFECYCLE     =======================
 
+        /** Default locked constructor, use NewSP */
+        FHTKey201 ( const ctor_key& );
+
+        /** DeSerializing locked constructor, use NewSP */
+        FHTKey201 ( const YAML::Node& node, const ctor_key& );
+
+        /** Default protected destructor, use Delete */
+        ~FHTKey201 ();
+
         /**
          * @copybrief LemmaObject::New()
          * @copydetails LemmaObject::New()
          */
-        static FHTKey* New();
+        static std::shared_ptr<FHTKey201> NewSP();
+
+        /** YAML Serializing method
+         */
+        YAML::Node Serialize() const;
 
         /**
-         *  @copybrief   LemmaObject::Delete()
-         *  @copydetails LemmaObject::Delete()
+         *   Constructs an object from a YAML::Node.
          */
-        void Delete();
+        static std::shared_ptr< FHTKey201 > DeSerialize(const YAML::Node& node);
 
         // ====================  OPERATORS     =======================
 
 
         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);
 
         /// 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::shared_ptr<KernelEM1DBase> Kernel);
 
-        void ComputeRelated(const Real& rho, std::vector< KernelEm1DBase* > KernelVec);
+        void ComputeRelated(const Real& rho, std::vector< std::shared_ptr<KernelEM1DBase> > KernelVec);
 
-        void ComputeRelated(const Real& rho, KernelEM1DManager* KernelManager);
+        void ComputeRelated(const Real& rho, std::shared_ptr<KernelEM1DManager> KernelManager);
 
         // ====================  ACCESS        =======================
 
         // ====================  INQUIRY       =======================
 
+        /** Returns the name of the underlying class, similiar to Python's type */
+        virtual inline std::string GetName() const {
+            return CName;
+        }
+
         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  =========================
         /// Holds answer, dimensions are NumConv, and NumberRelated.
         Eigen::Matrix<Complex, Eigen::Dynamic, Eigen::Dynamic> Zans;
 
-    }; // -----  end of class  FHTKey  -----
+        /** ASCII string representation of the class name */
+        static constexpr auto CName = "FHTKey201";
+
+    }; // -----  end of class  FHTKey201  -----
 
 }		// -----  end of Lemma  name  -----
 
-#endif   // ----- #ifndef FHTKEY_INC  -----
+#endif   // ----- #ifndef FHTKEY201_INC  -----
 

Modules/FDEM1D/include/HankelTransform.h

                 /// 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
+                /// @note compare performance of passing Kernel, instead consider
+                ///       passing by reference and using Kernel.get() instead.
                 virtual Complex Zgauss(const int &ikk, const EMMODE &imode,
                             const int &itype, const Real &rho,
                             const Real &wavef, std::shared_ptr<KernelEM1DBase> Kernel)=0;
                 HankelTransform ( );
 
                 /// Default protected constructor.
+                HankelTransform ( const YAML::Node& node );
+
+                /// Default protected constructor.
                 ~HankelTransform ( );
 
             private:

Modules/FDEM1D/include/PolygonalWireAntenna.h

 
             /// Makes a deep copy of this antenna with all connections except
             /// the dipole approximation.
-            std::shared_ptr<PolygonalWireAntenna> Clone();
+            std::shared_ptr<WireAntenna> Clone();
 
             /**
              *  Uses YAML to serialize this object.

Modules/FDEM1D/include/WireAntenna.h

 
         friend std::ostream &operator<<(std::ostream &stream, const WireAntenna &ob);
 
+        protected:
         struct ctor_key {};
 
         public:

Modules/FDEM1D/src/CMakeLists.txt

 set (FDEM1DSOURCE
 	${FDEM1DSOURCE}
 
-
-
 	${CMAKE_CURRENT_SOURCE_DIR}/LayeredEarthEM.cpp
 	
 	${CMAKE_CURRENT_SOURCE_DIR}/FieldPoints.cpp
 	
 	${CMAKE_CURRENT_SOURCE_DIR}/DipoleSource.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/WireAntenna.cpp
-
+	${CMAKE_CURRENT_SOURCE_DIR}/PolygonalWireAntenna.cpp
 	
 	${CMAKE_CURRENT_SOURCE_DIR}/KernelEM1DManager.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/KernelEM1DSpec.cpp
 
 	${CMAKE_CURRENT_SOURCE_DIR}/HankelTransform.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/FHTAnderson801.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/FHTKey201.cpp
+	#${CMAKE_CURRENT_SOURCE_DIR}/FHTKey101.cpp
+	#${CMAKE_CURRENT_SOURCE_DIR}/FHTKey51.cpp
 
 	#${CMAKE_CURRENT_SOURCE_DIR}/AEMSurvey.cpp
 	#${CMAKE_CURRENT_SOURCE_DIR}/AEMSurveyReader.cpp

Modules/FDEM1D/src/FHTKey.cpp → Modules/FDEM1D/src/FHTKey201.cpp

 /**
  * @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
+ * @email     Trevor.Irons@lemmasoftware.org
  * @copyright Copyright (c) 2014, Trevor Irons
  */
 
-#include "FHTKey.h"
+#include "FHTKey201.h"
 
 namespace Lemma {
 
     // ====================  FRIEND METHODS  =====================
 
-    std::ostream &operator<<(std::ostream &stream, const FHTKey &ob) {
-
-        stream << *(HankelTransform*)(&ob);
-
+    std::ostream &operator<<(std::ostream &stream, const FHTKey201 &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
         return stream;
     }
 
 
     // ====================  STATIC CONST MEMBERS     ============
 
-    const Eigen::Matrix<Real, 201, 3>  FHTKey::WT201 =
+    const Eigen::Matrix<Real, 201, 3>  FHTKey201::WT201 =
         ( Eigen::Matrix<Real, 201, 3>()   <<
         // Base                   J0                      J1
           4.1185887075357082e-06, 1.5020099209519960e-03, 4.7827871332506182e-10
     // ====================  LIFECYCLE     =======================
 
     //--------------------------------------------------------------------------------------
-    //       Class:  FHTKey
-    //      Method:  FHTKey
-    // Description:  constructor (protected)
+    //       Class:  FHTKey201
+    //      Method:  FHTKey201
+    // Description:  constructor (locked)
     //--------------------------------------------------------------------------------------
-    FHTKey::FHTKey (const std::string& name) : HankelTransform(name) {
+    FHTKey201::FHTKey201 (const ctor_key& ) : HankelTransform( ) {
+
+    }  // -----  end of method FHTKey201::FHTKey201  (constructor)  -----
 
-    }  // -----  end of method FHTKey::FHTKey  (constructor)  -----
+    FHTKey201::FHTKey201( const YAML::Node& node, const ctor_key& ) : HankelTransform(node) {
 
+    }
 
     //--------------------------------------------------------------------------------------
-    //       Class:  FHTKey
-    //      Method:  New()
+    //       Class:  FHTKey201
+    //      Method:  NewSP()
     // Description:  public constructor
     //--------------------------------------------------------------------------------------
-    FHTKey* FHTKey::New() {
-        FHTKey*  Obj = new FHTKey("FHTKey");
-        Obj->AttachTo(Obj);
-        return Obj;
+    std::shared_ptr<FHTKey201> FHTKey201::NewSP() {
+        return std::make_shared<FHTKey201>( ctor_key() );
     }
 
     //--------------------------------------------------------------------------------------
-    //       Class:  FHTKey
-    //      Method:  ~FHTKey
-    // Description:  destructor (protected)
+    //       Class:  FHTKey201
+    //      Method:  ~FHTKey201
+    // Description:  destructor
     //--------------------------------------------------------------------------------------
-    FHTKey::~FHTKey () {
+    FHTKey201::~FHTKey201 () {
 
-    }  // -----  end of method FHTKey::~FHTKey  (destructor)  -----
+    }  // -----  end of method FHTKey201::~FHTKey201  (destructor)  -----
 
     //--------------------------------------------------------------------------------------
-    //       Class:  FHTKey
-    //      Method:  Delete
-    // Description:  public destructor
+    //       Class:  FHTKey201
+    //      Method:  DeSerialize
+    // Description:  Factory method, converts YAML node into object
     //--------------------------------------------------------------------------------------
-    void FHTKey::Delete() {
-        this->DetachFrom(this);
+    std::shared_ptr<FHTKey201> FHTKey201::DeSerialize( const YAML::Node& node ) {
+        if (node.Tag() != "FHTKey201") {
+            throw  DeSerializeTypeMismatch( "FHTKey201", node.Tag());
+        }
+        return std::make_shared<FHTKey201> ( node, ctor_key() );
     }
 
     //--------------------------------------------------------------------------------------
-    //       Class:  FHTKey
-    //      Method:  Release
-    // Description:  destructor (protected)
+    //       Class:  FHTKey201
+    //      Method:  Serialize
+    // Description:  Converts object into Serialized version
     //--------------------------------------------------------------------------------------
-    void FHTKey::Release() {
-        delete this;
+    YAML::Node FHTKey201::Serialize() const {
+        YAML::Node node = HankelTransform::Serialize();
+        node.SetTag( GetName() );
+        //node["LayerConductivity"] = LayerConductivity;
+        return node;
     }
 
-
     //--------------------------------------------------------------------------------------
-    //       Class:  FHTKey
+    //       Class:  FHTKey201
     //      Method:  Zgauss
     //--------------------------------------------------------------------------------------
-    Complex FHTKey::Zgauss ( const int &ikk, const EMMODE &imode,
+    Complex FHTKey201::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 ) {
  		return Zans(0, Kernel->GetManagerIndex());
-    }		// -----  end of method FHTKey::ComputeRelated  -----
+    }		// -----  end of method FHTKey201::ComputeRelated  -----
 
 
     //--------------------------------------------------------------------------------------
-    //       Class:  FHTKey
+    //       Class:  FHTKey201
     //      Method:  ComputeRelated
     //--------------------------------------------------------------------------------------
-    void FHTKey::ComputeRelated ( const Real& rho, KernelEm1DBase* Kernel ) {
+    void FHTKey201::ComputeRelated ( const Real& rho, std::shared_ptr<KernelEM1DBase> Kernel ) {
         return ;
-    }		// -----  end of method FHTKey::ComputeRelated  -----
+    }		// -----  end of method FHTKey201::ComputeRelated  -----
 
     //--------------------------------------------------------------------------------------
-    //       Class:  FHTKey
+    //       Class:  FHTKey201
     //      Method:  ComputeRelated
     //--------------------------------------------------------------------------------------
-    void FHTKey::ComputeRelated ( const Real& rho, std::vector< KernelEm1DBase* > KernelVec ) {
+    void FHTKey201::ComputeRelated ( const Real& rho, std::vector< std::shared_ptr<KernelEM1DBase> > KernelVec ) {
         return ;
-    }		// -----  end of method FHTKey::ComputeRelated  -----
+    }		// -----  end of method FHTKey201::ComputeRelated  -----
 
     //--------------------------------------------------------------------------------------
-    //       Class:  FHTKey
+    //       Class:  FHTKey201
     //      Method:  ComputeRelated
     //--------------------------------------------------------------------------------------
-    void FHTKey::ComputeRelated ( const Real& rho, KernelEM1DManager* KernelManager ) {
+    void FHTKey201::ComputeRelated ( const Real& rho, std::shared_ptr<KernelEM1DManager> KernelManager ) {
 
         //kernelVec = KernelManager->GetSTLVector();
         int nrel = (int)(KernelManager->GetSTLVector().size());
         }
 
         return ;
-    }		// -----  end of method FHTKey::ComputeRelated  -----
+    }		// -----  end of method FHTKey201::ComputeRelated  -----
 
 }		// -----  end of Lemma  name  -----

Modules/FDEM1D/src/HankelTransform.cpp

 	HankelTransform::HankelTransform( ) : LemmaObject( )	{
 	}
 
+    HankelTransform::HankelTransform( const YAML::Node& node ) : LemmaObject( node )	{
+	}
+
 	HankelTransform::~HankelTransform( ) {
 	}
 

Modules/FDEM1D/src/PolygonalWireAntenna.cpp

 
 namespace Lemma {
 
-#ifdef HAVE_YAMLCPP
     std::ostream &operator << (std::ostream &stream, const PolygonalWireAntenna &ob) {
         stream << ob.Serialize()  << "\n---\n"; // End of doc --- as a direct stream should encapulste thingy
         return stream;
     }
-#else
-	std::ostream &operator<<(std::ostream &stream,
-				const PolygonalWireAntenna &ob) {
-
-		stream << *(WireAntenna*)(&ob);
-		//stream << "Current: " << ob.Current << " [A]\n";
-		//stream << "Frequencies: " << ob.Freqs.transpose() << " [Hz]\n";
-		//stream << "Number of points " << ob.NumberOfPoints << "\n";
-		//stream << "Points:\n" << ob.Points.transpose() << "\n";
-		//stream << "Dipoles used to approximate " << ob.Dipoles.size();
-		return stream;
-	}
-#endif
+
 	// ====================  LIFECYCLE     =======================
 
-	PolygonalWireAntenna::PolygonalWireAntenna(const std::string& name)
-		: WireAntenna(name), minDipoleRatio(.15),
+	PolygonalWireAntenna::PolygonalWireAntenna( const ctor_key& key ) : WireAntenna( WireAntenna::ctor_key() ), minDipoleRatio(.15),
    		minDipoleMoment(1e-6), maxDipoleMoment(1e1), rRepeat(1e10,1e10,1e10) {
 		Points.setZero();
         //rRepeat.setOnes();
 	}
 
-#ifdef HAVE_YAMLCPP
-    PolygonalWireAntenna::PolygonalWireAntenna(const YAML::Node& node)
-		: WireAntenna(node) {
-// minDipoleRatio(.15),
-// minDipoleMoment(1e-4),
-// maxDipoleMoment(1e-0)
+    PolygonalWireAntenna::PolygonalWireAntenna( const YAML::Node& node, const ctor_key& ) : WireAntenna(node, WireAntenna::ctor_key() ) {
         minDipoleRatio   = node["minDipoleRatio"].as<Real>();
         maxDipoleMoment  = node["maxDipoleMoment"].as<Real>();
         minDipoleMoment  = node["minDipoleMoment"].as<Real>();
 	}
-#endif
 
 	PolygonalWireAntenna::~PolygonalWireAntenna() {
-        if (this->NumberOfReferences != 0)
-            throw DeleteObjectWithReferences( this );
-		// Taken care of in parent
-        //for (unsigned int id=0; id<Dipoles.size(); ++id) {
-		//	Dipoles[id]->Delete();
-		//}
-		//Dipoles.clear();
 	}
 
-	PolygonalWireAntenna* PolygonalWireAntenna::New() {
-		PolygonalWireAntenna* Obj = new
-            PolygonalWireAntenna("PolygonalWireAntenna");
-        Obj->AttachTo(Obj);
-        return Obj;
+    //--------------------------------------------------------------------------------------
+    //       Class:  PolygonalWireAntenna
+    //      Method:  Serialize
+    //--------------------------------------------------------------------------------------
+    YAML::Node PolygonalWireAntenna::Serialize (  ) const {
+        YAML::Node node = WireAntenna::Serialize();
+        node.SetTag( this->GetName() );
+        node["minDipoleRatio"]  = minDipoleRatio;
+        node["maxDipoleMoment"] = maxDipoleMoment;
+        node["minDipoleMoment"] = minDipoleMoment;
+        return node;
+    }		// -----  end of method PolygonalWireAntenna::Serialize  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  WireAntenna
+    //      Method:  DeSerialize
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr<PolygonalWireAntenna> PolygonalWireAntenna::DeSerialize ( const YAML::Node& node ) {
+        if (node.Tag() != "PolygonalWireAntenna") {
+            throw  DeSerializeTypeMismatch( "PolygonalWireAntenna", node.Tag());
+        }
+        return std::make_shared<PolygonalWireAntenna> ( node, ctor_key() );
+    }		// -----  end of method WireAntenna::DeSerialize  -----
+
+	std::shared_ptr<PolygonalWireAntenna> PolygonalWireAntenna::NewSP() {
+        return std::make_shared<PolygonalWireAntenna>( ctor_key() );
 	}
 
-	PolygonalWireAntenna* PolygonalWireAntenna::Clone() {
-		PolygonalWireAntenna* copy = PolygonalWireAntenna::New();
-		//copy->AttachTo(copy); // NO! Attached above!
+	std::shared_ptr<WireAntenna> PolygonalWireAntenna::Clone() {
+		auto copy = PolygonalWireAntenna::NewSP();
         copy->minDipoleRatio = this->minDipoleRatio;
 		copy->minDipoleMoment = this->minDipoleMoment;
 		copy->maxDipoleMoment = this->maxDipoleMoment;
 		return copy;
 	}
 
-	void PolygonalWireAntenna::Delete() {
-		this->DetachFrom(this);
-	}
-
-    void PolygonalWireAntenna::Release() {
-		delete this;
-	}
-
     void PolygonalWireAntenna::SetMinDipoleRatio (const Real& ratio) {
         minDipoleRatio = ratio;
     }
 	void PolygonalWireAntenna::ApproximateWithElectricDipoles(const Vector3r &rp) {
         // Only resplit if necessary. Save a few cycles if repeated
         if ( (rRepeat-rp).norm() > 1e-16 ) {
-		    for (unsigned int id=0; id<Dipoles.size(); ++id) {
-			    Dipoles[id]->Delete();
-		    }
 		    Dipoles.clear();
 
 		    // loop over all segments
 
 	void PolygonalWireAntenna::PushXYZDipoles(const Vector3r &step,
 				    const Vector3r &cp, const Vector3r &dir,
-					std::vector<DipoleSource*> &xDipoles) {
+					std::vector< std::shared_ptr<DipoleSource> > &xDipoles) {
 
 		Real scale = (Real)(NumberOfTurns)*Current;
 
-        DipoleSource *tx = DipoleSource::New();
+        auto tx = DipoleSource::NewSP();
 		    tx->SetLocation(cp);
 		    tx->SetType(UNGROUNDEDELECTRICDIPOLE);
 			tx->SetPolarisation(dir);
 
 	void PolygonalWireAntenna::CorrectOverstepXYZDipoles(const Vector3r &step,
 				    const Vector3r &cp,	const Vector3r &dir,
-					std::vector<DipoleSource*> &xDipoles ) {
+					std::vector< std::shared_ptr<DipoleSource> > &xDipoles ) {
 
 		Real scale = (Real)(NumberOfTurns)*Current;
 
 
 		///////////////////
 		// dipoles for this segment
-		std::vector<DipoleSource*>           xDipoles;
+		std::vector< std::shared_ptr<DipoleSource> >       xDipoles;
 
 		// go towards p1
 		if ( ((c-p1).array().abs() > minDipoleMoment).any() ) {
 		Dipoles.insert(Dipoles.end(), xDipoles.begin(), xDipoles.end());
 	}
 
-    #ifdef HAVE_YAMLCPP
-
-    //--------------------------------------------------------------------------------------
-    //       Class:  PolygonalWireAntenna
-    //      Method:  Serialize
-    //--------------------------------------------------------------------------------------
-    YAML::Node PolygonalWireAntenna::Serialize (  ) const {
-        YAML::Node node = WireAntenna::Serialize();
-        node.SetTag( this->Name );
-        node["minDipoleRatio"]  = minDipoleRatio;
-        node["maxDipoleMoment"] = maxDipoleMoment;
-        node["minDipoleMoment"] = minDipoleMoment;
-        return node;
-    }		// -----  end of method PolygonalWireAntenna::Serialize  -----
-
-
-    //--------------------------------------------------------------------------------------
-    //       Class:  WireAntenna
-    //      Method:  DeSerialize
-    //--------------------------------------------------------------------------------------
-    PolygonalWireAntenna* PolygonalWireAntenna::DeSerialize ( const YAML::Node& node ) {
-        PolygonalWireAntenna* Object = new PolygonalWireAntenna(node);
-        Object->AttachTo(Object);
-        DESERIALIZECHECK( node, Object )
-        return Object ;
-    }		// -----  end of method WireAntenna::DeSerialize  -----
-
-    #endif
 
 }

vim/c.vim

 
 " Lemma types
 highlight leType ctermfg=Yellow guifg=Yellow
-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 
+syn keyword leType HankelTransform FHTAnderson801 FHTKey201 FHTKey101 FHTKey51 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