Python wrapper for DipoleSource added

Modules/FDEM1D/include/DipoleSource.h

@@ -85,6 +85,13 @@ namespace Lemma {
              */
             static std::shared_ptr< DipoleSource > 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<DipoleSource> DeSerialize( const std::string& node ) {
+                return DipoleSource::DeSerialize(YAML::Load(node));
+            }
 
             /** Returns a deep copy of the dipole. Used to make thread safe methods. Does not
                 copy attachments.

Modules/FDEM1D/python/pyFDEM1D.cpp

@@ -92,12 +92,40 @@ PYBIND11_MODULE(FDEM1D, m) {
 
         // 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")
+        .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)
 
+        // accessors
+        .def("GetName", &Lemma::DipoleSource::GetName, "Returns the name of the class")
+        .def("GetNumberOfFrequencies", &Lemma::DipoleSource::GetNumberOfFrequencies,
+                "Returns the number of frequencies")
+        .def("GetFrequencies", &Lemma::DipoleSource::GetFrequencies, "Returns an array of frequencies")
+        .def("GetFrequency", &Lemma::DipoleSource::GetFrequency, "Returns the frequency of the argument index")
+        .def("GetAngularFrequency", &Lemma::DipoleSource::GetAngularFrequency,
+            "Returns the angular frequency of the argument index")
+        .def("GetPhase", &Lemma::DipoleSource::GetPhase, "Returns the phase of the dipole")
+        .def("GetMoment", &Lemma::DipoleSource::GetMoment, "Returns the moment of the dipole")
+        .def("GetLocation", py::overload_cast< >(&Lemma::DipoleSource::GetLocation), "Returns the location of the dipole")
+        .def("GetPolarisation", &Lemma::DipoleSource::GetPolarisation, "Returns the polarisation of the dipole")
+
+        // modifiers
+        .def("SetLocation", py::overload_cast<const Lemma::Vector3r&> (&Lemma::DipoleSource::SetLocation),
+            "Sets the location of the dipole")
+        .def("SetPolarisation", py::overload_cast<const Lemma::Vector3r&> (&Lemma::DipoleSource::SetPolarisation),
+            "Sets the polarisation of the dipole")
+        .def("SetType", &Lemma::DipoleSource::SetType, "Sets the type")
+        .def("SetMoment", &Lemma::DipoleSource::SetMoment, "Sets the moment of the dipole")
+        .def("SetPhase", &Lemma::DipoleSource::SetPhase, "Sets the phase of the dipole")
+        .def("SetNumberOfFrequencies", &Lemma::DipoleSource::SetNumberOfFrequencies,
+            "Sets the number of frequencies to calculate for the dipole")
+        .def("SetFrequency", &Lemma::DipoleSource::SetFrequency,
+            "Sets a single frequency, first argument is index, second argument is frequency")
+        .def("SetFrequencies", &Lemma::DipoleSource::SetFrequencies,
+            "Sets all frequencies, argument is numpy array of frequencies")
         ;
 }
 

Modules/LemmaCore/python/pyLemmaCore.cpp

@@ -30,6 +30,86 @@ PYBIND11_MODULE(LemmaCore, m) {
 
     m.doc() = "Python binding of LemmaCore, additional details can be found at https://lemmasoftware.org";
 
+    //////////////////
+    // Enumerations //
+    //////////////////
+
+    py::enum_<Lemma::MAGUNITS>(m, "MAGUNITS")
+        .value("TESLA", Lemma::TESLA)
+        .value("NANOTESLA", Lemma::NANOTESLA)
+        .value("GAUSS", Lemma::GAUSS)
+        .export_values();
+
+    py::enum_<Lemma::TEMPUNITS>(m, "TEMPUNITS")
+        .value("CELCIUS", Lemma::CELCIUS)
+        .value("KELVIN", Lemma::KELVIN)
+        .export_values();
+
+    py::enum_<Lemma::TIMEUNITS>(m, "TIMEUNITS")
+        .value("SEC", Lemma::SEC)
+        .value("MILLISEC", Lemma::MILLISEC)
+        .value("MICROSEC", Lemma::MICROSEC)
+        .value("NANOSEC", Lemma::NANOSEC)
+        .value("PICOSEC", Lemma::PICOSEC)
+        .export_values();
+
+    py::enum_<Lemma::FREQUENCYUNITS>(m, "FREQUENCYUNITS")
+        .value("HZ", Lemma::HZ)
+        .value("KHZ", Lemma::KHZ)
+        .value("MHZ", Lemma::MHZ)
+        .value("GHZ", Lemma::GHZ)
+        .export_values();
+
+    py::enum_<Lemma::FEMCOILORIENTATION>(m, "FEMCOILORIENTATION")
+        .value("COAXIAL", Lemma::COAXIAL)
+        .value("COPLANAR", Lemma::COPLANAR)
+        .export_values();
+
+    py::enum_<Lemma::DIPOLESOURCETYPE>(m, "DIPOLESOURCETYPE")
+        .value("NOSOURCETYPE", Lemma::NOSOURCETYPE)
+        .value("GROUNDEDELECTRICDIPOLE", Lemma::GROUNDEDELECTRICDIPOLE )
+        .value("UNGROUNDEDELECTRICDIPOLE", Lemma::UNGROUNDEDELECTRICDIPOLE )
+        .value("MAGNETICDIPOLE", Lemma::MAGNETICDIPOLE )
+        .export_values();
+
+    py::enum_<Lemma::HANKELTRANSFORMTYPE>(m, "HANKELTRANSFORMTYPE")
+        .value("ANDERSON801", Lemma::ANDERSON801)
+        .value("CHAVE", Lemma::CHAVE)
+        .value("FHTKEY201", Lemma::FHTKEY201)
+        .value("FHTKEY101", Lemma::FHTKEY101)
+        .value("FHTKEY51", Lemma::FHTKEY51)
+        .value("QWEKEY", Lemma::QWEKEY)
+        .value("FHTKONG61", Lemma::FHTKONG61)
+        .value("FHTKONG121", Lemma::FHTKONG121)
+        .value("FHTKONG241", Lemma::FHTKONG241)
+        .value("IRONS", Lemma::IRONS)
+        .export_values();
+
+
+    py::enum_<Lemma::FIELDCALCULATIONS>(m, "FIELDCALCULATIONS")
+        .value("E", Lemma::E)
+        .value("H", Lemma::H)
+        .value("BOTH", Lemma::BOTH)
+        .export_values();
+
+    //what the what? This won't compile on gcc?? Maybe because not all caps?
+    /*
+    py::enum_<Lemma::DipoleSourcePolarity>(m "DipoleSourcePolarity")
+        .value("NEGATIVE", Lemma::NEGATIVE)
+        .value("POSITIVE", Lemma::POSITIVE)
+        .export_values();
+
+    py::enum_<Lemma::DipoleSourcePolarisation>(m "DipoleSourcePolarisation")
+        .value("NOPOLARISATION", Lemma::NOPOLARISATION)
+        .value("XPOLARISATION", Lemma::XPOLARISATION)
+        .value("YPOLARISATION", Lemma::YPOLARISATION)
+        .value("ZPOLARISATION", Lemma::ZPOLARISATION)
+        .export_values();
+    */
+
+    ///////////////////////
+    // LemmaCore Classes //
+    ///////////////////////
     py::class_<Lemma::RectilinearGrid, std::shared_ptr<Lemma::RectilinearGrid> > RectilinearGrid(m, "RectilinearGrid");
 
         // lifecycle