Updates for python wrapping of LemmaCore

Modules/FDEM1D/python/pyFDEM1D.cpp

 
         // lifecycle
         WireAntenna.def(py::init(&Lemma::WireAntenna::NewSP))
+        .def("Serialize", &Lemma::WireAntenna::Print, "YAML representation of the class")
+        .def_static("DeSerialize", py::overload_cast<const std::string&>(&Lemma::WireAntenna::DeSerialize), "Construct object from yaml representation")
 
         // print
         .def("__repr__", &Lemma::WireAntenna::Print)
-        .def("Serialize", &Lemma::WireAntenna::Print, "YAML representation of the class")
-        .def_static("DeSerialize", py::overload_cast<const std::string&>(&Lemma::WireAntenna::DeSerialize), "Construct object from yaml representation")
 
         // modifiers
         .def("SetNumberOfPoints", &Lemma::WireAntenna::SetNumberOfPoints, "Sets the number of points comprising the antenna")
 
         // lifecycle
         PolygonalWireAntenna.def(py::init(&Lemma::PolygonalWireAntenna::NewSP))
+        .def_static("DeSerialize", py::overload_cast<const std::string&>(&Lemma::PolygonalWireAntenna::DeSerialize), "Construct object from yaml representation")
 
         // print
         .def("__repr__", &Lemma::PolygonalWireAntenna::Print)

Modules/LemmaCore/include/ASCIIParser.h

     static std::shared_ptr< ASCIIParser >  DeSerialize( const YAML::Node& node );
 
     /**
+     *   Constructs an object from a string representation of a YAML::Node. This is primarily
+     *   used in Python wrapping
+     */
+    static std::shared_ptr<ASCIIParser> DeSerialize( const std::string& node ) {
+        return ASCIIParser::DeSerialize(YAML::Load(node));
+    }
+
+    /**
      *  Uses YAML to serialize this object.
      *  @return a YAML::Node
      */

Modules/LemmaCore/include/CubicSplineInterpolator.h

      */
     static std::shared_ptr< CubicSplineInterpolator > DeSerialize(const YAML::Node& node);
 
+    /**
+     *   Constructs an object from a string representation of a YAML::Node. This is primarily
+     *   used in Python wrapping
+     */
+    static std::shared_ptr<CubicSplineInterpolator> DeSerialize( const std::string& node ) {
+        return CubicSplineInterpolator::DeSerialize(YAML::Load(node));
+    }
+
     // ====================  OPERATORS     =======================
 
     // ====================  OPERATIONS    =======================

Modules/LemmaCore/include/RectilinearGrid.h

              */
             static std::shared_ptr< RectilinearGrid > DeSerialize(const YAML::Node& node);
 
+            /**
+             *   Constructs an object from a string representation of a YAML::Node. This is primarily
+             *   used in Python wrapping
+             */
+            static std::shared_ptr<RectilinearGrid> DeSerialize( const std::string& node ) {
+                return RectilinearGrid::DeSerialize(YAML::Load(node));
+            }
+
             // ====================  OPERATORS     =======================
 
             // ====================  OPERATIONS    =======================

Modules/LemmaCore/python/pyLemmaCore.cpp

 
     m.doc() = "Python binding of LemmaCore, additional details can be found at https://lemmasoftware.org";
 
-    py::class_<Lemma::RectilinearGrid, std::shared_ptr<Lemma::RectilinearGrid> >(m, "RectilinearGrid")
+    py::class_<Lemma::RectilinearGrid, std::shared_ptr<Lemma::RectilinearGrid> > RectilinearGrid(m, "RectilinearGrid");
 
         // lifecycle
-        .def(py::init(&Lemma::RectilinearGrid::NewSP))
+        RectilinearGrid.def(py::init(&Lemma::RectilinearGrid::NewSP))
+        .def_static("DeSerialize", py::overload_cast<const std::string&>(&Lemma::RectilinearGrid::DeSerialize), "Construct object from yaml representation")
 
         // print
         .def("__repr__", &Lemma::RectilinearGrid::Print)
         // modifiers
         .def("SetDimensions", &Lemma::RectilinearGrid::SetDimensions, "Sets the number of cells in x, y, and z")
         .def("SetOffset", &Lemma::RectilinearGrid::SetOffset, "Sets the origin offset in x, y, and z")
-        .def("SetSpacing", &Lemma::RectilinearGrid::SetSpacing, "Sets the grid spacing in x, y, and z");
+        .def("SetSpacing", &Lemma::RectilinearGrid::SetSpacing, "Sets the grid spacing in x, y, and z")
+    ;
 
-    py::class_<Lemma::ASCIIParser, std::shared_ptr<Lemma::ASCIIParser> >(m, "ASCIIParser")
+    py::class_<Lemma::ASCIIParser, std::shared_ptr<Lemma::ASCIIParser> > ASCIIParser(m, "ASCIIParser");
 
         // lifecycle
