More work on Python wrapper

Modules/FDEM1D/include/DipoleSource.h

     ///           dipoles.
     // ==========================================================================
     class DipoleSource : public std::enable_shared_from_this<DipoleSource>,  LemmaObject {
+    //class DipoleSource : public LemmaObject {
 
         // ====================    FRIENDS     ======================
 

Modules/FDEM1D/python/pyFDEM1D.cpp

     m.doc() = "Python binding of Lemma::FDEM1D, additional details can be found at https://lemmasoftware.org";
 
 
-    py::class_<Lemma::WireAntenna, std::shared_ptr<Lemma::WireAntenna> > WireAntenna(m, "WireAntenna"); //, py::dynamic_attr());
+    py::class_<Lemma::WireAntenna, std::shared_ptr<Lemma::WireAntenna> > WireAntenna(m, "WireAntenna");
 
         // 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("Serialize", &Lemma::WireAntenna::Print, "YAML representation of the class")
         .def("__repr__", &Lemma::WireAntenna::Print)
 
         // modifiers
         .def("SetNumberOfPoints", &Lemma::WireAntenna::SetNumberOfPoints, "Sets the number of points comprising the antenna")
         .def("SetPoint", py::overload_cast<const int&, const Lemma::Real&, const Lemma::Real&, const Lemma::Real&>(&Lemma::WireAntenna::SetPoint), "Sets a point in the antenna")
-        .def("SetPoint", py::overload_cast<const int&, const Lemma::Vector3r&>(&Lemma::WireAntenna::SetPoint), "Sets a point in the antenna")
+        .def("SetPoint", py::overload_cast<const int&, const Lemma::Vector3r&>(&Lemma::WireAntenna::SetPoint),
+            "Sets a point in the antenna")
         .def("SetNumberOfTurns", &Lemma::WireAntenna::SetNumberOfTurns, "Sets the number of turns of the antenna")
-        .def("SetNumberOfFrequencies", &Lemma::WireAntenna::SetNumberOfFrequencies, "Sets the number of frequencies of the transmitter")
+        .def("SetNumberOfFrequencies", &Lemma::WireAntenna::SetNumberOfFrequencies,
+            "Sets the number of frequencies of the transmitter")
         .def("SetFrequency", &Lemma::WireAntenna::SetFrequency, "Sets a single frequency of the transmitter")
         .def("SetCurrent", &Lemma::WireAntenna::SetCurrent, "Sets the current of the transmitter in amps")
 
         .def("GetCurrent", &Lemma::WireAntenna::GetCurrent, "Returns the current of the transmitter in amps")
         .def("GetPoints", &Lemma::WireAntenna::GetPoints, "Returns the points defining the transmitter")
         .def("GetNumberOfDipoles", &Lemma::WireAntenna::GetNumberOfDipoles, "Returns the number of dipoles defining the transmitter")
-        .def("GetNumberOfFrequencies", &Lemma::WireAntenna::GetNumberOfFrequencies, "Returns the number of frequencies for the transmitter")
+        .def("GetNumberOfFrequencies", &Lemma::WireAntenna::GetNumberOfFrequencies,
+            "Returns the number of frequencies for the transmitter")
         .def("IsHorizontallyPlanar", &Lemma::WireAntenna::IsHorizontallyPlanar, "Returns true if the transmitter is flat")
         .def("GetName", &Lemma::WireAntenna::GetName, "Returns the class name of the object")
 
         // operations
-        .def("ApproximateWithElectricDipoles", &Lemma::WireAntenna::ApproximateWithElectricDipoles, "Approximates loop with electric dipoles")
+        .def("ApproximateWithElectricDipoles", &Lemma::WireAntenna::ApproximateWithElectricDipoles,
+            "Approximates loop with electric dipoles")
 
     ;
 
-    py::class_<Lemma::PolygonalWireAntenna, std::shared_ptr<Lemma::PolygonalWireAntenna> > PolygonalWireAntenna(m, "PolygonalWireAntenna", WireAntenna); //, py::dynamic_attr())
+    py::class_<Lemma::PolygonalWireAntenna, std::shared_ptr<Lemma::PolygonalWireAntenna> > PolygonalWireAntenna(m,
+            "PolygonalWireAntenna", WireAntenna);
 
         // 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")
+        .def_static("DeSerialize", py::overload_cast<const std::string&>(&Lemma::PolygonalWireAntenna::DeSerialize),
+            "Construct object from yaml representation")
 
         // print
         .def("__repr__", &Lemma::PolygonalWireAntenna::Print)
         // accessors
         .def("GetName", &Lemma::PolygonalWireAntenna::GetName, "Returns the name of the class")
 
-        // modifiers
-        //.def("SetNumberOfPoints", &Lemma::WireAntenna::SetNumberOfPoints, "Sets the number of points comprising the antenna")
-
         // operations
-        .def("ApproximateWithElectricDipoles", &Lemma::PolygonalWireAntenna::ApproximateWithElectricDipoles, "Approximates loop with series of electric dipoles around loop")
+        .def("ApproximateWithElectricDipoles", &Lemma::PolygonalWireAntenna::ApproximateWithElectricDipoles,
+            "Approximates loop with series of electric dipoles around loop")
 
     ;
 
+    //py::class_<Lemma::DipoleSource, std::shared_ptr<Lemma::DipoleSource> > DipoleSource(m, "DipoleSource");
+
+        // lifecycle
+        //DipoleSource.def(py::init(&Lemma::DipoleSource::NewSP))
+        //.def_static("DeSerialize", py::overload_cast<const std::string&>(&Lemma::DipoleSource::DeSerialize), "Construct object from yaml representation")
+
+        // print
+        //.def("Serialize", &Lemma::DipoleSource::Print, "YAML representation of the class")
+        //.def("__repr__", &Lemma::DipoleSource::Print)
+
+        //;
 }
 
 

