version bump

CMakeLists.txt

 # Configure Merlin 
 set(MERLIN_VERSION_MAJOR "0")
-set(MERLIN_VERSION_MINOR "0")
-set(MERLIN_VERSION_PATCH "4")
+set(MERLIN_VERSION_MINOR "1")
+set(MERLIN_VERSION_PATCH "0")
 set(MERLIN_VERSION "\"${MERLIN_VERSION_MAJOR}.${MERLIN_VERSION_MINOR}.${MERLIN_VERSION_PATCH}\"")
 set(MERLIN_VERSION_NOQUOTES "${MERLIN_VERSION_MAJOR}.${MERLIN_VERSION_MINOR}.${MERLIN_VERSION_PATCH}")
 

include/KernelV0.h

         }		// -----  end of method KernelV0::set_SigmaModel  -----
 
         /**
-         *
+         *  @param[in] size the size of the volume to be integrated
          */
         inline void SetIntegrationSize ( const Vector3r& size ) {
             Size = size;
         }		// -----  end of method KernelV0::SetIntegrationSize  -----
 
         /**
-         *
+         * @param[in] type The type of Hankel transform that will be used.
+         */
+        inline void SetHankelTransformType ( const HANKELTRANSFORMTYPE& type ) {
+            HankelType = type;
+            return ;
+        }		// -----  end of method KernelV0::SetIntegrationOrigin  -----
+
+
+        /**
+         * @param[in] min is the minimum leaf level, defaults to 0
+         */
+        inline void SetMinLevel ( const int& min ) {
+            minLevel = min;
+            return ;
+        }		// -----  end of method KernelV0::SetMinLevel  -----
+
+        /**
+         * @param[in] max is the maximum leaf level, defaults to 12
+         */
+        inline void SetMaxLevel ( const int& max ) {
+            maxLevel = max;
+            return ;
+        }		// -----  end of method KernelV0::SetMaxLevel  -----
+
+        /**
+         *  @param[in] origin The origin location (corner) for the integration volume
          */
         inline void SetIntegrationOrigin ( const Vector3r& origin ) {
             Origin = origin;
         }		// -----  end of method KernelV0::SetIntegrationOrigin  -----
 
         /**
-         *
+         * @param[in] Amps is the current for each pulse moment
          */
         inline void SetPulseCurrent ( const VectorXr& Amps ) {
             PulseI = Amps;
 
         MatrixXcr                                 Kern;
 
+        HANKELTRANSFORMTYPE                       HankelType=ANDERSON801;
+
         std::shared_ptr< LayeredEarthEM >         SigmaModel = nullptr;
         std::shared_ptr< FieldPoints >            cpoints = nullptr;
 

python/pyMerlin.cpp

             .def("SetPulseCurrent", &Lemma::KernelV0::SetPulseCurrent, "Sets the current of the pulses")
             .def("SetTemperature", &Lemma::KernelV0::SetTemperature, "Sets the temperature, in K")
             .def("SetTolerance", &Lemma::KernelV0::SetTolerance, "Sets the tolerance used in octree splitting")
+            .def("SetMinLevel", &Lemma::KernelV0::SetMinLevel, "Sets the minimum leaf level used in octree splitting")
+            .def("SetMaxLevel", &Lemma::KernelV0::SetMaxLevel, "Sets the maximum leaf level used in octree splitting")
             .def("SetPulseDuration", &Lemma::KernelV0::SetPulseDuration, "Sets the duration of the pulse")
             .def("SetDepthLayerInterfaces", &Lemma::KernelV0::SetDepthLayerInterfaces, "Sets the layer depth interfaces")
+            .def("SetHankelTransformType", &Lemma::KernelV0::SetHankelTransformType, "Sets the Hankel transform type")
 
             // accessors
             .def("GetName", &Lemma::KernelV0::GetName, "Returns the name of the class")

src/KernelV0.cpp

     //--------------------------------------------------------------------------------------
     KernelV0::KernelV0 (const YAML::Node& node, const ctor_key& key) : MerlinObject(node, key) {
 
-        std::cout << "DESERIALIZING" << std::endl;
-
         //node["PulseType"] = "FID";
         Larmor = node["Larmor"].as<Real>();
         Temperature = node["Temperature"].as<Real>();
                 EMEarths[tx]->AttachLayeredEarthEM(SigmaModel);
                 EMEarths[tx]->AttachFieldPoints( cpoints );
          		EMEarths[tx]->SetFieldsToCalculate(H);
-                // TODO query for method, altough with flat antennae, this is fastest
-                //EMEarths[tx]->SetHankelTransformMethod(FHTKEY201);
-                EMEarths[tx]->SetHankelTransformMethod(ANDERSON801);
+                // TODO query for method
+                //EMEarths[tx]->SetHankelTransformMethod(ANDERSON801);
+                EMEarths[tx]->SetHankelTransformMethod(HankelType);
                 EMEarths[tx]->SetTxRxMode(TX);
                 TxRx[tx]->SetCurrent(1.);
         }
                     EMEarths[rx]->AttachLayeredEarthEM(SigmaModel);
                     EMEarths[rx]->AttachFieldPoints( cpoints );
          		    EMEarths[rx]->SetFieldsToCalculate(H);
-                    // TODO query for method, altough with flat antennae, this is fastest
-                    //EMEarths[rx]->SetHankelTransformMethod(FHTKEY201);
-                    EMEarths[rx]->SetHankelTransformMethod(ANDERSON801);
+                    // TODO query for method
+                    //EMEarths[rx]->SetHankelTransformMethod(ANDERSON801);
+                    EMEarths[rx]->SetHankelTransformMethod(HankelType);
                     EMEarths[rx]->SetTxRxMode(RX);
                     TxRx[rx]->SetCurrent(1.);
             }
 
         std::cout << "Calculating K0 kernel\n";
         Kern = MatrixXcr::Zero( Interfaces.size()-1, PulseI.size() );
+        //for (ilay=0; ilay<Interfaces.size()-1; ++ilay) {
         for (ilay=0; ilay<Interfaces.size()-1; ++ilay) {
             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 );
+            //std::cout << "Kernel row " << Kern.row(ilay);
         }
         std::cout << "\nFinished KERNEL\n";
     }