Fixes for python wrapper with ABC inheritence. Also fixed EM1D to not clone antenna in tight loop

Modules/FDEM1D/examples/inp/points.inp

-20 20 20          // number of points (nx, ny, nz) in (northing, easting, depth) z pos down
--100 -100 1e-1    // offset in x, y, z (location of first calculation)
-5 4 3 2 1 .5 .5 .5 .5 .5 .5 .5 .5 .5 1 2 3 4 5 // x direction point spacing, in metres, (nx-1) 
-5 4 3 2 1 .5 .5 .5 .5 .5 .5 .5 .5 .5 1 2 3 4 5 // y direction point spacing, in metres, (ny-1) 
-.1 .1 .1 2 2 2 3 3 3 4 4 4 4 4 4 5 5 5 5       // z direction point spacing, in metres, (nz-1) 
+40 40 40          // number of points (nx, ny, nz) in (northing, easting, depth) z pos down
+32.5 32.5 1e-1    // offset in x, y, z (location of first calculation)
+5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 .5 .5 .5 .5 .5 .5 .5 .5 .5 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 // x direction point spacing, in metres, (nx-1) 
+5 5 5 5 5 5 5 5 5 5 5 4 3 2 1 .5 .5 .5 .5 .5 .5 .5 .5 .5 1 2 3 4 5 5 5 5 5 5 5 5 5 5 5 // y direction point spacing, in metres, (nx-1) 
+.1 .1 .1 1 1 1 1 1 1 1 1 1 1 2 2 2 3 3 3 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 5 5 5       // z direction point spacing, in metres, (nz-1) 

Modules/FDEM1D/include/DipoleSource.h

 #include <memory>
 #include "LemmaObject.h"
 #include "LayeredEarthEM.h"
+//#include "PolygonalWireAntenna.h"
 
 #ifdef LEMMAUSEVTK
 #include "vtkActor.h"
         friend std::ostream &operator<<(std::ostream &stream, const DipoleSource &ob);
 
         friend class EMEarth1D;
+        friend class PolygonalWireAntenna;
 
         public:
 

Modules/FDEM1D/python/pyFDEM1D.cpp

             "Sets all frequencies, argument is numpy array of frequencies")
         ;
 
-    py::class_<Lemma::LayeredEarthEM, std::shared_ptr<Lemma::LayeredEarthEM> >
-        LayeredEarthEM(m, "LayeredEarthEM");
+    py::class_<Lemma::LayeredEarthEM, std::shared_ptr<Lemma::LayeredEarthEM>, Lemma::EarthModel > LayeredEarthEM(m, "LayeredEarthEM");
 
         // lifecycle
         LayeredEarthEM.def(py::init(&Lemma::LayeredEarthEM::NewSP))
         .def("SetLayerBreathPermitivity", &Lemma::LayeredEarthEM::SetLayerBreathPermitivity,
             "Sets the permitivity breath for Cole-COle model")
 
-
         // methods
         .def("EvaluateColeColeModel", &Lemma::LayeredEarthEM::EvaluateColeColeModel,
             "Calculates complex resistivity based on cole-cole parameters")

Modules/FDEM1D/src/DipoleSource.cpp

         lays = Earth->GetLayerAtThisDepth(Location[2]);
         layr = Earth->GetLayerAtThisDepth(Receivers->GetLocation(irec)[2]);
 
+        // TODO, avoid smart pointer here maybe?
         KernelManager = KernelEM1DManager::NewSP();
 
             KernelManager->SetEarth(Earth);
                             }
                             break;
                         case H:
-                            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]));
+                            // TI - Comparisons with Amira show slight better agreement when neglecting these grounding terms
+                            f(5) = 0; //Hankel->Zgauss(5, TM, 0, rho, wavef, KernelManager->GetRAWKernel(ik[5]));
+                            f(6) = 0; //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();
                                         Pol[1]*QPI*(sps*f(5)+c2p*f(6)/rho-cps*f(7)+c2p*f(8)/rho)*Moment,
                                         Pol[1]*QPI*scp*(-f(5)+(Real)(2.)*f(6)/rho-f(7)+(Real)(2.)*f(8)/rho)*Moment,
                                         -Pol[1]*QPI*cp*f(9)*Moment );