Modules/LemmaCore/include/RectilinearGridReader.h

             static std::shared_ptr< RectilinearGridReader >  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<RectilinearGridReader> DeSerialize( const std::string& node ) {
+                return RectilinearGridReader::DeSerialize(YAML::Load(node));
+            }
+
+            /**
              *  Uses YAML to serialize this object.
              *  @return a YAML::Node
              */

Modules/LemmaCore/python/pyLemmaCore.cpp

 
         // lifecycle
         RectilinearGrid.def(py::init(&Lemma::RectilinearGrid::NewSP))
-        .def_static("DeSerialize", py::overload_cast<const std::string&>(&Lemma::RectilinearGrid::DeSerialize), "Construct object from yaml representation")
+        .def_static("DeSerialize", py::overload_cast<const std::string&>(&Lemma::RectilinearGrid::DeSerialize),
+            "Construct object from yaml representation")
 
         // print
         .def("__repr__", &Lemma::RectilinearGrid::Print)
         .def("SetSpacing", &Lemma::RectilinearGrid::SetSpacing, "Sets the grid spacing in x, y, and z")
     ;
 
+    py::class_<Lemma::RectilinearGridReader, std::shared_ptr<Lemma::RectilinearGridReader> > RectilinearGridReader(m, "RectilinearGridReader");
+
+        // lifecycle
+        RectilinearGridReader.def(py::init(&Lemma::RectilinearGridReader::NewSP))
+        .def_static("DeSerialize", py::overload_cast<const std::string&>(&Lemma::RectilinearGridReader::DeSerialize),
+            "Construct object from yaml representation")
+
+        // print
+        .def("__repr__", &Lemma::RectilinearGridReader::Print)
+        .def("Serialize", &Lemma::RectilinearGridReader::Print, "YAML representation of the class")
+
+        // accessors
+        .def("GetName", &Lemma::RectilinearGridReader::GetName, "Returns the name of the class")
+
+        // modifiers
+
+        //methods
+        .def("ReadASCIIGridFile", &Lemma::RectilinearGridReader::ReadASCIIGridFile, "Opens file specified by argument")
+
+        //methods
+        .def("GetGrid", &Lemma::RectilinearGridReader::GetGrid, "Returns the grid object")
+    ;
+
     py::class_<Lemma::ASCIIParser, std::shared_ptr<Lemma::ASCIIParser> > ASCIIParser(m, "ASCIIParser");
 
         // lifecycle
         ASCIIParser.def(py::init(&Lemma::ASCIIParser::NewSP))
-        .def_static("DeSerialize", py::overload_cast<const std::string&>(&Lemma::ASCIIParser::DeSerialize), "Construct object from yaml representation")
+        .def_static("DeSerialize", py::overload_cast<const std::string&>(&Lemma::ASCIIParser::DeSerialize),
+            "Construct object from yaml representation")
 
         // print
         .def("__repr__", &Lemma::ASCIIParser::Print)
 
         // lifecycle
         .def(py::init(&Lemma::CubicSplineInterpolator::NewSP))
-        .def_static("DeSerialize", py::overload_cast<const std::string&>(&Lemma::CubicSplineInterpolator::DeSerialize), "Construct object from yaml representation")
+        .def_static("DeSerialize", py::overload_cast<const std::string&>(&Lemma::CubicSplineInterpolator::DeSerialize),
+            "Construct object from yaml representation")
 
         // print
         .def("__repr__", &Lemma::CubicSplineInterpolator::Print)
 
         // 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")
+        .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")
+        .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")
 
     ;