package install itself and new unit tests

Author: Teseo Schneider

.gitignore

@@ -1,3 +1,4 @@
+build/
 bin/
 bin_rel/
 3rdparty/

setup.py

@@ -1,21 +1,86 @@
-import setuptools
+import os
+import re
+import sys
+# import sysconfig
+import platform
+import subprocess
+
+from distutils.version import LooseVersion
+from setuptools import setup, Extension, find_packages
+from setuptools.command.build_ext import build_ext
+
+
+class CMakeExtension(Extension):
+    def __init__(self, name, sourcedir=''):
+        Extension.__init__(self, name, sources=[])
+        self.sourcedir = os.path.abspath(sourcedir)
+
+
+class CMakeBuild(build_ext):
+    def run(self):
+        try:
+            out = subprocess.check_output(['cmake', '--version'])
+        except OSError:
+            raise RuntimeError(
+                "CMake must be installed to build the following extensions: , ".join(e.name for e in self.extensions))
+
+        # if platform.system() == "Windows":
+        cmake_version = LooseVersion(re.search(r'version\s*([\d.]+)', out.decode()).group(1))
+        if cmake_version < '3.1.0':
+            raise RuntimeError("CMake >= 3.1.0 is required on Windows")
+
+        for ext in self.extensions:
+            self.build_extension(ext)
+
+
+    def build_extension(self, ext):
+        extdir = os.path.join(os.path.abspath(os.path.dirname(self.get_ext_fullpath(ext.name))),"polyfempy")
+
+        cmake_args = ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=' + extdir, '-DPYTHON_EXECUTABLE=' + sys.executable, '-DENABLE_PARDISO=OFF']
+
+        cfg = 'Debug' if self.debug else 'Release'
+        build_args = ['--config', cfg]
+
+        if platform.system() == "Windows":
+            cmake_args += ['-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{}={}'.format(cfg.upper(), extdir)]
+            if sys.maxsize > 2**32:
+                cmake_args += ['-A', 'x64']
+            build_args += ['--', '/m']
+        else:
+            cmake_args += ['-DCMAKE_BUILD_TYPE=' + cfg]
+            build_args += ['--', '-j2']
+
+        env = os.environ.copy()
+        env['CXXFLAGS'] = '{} -DVERSION_INFO=\\"{}\\"'.format(env.get('CXXFLAGS', ''),self.distribution.get_version())
+
+        if not os.path.exists(self.build_temp):
+            os.makedirs(self.build_temp)
+        subprocess.check_call(['cmake', ext.sourcedir] + cmake_args, cwd=self.build_temp, env=env)
+
+        subprocess.check_call(['cmake', '--build', '.'] + build_args, cwd=self.build_temp)
+
+        print()  # Add an empty line for cleaner output
+
 
 with open("README.md", "r") as fh:
     long_description = fh.read()
 
-setuptools.setup(
+
+setup(
     name="polyfempy",
     version="0.0.1",
     author="Teseo Schneider",
-    author_email="email@email.com",
+    author_email="",
     description="Polyfem Python Bindings",
     long_description=long_description,
     long_description_content_type="text/markdown",
     url="https://polyfem.github.io/",
-    packages=setuptools.find_packages(),
+    ext_modules=[CMakeExtension('polyfempy')],
+    cmdclass=dict(build_ext=CMakeBuild),
+    packages=find_packages(),
     classifiers=[
         "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: OS Independent",
+        "License :: OSI Approved :: MIT License"
     ],
+    test_suite="tests"
 )

src/binding.cpp

@@ -2,6 +2,14 @@
 #include <polyfem/AssemblerUtils.hpp>
 #include <polyfem/Logger.hpp>
 
+#include <geogram/basic/command_line.h>
+#include <geogram/basic/command_line_args.h>
+
+#ifdef USE_TBB
+#include <tbb/task_scheduler_init.h>
+#include <thread>
+#endif
+
 #include <pybind11/pybind11.h>
 #include <pybind11/eigen.h>
 
@@ -10,6 +18,39 @@ namespace py = pybind11;
 class ScalarAssemblers { };
 class TensorAssemblers { };
 
+
+
+namespace {
+	void init_globals()
+	{
+		static bool initialized = false;
+
+		if(!initialized)
+		{
+#ifndef WIN32
+			setenv("GEO_NO_SIGNAL_HANDLER", "1", 1);
+#endif
+
+			GEO::initialize();
+
+#ifdef USE_TBB
+			const size_t MB = 1024*1024;
+			const size_t stack_size = 64 * MB;
+			unsigned int num_threads = std::max(1u, std::thread::hardware_concurrency());
+			tbb::task_scheduler_init scheduler(num_threads, stack_size);
+#endif
+
+    		// Import standard command line arguments, and custom ones
+			GEO::CmdLine::import_arg_group("standard");
+			GEO::CmdLine::import_arg_group("pre");
+			GEO::CmdLine::import_arg_group("algo");
+
+			initialized = true;
+		}
+	}
+
+}
+
 PYBIND11_MODULE(polyfempy, m) {
 	const auto &sa = py::class_<ScalarAssemblers>(m, "ScalarFormulations");
 	for(auto &a : polyfem::AssemblerUtils::instance().scalar_assemblers())
@@ -26,37 +67,46 @@ PYBIND11_MODULE(polyfempy, m) {
 	py::class_<polyfem::State>(m, "Solver")
 	.def(py::init<>())
 	.def("settings", [](polyfem::State &s, const std::string &json) {
+		init_globals();
 		s.init(json::parse(json));
 	}, 																"load PDE and problem parameters from the settings")
 
 	.def("set_log_level", [](polyfem::State &s, int log_level) {
+		init_globals();
 		log_level = std::max(0, std::min(6, log_level));
 		spdlog::set_level(static_cast<spdlog::level::level_enum>(log_level));
 	},																"sets polyfem log level, valid value between 0 (all logs) and 6 (no logs)")
 
 	.def("load_mesh", [](polyfem::State &s) {
+		init_globals();
 		s.load_mesh();
 	},																"Loads a mesh from the 'mesh' field of the json and 'bc_tag' if any bc tags")
 	.def("load_mesh", [](polyfem::State &s, std::string &path) {
+		init_globals();
 		s.args["mesh"] = path;
 		s.load_mesh();
 	},																"Loads a mesh from the path and 'bc_tag' from the json if any bc tags")
 	.def("load_mesh", [](polyfem::State &s, std::string &path, std::string &bc_tag) {
+		init_globals();
 		s.args["mesh"] = path;
 		s.args["bc_tag"] = bc_tag;
 		s.load_mesh();
 	},																"Loads a mesh and bc_tags from path")
 
 	.def("set_rhs", [](polyfem::State &s, std::string &path) {
+		init_globals();
 		s.args["rhs_path"] = path;
 	}, 																"Loads the rhs from a file")
 	.def("set_rhs", [](polyfem::State &s, const Eigen::MatrixXd &rhs) {
+		init_globals();
 		s.rhs_in = rhs;
 	}, 																"Sets the rhs")
 
 
 
 	.def("solve", 			[](polyfem::State &s) {
+		init_globals();
+
 		s.compute_mesh_stats();
 
 		s.build_basis();