Towards a new Python wrapper

CMake/SuperBuild.cmake

@@ -102,7 +102,7 @@ if (LEMMA_ENABLE_TESTING)
 endif()
 
 # tinyxml2, this library is used for XML IO 
-option( LEMMA_TINYXML_SUPPORT  "TinyXML library support for .xml files" OFF)
+#option( LEMMA_TINYXML_SUPPORT  "TinyXML library support for .xml files" OFF)
 if ( LEMMA_TINYXML_SUPPORT )
 	ExternalProject_Add(TINYXML2
 		GIT_REPOSITORY "https://github.com/leethomason/tinyxml2.git"
@@ -116,7 +116,7 @@ if ( LEMMA_TINYXML_SUPPORT )
 	add_compile_options(-DTINYXMLSUPPORT) 
 endif()
 
-option( LEMMA_MATIO_SUPPORT  "MATIO library support for MATLAB .mat files" OFF)
+#option( LEMMA_MATIO_SUPPORT  "MATIO library support for MATLAB .mat files" OFF)
 if ( LEMMA_MATIO_SUPPORT )
 	add_compile_options(-DHAVE_MATIO) 
 	# matio, this library is used for MATLAB file IO

CMakeLists.txt

@@ -47,6 +47,7 @@ option ( LEMMA_BUILD_EXAMPLES       "Compile example Lemma applications" OFF )
 option ( LEMMA_USE_OPENMP           "Use OpenMP in Lemma" OFF )
 option ( LEMMA_BUILD_DOCUMENTATION  "Build Doxygen man pages" OFF )
 option ( LEMMA_VTK8_SUPPORT         "VTK 8.x library for visualisation and grids" OFF )
+option ( LEMMA_PYTHON3_BINDINGS     "Compile Python 3 bindings" OFF )
 
 # We end up using this for all builds, TODO remove this variable but follow same path
 #option (CMAKE_CROSSCOMPILING "Target different arch than you are on" OFF)
@@ -118,6 +119,7 @@ else()
 endif()
 
 INCLUDE_DIRECTORIES(${YAML_CPP_INCLUDE_DIR})
+
 if (VTK_VERSION VERSION_GREATER "8.2.0")
     message( STATUS "${VTK_VERSION} is compatible: ${VTK_VERSION_COMPATIBLE} exact? ${VTK_VERSION_EXACT}" )
     set (VTK_FOUND False) 
@@ -226,7 +228,7 @@ endif()
 option (LEMMA_USE_BOOST "Boost is required by gaussian quadrature classes" OFF)
 if (LEMMA_USE_BOOST)
 	find_package(Boost
-  		1.58.0                         # Minimum or EXACT version e.g. 1.36.0
+  		1.64.0                         # Minimum or EXACT version e.g. 1.36.0
 #  		COMPONENTS math                # Boost libraries by their canonical name
 	)  
 	if(Boost_FOUND)
@@ -242,6 +244,20 @@ if (LEMMA_USE_BOOST)
 	endif()
 endif()
 
+if (LEMMA_PYTHON3_BINDINGS)
+
+    find_package(PythonLibs 3.0 REQUIRED)
+    find_package(Boost 1.64.0   REQUIRED COMPONENTS system python3 numpy3)
+
+    # Is this OK for portability of non-python libraries
+    include_directories(${PYTHON_INCLUDE_DIRS})
+    include_directories(${Boost_INCLUDE_DIRS})
+
+endif()
+
+####################
+# MSVC error fix 
+####################
 option( MSVC_EXTENDED_ALIGNMENT "Turn on MSVC compiler definition _ENABLE_EXTENDED_ALIGNED_STORAGE " OFF  )
 if (MSVC_EXTENDED_ALIGNMENT)
     add_definitions(-D_ENABLE_EXTENDED_ALIGNED_STORAGE)

Modules/FDEM1D/examples/CircularLoop.cpp

@@ -46,6 +46,9 @@ int main(int argc, char** argv) {
         }
         wire->SetPoint(np-1, cx, cy+rad, -1e-3);
 
+    wire->SetNumberOfFrequencies(1);
+        wire->SetFrequency(0, 1);
+
     std::cout << *wire << std::endl;
 
     //auto wire2 = wire->Clone();

Modules/FDEM1D/include/ChargedWellCasing.h

@@ -0,0 +1,151 @@
+/* This file is part of Lemma, a geophysical modelling and inversion API.
+ * More information is available at http://lemmasoftware.org
+ */
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+/**
+ * @file
+ * @date      14/04/19 14:25:07
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@utah.edu
+ * @copyright Copyright (c) 2019, University of Utah
+ * @copyright Copyright (c) 2019, Lemma Software, LLC
+ */
+
+
+#pragma once
+#include "LemmaObject.h"
+
+namespace Lemma {
+
+    /**
+     * \ingroup FDEM1D
+     * \brief
+     * \details
+     */
+    class ChargedWellCasing : public LemmaObject {
+
+        friend std::ostream &operator<<(std::ostream &stream, const ChargedWellCasing &ob);
+
+        protected:
+        /*
+         *  This key is used to lock the constructor. It is protected so that inhereted
+         *  classes also have the key to contruct their base class.
+         */
+        struct ctor_key {};
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        /**
+         * Default constructor.
+         * @note This method is locked, and cannot be called directly.
+         *       The reason that the method is public is to enable the use
+         *       of make_shared whilst enforcing the use of shared_ptr,
+         *       in c++-17, this curiosity may be resolved.
+         * @see ChargedWellCasing::NewSP
+         */
+        explicit ChargedWellCasing ( const ctor_key& );
+
+        /**
+         * DeSerializing constructor.
+         * @note This method is locked, and cannot be called directly.
+         *       The reason that the method is public is to enable the use
+         *       of make_shared whilst enforcing the use of shared_ptr,
+         *       in c++-17, this curiosity may be resolved.
+         * @see ChargedWellCasing::DeSerialize
+         */
+        ChargedWellCasing ( const YAML::Node& node, const ctor_key& );
+
+        /**
+         * Default destructor.
+         * @note This method should never be called due to the mandated
+         *       use of smart pointers. It is necessary to keep the method
+         *       public in order to allow for the use of the more efficient
+         *       make_shared constructor.
+         */
+        virtual ~ChargedWellCasing ();
+
+        /**
+         *  Uses YAML to serialize this object.
+         *  @return a YAML::Node
+         *  @see ChargedWellCasing::DeSerialize
+         */
+        virtual YAML::Node Serialize() const;
+
+        /*
+         *  Factory method for generating concrete class.
+         *  @return a std::shared_ptr of type ChargedWellCasing
+         */
+        static std::shared_ptr< ChargedWellCasing > NewSP();
+
+        /**
+         *   Constructs an ChargedWellCasing object from a YAML::Node.
+         *   @see ChargedWellCasing::Serialize
+         */
+        static std::shared_ptr<ChargedWellCasing> DeSerialize(const YAML::Node& node);
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        // ====================  ACCESS        =======================
+
+        /**
+         *  Many boreholes have numerous segments of varying thickness.
+         *  @param[in] The number of segments that the borehole contains.
+         */
+        void SetNumberOfSegments( const int& ns ) {
+            NumberOfSegments = ns;
+        }
+
+        /**
+         * @return The number of segments
+         */
+        int GetNumberOfSegments( void );
+
+        // ====================  INQUIRY       =======================
+        /**
+         *  Returns the name of the underlying class, similiar to Python's type
+         *  @return string of class name
+         */
+        virtual inline std::string GetName() const {
+            return CName;
+        }
+
+        protected:
+
+        // ====================  LIFECYCLE     =======================
+
+        /** Copy is disabled */
+        ChargedWellCasing( const ChargedWellCasing& ) = delete;
+
+        // ====================  DATA MEMBERS  =========================
+
+        private:
+
+        /** ASCII string representation of the class name */
+        static constexpr auto CName = "ChargedWellCasing";
+
+        /** Total number of casing segments */
+        int NumberOfSegments;
+
+        VectorXr OutsideDiameter;
+
+        VectorXr InsideDiameter;
+
+        VectorXr SegmentConductivity;
+
+    }; // -----  end of class  ChargedWellCasing  -----
+}  // -----  end of namespace Lemma ----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+
+

Modules/FDEM1D/include/FDEM1D

@@ -7,6 +7,7 @@
 
 #include "WireAntenna.h"
 #include "PolygonalWireAntenna.h"
+#include "ChargedWellCasing.h"
 
 #include "DipoleSource.h"
 

Modules/FDEM1D/src/CMakeLists.txt

@@ -16,6 +16,8 @@ set (FDEM1DSOURCE
 	${CMAKE_CURRENT_SOURCE_DIR}/WireAntenna.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/PolygonalWireAntenna.cpp
 
+	${CMAKE_CURRENT_SOURCE_DIR}/ChargedWellCasing.cpp
+
 	# Kernel management	
 	${CMAKE_CURRENT_SOURCE_DIR}/KernelEM1DManager.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/KernelEM1DSpec.cpp

Modules/FDEM1D/src/ChargedWellCasing.cpp

@@ -0,0 +1,97 @@
+/* This file is part of Lemma, a geophysical modelling and inversion API.
+ * More information is available at http://lemmasoftware.org
+ */
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+/**
+ * @file
+ * @date      14/04/19 15:39:02
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@utah.edu
+ * @copyright Copyright (c) 2019, University of Utah
+ * @copyright Copyright (c) 2019, Lemma Software, LLC
+ */
+
+
+#include "ChargedWellCasing.h"
+
+namespace Lemma {
+
+    // ====================  FRIEND METHODS  =====================
+
+    std::ostream &operator << (std::ostream &stream, const ChargedWellCasing &ob) {
+        stream << ob.Serialize()  << "\n---\n"; // End of doc ---
+        return stream;
+    }
+
+    // ====================  LIFECYCLE     =======================
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ChargedWellCasing
+    //      Method:  ChargedWellCasing
+    // Description:  constructor (locked)
+    //--------------------------------------------------------------------------------------
+    ChargedWellCasing::ChargedWellCasing (const ctor_key&) : LemmaObject( LemmaObject::ctor_key()  ) {
+
+    }  // -----  end of method ChargedWellCasing::ChargedWellCasing  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ChargedWellCasing
+    //      Method:  ChargedWellCasing
+    // Description:  DeSerializing constructor (locked)
+    //--------------------------------------------------------------------------------------
+    ChargedWellCasing::ChargedWellCasing (const YAML::Node& node, const ctor_key&) :
+        LemmaObject(node, LemmaObject::ctor_key()) {
+
+    }  // -----  end of method ChargedWellCasing::ChargedWellCasing  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ChargedWellCasing
+    //      Method:  NewSP()
+    // Description:  public constructor returing a shared_ptr
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr< ChargedWellCasing >  ChargedWellCasing::NewSP() {
+        return std::make_shared< ChargedWellCasing >( ctor_key() );
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ChargedWellCasing
+    //      Method:  ~ChargedWellCasing
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
+    ChargedWellCasing::~ChargedWellCasing () {
+
+    }  // -----  end of method ChargedWellCasing::~ChargedWellCasing  (destructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ChargedWellCasing
+    //      Method:  Serialize
+    //--------------------------------------------------------------------------------------
+    YAML::Node  ChargedWellCasing::Serialize (  ) const {
+        YAML::Node node = LemmaObject::Serialize();
+        node.SetTag( GetName() );
+        // FILL IN CLASS SPECIFICS HERE
+        return node;
+    }		// -----  end of method ChargedWellCasing::Serialize  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  ChargedWellCasing
+    //      Method:  DeSerialize
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr<ChargedWellCasing> ChargedWellCasing::DeSerialize ( const YAML::Node& node  ) {
+        if (node.Tag() !=  "ChargedWellCasing" ) {
+            throw  DeSerializeTypeMismatch( "ChargedWellCasing", node.Tag());
+        }
+        return std::make_shared< ChargedWellCasing > ( node, ctor_key() );
+    }		// -----  end of method ChargedWellCasing::DeSerialize  -----
+
+} // ----  end of namespace Lemma  ----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+

Modules/FDEM1D/testing/GetNameCheck.h

@@ -87,6 +87,12 @@ class MyTestSuite : public CxxTest::TestSuite
         TS_ASSERT_EQUALS( Obj->GetName(), std::string("AEMSurveyReader") );
     }
 
+    void testChargedWellCasing( void )
+    {
+        auto Obj = ChargedWellCasing::NewSP();
+        TS_ASSERT_EQUALS( Obj->GetName(), std::string("ChargedWellCasing") );
+    }
+
 //     void testKernelEM1DManager( void )
 //     {
 //         auto Obj = KernelEM1DManager::NewSP();

Modules/FDEM1D/testing/SerializeCheck.h

@@ -109,6 +109,14 @@ class MyTestSuite : public CxxTest::TestSuite
         TS_ASSERT_EQUALS( Obj->GetName(), Obj2->GetName() );
     }
 
+    void testChargedWellCasing(void)
+    {
+        auto Obj = ChargedWellCasing::NewSP();
+        YAML::Node node = Obj->Serialize();
+        auto Obj2 = ChargedWellCasing::DeSerialize(node);
+        TS_ASSERT_EQUALS( Obj->GetName(), Obj2->GetName() );
+    }
+
 
 };
 

