Fix MSVC warnings regarding unsigned integer comparisons, and DipoleSource::Serialize infinite recursion.

Modules/DCIP/CMakeLists.txt

 
 	# Install
 	install ( TARGETS dcip DESTINATION ${CMAKE_INSTALL_PREFIX}/lib )
-	install ( FILES include/EMSchur3D  DESTINATION ${CMAKE_INSTALL_PREFIX}/include/Lemma ) 
+	install ( FILES include/DCIP  DESTINATION ${CMAKE_INSTALL_PREFIX}/include/Lemma ) 
 	install ( DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_PREFIX}/include/Lemma  FILES_MATCHING PATTERN "*.h")
 
 	#install ( DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_PREFIX}/include/Lemma/  FILES_MATCHING PATTERN "FDEM1D")

Modules/DCIP/include/DCIP

+#ifndef  DCIP_INC
+#define  DCIP_INC
+
+#include "DCSurvey.h"
+#include "DCIPElectrode.h"
+
+#endif   // ----- #ifndef DCIP_INC  -----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+

Modules/FDEM1D/examples/CMakeLists.txt

 target_link_libraries(  Hantenna  "lemmacore" "fdem1d")
 set_property(TARGET Hantenna PROPERTY CXX_STANDARD 14)
 
+add_executable( DipoleSource DipoleSource.cpp  )
+target_link_libraries(  DipoleSource  "lemmacore" "fdem1d")
+set_property(TARGET DipoleSource PROPERTY CXX_STANDARD 14)
+
 INSTALL_TARGETS( "/share/FDEM1D/"
 	LayeredEarthEM 
 	FieldPoints
 	EMDipEarth1D
     CircularLoop
 	Hantenna
+	DipoleSource
 )
 
 install (DIRECTORY inp  DESTINATION "${CMAKE_INSTALL_PREFIX}/share/FDEM1D/" )

Modules/FDEM1D/examples/DipoleSource.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      10/25/2018 12:41:37 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@utah.edu
+ * @copyright Copyright (c) 2018, University of Utah
+ * @copyright Copyright (c) 2018, Lemma Software, LLC
+ */
+
+#include "FDEM1D"
+
+using namespace Lemma;
+
+int main() {
+    auto dip = DipoleSource::NewSP();
+    dip->SetLocation( Vector3r(1.,2.,3.) );
+    std::cout << "Dipole 1: " << dip << "\n" << *dip << std::endl;
+
+    auto dip2 = dip->Clone(); // literal copy of pointer
+    dip2->SetLocation( Vector3r(1.,2.,3.) );
+    std::cout << "Dipole 2: " << dip2 << "\n" << *dip2 << std::endl;
+
+//    if (*dip == *dip2) {
+//        std::cout << "equal" << std::endl;
+//    } else {
+//        std::cout << "not equal" << std::endl;
+//    }
+}
+

Modules/FDEM1D/include/DipoleSource.h

   @file
   @author   Trevor Irons
   @date     12/02/2009
-  @version  $Id: dipolesource.h 203 2015-01-09 21:19:04Z tirons $
  **/
 
 #ifndef __DIPOLESOURCE_H
 
         friend std::ostream &operator<<(std::ostream &stream, const DipoleSource &ob);
 
+        friend class EMEarth1D;
+
         public:
 
+            //bool operator==(DipoleSource& rhs)const;
+
             // ====================  LIFECYCLE     ======================
 
             /** Default locked constructor. */
 
             // ====================  OPERATORS     ======================
 
-            // ====================  OPERATIONS    ======================
-
-            /** Determines if kernels have been loaded already, and if so if they can be reused
-             */
-            void SetKernels(const int& ifreq,  const FIELDCALCULATIONS&  Fields, std::shared_ptr<FieldPoints> Receivers, const int& irec,
-                    std::shared_ptr<LayeredEarthEM> Earth );
-
-            /** resets the kernels if they cannot be reused */
-            virtual void ReSetKernels(const int& ifreq,  const FIELDCALCULATIONS&  Fields, std::shared_ptr<FieldPoints> Receivers,
-                    const int& irec, std::shared_ptr<LayeredEarthEM> Earth );
-
-            /** Updates the receiver fields */
-            virtual void UpdateFields(const int& ifreq, HankelTransform* Hankel, const Real& wavef);
 
             // ====================  ACCESS        ======================
 
             /// Sets the dipole source type
             /// @param[in] stype is one of the enerated values taking either
             /// ELECTRICDIPOLE or MAGNETICDIPOLE