-        .def(py::init(&Lemma::ASCIIParser::NewSP))
+        ASCIIParser.def(py::init(&Lemma::ASCIIParser::NewSP))
+        .def_static("DeSerialize", py::overload_cast<const std::string&>(&Lemma::ASCIIParser::DeSerialize), "Construct object from yaml representation")
 
         // print
         .def("__repr__", &Lemma::ASCIIParser::Print)
         .def("JumpToLocation", &Lemma::ASCIIParser::JumpToLocation, "File object jumps to specified location")
 
     ;
-}
-
 
-/*
-BOOST_PYTHON_MODULE(pyLemmaCore)
-{
-    Py_Initialize();
-    np::initialize();
+    py::class_<Lemma::CubicSplineInterpolator, std::shared_ptr<Lemma::CubicSplineInterpolator> >(m, "CubicSplineInterpolator")
 
- 	bp::class_<Lemma::RectilinearGrid, boost::noncopyable> ("RectilinearGrid", boost::python::no_init)
+        // lifecycle
+        .def(py::init(&Lemma::CubicSplineInterpolator::NewSP))
+        .def_static("DeSerialize", py::overload_cast<const std::string&>(&Lemma::CubicSplineInterpolator::DeSerialize), "Construct object from yaml representation")
 
         // print
-        .def(boost::python::self_ns::str(bp::self))
+        .def("__repr__", &Lemma::CubicSplineInterpolator::Print)
+        .def("Serialize", &Lemma::CubicSplineInterpolator::Print, "YAML representation of the class")
+
+        // accessors
+        .def("GetName", &Lemma::CubicSplineInterpolator::GetName, "Returns the name of the class")
+        .def("GetKnotAbscissa", &Lemma::CubicSplineInterpolator::GetKnotAbscissa, "Returns the knot abscissa values")
+        .def("GetKnotOrdinate", &Lemma::CubicSplineInterpolator::GetKnotOrdinate, "Returns the knot ordinate values")
+
+        // modifiers
+        .def("SetKnots", &Lemma::CubicSplineInterpolator::SetKnots, "Sets the knots to use for interpolation")
+        .def("ResetKnotOrdinate", &Lemma::CubicSplineInterpolator::ResetKnotOrdinate, "Resets the knots to use for interpolation, when abscissa values haven't changed")
+
+        // methods
+        .def("InterpolateOrderedSet", &Lemma::CubicSplineInterpolator::InterpolateOrderedSet, "Interpolate a monotonically increasing ordered set.")
+        .def("Integrate", py::overload_cast<const Lemma::Real&, const Lemma::Real& >(&Lemma::CubicSplineInterpolator::Integrate), "Integrates between the arguments using cubic spline values.")
+        .def("IntegrateN", py::overload_cast<const Lemma::Real&, const Lemma::Real&, const int& >(&Lemma::CubicSplineInterpolator::Integrate), "Integrates the spline from x0 to x1. Uses composite Simpson's rule and n is the number of segments")
+        .def("Interpolate", py::overload_cast<const Lemma::Real& >(&Lemma::CubicSplineInterpolator::Interpolate), "Interpolation at a single point, x is the interpolation abscissa point, returns the ordinate value at x")
+        .def("InterpolateI", py::overload_cast<const Lemma::Real&, int& >(&Lemma::CubicSplineInterpolator::Interpolate), "Interpolation at a single point, x is the interpolation abscissa point and i is the knot to begin searchin at returns the ordinate value at x")
+
+    ;
 
-        // Lifecycle
-        .def("__init__", boost::python::make_constructor(&Lemma::RectilinearGrid::NewSP))
-        //.def("Serialize", &Lemma::RectilinearGrid::Serialize)
-        //.def("DeSerialize", &Lemma::RectilinearGrid::DeSerialize)
+    // ABC
+    //py::class_<Lemma::EarthModel, std::shared_ptr<Lemma::EarthModel> >(m, "EarthModel")
+
+    /*
+    py::class_<Lemma::LayeredEarth, std::shared_ptr<Lemma::LayeredEarth> >(m, "LayeredEarth")
+
+        // lifecycle
+        .def(py::init(&Lemma::LayeredEarth::NewSP))
+        //.def_static("DeSerialize", py::overload_cast<const std::string&>(&Lemma::LayeredEarth::DeSerialize), "Construct object from yaml representation")
+
+        // print
+        .def("__repr__", &Lemma::LayeredEarth::Print)
+        .def("Serialize", &Lemma::LayeredEarth::Print, "YAML representation of the class")
 
-        // Accessors
     ;
+    */
 }
-*/
+

python/pyLemma/__init__.py

+# Import the most used portions of Lemma automatically 
+from . import LemmaCore 
+from . import FDEM1D