Merge remote-tracking branch 'upstream/master' into stiffnessmassmatrix

Author: alxbilger

.github/workflows/ci.yml

@@ -20,7 +20,7 @@ jobs:
       matrix:
         os: [ubuntu-20.04, macos-10.15, windows-2019]
         sofa_branch: [master]
-        python_version: ['3.9']
+        python_version: ['3.8']
 
     steps:
       - name: Setup SOFA and environment

Plugin/CMakeLists.txt

@@ -68,8 +68,6 @@ if(CMAKE_SYSTEM_NAME STREQUAL Linux)
 endif()
 
 if (CMAKE_SYSTEM_NAME STREQUAL Windows )
-    target_include_directories(${PROJECT_NAME} PUBLIC "${pybind11_INCLUDE_DIR}")
-
     # https://github.com/boostorg/system/issues/32
     target_compile_definitions(${PROJECT_NAME} PUBLIC "-DHAVE_SNPRINTF")
 endif()

Plugin/src/SofaPython3/DataHelper.cpp

@@ -294,7 +294,7 @@ size_t getSize(BaseData* self)
 
 py::buffer_info toBufferInfo(BaseData& m)
 {
-    scoped_read_access guard(&m);
+    m.updateIfDirty();
 
     const AbstractTypeInfo& nfo { *m.getValueTypeInfo() };
     auto itemNfo = nfo.BaseType();

Plugin/src/SofaPython3/DataHelper.h

@@ -221,9 +221,9 @@ void copyScalar(BaseData* a, const AbstractTypeInfo& nfo, pybind11::array_t<T, p
     void* ptr = a->beginEditVoidPtr();
 
     auto r = src.unchecked();
-    for (ssize_t i = 0; i < r.shape(0); i++)
+    for (pybind11::ssize_t i = 0; i < r.shape(0); i++)
     {
-        for (ssize_t j = 0; j < r.shape(1); j++)
+        for (pybind11::ssize_t j = 0; j < r.shape(1); j++)
         {
             nfo.setScalarValue( ptr, i*r.shape(1)+j, r(i,j) );
         }

Plugin/src/SofaPython3/PythonEnvironment.cpp

@@ -103,7 +103,8 @@ class PythonEnvironmentData
 
     std::set<std::string> addedPath;
 
-    py::module m_sofamodule ;
+    py::module m_sofaModule ;
+    py::module m_sofaRuntimeModule ;
 private:
     std::vector<wchar_t*> m_argv;
 };
@@ -180,27 +181,26 @@ void PythonEnvironment::Init()
     }
 
     PyEval_InitThreads();
-    gil lock;
 
     // Required for sys.path, used in addPythonModulePath().
-    PyRun_SimpleString("import sys");
+    executePython([]{ PyRun_SimpleString("import sys");});
 
     // Force C locale.
-    PyRun_SimpleString("import locale");
-    PyRun_SimpleString("locale.setlocale(locale.LC_ALL, 'C')");
+    executePython([]{ PyRun_SimpleString("import locale");});
+    executePython([]{ PyRun_SimpleString("locale.setlocale(locale.LC_ALL, 'C')");});
 
     // Workaround: try to import numpy and to launch numpy.finfo to cache data;
     // this prevents a deadlock when calling numpy.finfo from a worker thread.
-    PyRun_SimpleString("try:\n\timport numpy;numpy.finfo(float)\nexcept:\n\tpass");
+    executePython([]{ PyRun_SimpleString("try:\n\timport numpy;numpy.finfo(float)\nexcept:\n\tpass");});
 
     // Workaround: try to import scipy from the main thread this prevents a deadlock when importing
     // scipy from a worker thread when we use the SofaScene asynchronous loading
-    PyRun_SimpleString("try:\n\tfrom scipy import misc, optimize\nexcept:\n\tpass\n");
+    executePython([]{ PyRun_SimpleString("try:\n\tfrom scipy import misc, optimize\nexcept:\n\tpass\n");});
 
     // If the script directory is not available (e.g. if the interpreter is invoked interactively
     // or if the script is read from standard input), path[0] is the empty string,
     // which directs Python to search modules in the current directory first.
-    PyRun_SimpleString(std::string("sys.path.insert(0,\"\")").c_str());
+    executePython([]{ PyRun_SimpleString(std::string("sys.path.insert(0,\"\")").c_str());});
 
     // Add the paths to the plugins' python modules to sys.path.  Those paths
     // are read from all the files in 'etc/sofa/python.d'
@@ -237,11 +237,12 @@ void PythonEnvironment::Init()
     // Lastly, we (try to) add modules from the root of SOFA
     addPythonModulePathsFromDirectory( Utils::getSofaPathPrefix() );
 
-    getStaticData()->m_sofamodule = py::module::import("Sofa");
-    PyRun_SimpleString("import SofaRuntime");
+    executePython([]{ getStaticData()->m_sofaModule = py::module::import("Sofa"); });
+    executePython([]{ getStaticData()->m_sofaRuntimeModule = py::module::import("SofaRuntime"); });
+    executePython([]{ PyRun_SimpleString("import SofaRuntime");});
 
     // python livecoding related
-    PyRun_SimpleString("from Sofa.livecoding import onReimpAFile");
+    executePython([]{ PyRun_SimpleString("from Sofa.livecoding import onReimpAFile");});
 
     // general sofa-python stuff
 
@@ -311,16 +312,14 @@ void PythonEnvironment::Release()
 void PythonEnvironment::addPythonModulePath(const std::string& path)
 {
     PythonEnvironmentData* data = getStaticData() ;
-    if (  data->addedPath.find(path)==data->addedPath.end()) {
+    if (  data->addedPath.find(path)==data->addedPath.end())
+    {
         // note not to insert at first 0 place
         // an empty string must be at first so modules can be found in the current directory first.
 
-        {
-            gil lock;
-            PyRun_SimpleString(std::string("sys.path.insert(1,\""+path+"\")").c_str());
-        }
+        executePython([&]{ PyRun_SimpleString(std::string("sys.path.insert(1,\""+path+"\")").c_str());});
 
-        msg_info("SofaPython3") << "Added '" + path + "' to sys.path";
+        msg_info("SofaPython3")<< "Added '" + path + "' to sys.path";
         data->addedPath.insert(path);
     }
 }
@@ -508,22 +507,15 @@ std::string PythonEnvironment::getStackAsString()
 
 std::string PythonEnvironment::getPythonCallingPointString()
 {
-    return py::cast<std::string>(getStaticData()->m_sofamodule.attr("getPythonCallingPointAsString")());
+    gil lock;
+    return py::cast<std::string>(getStaticData()->m_sofaModule.attr("getPythonCallingPointAsString")());
 }
 
 sofa::helper::logging::FileInfo::SPtr PythonEnvironment::getPythonCallingPointAsFileInfo()
 {
-    PyObject* pDict = PyModule_GetDict(PyImport_AddModule("SofaRuntime"));
-    PyObject* res = PyDict_GetItemString(pDict, "getPythonCallingPoint");
-    if(res && PySequence_Check(res) ){
-        PyObject* filename = PySequence_GetItem(res, 0) ;
-        PyObject* number = PySequence_GetItem(res, 1) ;
-        std::string tmp=PyBytes_AsString(filename);
-        auto lineno = PyLong_AsLong(number);
-        Py_DECREF(res) ;
-        return SOFA_FILE_INFO_COPIED_FROM(tmp, lineno);
-    }
-    return SOFA_FILE_INFO_COPIED_FROM("undefined", -1);
+    gil lock;
+    py::tuple cp = getStaticData()->m_sofaRuntimeModule.attr("getPythonCallingPoint")();
+    return SOFA_FILE_INFO_COPIED_FROM(py::cast<std::string>(cp[0]), py::cast<int>(cp[1]));
 }
 
 void PythonEnvironment::setArguments(const std::string& filename, const std::vector<std::string>& arguments)
@@ -546,9 +538,8 @@ void PythonEnvironment::setArguments(const std::string& filename, const std::vec
 
 void PythonEnvironment::SceneLoaderListerner::rightBeforeLoadingScene()
 {
-    gil lock;
     // unload python modules to force importing their eventual modifications
-    PyRun_SimpleString("SofaRuntime.unloadModules()");
+    executePython([]{ PyRun_SimpleString("SofaRuntime.unloadModules()");});
 }
 
 void PythonEnvironment::setAutomaticModuleReload( bool b )
@@ -561,8 +552,7 @@ void PythonEnvironment::setAutomaticModuleReload( bool b )
 
 void PythonEnvironment::excludeModuleFromReload( const std::string& moduleName )
 {
-    gil lock;
-    PyRun_SimpleString( std::string( "try: SofaRuntime.__SofaPythonEnvironment_modulesExcludedFromReload.append('" + moduleName + "')\nexcept:pass" ).c_str() );
+    executePython([&]{ PyRun_SimpleString( std::string( "try: SofaRuntime.__SofaPythonEnvironment_modulesExcludedFromReload.append('" + moduleName + "')\nexcept:pass" ).c_str() );});
 }
 
 static const bool debug_gil = false;

Plugin/src/SofaPython3/SceneLoaderPY3.cpp

@@ -106,6 +106,9 @@ void SceneLoaderPY3::loadSceneWithArguments(const char *filename,
 
         py::object createScene = module.attr("createScene");
         createScene( PythonFactory::toPython(root_out.get()) );
+
+        root_out->setInstanciationSourceFileName(filename);
+        root_out->setInstanciationSourceFilePos(0);
     }catch(py::error_already_set& e)
     {
         msg_error() << "Unable to completely load the scene from file '"<< filename << "'." << msgendl

bindings/Modules/Bindings.ModulesConfig.cmake.in

@@ -9,6 +9,8 @@ find_package(SofaPython3 QUIET REQUIRED COMPONENTS Plugin Bindings.Sofa)
 find_package(SofaBaseTopology QUIET REQUIRED)
 # Required by Bindings.Modules.SofaDeformable
 find_package(SofaDeformable QUIET REQUIRED)
+# Required by Bindings.Modules.SofaLinearSolver
+find_package(Sofa.Component.LinearSolver.Iterative REQUIRED)
 
 # If we are importing this config file and the target is not yet there this is indicating that
 # target is an imported one. So we include it

bindings/Modules/CMakeLists.txt

@@ -1,6 +1,6 @@
 project(Bindings.Modules)
 
-set(MODULEBINDINGS_MODULE_LIST SofaBaseTopology SofaDeformable)
+set(MODULEBINDINGS_MODULE_LIST SofaBaseTopology SofaDeformable SofaLinearSolver)
 
 find_package(Sofa.GL QUIET)
 if(Sofa.GL_FOUND)

bindings/Modules/src/SofaPython3/SofaLinearSolver/Binding_LinearSolver.cpp

@@ -0,0 +1,110 @@
+/******************************************************************************
+*                 SOFA, Simulation Open-Framework Architecture                *
+*                    (c) 2021 INRIA, USTL, UJF, CNRS, MGH                     *
+*                                                                             *
+* This program is free software; you can redistribute it and/or modify it     *
+* under the terms of the GNU Lesser General Public License as published by    *
+* the Free Software Foundation; either version 2.1 of the License, or (at     *
+* your option) any later version.                                             *
+*                                                                             *
+* This program is distributed in the hope that it will be useful, but WITHOUT *
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       *
+* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License *
+* for more details.                                                           *
+*                                                                             *
+* You should have received a copy of the GNU Lesser General Public License    *
+* along with this program. If not, see <http://www.gnu.org/licenses/>.        *
+*******************************************************************************
+* Contact information: contact@sofa-framework.org                             *
+******************************************************************************/
+#include <SofaPython3/SofaLinearSolver/Binding_LinearSolver.h>
+#include <SofaPython3/SofaLinearSolver/Binding_LinearSolver_doc.h>
+#include <pybind11/pybind11.h>
+
+#include <SofaPython3/Sofa/Core/Binding_Base.h>
+#include <SofaPython3/PythonFactory.h>
+
+#include <sofa/component/linearsolver/iterative/MatrixLinearSolver.h>
+#include <pybind11/eigen.h>
+
+namespace py { using namespace pybind11; }
+
+namespace sofapython3 {
+
+using EigenSparseMatrix = Eigen::SparseMatrix<SReal, Eigen::RowMajor>;
+using EigenMatrixMap = Eigen::Map<Eigen::SparseMatrix<SReal, Eigen::RowMajor> >;
+using Vector = Eigen::Matrix<SReal,Eigen::Dynamic, 1>;
+using EigenVectorMap = Eigen::Map<Vector>;
+
+template<class TBlock>
+EigenSparseMatrix toEigen(sofa::linearalgebra::CompressedRowSparseMatrix<TBlock>& matrix)
+{
+    sofa::linearalgebra::CompressedRowSparseMatrix<typename TBlock::Real> filtered;
+    filtered.copyNonZeros(matrix);
+    filtered.compress();
+    return EigenMatrixMap(filtered.rows(), filtered.cols(), filtered.getColsValue().size(),
+            (EigenMatrixMap::StorageIndex*)filtered.rowBegin.data(), (EigenMatrixMap::StorageIndex*)filtered.colsIndex.data(), filtered.colsValue.data());
+}
+
+template<>
+EigenSparseMatrix toEigen<SReal>(sofa::linearalgebra::CompressedRowSparseMatrix<SReal>& matrix)
+{
+    return EigenMatrixMap(matrix.rows(), matrix.cols(), matrix.getColsValue().size(),
+                    (EigenMatrixMap::StorageIndex*)matrix.rowBegin.data(), (EigenMatrixMap::StorageIndex*)matrix.colsIndex.data(), matrix.colsValue.data());
+}
+
+template<class TBlock>
+void bindLinearSolvers(py::module &m)
+{
+    using CRS = sofa::linearalgebra::CompressedRowSparseMatrix<TBlock>;
+    using CRSLinearSolver = sofa::component::linearsolver::MatrixLinearSolver<CRS, sofa::linearalgebra::FullVector<SReal> >;
+    using Real = typename CRS::Real;
+
+    const std::string typeName = CRSLinearSolver::GetClass()->className + CRSLinearSolver::GetCustomTemplateName();
+
+    py::class_<CRSLinearSolver,
+               sofa::core::objectmodel::BaseObject,
+               sofapython3::py_shared_ptr<CRSLinearSolver> > c(m, typeName.c_str(), sofapython3::doc::linearsolver::linearSolverClass);
+
+    c.def("A", [](CRSLinearSolver& self) -> EigenSparseMatrix
+    {
+        if (CRS* matrix = self.getSystemMatrix())
+        {
+            return toEigen(*matrix);
+        }
+        return {};
+    }, sofapython3::doc::linearsolver::linearSolver_A);
+
+    c.def("b", [](CRSLinearSolver& self) -> Vector
+    {
+        if (auto* vector = self.getSystemRHVector())
+        {
+            return EigenVectorMap(vector->ptr(), vector->size());
+        }
+        return {};
+    }, sofapython3::doc::linearsolver::linearSolver_b);
+
+    c.def("x", [](CRSLinearSolver& self) -> Vector
+    {
+        if (auto* vector = self.getSystemLHVector())
+        {
+            return EigenVectorMap(vector->ptr(), vector->size());
+        }
+        return {};
+    }, sofapython3::doc::linearsolver::linearSolver_x);
+
+
+    /// register the binding in the downcasting subsystem
+    PythonFactory::registerType<CRSLinearSolver>([](sofa::core::objectmodel::Base* object)
+    {
+        return py::cast(dynamic_cast<CRSLinearSolver*>(object));
+    });
+}
+
+void moduleAddLinearSolver(py::module &m)
+{
+    bindLinearSolvers<SReal>(m);
+    bindLinearSolvers<sofa::type::Mat<3, 3, SReal> >(m);
+}
+
+}

bindings/Modules/src/SofaPython3/SofaLinearSolver/Binding_LinearSolver.h

@@ -0,0 +1,31 @@
+/******************************************************************************
+*                 SOFA, Simulation Open-Framework Architecture                *
+*                    (c) 2021 INRIA, USTL, UJF, CNRS, MGH                     *
+*                                                                             *
+* This program is free software; you can redistribute it and/or modify it     *
+* under the terms of the GNU Lesser General Public License as published by    *
+* the Free Software Foundation; either version 2.1 of the License, or (at     *
+* your option) any later version.                                             *
+*                                                                             *
+* This program is distributed in the hope that it will be useful, but WITHOUT *
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       *
+* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License *
+* for more details.                                                           *
+*                                                                             *
+* You should have received a copy of the GNU Lesser General Public License    *
+* along with this program. If not, see <http://www.gnu.org/licenses/>.        *
+*******************************************************************************
+* Contact information: contact@sofa-framework.org                             *
+******************************************************************************/
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace sofapython3
+{
+
+void moduleAddLinearSolver(pybind11::module &m);
+
+} /// namespace sofapython3
+