-                                // Analytic whole space solution could go here
                             }
                             if (std::abs(Pol[0]) > 0) {
                                 this->Receivers->AppendHfield(ifreq, irec,
                                     Pol[0]*Moment*QPI*scp*(f(5)-(Real)(2.)*f(6)/rho+f(7)-(Real)(2.)*f(8)/rho),
                                     Pol[0]*Moment*QPI*(-cps*f(5)+c2p*f(6)/rho+sps*f(7)+c2p*f(8)/rho),
                                     Pol[0]*Moment*QPI*sp*f(9) );
-                                // Analytic whole space solution
                             }
                             break;
 
                             f(4) = 0;
                             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(5) = 0;//Hankel->Zgauss(5, TM, 0, rho, wavef, KernelManager->GetRAWKernel(ik[5]));
+                            f(6) = 0;//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();

Modules/FDEM1D/src/EMEarth1D.cpp

         if (Antenna->GetName() == std::string("PolygonalWireAntenna") || Antenna->GetName() == std::string("TEMTransmitter") ) {
             icalc += 1;
             // Check to see if they are all on a plane? If so we can do this fast
-            if (Antenna->IsHorizontallyPlanar() && ( HankelType == ANDERSON801 || HankelType== FHTKEY201 || HankelType==FHTKEY101 ||
+            if ( Antenna->IsHorizontallyPlanar() && ( HankelType == ANDERSON801 || HankelType== FHTKEY201 || HankelType==FHTKEY101 ||
                                                      HankelType == FHTKEY51 || HankelType == FHTKONG61 || HankelType == FHTKONG121 ||
                                                      HankelType == FHTKONG241 || HankelType == IRONS )) {
                 #ifdef HAVE_BOOST_PROGRESS
                     {
                     #endif
                     auto Hankel = HankelTransformFactory::NewSP( HankelType );
+                    auto AntCopy = static_cast<PolygonalWireAntenna*>(Antenna.get())->ClonePA();
                     #ifdef LEMMAUSEOMP
                     #pragma omp for schedule(static, 1)
                     #endif
                     for (int irec=0; irec<Receivers->GetNumberOfPoints(); ++irec) {
-                        auto AntCopy = static_cast<PolygonalWireAntenna*>(Antenna.get())->ClonePA();
                         SolveLaggedTxRxPair(irec, Hankel.get(), wavef, ifreq, AntCopy.get());
                         #ifdef HAVE_BOOST_PROGRESS
                         if (progressbar) ++(*disp);
                     disp = new boost::progress_display( Receivers->GetNumberOfPoints()*Antenna->GetNumberOfFrequencies() );
                 }
                 #endif
-
                 // parallelise across receivers
                 #ifdef LEMMAUSEOMP
                 #pragma omp parallel
                                     //}
                                     auto tDipole = Antenna->GetDipoleSource(idip);
                                     // Propogation constant in free space
-                                    Real wavef   = tDipole->GetAngularFrequency(ifreq) *
-                                          std::sqrt(MU0*EPSILON0);
+                                    Real wavef   = tDipole->GetAngularFrequency(ifreq) * std::sqrt(MU0*EPSILON0);
                                     SolveSingleTxRxPair(irec, Hankel.get(), wavef, ifreq, tDipole.get());
                                 } // dipole loop
                             } // frequency loop
     void EMEarth1D::SolveLaggedTxRxPair(const int &irec, HankelTransform* Hankel,
                     const Real &wavef, const int &ifreq, PolygonalWireAntenna* antenna) {
 
-        //std::cout << "SolveLaggedTxRxPair" << std::endl;
-
         antenna->ApproximateWithElectricDipoles(Receivers->GetLocation(irec));
-
         // Determine the min and max arguments
         Real rhomin = 1e9;
         Real rhomax = 1e-9;

Modules/FDEM1D/testing/CMakeLists.txt

 CXXTEST_ADD_TEST(unittest_FEM1D_SerializeCheck SerializeCheck.cc ${CMAKE_CURRENT_SOURCE_DIR}/SerializeCheck.h)
 target_link_libraries(unittest_FEM1D_SerializeCheck "lemmacore" "fdem1d" "yaml-cpp")
 
-#CXXTEST_ADD_TEST(benchKiHa BenchKiHa.cc ${CMAKE_CURRENT_SOURCE_DIR}/BenchKiHa.h)
-#target_link_libraries(benchKiHa "lemmacore" "fdem1d" "yaml-cpp")
+if(KIHA_EM1D)
+	CXXTEST_ADD_TEST(benchKiHa BenchKiHa.cc ${CMAKE_CURRENT_SOURCE_DIR}/BenchKiHa.h)
+	target_link_libraries(benchKiHa "lemmacore" "fdem1d" "yaml-cpp")
+endif()
 
 #set_target_properties(unittest_FEM1D_GetNameCheck
 #	              unittest_FEM1D_SerializeCheck 

Modules/LemmaCore/include/EarthModel.h

         public:
 
             // ====================  LIFECYCLE     =======================
+
+            /// Default destructor
+            ~EarthModel ();
+
             /** YAML Serializing method
              */
             YAML::Node Serialize() const;
             /** Deserialize constructor */
             EarthModel (const YAML::Node& node, const ctor_key&);
 
-            /// Default protected constructor.
-            ~EarthModel ();
 
             // ====================  DATA MEMBERS  =========================
 

Modules/LemmaCore/python/pyLemmaCore.cpp

     ;
 
     // ABC
-    //py::class_<Lemma::EarthModel, std::shared_ptr<Lemma::EarthModel> >(m, "EarthModel")
+    py::class_<Lemma::EarthModel, std::shared_ptr<Lemma::EarthModel> > abcEarthModel (m, "EarthModel");
+
+    // Modifiers
+    abcEarthModel.def("SetMagneticFieldIncDecMag", &Lemma::EarthModel::SetMagneticFieldIncDecMag, "Sets the inducing field" );
+    abcEarthModel.def("SetMagneticFieldComponents", &Lemma::EarthModel::SetMagneticFieldComponents, "Sets the inducing field" );
+
+    // Accessors
+    abcEarthModel.def("GetMagneticField", &Lemma::EarthModel::GetMagneticField, "returns the inducing field in Tesla" );
+    abcEarthModel.def("GetMagneticFieldInGauss", &Lemma::EarthModel::GetMagneticFieldInGauss, "returns the inducing field in Gauss" );
+    abcEarthModel.def("GetMagneticFieldUnitVector", &Lemma::EarthModel::GetMagneticFieldUnitVector, "returns the inducing field unit vector" );
+    abcEarthModel.def("GetMagneticFieldMagnitude", &Lemma::EarthModel::GetMagneticFieldMagnitude, "returns the magnitude of the inducing field" );
+    abcEarthModel.def("GetMagneticFieldMagnitudeInGauss", &Lemma::EarthModel::GetMagneticFieldMagnitudeInGauss, "returns the magnitude of the inducing field" );
+
 
     /*
     py::class_<Lemma::LayeredEarth, std::shared_ptr<Lemma::LayeredEarth> >(m, "LayeredEarth")

python/setup.py

     #'pyLemma.pyFDEM1D': ['pyFDEM1D.*.so']
     #'pyLemma.pyFDEM1D': ['pyFDEM1D.*.so']
     #'': ['LemmaCore.*.so','FDEM1D.*.so']
-    '': ['LemmaCore.*','FDEM1D.*']
+    '': ['LemmaCore.*','FDEM1D.*','Merlin.*']
   },
   zip_safe=False,
   cmdclass={'install':InstallPlatlib},

vim/c.vim

 
 " Lemma types
 highlight leType ctermfg=Yellow guifg=Yellow
-syn keyword leType HankelTransform FHTAnderson801 FHTKey201 FHTKey101 FHTKey51 GQChave QWEKey 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 EMEarth1D 
+syn keyword leType HankelTransform FHTAnderson801 FHTKey201 FHTKey101 FHTKey51 GQChave QWEKey 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 EMEarth1D KernelV0 
 
 " Deprecated Lemma Types
 highlight dleType ctermfg=Blue guifg=Blue