-            void SetType(const DipoleSourceType &stype);
+            void SetType(const DIPOLESOURCETYPE &stype);
 
             /// Sets the dipole moment
             void SetMoment(const Real &moment);
             /// number of frequencies
             void SetFrequencies(const VectorXr& freqs);
 
-
             // ====================  INQUIRY       ======================
 
             /**  Accessor to polarisation vector.
             /// @param coordinate 0=x, 1=y, 2=z
             Real  GetLocation(const int &coordinate);
 
-            /// Returns enumerated of DipoleSourceType
-            DipoleSourceType GetDipoleSourceType();
+            /// Returns enumerated of DIPOLESOURCETYPE
+            DIPOLESOURCETYPE GetDipoleSourceType();
 
             /// Returns the dipole type
-            DipoleSourceType GetType();
+            DIPOLESOURCETYPE GetType();
 
             /// Returns pointer to KernelEM1DManager
             std::shared_ptr<KernelEM1DManager>  GetKernelManager();
             /** Returns the name of the underlying class, similiar to Python's type */
             virtual std::string GetName() const ;
 
+        protected:
+
+            // ====================  OPERATIONS    ======================
+
+            /** Determines if kernels have been loaded already, and if so if they can be reused
+             */
+            void SetKernels(const int& ifreq,  const FIELDCALCULATIONS&  Fields, std::shared_ptr<FieldPoints> Receivers, const int& irec,
+                    std::shared_ptr<LayeredEarthEM> Earth );
+
+            /** resets the kernels if they cannot be reused */
+            virtual void ReSetKernels(const int& ifreq,  const FIELDCALCULATIONS&  Fields, std::shared_ptr<FieldPoints> Receivers,
+                    const int& irec, std::shared_ptr<LayeredEarthEM> Earth );
+
+            /** Updates the receiver fields */
+            virtual void UpdateFields(const int& ifreq, HankelTransform* Hankel, const Real& wavef);
+
         private:
 
             // ====================  DATA MEMBERS  ======================
 
             /// Defines the type of source (magnetic or electric)
-            DipoleSourceType             Type;
+            DIPOLESOURCETYPE             Type;
 
             // Polarization of the dipole, (x, y or z)
             //DipoleSourcePolarisation     Polarisation;
             VectorXi                     ik;
 
             /// Central location of the dipole
-            Vector3r                     Location;
+            Vector3r                                    Location;
 
             /// Unit vector defining directionality of the dipole
-            Vector3r                     Phat;
+            Vector3r                                    Phat;
 
             /// Freqencies of the source, in Hz
-            VectorXr                     Freqs;
+            VectorXr                                    Freqs;
 
             /// Storage of the EM1D kernels used by this dipole
             std::shared_ptr<KernelEM1DManager>          KernelManager;

Modules/FDEM1D/src/DipoleSource.cpp

 
 
     // ====================    FRIENDS     ======================
+
     std::ostream &operator<<(std::ostream &stream, const DipoleSource &ob) {
         stream << ob.Serialize()  << "\n";
         return stream;
     }
 
+/*
+    bool DipoleSource::operator == (DipoleSource& rhs) const {
+        if (Location != rhs.Location) return false;
+        return true;
+    }
+*/
 
     // ====================  LIFECYCLE     ======================
 
         this->Phat.setZero();
     }
 
