Added serialization of KernelV0 encompasing all input parameters. No need to compile to change settings.

examples/KernelV0-2.cpp

 
 int main(int argc, char** argv) {
 
-    if (argc<4) {
-        std::cout << "./KernelV0-2 earth.yaml tx.yaml  rx.yaml \n";
+    if (argc<3) {
+        //std::cout << "./KernelV0-2 earth.yaml tx.yaml  rx.yaml \n";
+        std::cout << "./KernelV0-2 Kernel.yaml TxString RxString  \n";
         return(EXIT_SUCCESS);
     }
-    std::cout << "Using earth model: " << argv[1] << std::endl;
-    auto earth = LayeredEarthEM::DeSerialize( YAML::LoadFile(argv[1]) );
 
-    std::cout << "Using transmitter: " << argv[2] << std::endl;
-    auto Tx = PolygonalWireAntenna::DeSerialize( YAML::LoadFile(argv[2]) );
+    std::cout << "Using kernel paramaters: " << argv[1] << std::endl;
+    auto Kern = KernelV0::DeSerialize( YAML::LoadFile(argv[1]) );
 
-    std::cout << "Using receivers: " << argv[3] << std::endl;
-    auto Rx1 = PolygonalWireAntenna::DeSerialize( YAML::LoadFile(argv[3]) );
+//     std::cout << "Using earth model: " << argv[1] << std::endl;
+//     auto earth = LayeredEarthEM::DeSerialize( YAML::LoadFile(argv[2]) );
+//
+//     std::cout << "Using transmitter: " << argv[2] << std::endl;
+//     auto Tx = PolygonalWireAntenna::DeSerialize( YAML::LoadFile(argv[3]) );
+//
+//     std::cout << "Using receivers: " << argv[3] << std::endl;
+//     auto Rx1 = PolygonalWireAntenna::DeSerialize( YAML::LoadFile(argv[4]) );
 
+#if 0
     auto Kern = KernelV0::NewSP();
-        Kern->PushCoil( "Coil 1", Tx );
-        Kern->PushCoil( "Coil 2", Rx1 );
-        Kern->SetLayeredEarthEM( earth );
+        //Kern->PushCoil( "Coil 1", Tx );
+        //Kern->PushCoil( "Coil 2", Rx1 );
+        //Kern->SetLayeredEarthEM( earth );
 
         Kern->SetIntegrationSize( (Vector3r() << 200, 200., 100).finished() );
         Kern->SetIntegrationOrigin( (Vector3r() << -100, -100, .5).finished() );
 
         //VectorXr interfaces = VectorXr::LinSpaced( 41, .5, 45.5 ); // nlay, low, high
         //VectorXr interfaces = VectorXr::LinSpaced( 61, .5, 45.5 ); // nlay, low, high
-        VectorXr interfaces = VectorXr::LinSpaced( 61, .5, 45.5 ); // nlay, low, high
+        VectorXr interfaces = VectorXr::LinSpaced( 58, .5, 45.5 ); // nlay, low, high
         Real thick = .1;
         for (int ilay=1; ilay<interfaces.size(); ++ilay) {
             interfaces(ilay) = interfaces(ilay-1) + thick;
-            thick *= 1.075;
+            thick *= 1.085;
         }
         Kern->SetDepthLayerInterfaces( interfaces ); // nlay, low, high
 
     // We could, I suppose, take the earth model in here? For non-linear that
     // may be more natural to work with?
-    std::vector<std::string> tx = {std::string("Coil 1")};
-    std::vector<std::string> rx = {std::string("Coil 2")};
-
-    //std::cout << "KERNEL.yaml" << std::endl;
-    //std::cout << *Kern << std::endl;
+#endif
 
+    std::vector<std::string> tx = {std::string(argv[2])};
+    std::vector<std::string> rx = {std::string(argv[3])};
     Kern->CalculateK0( tx, rx, false ); // 3rd argument is vtk output
 
     std::ofstream dout = std::ofstream(std::string("Rx-")+std::string(argv[3])+std::string(".dat"));
     for (auto lp : rx) {
         dout << lp << "\t";
     }
-    dout << "\n# Tolerance: " << tol << std::endl;
-
-        dout << interfaces.transpose() << std::endl;
-        dout << I.transpose() << std::endl;
+    dout << "\n# Tolerance: " << Kern->GetTolerance() << std::endl;
+        dout << Kern->GetInterfaces().transpose() << std::endl;
+        dout << Kern->GetPulseDuration()*Kern->GetPulseCurrent().transpose() << std::endl;
         dout << "#real\n";
         dout << Kern->GetKernel().real() << std::endl;
         dout << "#imag\n";
     //std::ofstream out = std::ofstream(std::string("k-coincident.yaml"));
     out << *Kern;
     out.close();
+
 }
 
 

include/KernelV0.h

         }
 
         /**
+         * @return the integration tolerance
+         */
+        inline Real GetTolerance ( ) {
+            return tol;
+        }
+
+        /**
+         * @return the layer interfaces
+         */
+        inline VectorXr GetInterfaces ( ) {
+            return Interfaces;
+        }
+
+        /**
+         * @return the pulse peak current
+         */
+        inline VectorXr GetPulseCurrent ( ) {
+            return PulseI;
+        }
+
+        /**
          * @param[in] value the 1D-EM model used for calculations
          */
         inline void SetLayeredEarthEM ( std::shared_ptr< LayeredEarthEM > value ) {
         Vector3r                                  Size;
         Vector3r                                  Origin;
 
-        VectorXr   PulseI;
-        VectorXr   Interfaces;
+        VectorXr                                  PulseI;
+        VectorXr                                  Interfaces;
 
-        MatrixXcr   Kern;
+        MatrixXcr                                 Kern;
 
         std::shared_ptr< LayeredEarthEM >         SigmaModel = nullptr;
         std::shared_ptr< FieldPoints >            cpoints = nullptr;

src/KernelV0.cpp

     // Description:  DeSerializing constructor (locked)
     //--------------------------------------------------------------------------------------
     KernelV0::KernelV0 (const YAML::Node& node, const ctor_key&) : LemmaObject(node) {
+        //node["PulseType"] = "FID";
+        Larmor = node["Larmor"].as<Real>();
+        Temperature = node["Temperature"].as<Real>();
+        tol = node["tol"].as<Real>();
+        minLevel = node["minLevel"].as<int>();
+        maxLevel = node["maxLevel"].as<int>();
+        Taup = node["Taup"].as<Real>();
+        PulseI = node["PulseI"].as<VectorXr>();
+        Interfaces = node["Interfaces"].as<VectorXr>();
+        Size = node["IntegrationSize"].as<Vector3r>();
+        Origin = node["IntegrationOrigin"].as<Vector3r>();
+
+        if (node["SigmaModel"]) {
+            if (node["SigmaModel"].Tag() == "LayeredEarthEM") {
+                SigmaModel = LayeredEarthEM::DeSerialize(node["SigmaModel"]);
+            } else {
+                SigmaModel = LayeredEarthEM::DeSerialize( YAML::LoadFile( node["SigmaModel"].as<std::string>() ));
+            }
+        }
+
+        if (node["Coils"]) {
+            for ( auto coil : node["Coils"] ) {
+                std::cout << "coil " << coil.first << coil.second << std::endl;
+                if ( coil.second.Tag() == "PolygonalWireAntenna" ) {
+                    TxRx[ coil.first.as<std::string>() ] = PolygonalWireAntenna::DeSerialize( coil.second );
+                } else {
+                    TxRx[ coil.first.as<std::string>() ] =
+                        PolygonalWireAntenna::DeSerialize( YAML::LoadFile(coil.second.as<std::string>()) );
+                }
+            }
+        }
 
     }  // -----  end of method KernelV0::KernelV0  (constructor)  -----
 
         node.SetTag( GetName() );
 
         // Coils Transmitters & Receivers
-        for ( auto txm : TxRx) {
-            node[txm.first] = txm.second->Serialize();
+        if (!TxRx.empty()) {
+            for ( auto txm : TxRx) {
+                node["Coils"][txm.first] = txm.second->Serialize();
+            }
         }
 
         // LayeredEarthEM
-        node["SigmaModel"] = SigmaModel->Serialize();
+        if (SigmaModel != nullptr) {
+            node["SigmaModel"] = SigmaModel->Serialize();
+        }
 
+        node["PulseType"] = "FID";
         node["Larmor"] = Larmor;
         node["Temperature"] = Temperature;
         node["tol"] = tol;
         node["minLevel"] = minLevel;
         node["maxLevel"] = maxLevel;
         node["Taup"] = Taup;
-
         node["PulseI"] = PulseI;
         node["Interfaces"] = Interfaces;
+        node["IntegrationSize"] = Size;
+        node["IntegrationOrigin"] = Origin;
 
-        for ( int ilay=0; ilay<Interfaces.size()-1; ++ilay ) {
-            node["Kern-" + to_string(ilay) ] = static_cast<VectorXcr>(Kern.row(ilay));
+        if (Kern.array().abs().any() > 1e-16) {
+            for ( int ilay=0; ilay<Interfaces.size()-1; ++ilay ) {
+                node["K0"]["layer-" + to_string(ilay) ] = static_cast<VectorXcr>(Kern.row(ilay));
+            }
         }
         return node;
     }		// -----  end of method KernelV0::Serialize  -----
     //       Class:  KernelV0
     //      Method:  DeSerialize
     //--------------------------------------------------------------------------------------
-    void KernelV0::CalculateK0 (const std::vector< std::string>& Tx, const std::vector<std::string >& Rx,
-            bool vtkOutput ) {
-
+    void KernelV0::CalculateK0 (const std::vector< std::string>& Tx,
+                                const std::vector<std::string >& Rx, bool vtkOutput ) {
         // Set up
         Larmor = SigmaModel->GetMagneticFieldMagnitude()*GAMMA; // in rad  2246.*2.*PI;
 
         std::cout << "Calculating K0 kernel\n";
         Kern = MatrixXcr::Zero( Interfaces.size()-1, PulseI.size() );
         for (ilay=0; ilay<Interfaces.size()-1; ++ilay) {
-            std::cout << "Layer " << ilay << "\tfrom " << Interfaces(ilay) <<" to "<< Interfaces(ilay+1) << std::endl;
+            std::cout << "Layer " << ilay << "\tfrom " << Interfaces(ilay) <<" to "
+                      << Interfaces(ilay+1) << std::endl;
             Size(2) = Interfaces(ilay+1) - Interfaces(ilay);
             Origin(2) = Interfaces(ilay);
             IntegrateOnOctreeGrid( vtkOutput );
             EvaluateKids2( Size, 0, cpos, VectorXcr::Ones(PulseI.size()), oct, curse );
 
             for (int iq=0; iq<PulseI.size(); ++iq) {
-
             // Fill in leaf data
             vtkDoubleArray* kr = vtkDoubleArray::New();
                 kr->SetNumberOfComponents(1);
                 hri->SetNumberOfComponents(3);
                 hri->SetName("Im($\\mathbf{\\mathcal{H}}_R$)");
                 hri->SetNumberOfTuples( oct->GetNumberOfLeaves() );
-
             //Real LeafVol(0);
             for (auto leaf : LeafDict) {
                 kr->InsertTuple1( leaf.first, std::real(leaf.second(iq)) );
             hri->Delete();
 
             }
-
             curse->Delete();
             oct->Delete();
         #else
 
         // Compute Mn0
         Vector3r Mn0 = ComputeMn0(1.0, B0);
-        //std::cout << "Mn0\t" << Mn0.transpose() << std::endl;
         Real Mn0Abs = Mn0.norm();
 
         // Compute phase delay