Found memory leak, in a cycle of shared_ptr, hence the existence of weak_ptr....

Modules/FDEM1D/include/DipoleSource.h

             Real                         c2p;
             Real                         kernelFreq;
 
-            FIELDCALCULATIONS            FieldsToCalculate;
+            FIELDCALCULATIONS            FieldsToCalculate = BOTH;
 
             VectorXcr                    f;
             VectorXi                     ik;

Modules/FDEM1D/include/EMEarth1D.h

                     const Real &wavef, const int &ifreq,
                     DipoleSource* tDipole);
 
+//             void SolveSingleTxRxPair(const int &irec,
+//                     std::shared_ptr<HankelTransform> Hankel,
+//                     const Real &wavef, const int &ifreq,
+//                     std::shared_ptr<DipoleSource> tDipole);
+
             /** Used internally, this is the innermost loop of the MakeCalc3,
              *  and CalculateWireAntennaField routines.
              */

Modules/FDEM1D/include/KernelEM1DManager.h

             void SetEarth( std::shared_ptr<LayeredEarthEM>   Earth);
 
             /** Sets the source of the kernels */
-            void SetDipoleSource( std::shared_ptr<DipoleSource> Dipole, const int& ifreq, const Real& rx_zin);
+            void SetDipoleSource( DipoleSource* Dipole, const int& ifreq, const Real& rx_zin);
 
             /** Returns pointer to specified kernel indice. Indices are assigned in the same
                 order as they are created by AddKernel.
 
             /** Returns pointer to connected dipole.
              */
-            std::shared_ptr<DipoleSource>    GetDipole( );
+            DipoleSource*                      GetDipole( );
 
             inline std::vector< std::shared_ptr<KernelEM1DBase> >  GetSTLVector() {
                 return KernelVec;
             std::shared_ptr<LayeredEarthEM>            Earth;
 
             /** EM dipole souce */
-            std::shared_ptr<DipoleSource>              Dipole;
+            DipoleSource*                              Dipole;
 
             /** Frequency index for the sources */
             int                                        ifreq;

Modules/FDEM1D/include/KernelEM1DReflBase.h

 
             }
 
-            void SetUpSource( std::shared_ptr<DipoleSource> Dipole, const int &ifreq ) {
+            void SetUpSource( DipoleSource* Dipole, const int &ifreq ) {
 
                 zh(0) = Complex(0, Dipole->GetAngularFrequency(ifreq)*MU0);
                 yh(0) = Complex(0, Dipole->GetAngularFrequency(ifreq)*EPSILON0);

Modules/FDEM1D/src/DipoleSource.cpp

 
     DipoleSource::DipoleSource( const ctor_key& ) : LemmaObject( ),
                     Type(NOSOURCETYPE),
+                    irec(-1),
                     Phase(0),
                     Moment(1),
                     KernelManager(nullptr),
         if (Receivers != ReceiversIn) {
             Receivers = ReceiversIn;
         }
-
         if (Earth != EarthIn) {
             Earth = EarthIn;
         }
-
         if (irecin != irec) {
             irec = irecin;
         }
-
         if (FieldsToCalculate != Fields) {
             FieldsToCalculate = Fields;
         }
 
         KernelManager = KernelEM1DManager::NewSP();
             KernelManager->SetEarth(Earth);
-            KernelManager->SetDipoleSource(shared_from_this(), ifreq, Receivers->GetLocation(irec)[2]);
-        kernelFreq = Freqs(ifreq); // this is never used
+            // alternative is to use weak_ptr here, this is deep and internal, and we are safe.
+            KernelManager->SetDipoleSource( shared_from_this().get() , ifreq, Receivers->GetLocation(irec)[2]);
+            kernelFreq = Freqs(ifreq); // this is never used
+
         ReSetKernels( ifreq, Fields, Receivers, irec, Earth );
 
         return;

Modules/FDEM1D/src/EMEarth1D.cpp

     void EMEarth1D::SolveSingleTxRxPair (const int &irec, HankelTransform *Hankel, const Real &wavef, const int &ifreq,
                    DipoleSource *tDipole) {
         ++icalcinner;
-
         Real rho = (Receivers->GetLocation(irec).head<2>() - tDipole->GetLocation().head<2>()).norm();
-
         tDipole->SetKernels(ifreq, FieldsToCalculate, Receivers, irec, Earth);
         Hankel->ComputeRelated( rho, tDipole->GetKernelManager() );
         tDipole->UpdateFields( ifreq,  Hankel, wavef );
     }
 
+//     void EMEarth1D::SolveSingleTxRxPair (const int &irec, std::shared_ptr<HankelTransform> Hankel, const Real &wavef, const int &ifreq,
+//                    std::shared_ptr<DipoleSource> tDipole) {
+//         ++icalcinner;
+//         Real rho = (Receivers->GetLocation(irec).head<2>() - tDipole->GetLocation().head<2>()).norm();
+//         tDipole->SetKernels(ifreq, FieldsToCalculate, Receivers, irec, Earth);
+//         //Hankel->ComputeRelated( rho, tDipole->GetKernelManager() );
+//         //tDipole->UpdateFields( ifreq,  Hankel, wavef );
+//     }
+
     void EMEarth1D::SolveLaggedTxRxPair(const int &irec, FHTAnderson801* Hankel,
                     const Real &wavef, const int &ifreq, PolygonalWireAntenna* antenna) {
 
         #pragma omp parallel
         #endif
         { // OpenMP Parallel Block
-
             #ifdef LEMMAUSEOMP
             int tid = omp_get_thread_num();
             int nthreads = omp_get_num_threads();
             int tid=0;
             int nthreads=1;
             #endif
-
             auto tDipole = Dipole->Clone();
-
             std::shared_ptr<HankelTransform> Hankel;
             switch (HankelType) {
                 case ANDERSON801:
                     std::cerr << "Hankel transform cannot be created\n";
                     exit(EXIT_FAILURE);
             }
-
             if ( tDipole->GetNumberOfFrequencies() < Receivers->GetNumberOfPoints() ) {
                 for (int ifreq=0; ifreq<tDipole->GetNumberOfFrequencies(); ++ifreq) {
                     // Propogation constant in free space being input to Hankel

Modules/FDEM1D/src/KernelEM1DManager.cpp

         Earth = Earthin;
     }
 
-    void KernelEM1DManager::SetDipoleSource( std::shared_ptr<DipoleSource> DipoleIn, const int& ifreqin,
+    void KernelEM1DManager::SetDipoleSource( DipoleSource* DipoleIn, const int& ifreqin,
             const Real& rx_zin) {
         Dipole = DipoleIn;
 
         return KernelVec[ik].get();
     }
 
-    std::shared_ptr<DipoleSource> KernelEM1DManager::GetDipole( ) {
+    DipoleSource* KernelEM1DManager::GetDipole( ) {
         return Dipole;
     }