Improved speed for horizontal loops, reduced initialization of unused resources

CMakeLists.txt

 # Lemma versioning, set Major, minor, and patch here                                               #
 set(LEMMA_VERSION_MAJOR "0")                                                                       #
 set(LEMMA_VERSION_MINOR "3")                                                                       #
-set(LEMMA_VERSION_PATCH "2")                                                                       #
+set(LEMMA_VERSION_PATCH "3")                                                                       #
 set(LEMMA_VERSION "\"${LEMMA_VERSION_MAJOR}.${LEMMA_VERSION_MINOR}.${LEMMA_VERSION_PATCH}\"")      #
 set(LEMMA_VERSION_NOQUOTES "${LEMMA_VERSION_MAJOR}.${LEMMA_VERSION_MINOR}.${LEMMA_VERSION_PATCH}") #
 ####################################################################################################

Modules/FDEM1D/include/DipoleSource.h

                     std::shared_ptr<FieldPoints> Receivers, const int& irec,
                     std::shared_ptr<LayeredEarthEM> Earth );
 
+            /** For use in lagged calculations, this does the necessary parts to make field calculations
+                for a segment.
+             */
+            void SetupLight(const int& ifreq,  const FIELDCALCULATIONS&  Fields, const int& irec);
+
             /** resets the kernels if they cannot be reused */
             virtual void ReSetKernels(const int& ifreq,  const FIELDCALCULATIONS&  Fields,
                     std::shared_ptr<FieldPoints> Receivers,

Modules/FDEM1D/include/KernelEM1DSpec.h

                 return std::make_shared< KernelEM1DSpec > ( ctor_key() );
             }
 
-            static std::shared_ptr<KernelEM1DSpec> NewSP(LayeredEarthEM* Earth, std::shared_ptr<DipoleSource> Dipole,
+            /* Management has shifted from this approach, this will be removed
+            static std::shared_ptr<KernelEM1DSpec> NewSP2(LayeredEarthEM* Earth, std::shared_ptr<DipoleSource> Dipole,
                                                          const int& ifreq, const Real& rz) {
                 auto Obj = std::make_shared< KernelEM1DSpec > ( ctor_key() );
 
 
                 return Obj;
             }
+            */
 
             // ====================  OPERATORS     =======================
 

Modules/FDEM1D/src/DipoleSource.cpp

         return;
     }
 
+    void DipoleSource::SetupLight(const int& ifreq, const FIELDCALCULATIONS&  Fields, const int& irecin) {
+
+        xxp = Receivers->GetLocation(irec)[0] - Location[0];
+        yyp = Receivers->GetLocation(irec)[1] - Location[1];
+        rho = (Receivers->GetLocation(irec).head<2>() - Location.head<2>()).norm();
+
+        sp = yyp/rho;
+        cp = xxp/rho;
+        scp = sp*cp;
+        sps = sp*sp;
+        cps = cp*cp;
+        c2p = cps-sps;
+
+        return;
+    }
+
+
+
     // TODO we could make the dipoles template specializations avoiding this rats nest of switch statements. Probably
     //      not the most critical piece though
     void DipoleSource::ReSetKernels(const int& ifreq, const FIELDCALCULATIONS&  Fields ,

Modules/FDEM1D/src/EMEarth1D.cpp

 
         // Sort the dipoles by rho
         for (unsigned int idip=0; idip<antenna->GetNumberOfDipoles(); ++idip) {
-            auto tDipole = antenna->GetDipoleSource(idip);
-            tDipole->SetKernels(ifreq, FieldsToCalculate, Receivers, irec, Earth);
+            // Can we avoid these two lines, and instead vary the moment of the previous tDipole?
+            // SetKernels is somewhat heavy
+            auto rDipole = antenna->GetDipoleSource(idip);
+            //tDipole->SetKernels(ifreq, FieldsToCalculate, Receivers, irec, Earth); // expensive, and not used
+            tDipole->SetLocation( rDipole->GetLocation() );
+            tDipole->SetMoment( rDipole->GetMoment() );
+            tDipole->SetPolarisation( rDipole->GetPolarisation() );
+            tDipole->SetupLight( ifreq, FieldsToCalculate, irec );
+
             // Pass Hankel2 a message here so it knows which one to return in Zgauss!
             Real rho = (Receivers->GetLocation(irec).head<2>() - tDipole->GetLocation().head<2>()).norm();
             Hankel->SetLaggedArg( rho );