Added more Hankel transforms and modified things a bit.

Modules/FDEM1D/include/FHTAnderson801.h

         /// = 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, std::shared_ptr<KernelEM1DBase> Kernel);
+                        const Real &wavef, KernelEM1DBase* Kernel);
 
         /** Returns the name of the underlying class, similiar to Python's type */
         virtual inline std::string GetName() const {

Modules/FDEM1D/include/FHTKey101.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  FHTKEY101_INC
 #define  FHTKEY101_INC
 
-#include "hankeltransform.h"
+#include "HankelTransform.h"
 
 namespace Lemma {
 
      */
     class FHTKey101 : public HankelTransform {
 
-        friend std::ostream &operator<<(std::ostream &stream,
-                const FHTKey101 &ob);
+        friend std::ostream &operator<<(std::ostream &stream, const FHTKey101 &ob);
+
+        struct ctor_key {};
 
         public:
 
         // ====================  LIFECYCLE     =======================
 
+        /** Default protected constructor, use New */
+        FHTKey101 ( const ctor_key& );
+
+        /** DeSerializing locked constructor, use NewSP */
+        FHTKey101 ( const YAML::Node& node, const ctor_key& );
+
+        /** Default protected destructor, use Delete */
+        ~FHTKey101 ();
+
         /**
          * @copybrief LemmaObject::New()
          * @copydetails LemmaObject::New()
          */
-        static FHTKey101* New();
+        static std::shared_ptr<FHTKey101> 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< FHTKey101 > 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, 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       =======================
+        virtual inline std::string GetName() const {
+            return CName;
+        }
 
         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  =========================
         /// Holds answer, dimensions are NumConv, and NumberRelated.
         Eigen::Matrix<Complex, Eigen::Dynamic, Eigen::Dynamic> Zans;
 
+        /** ASCII string representation of the class name */
+        static constexpr auto CName = "FHTKey101";
+
     }; // -----  end of class  FHTKey101  -----
 
 }		// -----  end of Lemma  name  -----

Modules/FDEM1D/include/FHTKey201.h

         /** Default locked constructor, use NewSP */
         FHTKey201 ( const ctor_key& );
 
-        /** DeSerializing locked constructor, use NewSP */
+        /** DeSerializing locked constructor, use DeSerialize */
         FHTKey201 ( const YAML::Node& node, const ctor_key& );
 
-        /** Default protected destructor, use Delete */
+        /** Default destructor */
         ~FHTKey201 ();
 
         /**
-         * @copybrief LemmaObject::New()
-         * @copydetails LemmaObject::New()
+         *  Factory method for generating objects.
+         *   @return std::shared_ptr< FHTKey201 >
          */
         static std::shared_ptr<FHTKey201> NewSP();
 
 
         Complex Zgauss(const int &ikk, const EMMODE &imode,
                             const int &itype, const Real &rho,
-                            const Real &wavef, std::shared_ptr<KernelEM1DBase> Kernel);
+                            const Real &wavef, KernelEM1DBase* Kernel);
 
         /// Computes related kernels, if applicable, otherwise this is
         /// just a dummy function.

Modules/FDEM1D/include/FHTKey51.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  FHTKEY51_INC
 #define  FHTKEY51_INC
 
-#include "hankeltransform.h"
+#include "HankelTransform.h"
 
 namespace Lemma {
 
      */
     class FHTKey51 : public HankelTransform {
 
-        friend std::ostream &operator<<(std::ostream &stream,
-                const FHTKey51 &ob);
+        friend std::ostream &operator<<(std::ostream &stream, const FHTKey51 &ob);
+
+        struct ctor_key {};
 
         public:
 
         // ====================  LIFECYCLE     =======================
 
+        /** Default locked constructor, use NewSP */
+        FHTKey51 ( const ctor_key& );
+
+        /** DeSerializing locked constructor, use DeSerialize */
+        FHTKey51 ( const YAML::Node& node, const ctor_key& );
+
+        /** Default destructor */
+        ~FHTKey51 ();
+
         /**
-         * @copybrief LemmaObject::New()
-         * @copydetails LemmaObject::New()
+         *  Factory method for generating objects.
+         *  @return std::shared_ptr<FHTKey51>
          */
-        static FHTKey51* New();
+        static std::shared_ptr<FHTKey51> 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< FHTKey51 > 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, 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       =======================
 
-        protected:
+        /** Returns the name of the underlying class, similiar to Python's type */
+        virtual inline std::string GetName() const {
+            return CName;
+        }
 
-        // ====================  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();
+        protected:
 
         private:
 
         /// Holds answer, dimensions are NumConv, and NumberRelated.
         Eigen::Matrix<Complex, Eigen::Dynamic, Eigen::Dynamic> Zans;
 
+        /** ASCII string representation of the class name */
+        static constexpr auto CName = "FHTKey51";
+
     }; // -----  end of class  FHTKey51  -----
 
 }		// -----  end of Lemma  name  -----

Modules/FDEM1D/include/hankeltransformgaussianquadrature.h → Modules/FDEM1D/include/GQChave.h

 #ifndef  _HANKELTRANSFORMGAUSSIANQUADRATURE_h_INC
 #define  _HANKELTRANSFORMGAUSSIANQUADRATURE_h_INC
 
-#include "hankeltransform.h"
+#include "HankelTransform.h"
 #include "KernelEM1DBase.h"
-
-#ifdef HAVEBOOSTCYLBESSEL
+//#include <cmath>
 #include "boost/math/special_functions.hpp"
-#endif
+
 
 namespace Lemma {
 
 
 	// =======================================================================
-	//        Class:  HankelTransformGaussianQuadrature
+	//        Class:  GQChave
 	/// \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 {
+	class GQChave : public HankelTransform {
 
-		friend std::ostream &operator<<(std::ostream &stream,
-				const HankelTransformGaussianQuadrature &ob);
+		friend std::ostream &operator<<(std::ostream &stream, const GQChave &ob);
+
+        struct ctor_key{};
 
 		public:
 
 			// ====================  LIFECYCLE     ===========================
 
+			/// Default locked constructor.
+			GQChave ( const ctor_key& );
+
+            /** DeSerializing locked constructor, use DeSerialize */
+            GQChave ( const YAML::Node& node, const ctor_key& );
+
+            /// Default destructor
+			~GQChave ();
+
             /**
-             *  Returns pointer to new HankelTransformGaussianQuadrature.
+             *  Returns shared_ptr to new GQChave.
              *  Location is
              *  initialized to (0,0,0) type and polarization are
              *  initialized  to nonworking values that will throw
              *  exceptions if used.
              */
-			static HankelTransformGaussianQuadrature* New();
+			static std::shared_ptr<GQChave> 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< GQChave > DeSerialize(const YAML::Node& node);
 
 			// ====================  OPERATORS     ===========================
 
             //template <EMMODE T>
 			Complex Zgauss(const int &ikk, const EMMODE &imode,
 							const int &itype, const Real &rho,
-							const Real &wavef, KernelEm1DBase *Kernel);
+							const Real &wavef, KernelEM1DBase* Kernel);
 
 			// ====================  ACCESS        ============================
 
 			// ====================  INQUIRY       ============================
 
+            /** Returns the name of the underlying class, similiar to Python's type */
+            virtual inline std::string GetName() const {
+                return CName;
+            }
+
 			// ====================  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
 			///         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
+			/// RELATIVE AND ABSOLUTE ERROR
 			///
 			/// ARGUMENT LIST:
 			///
 							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);
+							KernelEM1DBase* Kernel);
 
 			/// COMPUTES BESSEL TRANSFORM OF SPECIFIED ORDER DEFINED AS
 			/// INTEGRAL(FUNCT(X)*J-SUB-ORDER(X*R)*DX) FROM X=0 TO INFINITY
  					const Real &RERR, const Real &AERR, const int &npcs,
  					VectorXi &XSUM, int &NSUM, int &NEW,
  					int &IERR, int &NCNTRL, const Real &AORB,