+    DipoleSource::DipoleSource( const YAML::Node& node, const ctor_key& key ) : LemmaObject( node, key ),
+                    Type(NOSOURCETYPE),
+                    irec(-1),
+                    Phase(0),
+                    Moment(1),
+                    KernelManager(nullptr),
+                    Receivers(nullptr),
+                    Earth(nullptr)
+    {
+        Type = string2Enum<DIPOLESOURCETYPE>(node["Type"].as<std::string>());
+        this->Location = node["Location"].as<Vector3r>();
+        this->Phat.setZero();
+    }
+
+
     DipoleSource::~DipoleSource() {
     }
 
     }
 
     YAML::Node DipoleSource::Serialize() const {
-        YAML::Node node = DipoleSource::Serialize();
+        YAML::Node node = LemmaObject::Serialize();
         node.SetTag( GetName() );
-        /*
-        node["LayerConductivity"] = LayerConductivity;
-        node["LayerSusceptibility"] = LayerSusceptibility;
-        node["LayerLowFreqSusceptibility"] = LayerLowFreqSusceptibility;
-        node["LayerHighFreqSusceptibility"] = LayerHighFreqSusceptibility;
-        node["LayerTauSusceptibility"] = LayerTauSusceptibility;
-        node["LayerBreathSusceptibility"] = LayerBreathSusceptibility;
-        node["LayerPermitivity"] = LayerPermitivity;
-        node["LayerLowFreqPermitivity"] = LayerLowFreqPermitivity;
-        node["LayerHighFreqPermitivity"] = LayerHighFreqPermitivity;
-        node["LayerTauPermitivity"] = LayerTauPermitivity;
-        node["LayerBreathPermitivity"] = LayerBreathPermitivity;
-        */
+        node["Type"] = enum2String(Type);
+        node["Location"] = Location;
+        node["Phat"] = Phat;
+        node["Freqs"] = Freqs;
+        node["Phase"] = Phase;
+        node["Moment"] = Moment;
         return node;
     }
 
+    std::shared_ptr< DipoleSource > DipoleSource::DeSerialize(const YAML::Node& node) {
+        if (node.Tag() != "DipoleSource") {
+            throw  DeSerializeTypeMismatch( "DipoleSource", node.Tag());
+        }
+        return std::make_shared<DipoleSource> ( node, ctor_key() );
+    }
+
     std::shared_ptr<DipoleSource> DipoleSource::Clone() {
 
         auto Obj = DipoleSource::NewSP();
 //         };
     }
 
