EMEarth1D functional in pyLemma

Modules/FDEM1D/include/EMEarth1D.h

              */
             YAML::Node Serialize() const;
 
+            // TODO, add this
             //static EMEarth1D* DeSerialize(const YAML::Node& node);
 
             // ====================  OPERATORS     ===========================
             // ====================  ACCESS        ===========================
 
             /** Attaches an antennae */
-            void AttachWireAntenna( std::shared_ptr<WireAntenna> antennae);
+            void AttachWireAntenna( std::shared_ptr<WireAntenna> antennae );
 
             /** Attaches a dipole for calculation */
-            void AttachDipoleSource( std::shared_ptr<DipoleSource> dipole);
+            void AttachDipoleSource( std::shared_ptr<DipoleSource> dipole );
 
             /** Attaches a layered earth model for calculation */
-            void AttachLayeredEarthEM( std::shared_ptr<LayeredEarthEM> Earth);
+            void AttachLayeredEarthEM( std::shared_ptr<LayeredEarthEM> Earth );
 
             /** Attaches a set of receiver points for calculation */
-            void AttachFieldPoints( std::shared_ptr<FieldPoints> Receivers);
+            void AttachFieldPoints( std::shared_ptr<FieldPoints> Receivers );
 
             /** Sets the fields that are calcultated, E,H or BOTH */
-            void SetFieldsToCalculate(const FIELDCALCULATIONS &calc);
+            void SetFieldsToCalculate( const FIELDCALCULATIONS &calc );
 
             /** Sets the method to use to evaluate the Hankel integral,
              */
-            void SetHankelTransformMethod(const HANKELTRANSFORMTYPE &type);
+            void SetHankelTransformMethod( const HANKELTRANSFORMTYPE &type );
 
             /**
              *   Accesor for field points

Modules/FDEM1D/include/FieldPoints.h

              */
             static std::shared_ptr<FieldPoints> 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<FieldPoints> DeSerialize( const std::string& node ) {
+                return FieldPoints::DeSerialize(YAML::Load(node));
+            }
+
             // ====================  OPERATORS     ===========================
 
             // ====================  OPERATIONS    ===========================
             /// Returns the number of receiverpoints.
             int GetNumberOfPoints();
 
-            /// Returns all the receiver locations as a 3 X matrix
-            Vector3Xr GetLocations();
-
-            /// Returns all the receiver locations as a general matrix, useful for python wrapper
-            MatrixXr GetLocationsMat();
+            /// Returns all of the computed E fields. Every frequency
+            std::vector<Vector3Xcr> GetEfield( );
 
             /// Returns the E field for all locations
             /// nfreq is the freqency desired
             /// nfreq is the freqency desired, cast to general dynamic matrix, for python interoperability
             MatrixXcr GetEfieldMat(const int &nfreq);
 
-            /// Returns the H field for all locations
-            /// nfreq is the freqency desired, cast to general dynamic matrix, for python interoperability
-            MatrixXcr GetHfieldMat(const int &nfreq);
-
-            /// Returns the H field for all locations
+            /// Returns the E field of a single receiver as an Eigen Vector
             /// nfreq is the freqency desired
-            Vector3Xcr GetHfield(const int &nfreq);
+            Vector3cr GetEfield(const int &nfreq, const int& loc);
 
             /// Returns all of the computed H fields. Every frequency
             std::vector<Vector3Xcr> GetHfield( );
 
-            /// Returns all of the computed E fields. Every frequency
-            std::vector<Vector3Xcr> GetEfield( );
-
-            /// Returns the E field of a single receiver as an Eigen Vector
+            /// Returns the H field for all locations
             /// nfreq is the freqency desired
-            Vector3cr GetEfield(const int &nfreq, const int& loc);
+            Vector3Xcr GetHfield(const int &nfreq);
+
+            /// Returns the H field for all locations
+            /// nfreq is the freqency desired, cast to general dynamic matrix, for python interoperability
+            MatrixXcr GetHfieldMat(const int &nfreq);
 
             /// Returns the H field of a single receiver as an Eigen Vector
             /// nfreq is the freqency desired
                 const VectorXr& Freqs);
             #endif
 
+            /// Returns all the receiver locations as a 3 X matrix
+            Vector3Xr GetLocations();
+
+            /// Returns all the receiver locations as a general matrix, useful for python wrapper
+            MatrixXr GetLocationsMat();
+
             /// Returns the location of a single receiver as an Eigen Vector
             Vector3r GetLocation(const int& loc);
 