-					KernelEm1DBase *Kernel);
+					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
             //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);
+							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
 
 		private:
 
-	}; // -----  end of class  HankelTransformGaussianQuadrature  -----
+            /** ASCII string representation of the class name */
+            static constexpr auto CName = "FHTKey51";
+
+	}; // -----  end of class  GQChave  -----
 
     //////////////////////////////////////////////////////////////
     // Exception Classes

Modules/FDEM1D/include/HankelTransform.h

                 ///       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;
+                            const Real &wavef, KernelEM1DBase* Kernel)=0;
 
                 /// Computes related kernels, if applicable, otherwise this is
                 /// just a dummy function.

Modules/FDEM1D/include/KernelEM1DBase.h

 
             virtual void SetMode(const EMMODE& mode)=0;
 
-            int GetManagerIndex() {
+            int GetManagerIndex() const {
                 return this->managerIdx;
             }
 

Modules/FDEM1D/include/KernelEM1DManager.h

              */
             std::shared_ptr<KernelEM1DBase>    GetKernel(const unsigned int& ik);
 
+            /** Returns RAW pointer to specified kernel indice. Indices are assigned in the same
+                order as they are created by AddKernel.
+             */
+            KernelEM1DBase*                    GetRAWKernel(const unsigned int& ik);
+
             /** Returns pointer to connected dipole.
              */
             std::shared_ptr<DipoleSource>    GetDipole( );

Modules/FDEM1D/src/CMakeLists.txt

 	${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}/FHTKey101.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/FHTKey51.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/GQChave.cpp
+	#${CMAKE_CURRENT_SOURCE_DIR}/QWEKey.cpp
+	
 
 	#${CMAKE_CURRENT_SOURCE_DIR}/AEMSurvey.cpp
 	#${CMAKE_CURRENT_SOURCE_DIR}/AEMSurveyReader.cpp

Modules/FDEM1D/src/DipoleSource.cpp

                 if (std::abs(Pol[2]) > 0) { // z dipole
                     switch(FieldsToCalculate) {
                         case E:
-                            f(10) = Hankel->Zgauss(10, TM, 1, rho, wavef, KernelManager->GetKernel(ik[10])) / KernelManager->GetKernel(ik[10])->GetYm();
-                            f(11) = Hankel->Zgauss(11, TM, 0, rho, wavef, KernelManager->GetKernel(ik[11])) / KernelManager->GetKernel(ik[11])->GetYm();
+                            f(10) = Hankel->Zgauss(10, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[10])) / KernelManager->GetRAWKernel(ik[10])->GetYm();
+                            f(11) = Hankel->Zgauss(11, TM, 0, rho, wavef, KernelManager->GetRAWKernel(ik[11])) / KernelManager->GetRAWKernel(ik[11])->GetYm();
                             std::cout.precision(12);
                             this->Receivers->AppendEfield(ifreq, irec,
                                 -Pol[2]*QPI*cp*f(10)*Moment,
                             break;
 
                         case H:
-                            f(12) = Hankel->Zgauss(12, TM, 1, rho, wavef, KernelManager->GetKernel(ik[12]));
+                            f(12) = Hankel->Zgauss(12, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[12]));
                             this->Receivers->AppendHfield(ifreq, irec,
                                 -Pol[2]*QPI*sp*f(12)*Moment,
                                  Pol[2]*QPI*cp*f(12)*Moment,
                             break;
 
                         case BOTH:
-                            f(10) = Hankel->Zgauss(10, TM, 1, rho, wavef, KernelManager->GetKernel(ik[10])) / KernelManager->GetKernel(ik[10])->GetYm();
-                            f(11) = Hankel->Zgauss(11, TM, 0, rho, wavef, KernelManager->GetKernel(ik[11])) / KernelManager->GetKernel(ik[11])->GetYm();
+                            f(10) = Hankel->Zgauss(10, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[10])) / KernelManager->GetRAWKernel(ik[10])->GetYm();
+                            f(11) = Hankel->Zgauss(11, TM, 0, rho, wavef, KernelManager->GetRAWKernel(ik[11])) / KernelManager->GetRAWKernel(ik[11])->GetYm();
                             this->Receivers->AppendEfield(ifreq, irec,
                                     -Pol[2]*QPI*cp*f(10)*Moment,
                                     -Pol[2]*QPI*sp*f(10)*Moment,
                                      Pol[2]*QPI*f(11)*Moment   );
 
-                            f(12) = Hankel->Zgauss(12, TM, 1, rho, wavef, KernelManager->GetKernel(ik[12]));
+                            f(12) = Hankel->Zgauss(12, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[12]));
                             this->Receivers->AppendHfield(ifreq, irec,
                                     -Pol[2]*QPI*sp*f(12)*Moment,
                                      Pol[2]*QPI*cp*f(12)*Moment,
                 if (std::abs(Pol[1]) > 0 || std::abs(Pol[0]) > 0) { // y dipole
                     switch(FieldsToCalculate) {
                         case E:
-                            f(2) = Hankel->Zgauss(2, TE, 0, rho, wavef, KernelManager->GetKernel(ik[2])) * KernelManager->GetKernel(ik[2])->GetZs();
-                            f(3) = Hankel->Zgauss(3, TE, 1, rho, wavef, KernelManager->GetKernel(ik[3])) * KernelManager->GetKernel(ik[3])->GetZs();
-                            f(0) = Hankel->Zgauss(0, TM, 0, rho, wavef, KernelManager->GetKernel(ik[0])) / KernelManager->GetKernel(ik[0])->GetYm();
-                            f(1) = Hankel->Zgauss(1, TM, 1, rho, wavef, KernelManager->GetKernel(ik[1])) / KernelManager->GetKernel(ik[1])->GetYm();
-                            f(4) = Hankel->Zgauss(4, TM, 1, rho, wavef, KernelManager->GetKernel(ik[4])) / KernelManager->GetKernel(ik[4])->GetYm();
+                            f(2) = Hankel->Zgauss(2, TE, 0, rho, wavef, KernelManager->GetRAWKernel(ik[2])) * KernelManager->GetRAWKernel(ik[2])->GetZs();
+                            f(3) = Hankel->Zgauss(3, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[3])) * KernelManager->GetRAWKernel(ik[3])->GetZs();
+                            f(0) = Hankel->Zgauss(0, TM, 0, rho, wavef, KernelManager->GetRAWKernel(ik[0])) / KernelManager->GetRAWKernel(ik[0])->GetYm();
+                            f(1) = Hankel->Zgauss(1, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[1])) / KernelManager->GetRAWKernel(ik[1])->GetYm();
+                            f(4) = Hankel->Zgauss(4, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[4])) / KernelManager->GetRAWKernel(ik[4])->GetYm();
                             if (std::abs(Pol[1]) > 0) {
                                 this->Receivers->AppendEfield(ifreq, irec,
                                     Pol[1]*QPI*scp*((f(0)-(Real)(2.)*f(1)/rho)+(f(2)-(Real)(2.)*f(3)/rho))*Moment,
                             }
                             break;
                         case H:
-                            f(5) = Hankel->Zgauss(5, TM, 0, rho, wavef, KernelManager->GetKernel(ik[5]));
-                            f(6) = Hankel->Zgauss(6, TM, 1, rho, wavef, KernelManager->GetKernel(ik[6]));
-                            f(7) = Hankel->Zgauss(7, TE, 0, rho, wavef, KernelManager->GetKernel(ik[7]))*KernelManager->GetKernel(ik[7])->GetZs()/KernelManager->GetKernel(ik[7])->GetZm();
-                            f(8) = Hankel->Zgauss(8, TE, 1, rho, wavef, KernelManager->GetKernel(ik[8]))*KernelManager->GetKernel(ik[8])->GetZs()/KernelManager->GetKernel(ik[8])->GetZm();
-                            f(9) = Hankel->Zgauss(9, TE, 1, rho, wavef, KernelManager->GetKernel(ik[9]))*KernelManager->GetKernel(ik[9])->GetZs()/KernelManager->GetKernel(ik[9])->GetZm();
+                            f(5) = Hankel->Zgauss(5, TM, 0, rho, wavef, KernelManager->GetRAWKernel(ik[5]));
+                            f(6) = Hankel->Zgauss(6, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[6]));
+                            f(7) = Hankel->Zgauss(7, TE, 0, rho, wavef, KernelManager->GetRAWKernel(ik[7]))*KernelManager->GetRAWKernel(ik[7])->GetZs()/KernelManager->GetRAWKernel(ik[7])->GetZm();
+                            f(8) = Hankel->Zgauss(8, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[8]))*KernelManager->GetRAWKernel(ik[8])->GetZs()/KernelManager->GetRAWKernel(ik[8])->GetZm();
+                            f(9) = Hankel->Zgauss(9, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[9]))*KernelManager->GetRAWKernel(ik[9])->GetZs()/KernelManager->GetRAWKernel(ik[9])->GetZm();
                             if (std::abs(Pol[1]) > 0) {
                                 this->Receivers->AppendHfield(ifreq, irec,
                                         Pol[1]*QPI*(sps*f(5)+c2p*f(6)/rho-cps*f(7)+c2p*f(8)/rho)*Moment,
                             }
                             break;
                         case BOTH:
-                            f(0) = Hankel->Zgauss(0, TM, 0, rho, wavef, KernelManager->GetKernel(ik[0])) / KernelManager->GetKernel(ik[0])->GetYm();
-                            f(1) = Hankel->Zgauss(1, TM, 1, rho, wavef, KernelManager->GetKernel(ik[1])) / KernelManager->GetKernel(ik[1])->GetYm();
-                            f(4) = Hankel->Zgauss(4, TM, 1, rho, wavef, KernelManager->GetKernel(ik[4])) / KernelManager->GetKernel(ik[4])->GetYm();
-                            f(2) = Hankel->Zgauss(2, TE, 0, rho, wavef, KernelManager->GetKernel(ik[2])) * KernelManager->GetKernel(ik[2])->GetZs();
-                            f(3) = Hankel->Zgauss(3, TE, 1, rho, wavef, KernelManager->GetKernel(ik[3])) * KernelManager->GetKernel(ik[3])->GetZs();
-                            f(5) = Hankel->Zgauss(5, TM, 0, rho, wavef, KernelManager->GetKernel(ik[5]));
-                            f(6) = Hankel->Zgauss(6, TM, 1, rho, wavef, KernelManager->GetKernel(ik[6]));
-                            f(7) = Hankel->Zgauss(7, TE, 0, rho, wavef, KernelManager->GetKernel(ik[7]))*KernelManager->GetKernel(ik[7])->GetZs()/KernelManager->GetKernel(ik[7])->GetZm();
-                            f(8) = Hankel->Zgauss(8, TE, 1, rho, wavef, KernelManager->GetKernel(ik[8]))*KernelManager->GetKernel(ik[8])->GetZs()/KernelManager->GetKernel(ik[8])->GetZm();
-                            f(9) = Hankel->Zgauss(9, TE, 1, rho, wavef, KernelManager->GetKernel(ik[9]))*KernelManager->GetKernel(ik[9])->GetZs()/KernelManager->GetKernel(ik[9])->GetZm();
+                            f(0) = Hankel->Zgauss(0, TM, 0, rho, wavef, KernelManager->GetRAWKernel(ik[0])) / KernelManager->GetRAWKernel(ik[0])->GetYm();
+                            f(1) = Hankel->Zgauss(1, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[1])) / KernelManager->GetRAWKernel(ik[1])->GetYm();
+                            f(4) = Hankel->Zgauss(4, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[4])) / KernelManager->GetRAWKernel(ik[4])->GetYm();
+                            f(2) = Hankel->Zgauss(2, TE, 0, rho, wavef, KernelManager->GetRAWKernel(ik[2])) * KernelManager->GetRAWKernel(ik[2])->GetZs();
+                            f(3) = Hankel->Zgauss(3, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[3])) * KernelManager->GetRAWKernel(ik[3])->GetZs();
+                            f(5) = Hankel->Zgauss(5, TM, 0, rho, wavef, KernelManager->GetRAWKernel(ik[5]));
+                            f(6) = Hankel->Zgauss(6, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[6]));
+                            f(7) = Hankel->Zgauss(7, TE, 0, rho, wavef, KernelManager->GetRAWKernel(ik[7]))*KernelManager->GetRAWKernel(ik[7])->GetZs()/KernelManager->GetRAWKernel(ik[7])->GetZm();
+                            f(8) = Hankel->Zgauss(8, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[8]))*KernelManager->GetRAWKernel(ik[8])->GetZs()/KernelManager->GetRAWKernel(ik[8])->GetZm();
+                            f(9) = Hankel->Zgauss(9, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[9]))*KernelManager->GetRAWKernel(ik[9])->GetZs()/KernelManager->GetRAWKernel(ik[9])->GetZm();
 
                             if (std::abs(Pol[1]) > 0) {
                                 this->Receivers->AppendEfield(ifreq, irec,
                     switch(FieldsToCalculate) {
                         case E:
                             f(10) = 0;
-                            f(11) = Hankel->Zgauss(11, TM, 0, rho, wavef, KernelManager->GetKernel(ik[11])) / KernelManager->GetKernel(ik[11])->GetYm();
+                            f(11) = Hankel->Zgauss(11, TM, 0, rho, wavef, KernelManager->GetRAWKernel(ik[11])) / KernelManager->GetRAWKernel(ik[11])->GetYm();
 
                             this->Receivers->AppendEfield(ifreq, irec,
                                 -Pol[2]*QPI*cp*f(10)*Moment,
                             break;
 
                         case H:
-                            f(12) = Hankel->Zgauss(12, TM, 1, rho, wavef, KernelManager->GetKernel(ik[12]));
+                            f(12) = Hankel->Zgauss(12, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[12]));
                             this->Receivers->AppendHfield(ifreq, irec,
                                 -Pol[2]*QPI*sp*f(12)*Moment,
                                  Pol[2]*QPI*cp*f(12)*Moment,
 
                         case BOTH:
                             f(10) = 0;
-                            f(11) = Hankel->Zgauss(11, TM, 0, rho, wavef, KernelManager->GetKernel(ik[11])) / KernelManager->GetKernel(ik[11])->GetYm();
+                            f(11) = Hankel->Zgauss(11, TM, 0, rho, wavef, KernelManager->GetRAWKernel(ik[11])) / KernelManager->GetRAWKernel(ik[11])->GetYm();
                             this->Receivers->AppendEfield(ifreq, irec,
                                     -Pol[2]*QPI*cp*f(10)*Moment,
                                     -Pol[2]*QPI*sp*f(10)*Moment,
                                      Pol[2]*QPI*f(11)*Moment   );
 
-                            f(12) = Hankel->Zgauss(12, TM, 1, rho, wavef, KernelManager->GetKernel(ik[12]));
+                            f(12) = Hankel->Zgauss(12, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[12]));
                             this->Receivers->AppendHfield(ifreq, irec,
                                     -Pol[2]*QPI*sp*f(12)*Moment,
                                      Pol[2]*QPI*cp*f(12)*Moment,
                         case E:
                             f(0) = 0;
                             f(1) = 0;
-                            f(2) = Hankel->Zgauss(2, TE, 0, rho, wavef, KernelManager->GetKernel(ik[2])) * KernelManager->GetKernel(ik[2])->GetZs();
-                            f(3) = Hankel->Zgauss(3, TE, 1, rho, wavef, KernelManager->GetKernel(ik[3])) * KernelManager->GetKernel(ik[3])->GetZs();
+                            f(2) = Hankel->Zgauss(2, TE, 0, rho, wavef, KernelManager->GetRAWKernel(ik[2])) * KernelManager->GetRAWKernel(ik[2])->GetZs();
+                            f(3) = Hankel->Zgauss(3, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[3])) * KernelManager->GetRAWKernel(ik[3])->GetZs();
                             f(4) = 0;
                             if (std::abs(Pol[1]) > 0) {
                                 this->Receivers->AppendEfield(ifreq, irec,
                             }
                             break;
                         case H:
-                            f(5) = Hankel->Zgauss(5, TM, 0, rho, wavef, KernelManager->GetKernel(ik[5]));
-                            f(6) = Hankel->Zgauss(6, TM, 1, rho, wavef, KernelManager->GetKernel(ik[6]));
-                            f(7) = Hankel->Zgauss(7, TE, 0, rho, wavef, KernelManager->GetKernel(ik[7]))*KernelManager->GetKernel(ik[7])->GetZs()/KernelManager->GetKernel(ik[7])->GetZm();
-                            f(8) = Hankel->Zgauss(8, TE, 1, rho, wavef, KernelManager->GetKernel(ik[8]))*KernelManager->GetKernel(ik[8])->GetZs()/KernelManager->GetKernel(ik[8])->GetZm();
-                            f(9) = Hankel->Zgauss(9, TE, 1, rho, wavef, KernelManager->GetKernel(ik[9]))*KernelManager->GetKernel(ik[9])->GetZs()/KernelManager->GetKernel(ik[9])->GetZm();
+                            f(5) = Hankel->Zgauss(5, TM, 0, rho, wavef, KernelManager->GetRAWKernel(ik[5]));
+                            f(6) = Hankel->Zgauss(6, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[6]));
+                            f(7) = Hankel->Zgauss(7, TE, 0, rho, wavef, KernelManager->GetRAWKernel(ik[7]))*KernelManager->GetRAWKernel(ik[7])->GetZs()/KernelManager->GetRAWKernel(ik[7])->GetZm();
+                            f(8) = Hankel->Zgauss(8, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[8]))*KernelManager->GetRAWKernel(ik[8])->GetZs()/KernelManager->GetRAWKernel(ik[8])->GetZm();
+                            f(9) = Hankel->Zgauss(9, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[9]))*KernelManager->GetRAWKernel(ik[9])->GetZs()/KernelManager->GetRAWKernel(ik[9])->GetZm();
                             if (std::abs(Pol[1]) > 0) {
                                 this->Receivers->AppendHfield(ifreq, irec,
                                         Pol[1]*QPI*(sps*f(5)+c2p*f(6)/rho-cps*f(7)+c2p*f(8)/rho)*Moment,
                             f(0) = 0;
                             f(1) = 0;
                             f(4) = 0;
-                            f(2) = Hankel->Zgauss(2, TE, 0, rho, wavef, KernelManager->GetKernel(ik[2])) * KernelManager->GetKernel(0)->GetZs();
-                            f(3) = Hankel->Zgauss(3, TE, 1, rho, wavef, KernelManager->GetKernel(ik[3])) * KernelManager->GetKernel(1)->GetZs();
-                            f(5) = Hankel->Zgauss(5, TM, 0, rho, wavef, KernelManager->GetKernel(ik[5]));
-                            f(6) = Hankel->Zgauss(6, TM, 1, rho, wavef, KernelManager->GetKernel(ik[6]));
-                            f(7) = Hankel->Zgauss(7, TE, 0, rho, wavef, KernelManager->GetKernel(ik[7]))*KernelManager->GetKernel(ik[7])->GetZs()/KernelManager->GetKernel(ik[7])->GetZm();
-                            f(8) = Hankel->Zgauss(8, TE, 1, rho, wavef, KernelManager->GetKernel(ik[8]))*KernelManager->GetKernel(ik[8])->GetZs()/KernelManager->GetKernel(ik[8])->GetZm();
-                            f(9) = Hankel->Zgauss(9, TE, 1, rho, wavef, KernelManager->GetKernel(ik[9]))*KernelManager->GetKernel(ik[9])->GetZs()/KernelManager->GetKernel(ik[9])->GetZm();
+                            f(2) = Hankel->Zgauss(2, TE, 0, rho, wavef, KernelManager->GetRAWKernel(ik[2])) * KernelManager->GetRAWKernel(0)->GetZs();
+                            f(3) = Hankel->Zgauss(3, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[3])) * KernelManager->GetRAWKernel(1)->GetZs();
+                            f(5) = Hankel->Zgauss(5, TM, 0, rho, wavef, KernelManager->GetRAWKernel(ik[5]));
+                            f(6) = Hankel->Zgauss(6, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[6]));
+                            f(7) = Hankel->Zgauss(7, TE, 0, rho, wavef, KernelManager->GetRAWKernel(ik[7]))*KernelManager->GetRAWKernel(ik[7])->GetZs()/KernelManager->GetRAWKernel(ik[7])->GetZm();
+                            f(8) = Hankel->Zgauss(8, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[8]))*KernelManager->GetRAWKernel(ik[8])->GetZs()/KernelManager->GetRAWKernel(ik[8])->GetZm();
+                            f(9) = Hankel->Zgauss(9, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[9]))*KernelManager->GetRAWKernel(ik[9])->GetZs()/KernelManager->GetRAWKernel(ik[9])->GetZm();
 
                             if (std::abs(Pol[1]) > 0) {
                                 this->Receivers->AppendEfield(ifreq, irec,
                 if (std::abs(Pol[2]) > 0) { // z dipole
                     switch(FieldsToCalculate) {
                         case E:
-                            f(12)=Hankel->Zgauss(12, TE, 1, rho, wavef, KernelManager->GetKernel(ik[12]))*KernelManager->GetKernel(ik[12])->GetZs();
+                            f(12)=Hankel->Zgauss(12, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[12]))*KernelManager->GetRAWKernel(ik[12])->GetZs();
                             this->Receivers->AppendEfield(ifreq, irec,
                                  Pol[2]*Moment*QPI*sp*f(12),
                                 -Pol[2]*Moment*QPI*cp*f(12),
                                  0);
                             break;
                         case H:
-                            f(10)=Hankel->Zgauss(10, TE, 1, rho, wavef, KernelManager->GetKernel(ik[10]))*KernelManager->GetKernel(ik[10])->GetZs()/KernelManager->GetKernel(ik[10])->GetZm();
-                            f(11)=Hankel->Zgauss(11, TE, 0, rho, wavef, KernelManager->GetKernel(ik[11]))*KernelManager->GetKernel(ik[11])->GetZs()/KernelManager->GetKernel(ik[11])->GetZm();
+                            f(10)=Hankel->Zgauss(10, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[10]))*KernelManager->GetRAWKernel(ik[10])->GetZs()/KernelManager->GetRAWKernel(ik[10])->GetZm();
+                            f(11)=Hankel->Zgauss(11, TE, 0, rho, wavef, KernelManager->GetRAWKernel(ik[11]))*KernelManager->GetRAWKernel(ik[11])->GetZs()/KernelManager->GetRAWKernel(ik[11])->GetZm();
                             this->Receivers->AppendHfield(ifreq, irec,
                                 -Pol[2]*Moment*QPI*cp*f(10),
                                 -Pol[2]*Moment*QPI*sp*f(10),
                             break;
 
                         case BOTH:
-                            f(12)=Hankel->Zgauss(12, TE, 1, rho, wavef, KernelManager->GetKernel(ik[12]))*KernelManager->GetKernel(ik[12])->GetZs();
-                            f(10)=Hankel->Zgauss(10, TE, 1, rho, wavef, KernelManager->GetKernel(ik[10]))*KernelManager->GetKernel(ik[10])->GetZs()/KernelManager->GetKernel(ik[10])->GetZm();
-                            f(11)=Hankel->Zgauss(11, TE, 0, rho, wavef, KernelManager->GetKernel(ik[11]))*KernelManager->GetKernel(ik[11])->GetZs()/KernelManager->GetKernel(ik[11])->GetZm();
+                            f(12)=Hankel->Zgauss(12, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[12]))*KernelManager->GetRAWKernel(ik[12])->GetZs();
+                            f(10)=Hankel->Zgauss(10, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[10]))*KernelManager->GetRAWKernel(ik[10])->GetZs()/KernelManager->GetRAWKernel(ik[10])->GetZm();
+                            f(11)=Hankel->Zgauss(11, TE, 0, rho, wavef, KernelManager->GetRAWKernel(ik[11]))*KernelManager->GetRAWKernel(ik[11])->GetZs()/KernelManager->GetRAWKernel(ik[11])->GetZm();
 
                             this->Receivers->AppendEfield(ifreq, irec,
                                  Pol[2]*Moment*QPI*sp*f(12),
 
                         case E:
 
-                            f(5) = Hankel->Zgauss(5, TE, 0, rho, wavef, KernelManager->GetKernel(ik[5]))*KernelManager->GetKernel(ik[5])->GetZs();
-                            f(6) = Hankel->Zgauss(6, TE, 1, rho, wavef, KernelManager->GetKernel(ik[6]))*KernelManager->GetKernel(ik[6])->GetZs();
-                            f(7) = Hankel->Zgauss(7, TM, 0, rho, wavef, KernelManager->GetKernel(ik[7]))*KernelManager->GetKernel(ik[7])->GetKs()/KernelManager->GetKernel(ik[7])->GetYm();
-                            f(8) = Hankel->Zgauss(8, TM, 1, rho, wavef, KernelManager->GetKernel(ik[8]))*KernelManager->GetKernel(ik[8])->GetKs()/KernelManager->GetKernel(ik[8])->GetYm();
-                            f(9) = Hankel->Zgauss(9, TM, 1, rho, wavef, KernelManager->GetKernel(ik[9]))*KernelManager->GetKernel(ik[9])->GetKs()/KernelManager->GetKernel(ik[9])->GetYm();
+                            f(5) = Hankel->Zgauss(5, TE, 0, rho, wavef, KernelManager->GetRAWKernel(ik[5]))*KernelManager->GetRAWKernel(ik[5])->GetZs();
+                            f(6) = Hankel->Zgauss(6, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[6]))*KernelManager->GetRAWKernel(ik[6])->GetZs();
+                            f(7) = Hankel->Zgauss(7, TM, 0, rho, wavef, KernelManager->GetRAWKernel(ik[7]))*KernelManager->GetRAWKernel(ik[7])->GetKs()/KernelManager->GetRAWKernel(ik[7])->GetYm();
+                            f(8) = Hankel->Zgauss(8, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[8]))*KernelManager->GetRAWKernel(ik[8])->GetKs()/KernelManager->GetRAWKernel(ik[8])->GetYm();
+                            f(9) = Hankel->Zgauss(9, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[9]))*KernelManager->GetRAWKernel(ik[9])->GetKs()/KernelManager->GetRAWKernel(ik[9])->GetYm();
 
                             if (std::abs(Pol[0]) > 0) {
                                 this->Receivers->AppendEfield(ifreq, irec,
                             break;
 
                         case H:
-                            f(0) = Hankel->Zgauss(0, TE, 0, rho, wavef, KernelManager->GetKernel(ik[0]))*KernelManager->GetKernel(ik[0])->GetZs()/KernelManager->GetKernel(ik[0])->GetZm();
-                            f(1) = Hankel->Zgauss(1, TE, 1, rho, wavef, KernelManager->GetKernel(ik[1]))*KernelManager->GetKernel(ik[1])->GetZs()/KernelManager->GetKernel(ik[1])->GetZm();
-                            f(4) = Hankel->Zgauss(4, TE, 1, rho, wavef, KernelManager->GetKernel(ik[4]))*KernelManager->GetKernel(ik[4])->GetZs()/KernelManager->GetKernel(ik[4])->GetZm();
-                            f(2) = Hankel->Zgauss(2, TM, 0, rho, wavef, KernelManager->GetKernel(ik[2]))*KernelManager->GetKernel(ik[2])->GetKs();
-                            f(3) = Hankel->Zgauss(3, TM, 1, rho, wavef, KernelManager->GetKernel(ik[3]))*KernelManager->GetKernel(ik[3])->GetKs();
+                            f(0) = Hankel->Zgauss(0, TE, 0, rho, wavef, KernelManager->GetRAWKernel(ik[0]))*KernelManager->GetRAWKernel(ik[0])->GetZs()/KernelManager->GetRAWKernel(ik[0])->GetZm();
+                            f(1) = Hankel->Zgauss(1, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[1]))*KernelManager->GetRAWKernel(ik[1])->GetZs()/KernelManager->GetRAWKernel(ik[1])->GetZm();
+                            f(4) = Hankel->Zgauss(4, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[4]))*KernelManager->GetRAWKernel(ik[4])->GetZs()/KernelManager->GetRAWKernel(ik[4])->GetZm();
+                            f(2) = Hankel->Zgauss(2, TM, 0, rho, wavef, KernelManager->GetRAWKernel(ik[2]))*KernelManager->GetRAWKernel(ik[2])->GetKs();
+                            f(3) = Hankel->Zgauss(3, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[3]))*KernelManager->GetRAWKernel(ik[3])->GetKs();
 
                             if (std::abs(Pol[0]) > 0) {
                                 this->Receivers->AppendHfield(ifreq, irec,
                             break;
 
                         case BOTH:
-                            f(5) = Hankel->Zgauss(5, TE, 0, rho, wavef, KernelManager->GetKernel(ik[5]))*KernelManager->GetKernel(ik[5])->GetZs();
-                            f(6) = Hankel->Zgauss(6, TE, 1, rho, wavef, KernelManager->GetKernel(ik[6]))*KernelManager->GetKernel(ik[6])->GetZs();
-                            f(7) = Hankel->Zgauss(7, TM, 0, rho, wavef, KernelManager->GetKernel(ik[7]))*KernelManager->GetKernel(ik[7])->GetKs()/KernelManager->GetKernel(ik[7])->GetYm();
-                            f(8) = Hankel->Zgauss(8, TM, 1, rho, wavef, KernelManager->GetKernel(ik[8]))*KernelManager->GetKernel(ik[8])->GetKs()/KernelManager->GetKernel(ik[8])->GetYm();
-                            f(9) = Hankel->Zgauss(9, TM, 1, rho, wavef, KernelManager->GetKernel(ik[9]))*KernelManager->GetKernel(ik[9])->GetKs()/KernelManager->GetKernel(ik[9])->GetYm();
-                            f(0) = Hankel->Zgauss(0, TE, 0, rho, wavef, KernelManager->GetKernel(ik[0]))*KernelManager->GetKernel(ik[0])->GetZs()/KernelManager->GetKernel(ik[0])->GetZm();
-                            f(1) = Hankel->Zgauss(1, TE, 1, rho, wavef, KernelManager->GetKernel(ik[1]))*KernelManager->GetKernel(ik[1])->GetZs()/KernelManager->GetKernel(ik[1])->GetZm();
-                            f(4) = Hankel->Zgauss(4, TE, 1, rho, wavef, KernelManager->GetKernel(ik[4]))*KernelManager->GetKernel(ik[4])->GetZs()/KernelManager->GetKernel(ik[4])->GetZm();
-                            f(2) = Hankel->Zgauss(2, TM, 0, rho, wavef, KernelManager->GetKernel(ik[2]))*KernelManager->GetKernel(ik[2])->GetKs();
-                            f(3) = Hankel->Zgauss(3, TM, 1, rho, wavef, KernelManager->GetKernel(ik[3]))*KernelManager->GetKernel(ik[3])->GetKs();
+                            f(5) = Hankel->Zgauss(5, TE, 0, rho, wavef, KernelManager->GetRAWKernel(ik[5]))*KernelManager->GetRAWKernel(ik[5])->GetZs();
+                            f(6) = Hankel->Zgauss(6, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[6]))*KernelManager->GetRAWKernel(ik[6])->GetZs();
+                            f(7) = Hankel->Zgauss(7, TM, 0, rho, wavef, KernelManager->GetRAWKernel(ik[7]))*KernelManager->GetRAWKernel(ik[7])->GetKs()/KernelManager->GetRAWKernel(ik[7])->GetYm();
+                            f(8) = Hankel->Zgauss(8, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[8]))*KernelManager->GetRAWKernel(ik[8])->GetKs()/KernelManager->GetRAWKernel(ik[8])->GetYm();
+                            f(9) = Hankel->Zgauss(9, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[9]))*KernelManager->GetRAWKernel(ik[9])->GetKs()/KernelManager->GetRAWKernel(ik[9])->GetYm();
+                            f(0) = Hankel->Zgauss(0, TE, 0, rho, wavef, KernelManager->GetRAWKernel(ik[0]))*KernelManager->GetRAWKernel(ik[0])->GetZs()/KernelManager->GetRAWKernel(ik[0])->GetZm();
+                            f(1) = Hankel->Zgauss(1, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[1]))*KernelManager->GetRAWKernel(ik[1])->GetZs()/KernelManager->GetRAWKernel(ik[1])->GetZm();
+                            f(4) = Hankel->Zgauss(4, TE, 1, rho, wavef, KernelManager->GetRAWKernel(ik[4]))*KernelManager->GetRAWKernel(ik[4])->GetZs()/KernelManager->GetRAWKernel(ik[4])->GetZm();
+                            f(2) = Hankel->Zgauss(2, TM, 0, rho, wavef, KernelManager->GetRAWKernel(ik[2]))*KernelManager->GetRAWKernel(ik[2])->GetKs();
+                            f(3) = Hankel->Zgauss(3, TM, 1, rho, wavef, KernelManager->GetRAWKernel(ik[3]))*KernelManager->GetRAWKernel(ik[3])->GetKs();
 
                             if (std::abs(Pol[0]) > 0) {
                                 this->Receivers->AppendEfield(ifreq, irec,

Modules/FDEM1D/src/FHTAnderson801.cpp

 
 	Complex FHTAnderson801::Zgauss(const int &ikk, const EMMODE &imode,
 						const int &itype, const Real &rho,
-						const Real &wavef, std::shared_ptr<KernelEM1DBase> Kernel) {
+						const Real &wavef, KernelEM1DBase* Kernel) {
 
         // TODO, right here we want to return the splined solution instead in the
         //       case of lagged convolution!
  		return Zans(0, Kernel->GetManagerIndex()); //Complex(0,0);
-
 	}
 
 	void FHTAnderson801::SetNumConv(const int &i) {

Modules/FDEM1D/src/FHTKey101.cpp

  * @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
  */
 
     // ====================  FRIEND METHODS  =====================
 
     std::ostream &operator<<(std::ostream &stream, const FHTKey101 &ob) {
-
-        stream << *(HankelTransform*)(&ob);
-
+        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
         return stream;
     }
 
-
     // ====================  STATIC CONST MEMBERS     ============
 
     const Eigen::Matrix<Real, 101, 3>  FHTKey101::WT101 =
     //--------------------------------------------------------------------------------------
     //       Class:  FHTKey101
     //      Method:  FHTKey101
-    // Description:  constructor (protected)
+    // Description:  constructor (locked)
     //--------------------------------------------------------------------------------------
-    FHTKey101::FHTKey101 (const std::string& name) : HankelTransform(name) {
+    FHTKey101::FHTKey101 ( const ctor_key& ) : HankelTransform( ) {
 
     }  // -----  end of method FHTKey101::FHTKey101  (constructor)  -----
 
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey101
+    //      Method:  FHTKey101
+    // Description:  constructor (protected)
+    //--------------------------------------------------------------------------------------
+    FHTKey101::FHTKey101( const YAML::Node& node, const ctor_key& ) : HankelTransform(node) {
+
+    }
 
     //--------------------------------------------------------------------------------------
     //       Class:  FHTKey101
     //      Method:  New()
     // Description:  public constructor
     //--------------------------------------------------------------------------------------
-    FHTKey101* FHTKey101::New() {
-        FHTKey101*  Obj = new FHTKey101("FHTKey101");
-        Obj->AttachTo(Obj);
-        return Obj;
+    std::shared_ptr<FHTKey101> FHTKey101::NewSP() {
+        return std::make_shared< FHTKey101 >( ctor_key() );
     }
 
     //--------------------------------------------------------------------------------------
 
     //--------------------------------------------------------------------------------------
     //       Class:  FHTKey101
-    //      Method:  Delete
-    // Description:  public destructor
+    //      Method:  DeSerialize
+    // Description:  Factory method, converts YAML node into object
     //--------------------------------------------------------------------------------------
-    void FHTKey101::Delete() {
-        this->DetachFrom(this);
+    std::shared_ptr<FHTKey101> FHTKey101::DeSerialize( const YAML::Node& node ) {
+        if (node.Tag() != "FHTKey101") {
+            throw  DeSerializeTypeMismatch( "FHTKey101", node.Tag());
+        }
+        return std::make_shared<FHTKey101> ( node, ctor_key() );
     }
 
     //--------------------------------------------------------------------------------------
     //       Class:  FHTKey101
-    //      Method:  Release
-    // Description:  destructor (protected)
+    //      Method:  Serialize
+    // Description:  Converts object into Serialized version
     //--------------------------------------------------------------------------------------
-    void FHTKey101::Release() {
-        delete this;
+    YAML::Node FHTKey101::Serialize() const {
+        YAML::Node node = HankelTransform::Serialize();
+        node.SetTag( GetName() );
+        //node["LayerConductivity"] = LayerConductivity;
+        return node;
     }
 
-
     //--------------------------------------------------------------------------------------
     //       Class:  FHTKey101
     //      Method:  Zgauss
     //--------------------------------------------------------------------------------------
     Complex FHTKey101::Zgauss ( const int &ikk, const EMMODE &imode,
                             const int &itype, const Real &rho,
-                            const Real &wavef, KernelEm1DBase *Kernel ) {
+                            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 ) {
+    void FHTKey101::ComputeRelated ( const Real& rho, std::shared_ptr<KernelEM1DBase> Kernel ) {
         return ;
     }		// -----  end of method FHTKey101::ComputeRelated  -----
 
     //       Class:  FHTKey101
     //      Method:  ComputeRelated
     //--------------------------------------------------------------------------------------
-    void FHTKey101::ComputeRelated ( const Real& rho, std::vector< KernelEm1DBase* > KernelVec ) {
+    void FHTKey101::ComputeRelated ( const Real& rho, std::vector< std::shared_ptr<KernelEM1DBase> > KernelVec ) {
         return ;
     }		// -----  end of method FHTKey101::ComputeRelated  -----
 
     //       Class:  FHTKey101
     //      Method:  ComputeRelated
     //--------------------------------------------------------------------------------------
-    void FHTKey101::ComputeRelated ( const Real& rho, KernelEM1DManager* KernelManager ) {
+    void FHTKey101::ComputeRelated ( const Real& rho, std::shared_ptr<KernelEM1DManager> KernelManager ) {
 
         //kernelVec = KernelManager->GetSTLVector();
         int nrel = (int)(KernelManager->GetSTLVector().size());
                 // 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

Modules/FDEM1D/src/FHTKey201.cpp

         return stream;
     }
 
-
     // ====================  STATIC CONST MEMBERS     ============
 
     const Eigen::Matrix<Real, 201, 3>  FHTKey201::WT201 =
 
     }  // -----  end of method FHTKey201::FHTKey201  (constructor)  -----
 
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey201
+    //      Method:  FHTKey201
+    // Description:  constructor (locked)
+    //--------------------------------------------------------------------------------------
     FHTKey201::FHTKey201( const YAML::Node& node, const ctor_key& ) : HankelTransform(node) {
 
     }
     //--------------------------------------------------------------------------------------
     Complex FHTKey201::Zgauss ( const int &ikk, const EMMODE &imode,
                             const int &itype, const Real &rho,
-                            const Real &wavef, std::shared_ptr<KernelEM1DBase> Kernel ) {
+                            const Real &wavef, KernelEM1DBase* Kernel ) {
  		return Zans(0, Kernel->GetManagerIndex());
     }		// -----  end of method FHTKey201::ComputeRelated  -----
 

Modules/FDEM1D/src/FHTKey51.cpp

     // ====================  FRIEND METHODS  =====================
 
     std::ostream &operator<<(std::ostream &stream, const FHTKey51 &ob) {
-
-        stream << *(HankelTransform*)(&ob);
-
+        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
         return stream;
     }
 
-
     // ====================  STATIC CONST MEMBERS     ============
 
     const Eigen::Matrix<Real, 51, 3>  FHTKey51::WT51 =
     //--------------------------------------------------------------------------------------
     //       Class:  FHTKey51
     //      Method:  FHTKey51
-    // Description:  constructor (protected)
+    // Description:  constructor (locked)
     //--------------------------------------------------------------------------------------
-    FHTKey51::FHTKey51 (const std::string& name) : HankelTransform(name) {
+    FHTKey51::FHTKey51 (const ctor_key& ) : HankelTransform( ) {
 
     }  // -----  end of method FHTKey51::FHTKey51  (constructor)  -----
 
+    //--------------------------------------------------------------------------------------
+    //       Class:  FHTKey51
+    //      Method:  FHTKey51
+    // Description:  constructor (protected)
+    //--------------------------------------------------------------------------------------
+    FHTKey51::FHTKey51( const YAML::Node& node, const ctor_key& ) : HankelTransform(node) {
+
+    }
 
     //--------------------------------------------------------------------------------------
     //       Class:  FHTKey51
     //      Method:  New()
     // Description:  public constructor
     //--------------------------------------------------------------------------------------
-    FHTKey51* FHTKey51::New() {
-        FHTKey51*  Obj = new FHTKey51("FHTKey51");
-        Obj->AttachTo(Obj);
-        return Obj;
+    std::shared_ptr<FHTKey51> FHTKey51::NewSP() {
+        return std::make_shared< FHTKey51 >( ctor_key() );
     }
 
     //--------------------------------------------------------------------------------------
     //       Class:  FHTKey51
     //      Method:  ~FHTKey51
-    // Description:  destructor (protected)
+    // Description:  destructor
     //--------------------------------------------------------------------------------------
     FHTKey51::~FHTKey51 () {
 
 
     //--------------------------------------------------------------------------------------
     //       Class:  FHTKey51
-    //      Method:  Delete
-    // Description:  public destructor
+    //      Method:  DeSerialize
+    // Description:  Factory method, converts YAML node into object
     //--------------------------------------------------------------------------------------
-    void FHTKey51::Delete() {
-        this->DetachFrom(this);
+    std::shared_ptr<FHTKey51> FHTKey51::DeSerialize( const YAML::Node& node ) {
+        if (node.Tag() != "FHTKey51") {
+            throw  DeSerializeTypeMismatch( "FHTKey51", node.Tag());
+        }
+        return std::make_shared<FHTKey51> ( node, ctor_key() );
     }
 
     //--------------------------------------------------------------------------------------
     //       Class:  FHTKey51
-    //      Method:  Release
-    // Description:  destructor (protected)
-    //--------------------------------------------------------------------------------------
-    void FHTKey51::Release() {
-        delete this;
+    //      Method:  Serialize
+    // Description:  Converts object into Serialized version
+    //--------------------------------------------------------------------------------------
+    YAML::Node FHTKey51::Serialize() const {
+        YAML::Node node = HankelTransform::Serialize();
+        node.SetTag( GetName() );
+        //node["LayerConductivity"] = LayerConductivity;
+        return node;
     }
 
-
     //--------------------------------------------------------------------------------------
     //       Class:  FHTKey51
     //      Method:  Zgauss
     //--------------------------------------------------------------------------------------
     Complex FHTKey51::Zgauss ( const int &ikk, const EMMODE &imode,
                             const int &itype, const Real &rho,
-                            const Real &wavef, KernelEm1DBase *Kernel ) {
+                            const Real &wavef, KernelEM1DBase* Kernel ) {
  		return Zans(0, Kernel->GetManagerIndex());
     }		// -----  end of method FHTKey51::ComputeRelated  -----
 
     //       Class:  FHTKey51
     //      Method:  ComputeRelated
     //--------------------------------------------------------------------------------------
-    void FHTKey51::ComputeRelated ( const Real& rho, KernelEm1DBase* Kernel ) {
+    void FHTKey51::ComputeRelated ( const Real& rho, std::shared_ptr<KernelEM1DBase> Kernel ) {
         return ;
     }		// -----  end of method FHTKey51::ComputeRelated  -----
 
     //       Class:  FHTKey51
     //      Method:  ComputeRelated
     //--------------------------------------------------------------------------------------
-    void FHTKey51::ComputeRelated ( const Real& rho, std::vector< KernelEm1DBase* > KernelVec ) {
+    void FHTKey51::ComputeRelated ( const Real& rho, std::vector< std::shared_ptr<KernelEM1DBase> > KernelVec ) {
         return ;
     }		// -----  end of method FHTKey51::ComputeRelated  -----
 
     //       Class:  FHTKey51
     //      Method:  ComputeRelated
     //--------------------------------------------------------------------------------------
-    void FHTKey51::ComputeRelated ( const Real& rho, KernelEM1DManager* KernelManager ) {
+    void FHTKey51::ComputeRelated ( const Real& rho, std::shared_ptr<KernelEM1DManager> KernelManager ) {
 
         //kernelVec = KernelManager->GetSTLVector();
         int nrel = (int)(KernelManager->GetSTLVector().size());

Modules/FDEM1D/src/hankeltransformgaussianquadrature.cpp → Modules/FDEM1D/src/GQChave.cpp

 //          quadrature and continued fraction expansion: Geophysics, 48
 //          1671--1686  doi: 10.1190/1.1441448
 
-#include "hankeltransformgaussianquadrature.h"
+#include "GQChave.h"
 
 namespace Lemma{
 
-    std::ostream &operator<<(std::ostream &stream,
-            const HankelTransformGaussianQuadrature &ob) {
-
-        stream << *(HankelTransform*)(&ob);
+    std::ostream &operator<<(std::ostream &stream, const GQChave &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
         return stream;
     }
 
     // Initialise static members
-    const VectorXr HankelTransformGaussianQuadrature::WT =
+    const VectorXr GQChave::WT =
         (VectorXr(254) << //  (WT(I),I=1,20)
         0.55555555555555555556e+00,0.88888888888888888889e+00,
         0.26848808986833344073e+00,0.10465622602646726519e+00,
         0.14055382072649964277e-01,0.14080351962553661325e-01,
         0.14092845069160408355e-01,0.14094407090096179347e-01).finished();
 
-        const VectorXr HankelTransformGaussianQuadrature::WA =
+        const VectorXr GQChave::WA =
         (VectorXr(127) << //  (WT(I),I=1,20)
         //  (WA(I),I=1,20)
         0.77459666924148337704e+00,0.96049126870802028342e+00,
     const Real J1_X12 = -0.5382308663841630e-15;
 */
 
-    // TODO don't hard code precision like this
-    HankelTransformGaussianQuadrature::HankelTransformGaussianQuadrature(
-                    const std::string &name) : HankelTransform(name) {
+    GQChave::GQChave( const ctor_key& ) : HankelTransform( ) {
         karg.resize(255, 100);
         kern.resize(510, 100);
     }
 
-    /////////////////////////////////////////////////////////////
-    HankelTransformGaussianQuadrature::~HankelTransformGaussianQuadrature() {
-        if (this->NumberOfReferences != 0)
-            throw DeleteObjectWithReferences( this );
-    }
+    GQChave::GQChave( const YAML::Node& node, const ctor_key& ) : HankelTransform(node) {
 
+    }
 
     /////////////////////////////////////////////////////////////
-    HankelTransformGaussianQuadrature*
-            HankelTransformGaussianQuadrature::New() {
-        HankelTransformGaussianQuadrature* Obj = new
-        HankelTransformGaussianQuadrature("HankelTransformGaussianQuadrature");
-        Obj->AttachTo(Obj);
-        return Obj;
+    GQChave::~GQChave() {
     }
 
     /////////////////////////////////////////////////////////////
-    void HankelTransformGaussianQuadrature::Delete() {
-        this->DetachFrom(this);
+    std::shared_ptr<GQChave> GQChave::NewSP() {
+        return std::make_shared<GQChave>( ctor_key() );
     }
 
-    void HankelTransformGaussianQuadrature::Release() {
-        delete this;
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  GQChave
+    //      Method:  DeSerialize
+    // Description:  Factory method, converts YAML node into object
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr<GQChave> GQChave::DeSerialize( const YAML::Node& node ) {
+        if (node.Tag() != "GQChave") {
+            throw  DeSerializeTypeMismatch( "GQChave", node.Tag());
+        }
+        return std::make_shared<GQChave> ( node, ctor_key() );
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  GQChave
+    //      Method:  Serialize
+    // Description:  Converts object into Serialized version
+    //--------------------------------------------------------------------------------------
+    YAML::Node GQChave::Serialize() const {
+        YAML::Node node = HankelTransform::Serialize();
+        node.SetTag( GetName() );
+        //node["LayerConductivity"] = LayerConductivity;
+        return node;
     }
 
     /////////////////////////////////////////////////////////////
 
-    Complex HankelTransformGaussianQuadrature::
+    Complex GQChave::
             Zgauss(const int &ikk, const EMMODE &mode,
                     const int &itype, const Real &rho, const Real &wavef,
-                    KernelEm1DBase *Kernel){
+                    KernelEM1DBase* Kernel){
 
         // TI, TODO, change calls to Zgauss to reflect this, go and fix so we
         // dont subract 1 from this everywhere
         //this->karg.setZero();
         //this->kern.setZero();
 
-        Besautn(Besr, Besi, itype, nl, nu, rho, rerr, aerr, npcs, inew,
-                        wavef, Kernel);
+        Besautn(Besr, Besi, itype, nl, nu, rho, rerr, aerr, npcs, inew, wavef, Kernel);
 
         return Complex(Besr, Besi);
     }
 
     //////////////////////////////////////////////////////////////////
-    void HankelTransformGaussianQuadrature::
+    void GQChave::
         Besautn(Real &besr, Real &besi,
                     const int &besselOrder,
                     const int &lowerGaussLimit,
                     const int& numPieces,
                     int &inew,
                     const Real &aorb,
-                    KernelEm1DBase *Kernel) {
+                    KernelEM1DBase* Kernel) {
 
         HighestGaussOrder      = 0;
         NumberPartialIntegrals = 0;
     }
 
     /////////////////////////////////////////////////////////////
-    void HankelTransformGaussianQuadrature::
+    void GQChave::
         Bestrn(Real &BESR, Real &BESI, const int &IORDER,
             const int &NG, const Real &rho,
             const Real &RERR, const Real &AERR, const int &NPCS,
             VectorXi &XSUM, int &NSUM, int &NEW,
-            int &IERR, int &NCNTRL, const Real &AORB, KernelEm1DBase *Kernel) {
+            int &IERR, int &NCNTRL, const Real &AORB, KernelEM1DBase* Kernel) {
 
 
         Xr.setZero();
 
 
     /////////////////////////////////////////////////////////////
-    void HankelTransformGaussianQuadrature::
+    void GQChave::
             Besqud(const Real &LowerLimit, const Real &UpperLimit,
                     Real &Besr, Real &Besi, const int &npoints,
                     const int &NEW,
                     const int &besselOrder, const Real &rho,
-                    KernelEm1DBase* Kernel) {
+                    KernelEM1DBase* Kernel) {
 
         const int NTERM = 100;
 
 
 
     /////////////////////////////////////////////////////////////
-    void HankelTransformGaussianQuadrature::
+    void GQChave::
             Padecf(Real &SUMR, Real &SUMI, const int &N) {
 
         if (N < 2) {
     }
 
     /////////////////////////////////////////////////////////////
-    void HankelTransformGaussianQuadrature::CF(Real& RESR, Real &RESI,
+    void GQChave::CF(Real& RESR, Real &RESI,
                     Eigen::Matrix<Real, 100, 1> &CFCOR,
                     Eigen::Matrix<Real, 100, 1> &CFCOI,
                     const int &N) {
     }
 
     /////////////////////////////////////////////////////////////
-    Real HankelTransformGaussianQuadrature::
+    Real GQChave::
         ZeroJ(const int &nzero, const int &besselOrder) {
 
         Real ZT1 = -1.e0/8.e0;
 
     /////////////////////////////////////////////////////////////
     // Dot product allowing non 1 based incrementing
-    Real HankelTransformGaussianQuadrature::_dot(const int&n,
+    Real GQChave::_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,
 
     /////////////////////////////////////////////////////////////
     //
-    Real HankelTransformGaussianQuadrature::Jbess(const Real &x, const int &IORDER) {
-
-        #ifdef HAVEBOOSTCYLBESSEL
-
+    Real GQChave::Jbess(const Real &x, const int &IORDER) {
         switch (IORDER) {
             case 0:
                 //return boost::math::detail::bessel_j0(X);
                 return boost::math::cyl_bessel_j(1, x);
                 break;
             default:
-                throw 77;
+                throw std::runtime_error("Non 0 or 1 Bessel argument specified in GQChave");
         }
-        #else
-        std::cerr << "Chave Hankel transform requires boost, which Lemma was bot built with\n";
-        return 0.;
-        #endif
-
     }
 
     //////////////////////////////////////////////////////

Modules/FDEM1D/src/KernelEM1DManager.cpp

         return KernelVec[ik];
     }
 
+    KernelEM1DBase* KernelEM1DManager::GetRAWKernel(const unsigned int& ik) {
+        return KernelVec[ik].get();
+    }
+
     std::shared_ptr<DipoleSource> KernelEM1DManager::GetDipole( ) {
         return Dipole;
     }