-    void DipoleSource::SetType(const DipoleSourceType & stype) {
+    void DipoleSource::SetType(const DIPOLESOURCETYPE & stype) {
 
         switch (stype) {
             case (GROUNDEDELECTRICDIPOLE):
         return Phat;
     }
 
-    DipoleSourceType DipoleSource::GetType() {
+    DIPOLESOURCETYPE DipoleSource::GetType() {
         return Type;
     }
 
         }
     }
 
-    DipoleSourceType DipoleSource::GetDipoleSourceType() {
+    DIPOLESOURCETYPE DipoleSource::GetDipoleSourceType() {
         return this->Type;
     }
 

Modules/FDEM1D/src/EMEarth1D.cpp

                     for (int irec=0; irec<Receivers->GetNumberOfPoints(); ++irec) {
                         if (!Receivers->GetMask(irec)) {
                             AntCopy->ApproximateWithElectricDipoles(Receivers->GetLocation(irec));
-                            for (int idip=0; idip<AntCopy->GetNumberOfDipoles(); ++idip) {
+                            for (unsigned int idip=0; idip<AntCopy->GetNumberOfDipoles(); ++idip) {
                                 auto tDipole = AntCopy->GetDipoleSource(idip);
                                 //#ifdef LEMMAUSEOMP
                                 //#pragma omp for schedule(static, 1)
                             #pragma omp for schedule(static, 1)
                             #endif
                             for (int ifreq=0; ifreq<Antenna->GetNumberOfFrequencies(); ++ifreq) {
-                                for (int idip=0; idip<Antenna->GetNumberOfDipoles(); ++idip) {
+                                for (unsigned int idip=0; idip<Antenna->GetNumberOfDipoles(); ++idip) {
                                     auto tDipole = Antenna->GetDipoleSource(idip);
                                     // Propogation constant in free space
                                     Real wavef   = tDipole->GetAngularFrequency(ifreq) *
                                 #ifdef LEMMAUSEOMP
                                 #pragma omp for schedule(static, 1)
                                 #endif
-                                for (int idip=0; idip<Antenna->GetNumberOfDipoles(); ++idip) {
+                                for (unsigned int idip=0; idip<Antenna->GetNumberOfDipoles(); ++idip) {
                                     //#pragma omp critical
                                     //{
                                     //cout << "idip=" << idip << "\tthread num=" << omp_get_thread_num() << '\n';
             // TODO, getting wrong answer, curiously worKernel->GetKs() with MakeCalc, maybe
             // a threading issue, use SolveSingleTxRxPair maype instead of call
             // to MakeCalc3? !!!
-            for (int idip=0; idip<Antenna->GetNumberOfDipoles(); ++idip) {
+            for (unsigned int idip=0; idip<Antenna->GetNumberOfDipoles(); ++idip) {
                 this->Dipole = Antenna->GetDipoleSource(idip);
                 MakeCalc3();
                 //++disp;
         // Determine the min and max arguments
         Real rhomin = 1e9;
         Real rhomax = 1e-9;
-        for (int idip=0; idip<antenna->GetNumberOfDipoles(); ++idip) {
+        for (unsigned int idip=0; idip<antenna->GetNumberOfDipoles(); ++idip) {
             auto tDipole = antenna->GetDipoleSource(idip);
             Real rho = (Receivers->GetLocation(irec).head<2>() - tDipole->GetLocation().head<2>()).norm();
             rhomin = std::min(rhomin, rho);
         Hankel->ComputeLaggedRelated( 1.0*rhomax, nlag, tDipole->GetKernelManager() );
 
         // Sort the dipoles by rho
-        for (int idip=0; idip<antenna->GetNumberOfDipoles(); ++idip) {
+        for (unsigned int idip=0; idip<antenna->GetNumberOfDipoles(); ++idip) {
             auto tDipole = antenna->GetDipoleSource(idip);
             tDipole->SetKernels(ifreq, FieldsToCalculate, Receivers, irec, Earth);
             // Pass Hankel2 a message here so it knows which one to return in Zgauss!

Modules/FDEM1D/testing/SerializeCheck.h

             TS_ASSERT_EQUALS( Obj->GetLocationZ(ip), Obj->GetLocation(ip)(2) );
         }
     }
+
+    void testDipoleSource(void)
+    {
+        auto Obj = DipoleSource::NewSP();
+        YAML::Node node = Obj->Serialize();
+        auto Obj2 = DipoleSource::DeSerialize(node);
+        TS_ASSERT_EQUALS( Obj->GetName(), Obj2->GetName() );
+    }
+
+
 };
 

Modules/LemmaCore/include/helper.h

     std::string enum2String(const FIELDCALCULATIONS& Htype);
     /// convert enums to string saves repeated code useful for YAML serializing
     std::string enum2String(const WINDOWTYPE& Wtype);
+    /// convert enums to string saves repeated code useful for YAML serializing
+    std::string enum2String(const DIPOLESOURCETYPE& Wtype);
 
     // other way around is a template, where template argument lets us know
     // which specialisation to use.
 } // end namespace Lemma
 
 ///////////////////////////////////////////////////////
-// YAML Serializing helper functions. Can we move this into helper.h
+// YAML Serializing helper functions.
 namespace YAML {
 
 template<>

Modules/LemmaCore/include/lemma.h

         typedef Eigen::Matrix<Real, 3, 1> Vector3r;
 
         typedef Eigen::Matrix<Real, Eigen::Dynamic, 1>::Index Index;
-        
-	/// A 3 X Dynamic Component Eigen matrix of Reals
+
+	    /// A 3 X Dynamic Component Eigen matrix of Reals
         typedef Eigen::Matrix<Real, 3, Eigen::Dynamic> Vector3Xr;
 
         /// Variable length Eigen vector of Reals
 
         /** Enum is OK because these are the only physically possible sources.
          @param NOSOURCETYPE is default.
-         @param ELECTRICDIPOLE is an electric dipole
+         @param GROUNDEDELECTRICDIPOLE is an grounded electric dipole
+         @param UNGROUNDEDELECTRICDIPOLE is an ungrounded electric dipole
          @param MAGNETICDIPOLE is a magnetic dipole
         */
-        enum DipoleSourceType {NOSOURCETYPE, GROUNDEDELECTRICDIPOLE, UNGROUNDEDELECTRICDIPOLE, MAGNETICDIPOLE};
+        enum DIPOLESOURCETYPE {NOSOURCETYPE, GROUNDEDELECTRICDIPOLE, UNGROUNDEDELECTRICDIPOLE, MAGNETICDIPOLE};
 
         /// Only three polarizations are supported. They may be summed to
         /// approximate others

Modules/LemmaCore/src/helper.cpp

     }
 }
 
+std::string enum2String( const DIPOLESOURCETYPE& Type ) {
+    switch (Type) {
+        case NOSOURCETYPE:
+            return std::string("NOSOURCETYPE");
+        case GROUNDEDELECTRICDIPOLE:
+            return std::string("GROUNDEDELECTRICDIPOLE");
+        case UNGROUNDEDELECTRICDIPOLE:
+            return std::string("UNGROUNDEDELECTRICDIPOLE");
+        case MAGNETICDIPOLE:
+            return std::string("MAGNETICDIPOLE");
+        default:
+            throw( std::runtime_error( "In enum2String DIPOLESOURCETYPE, type not identified" ) );
+    }
+}
+
 template<>
 FREQUENCYUNITS string2Enum<FREQUENCYUNITS>( const std::string& str ) {
     if       (str ==  "HZ") return   HZ;
     }
 }
 
+template<>
+DIPOLESOURCETYPE string2Enum<DIPOLESOURCETYPE>( const std::string& str ) {
+    if      (str == "NOSOURCETYPE")              return NOSOURCETYPE;
+    if      (str == "GROUNDEDELECTRICDIPOLE")    return GROUNDEDELECTRICDIPOLE;
+    if      (str == "UNGROUNDEDELECTRICDIPOLE")  return UNGROUNDEDELECTRICDIPOLE;
+    if      (str == "MAGNETICDIPOLE")            return MAGNETICDIPOLE;
+    else {
+        throw std::runtime_error("string not recognized as DipoleSource");
+    }
+}
+
 }		// -----  end of Lemma  name  -----
 

vim/c.vim

 "highlight cComment ctermfg=Green guifg=Green
 highlight cType ctermfg=Green guifg=Green
-syn keyword cType Real Complex VectorXr VectorXcr Vector3r Vector3Xr VectorXi Vector3cr Vector3Xcr MatrixXr MatrixXi MatrixXcr shared_ptr make_shared
+syn keyword cType string Real Complex VectorXr VectorXcr Vector3r Vector3Xr VectorXi Vector3cr Vector3Xcr MatrixXr MatrixXi MatrixXcr shared_ptr make_shared
 
 highlight constType ctermfg=Red guifg=Red
 syn keyword constType  PI EPSILON0 MU0 QPI  
 
 highlight eType ctermfg=Magenta guifg=Magenta
-syn keyword eType  MAGUNITS  TEMPUNITS  TIMEUNITS FREQUENCYUNITS FEMCOILORIENTATION ORIENTATION FIELDTYPE FIELDCOMPONENT SPATIALCOORDINANT HANKELTRANSFORMTYPE FIELDCALCULATIONS WINDOWTYPE 
+syn keyword eType  MAGUNITS  TEMPUNITS  TIMEUNITS FREQUENCYUNITS FEMCOILORIENTATION ORIENTATION FIELDTYPE FIELDCOMPONENT SPATIALCOORDINANT HANKELTRANSFORMTYPE FIELDCALCULATIONS WINDOWTYPE DIPOLESOURCETYPE 
 
 highlight eeType ctermfg=Cyan guifg=Cyan
-syn keyword eeType  TESLA NANOTESLA GAUSS CELCIUS KELVIN SEC MILLISEC MICROSEC NANOSEC PICOSEC HZ KHZ MHZ GHZ COAXIAL COPLANAR HFIELDREAL HFIELDIMAG EFIELDREAL EFIELDIMAG XCOMPONENT YCOMPONENT ZCOMPONENT XCOORD YCOORD ZCOORD X Y Z NX  NY  NZ ANDERSON801 CHAVE FHTKEY201 FHTKEY101 FHTKEY51 FHTKONG241 FHTKONG121 FHTKONG61 QWEKEY E H BOTH HAMMING HANNING RECTANGULAR
+syn keyword eeType  TESLA NANOTESLA GAUSS CELCIUS KELVIN SEC MILLISEC MICROSEC NANOSEC PICOSEC HZ KHZ MHZ GHZ COAXIAL COPLANAR HFIELDREAL HFIELDIMAG EFIELDREAL EFIELDIMAG XCOMPONENT YCOMPONENT ZCOMPONENT XCOORD YCOORD ZCOORD X Y Z NX  NY  NZ ANDERSON801 CHAVE FHTKEY201 FHTKEY101 FHTKEY51 FHTKONG241 FHTKONG121 FHTKONG61 QWEKEY E H BOTH HAMMING HANNING RECTANGULAR NOSOURCETYPE GROUNDEDELECTRICDIPOLE UNGROUNDEDELECTRICDIPOLE MAGNETICDIPOLE
 
 " Namespaces
 highlight nspace ctermfg=Red guifg=Red