Imporovements still coming to kernel calculation

examples/KernelV0.cpp

     // may be more natural to work with?
     std::vector<std::string> tx = {std::string("Coil 1")};
     std::vector<std::string> rx = {std::string("Coil 1")};
-    Kern->CalculateK0( tx, rx , false ); //, false );
+    Kern->CalculateK0( tx, rx , true ); //, false );
     //Kern->CalculateK0( "Coil 1", "Coil 1" );
 
 }

src/KernelV0.cpp

                 // TODO query for method, altough with flat antennae, this is fastest
                 EMEarths.back()->SetHankelTransformMethod(ANDERSON801);
         }
-        IntegrateOnOctreeGrid( 1e-1, vtkOutput );
+        IntegrateOnOctreeGrid( 1e-5, vtkOutput );
 
     }
 
 
         this->tol = tolerance;
         //Vector3r                Size;
-            Size << 200,200,100;
+            Size << 200,200,200;
         //Vector3r                Origin;
-            Origin << 0,0,0;
+            Origin << 0,0,1.0;
         Vector3r                cpos;  // centre position
             //cpos << 100,100,50;
             cpos = (Size-Origin).array() / 2.;
         //return Complex(volume*Bt.norm());
         return Complex(volume*Bt.norm());
         //return Complex(volume);
+
+//        Vn(ir) = ComputeV0Cell(Bt, Br, volume, 1.0);
     }
 
     //--------------------------------------------------------------------------------------
     bool KernelV0::EvaluateKids( const Vector3r& size, const int& level, const Vector3r& cpos,
         const Complex& parentVal ) {
 
+        std::cout << "\r" << (int)(1e2*VOLSUM/(Size[0]*Size[1]*Size[2])) << "\t" << nleaves;
+        std::cout.flush();
+
         // Next level step, interested in one level below
         // bitshift requires one extra, faster than, and equivalent to std::pow(2, level+1)
         Vector3r step  = size.array() / (Real)(1 << (level+1) );
     bool KernelV0::EvaluateKids2( const Vector3r& size, const int& level, const Vector3r& cpos,
         const Complex& parentVal, vtkHyperOctree* oct, vtkHyperOctreeCursor* curse) {
 
-        //std::cout << "\rlevel " << level << "\t" << nleaves;
-        //std::cout.flush();
+        std::cout << "\r" << (int)(1e2*VOLSUM/(Size[0]*Size[1]*Size[2])) << "\t" << nleaves;
+        std::cout.flush();
 
         // Next level step, interested in one level below
         // bitshift requires one extra, faster than, and equivalent to std::pow(2, level+1)
                 curse->ToChild(ichild);
                 Vector3r cp = pos; // Eigen complains about combining these
                 cp += posadd.row(ichild);
+                // Testing for position via alternative means
                 //Real p[3];
                 //GetPosition(curse, p);
                 //std::cout << cp[0] << "\t" << p[0] << "\t" << cp[1] << "\t" << p[1] << "\t" << cp[2] << "\t" << p[2] << "\t" <<  vol<< std::endl;
         return true;       // leaf
     }
 
+    //--------------------------------------------------------------------------------------
+    //       Class:  KernelV0
+    //      Method:  GetPosition
+    //--------------------------------------------------------------------------------------
     void KernelV0::GetPosition( vtkHyperOctreeCursor* Cursor, Real* p ) {
         Real ratio=1.0/(1<<(Cursor->GetCurrentLevel()));
         //step  = ((Size).array() / std::pow(2.,Cursor->GetCurrentLevel()));