Modules/FDEM1D/python/pyFDEM1D.cpp

         .def("__repr__", &Lemma::WireAntenna::Print)
 
         // modifiers
-        .def("SetNumberOfPoints", &Lemma::WireAntenna::SetNumberOfPoints, "Sets the number of points comprising the antenna")
+        .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 all frequencies, argument is numpy array of frequencies")
         ;
 
-    py::class_<Lemma::LayeredEarthEM, std::shared_ptr<Lemma::LayeredEarthEM> > LayeredEarthEM(m, "LayeredEarthEM");
+    py::class_<Lemma::LayeredEarthEM, std::shared_ptr<Lemma::LayeredEarthEM> >
+        LayeredEarthEM(m, "LayeredEarthEM");
 
         // lifecycle
         LayeredEarthEM.def(py::init(&Lemma::LayeredEarthEM::NewSP))
-        .def_static("DeSerialize", py::overload_cast<const std::string&>(&Lemma::LayeredEarthEM::DeSerialize),
-            "Construct object from yaml representation")
+        .def_static("DeSerialize", py::overload_cast<const std::string&>
+            (&Lemma::LayeredEarthEM::DeSerialize),"Construct object from yaml representation")
 
         // print
         .def("Serialize", &Lemma::LayeredEarthEM::Print, "YAML representation of the class")
 
 
         // modifiers
