CMake/SuperBuild.cmake

 
 if (LEMMA_PYTHON3_BINDINGS)
     if (pybind11_FOUND)
+	    find_package(PythonLibs 3.0 REQUIRED)
         message( STATUS "pybind11 was found" )
     else()
         message( STATUS "pybind11 was NOT found, please build or remove LEMMA_PYTHON3_BINDINGS" )

CMakeLists.txt

 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)
-    SET(CMAKE_EXE_LINKER_FLAGS  "${CMAKE_EXE_LINKER_FLAGS} /LTCG")
+    #if (${CMAKE_BUILD_TYPE} STREQUAL "Release") 
+    #    SET(CMAKE_EXE_LINKER_FLAGS     "${CMAKE_EXE_LINKER_FLAGS}    /LTCG")
+    #    SET(CMAKE_SHARED_LINKER_FLAGS  "${CMAKE_SHARED_LINKER_FLAGS} /LTCG")
+    #    SET(CMAKE_STATIC_LINKER_FLAGS  "${CMAKE_STATIC_LINKER_FLAGS} /LTCG")
+    #    SET(CMAKE_MODULE_LINKER_FLAGS  "${CMAKE_MODULE_LINKER_FLAGS} /LTCG")
+    #endif()
     #add_definitions(-DCMAKE_WINDOWS_EXPORT_ALL_SYMBOLS=TRUE)
     #set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS TRUE)
     #include(GenerateExportHeader)

Modules/FDEM1D/include/EMEarth1D.h

     // =======================================================================
     class EMEarth1D : public LemmaObject {
 
-		friend std::ostream &operator<<(std::ostream &stream,
-			const EMEarth1D &ob);
+	friend std::ostream &operator<<(std::ostream &stream, const EMEarth1D &ob);
 
         public:
 
             explicit EMEarth1D ( const ctor_key& );
 
             /** Default protected constructor. */
-			EMEarth1D ( const YAML::Node& node, const ctor_key& );
+            EMEarth1D ( const YAML::Node& node, const ctor_key& );
 
             /** Default protected constructor. */
-            ~EMEarth1D ();
+            virtual ~EMEarth1D ();
 
             /**
              *  Returns pointer to new EMEarth1D. Location is
 
             /** stream debugging info to std::out
              */
-            void Query();
+            //void Query();
 
             /** YAML Serializing method
              */

Modules/FDEM1D/python/CMakeLists.txt

 
 #pybind11_add_module(pyFDEM1D   MODULE pyFDEM1D.cpp)
 add_library(pyFDEM1D MODULE pyFDEM1D.cpp)
-target_link_libraries(pyFDEM1D PRIVATE pybind11::module lemmacore fdem1d )
+target_link_libraries(pyFDEM1D PRIVATE pybind11::module lemmacore fdem1d)
 set_target_properties(pyFDEM1D PROPERTIES PREFIX "${PYTHON_MODULE_PREFIX}"
-	SUFFIX "${PYTHON_MODULE_EXTENSION}"
-    OUTPUT_NAME "FDEM1D"
-	CXX_STANDARD 14 
-	CXX_STANDARD_REQUIRED ON
+	                       SUFFIX "${PYTHON_MODULE_EXTENSION}"
+                               OUTPUT_NAME "FDEM1D"
 )
 
 install(TARGETS pyFDEM1D

Modules/FDEM1D/python/pyFDEM1D.cpp

 PYBIND11_MODULE(FDEM1D, m) {
 
     py::add_ostream_redirect(m, "ostream_redirect");
-
     m.doc() = "Python binding of Lemma::FDEM1D, additional details can be found at https://lemmasoftware.org";
 
 
             "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")
             "Sets the TxRx mode flag")
 
         //methods
-#ifdef KIHALEE_EM1D
+	#ifdef KIHALEE_EM1D
         .def("MakeCalc", &Lemma::EMEarth1D::MakeCalc, "Calls KiHa Lee's EM1D FORTRAN77 code")
-#endif
+	#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");
 
         .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")
-
+	
         ;
 }
-
-

Modules/FDEM1D/src/EMEarth1D.cpp

         HankelType = type;
     }
 
+    /*
     void EMEarth1D::Query() {
         std::cout << "EmEarth1D::Query()" << std::endl;
 
 
         std::cout << "icalcinner " << icalcinner << std::endl;
     }
+    */
 
     // ====================  OPERATIONS    ===================================
 
 
             } else if (Receivers->GetNumberOfPoints() > Antenna->GetNumberOfFrequencies()) {
 
-                //** Progress display bar for long calculations */
+                /* Progress display bar for long calculations */
                 std::unique_ptr<ProgressBar> mdisp;
                 if (progressbar) {
                     mdisp = std::make_unique< ProgressBar > ( Receivers->GetNumberOfPoints()*Antenna->GetNumberOfFrequencies() );

Modules/LemmaCore/python/CMakeLists.txt

 set_target_properties(pyLemmaCore PROPERTIES PREFIX "${PYTHON_MODULE_PREFIX}"
                                              SUFFIX "${PYTHON_MODULE_EXTENSION}"
                                              OUTPUT_NAME "LemmaCore"
+					     CXX_STANDARD 14 
+					     CXX_STANDARD_REQUIRED ON
 )