Ternary array modifications

examples/Interference.cpp

         Kern->PushCoil( "Coil 2", Tx2 );
         Kern->SetLayeredEarthEM( earth );
 
-        Kern->SetIntegrationSize( (Vector3r()   << 50,200,50).finished() );
-        Kern->SetIntegrationOrigin( (Vector3r() << 0, 0, 0.1).finished() );
+        Kern->SetIntegrationSize( (Vector3r()   << 50,200,10).finished() );
+        Kern->SetIntegrationOrigin( (Vector3r() << 0, 0, 50).finished() );
         Kern->SetTolerance( 1e-5 ); // 1e-12
 
     std::vector<std::string> tx = {std::string("Coil 1")};//,std::string("Coil 2")};
     std::vector<std::string> rx = {std::string("Coil 2")};
     VectorXr Offsets = VectorXr::LinSpaced(61, 0.00, 60.0); // nbins, low, high
 
-    auto outfile = std::ofstream("interference-opposed.dat");
+    //auto outfile = std::ofstream("interference-opposed.dat");
+    auto outfile = std::ofstream("interference-50-60.dat");
     for (int ii=0; ii< Offsets.size(); ++ii) {
-        MoveLoop(Tx2, 21, 15, 50, 50 + Offsets(ii), Larmor, -1.);
-        #ifdef LEMMAUSEVTK
-        Complex coupling = Kern->Calculate( tx, rx, true );
-        #else
+        MoveLoop(Tx2, 21, 15, 50, 50 + Offsets(ii), Larmor, 1.);
+        //#ifdef LEMMAUSEVTK
+        //Complex coupling = Kern->Calculate( tx, rx, true );
+        //#else
         Complex coupling = Kern->Calculate( tx, rx, false );
-        #endif
+        //#endif
         std::cout << "coupling " << coupling << std::endl;
         outfile << Offsets(ii) << "\t" <<  std::real(coupling) << "\t" << std::imag(coupling) << std::endl;
     }

examples/KV0-3loops.cpp

     // 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::string("Coil 2"), std::string("Coil 3") };
-    std::vector<std::string> rx = {std::string("Coil 1"), std::string("Coil 2"), std::string("Coil 3") };
+    std::vector<std::string> rx = {std::string("Coil 1"), std::string("Coil 3")};
+    //std::vector<std::string> rx = {std::string("Coil 1"), std::string("Coil 2"), std::string("Coil 3") };
     //std::vector<std::string> rx = {std::string("Coil 1"), std::string("Coil 2")};//, std::string("Coil 3") };
     //std::vector<std::string> rx = {std::string(argv[3])};
-    Kern->CalculateK0( tx, rx, true );
+    Kern->CalculateK0( tx, rx, false );
 
-    std::ofstream dout = std::ofstream(std::string("k0-3Tx-RxCh-") + std::string(argv[3]) + std::string("-tol") + std::string(argv[1])+ std::string(".dat"));
+    //std::ofstream dout = std::ofstream(std::string("k0-3Tx-RxCh-") + std::string(argv[3]) + std::string("-tol") + std::string(argv[1])+ std::string(".dat"));
+    std::ofstream dout = std::ofstream(std::string("k0-3Tx-RxCh-13") + std::string("-off-") + std::string(argv[1])+ std::string(".dat"));
     dout << "# Transmitters: ";
     for (auto lp : tx) {
         dout << lp << "\t";
     dout << "\n# Tolerance: " << tol << std::endl;
     dout << "# Offset: " << offset << std::endl;
     dout << "# Radius: " << 15 << std::endl;
-    //std::ofstream dout = std::ofstream(std::string("k-coincident.dat"));
         dout << interfaces.transpose() << std::endl;
-        dout << I.transpose() << std::endl;
+        dout << Kern->GetPulseDuration()*I.transpose() << std::endl;
         dout << "#real\n";
         dout << Kern->GetKernel().real() << std::endl;
         dout << "#imag\n";
         dout.close();
 
     //std::ofstream out = std::ofstream(std::string("k0-3Tx-RxCh1-")+std::string(argv[1])+std::string(".yaml"));
+    std::ofstream out = std::ofstream(std::string("k0-3Tx-RxCh-13") + std::string("-off-") + std::string(argv[1])+ std::string(".yaml"));
     //std::ofstream out = std::ofstream(std::string("k-coincident.yaml"));
-    //out << *Kern;
-    //out.close();
+    out << *Kern;
+    out.close();
 }
 
 std::shared_ptr<Lemma::PolygonalWireAntenna> CircularLoop ( int nd, Real Radius, Real Offsetx, Real Offsety ) {

include/KernelV0.h

             Taup = taup;
         }
 
+        inline Real GetPulseDuration( ) {
+            return Taup;
+        }
+
         inline void SetDepthLayerInterfaces( const VectorXr& iface ){
             Interfaces = iface;
         }

src/LoopInteractions.cpp

 
     template <>
     Complex LoopInteractions<INTERFERENCE>::f( const Vector3r& r, const Real& volume, const Vector3cr& Ht, const Vector3cr& Hr ) {
-        //return volume * (1.-((Ht+Hr).norm()/(Hr.norm() + Ht.norm()))); // normalized interference
-        return volume * (Ht+Hr).norm();  // interference not normalized
+        //return volume * (1.-((Ht+Hr).norm()/(Hr.norm() + Ht.norm())));     // normalized interference
+        return volume * ( (Ht+Hr).norm() - std::max(Hr.norm(), Ht.norm()) ); // interference emphisized
+        //return volume * (Ht+Hr).norm();  // interference not normalized
     }
 
     template <>