-        .def("SetNumberOfLayers", &Lemma::LayeredEarthEM::SetNumberOfLayers, "Sets the number of layers in the model")
+        .def("SetNumberOfLayers", &Lemma::LayeredEarthEM::SetNumberOfLayers,
+            "Sets the number of layers in the model")
         .def("SetLayerConductivity", py::overload_cast< const Lemma::VectorXcr& >(&Lemma::LayeredEarthEM::SetLayerConductivity),
             "Sets the conductivity of the layers, the input is a complex array of conductivity")
         .def("SetLayerConductivity1", py::overload_cast< const int&, const Lemma::Complex& >(&Lemma::LayeredEarthEM::SetLayerConductivity),
         // methods
         .def("EvaluateColeColeModel", &Lemma::LayeredEarthEM::EvaluateColeColeModel,
             "Calculates complex resistivity based on cole-cole parameters")
+        ;
+
+    py::class_<Lemma::EMEarth1D, std::shared_ptr<Lemma::EMEarth1D> >
+        EMEarth1D(m, "EMEarth1D");
 
+        // lifecycle
+        EMEarth1D.def(py::init(&Lemma::EMEarth1D::NewSP))
+        //.def_static("DeSerialize", py::overload_cast<const std::string&>
+        //    (&Lemma::EMEarth1D::DeSerialize),"Construct object from yaml representation")
+
+        // print
+        .def("Serialize", &Lemma::EMEarth1D::Print, "YAML representation of the class")
+        .def("__repr__", &Lemma::EMEarth1D::Print)
 
+        // accessors
+        .def("GetName", &Lemma::EMEarth1D::GetName, "Returns the name of the class")
+        .def("GetFieldPoints", &Lemma::EMEarth1D::GetFieldPoints, "Returns the FieldPoint class")
+
+        // modifiers
+        .def("AttachWireAntenna", &Lemma::EMEarth1D::AttachWireAntenna,
+            "Sets the wire antenna to use for calculations")
+        .def("AttachDipoleSOurce", &Lemma::EMEarth1D::AttachDipoleSource,
+            "Sets a DipoleSource to use for calculations")
+        .def("AttachFieldPoints", &Lemma::EMEarth1D::AttachFieldPoints,
+            "Sets the FieldPoints to use for calculations")
+        .def("AttachLayeredEarthEM", &Lemma::EMEarth1D::AttachLayeredEarthEM,
+            "Sets the LayeredEarthEM to use for calculations")
+
+        .def("SetFieldToCalculate", &Lemma::EMEarth1D::SetFieldsToCalculate,
+            "Sets which fields to calculate")
+        .def("SetHankelTransformMethod", &Lemma::EMEarth1D::SetHankelTransformMethod,
+            "Sets which Hankel transform to use")
+        .def("SetTxRxMode", &Lemma::EMEarth1D::SetTxRxMode,
+            "Sets the TxRx mode flag")
+
+        //methods
+#ifdef KIHALEE_EM1D
+        .def("MakeCalc", &Lemma::EMEarth1D::MakeCalc, "Calls KiHa Lee's EM1D FORTRAN77 code")
+#endif
+
+        .def("MakeCalc3", &Lemma::EMEarth1D::MakeCalc3, "Native Lemma EM calculation")
+        .def("CalculateWireAntennaFields", &Lemma::EMEarth1D::CalculateWireAntennaFields,
+            "Native Lemma calculation of a wire antenna")
         ;
 
+    py::class_<Lemma::FieldPoints, std::shared_ptr<Lemma::FieldPoints> >
+        FieldPoints(m, "FieldPoints");
+
+        // lifecycle
+        FieldPoints.def(py::init(&Lemma::FieldPoints::NewSP))
+        .def_static("DeSerialize", py::overload_cast<const std::string&>
+            (&Lemma::FieldPoints::DeSerialize),"Construct object from yaml representation")
+
+        // print
+        .def("Serialize", &Lemma::FieldPoints::Print, "YAML representation of the class")
+        .def("__repr__", &Lemma::FieldPoints::Print)
+
+        // modifiers
+        .def("SetNumberOfPoints", &Lemma::FieldPoints::SetNumberOfPoints,
+            "Sets the number of locations to make calculations on.")
+        .def("SetLocation", py::overload_cast< const int&, const Lemma::Vector3r& >
+            (&Lemma::FieldPoints::SetLocation), "Sets the location of the index-specified point." )
+        .def("SetLocation", py::overload_cast< const int&,
+                    const Lemma::Real&, const Lemma::Real&, const Lemma::Real& >
+            (&Lemma::FieldPoints::SetLocation),
+            "Sets the location of the index-specified point with the three coordinates")
+
+        // accessors
+        .def("GetNumberOfPoints", &Lemma::FieldPoints::GetNumberOfPoints,
+            "Returns the number of locations to make calculations on.")
+        .def("GetLocations", &Lemma::FieldPoints::GetLocations,
+            "Returns the locations which calculations are made on.")
+        .def("GetLocationsMat", &Lemma::FieldPoints::GetLocationsMat,
+            "Returns a matrix of the locations which calculations are made on.")
+        .def("GetLocation", &Lemma::FieldPoints::GetLocation,
+            "Returns the location of the specified index.")
+        .def("GetLocationX", &Lemma::FieldPoints::GetLocationX,
+            "Returns the northing (x) location of the specified index.")
+        .def("GetLocationY", &Lemma::FieldPoints::GetLocationY,
+            "Returns the easting (y) location of the specified index.")
+        .def("GetLocationZ", &Lemma::FieldPoints::GetLocationZ,
+            "Returns the altitude/depth (z) location of the specified index.")
+        .def("GetEfield", py::overload_cast<  > (&Lemma::FieldPoints::GetEfield),
+            "Returns the electric field for all frequencies.")
+        .def("GetEfield", py::overload_cast< const int& > (&Lemma::FieldPoints::GetEfield),
+            "Returns the electric field for the specified frequency index.")
+        .def("GetEfield", py::overload_cast< const int&, const int& > (&Lemma::FieldPoints::GetEfield),
+            "Returns the electric field for the specified frequency and location index.")
+        .def("GetEfieldMat", &Lemma::FieldPoints::GetEfieldMat,
+            "Returns the electric field for the specified frequency.")
+        .def("GetHfield", py::overload_cast<  > (&Lemma::FieldPoints::GetHfield),
+            "Returns the H field for all frequencies.")
+        .def("GetHfield", py::overload_cast< const int& > (&Lemma::FieldPoints::GetHfield),
+            "Returns the H field for the specified frequency index.")
+        .def("GetHfield", py::overload_cast< const int&, const int& > (&Lemma::FieldPoints::GetHfield),
+            "Returns the H field for the specified frequency and location index.")
+        //.def("GetBfield", py::overload_cast< const int&, const int& > (&Lemma::FieldPoints::GetBfield),
+        //    "Returns the magnetic (B) field for the specified frequency and location index.")
+        .def("GetHfieldMat", &Lemma::FieldPoints::GetHfieldMat,
+            "Returns the H field for the specified frequency.")
+        .def("GetMask", &Lemma::FieldPoints::MaskPoint, "Return the mask boolean value for the specified index")
+
+        // methods
+        .def("ClearFields", &Lemma::FieldPoints::ClearFields, "Clears calculated fields")
+        .def("MaskPoint", &Lemma::FieldPoints::MaskPoint, "Masks the index resulting in no calculation")
+        .def("UnMaskPoint", &Lemma::FieldPoints::UnMaskPoint, "Unmasks the index resulting in a calculation")
+
+        ;
 }