Modules/LemmaCore/CMakeLists.txt

@@ -9,16 +9,14 @@ set_target_properties(lemmacore PROPERTIES
     CXX_STANDARD 14
     CXX_STANDARD_REQUIRED ON
 )
-
-# External project dependencies 
 #add_dependencies(lemmacore YAML_CPP)
 
-if (LEMMA_TINYXML_SUPPORT)
-	add_dependencies(lemmacore TINYXML2)
-endif()
-if (LEMMA_MATIO_SUPPORT)
-	add_dependencies(lemmacore MATIO)
-endif()
+#if (LEMMA_TINYXML_SUPPORT)
+#	add_dependencies(lemmacore TINYXML2)
+#endif()
+#if (LEMMA_MATIO_SUPPORT)
+#	add_dependencies(lemmacore MATIO)
+#endif()
 
 target_link_libraries (lemmacore Eigen3::Eigen)
 #target_link_libraries (lemmacore CxxTest)
@@ -45,6 +43,11 @@ if (LEMMA_ENABLE_TESTING)
 	add_subdirectory(testing)
 endif()
 
+# Python Bindings
+if (LEMMA_PYTHON3_BINDINGS)
+	add_subdirectory(python)
+endif()
+
 # Install
 install ( TARGETS lemmacore        DESTINATION ${CMAKE_INSTALL_PREFIX}/lib )
 install ( FILES include/LemmaCore  DESTINATION ${CMAKE_INSTALL_PREFIX}/include/Lemma ) 

Modules/LemmaCore/include/LemmaObject.h

@@ -131,7 +131,7 @@ class LemmaObject {
         /** Protected DeSerializing constructor */
         LemmaObject ( const YAML::Node& node, const ctor_key& );
 
-        /** Disable copying Lemma Object */
+        /* Disable copying Lemma Object */
         LemmaObject( const LemmaObject& ) = delete;
 
         /** Protected default destructor. This is an abstract class and

Modules/LemmaCore/testing/CMakeLists.txt

@@ -14,8 +14,8 @@ CXXTEST_ADD_TEST(unittest_LemmaCore_CopyDisableCheck CopyDisableCheck.cc ${CMAKE
 target_link_libraries(unittest_LemmaCore_CopyDisableCheck "lemmacore")
  
 set_target_properties( unittest_LemmaCore_GetNameCheck 
-	               unittest_LemmaCore_SerializeCheck
-		       unittest_LemmaCore_CopyDisableCheck
+	                   unittest_LemmaCore_SerializeCheck
+		               unittest_LemmaCore_CopyDisableCheck
 	PROPERTIES
 	CXX_STANDARD 14 
 	CXX_STANDARD_REQUIRED ON