mmgpy 0.1.0__tar.gz

mmgpy-0.1.0/.github/workflows/build-and-test.yml

@@ -0,0 +1,39 @@
+name: Build and Test
+
+on:
+  push:
+    branches: [main]
+  pull_request: # Any pull request
+  workflow_dispatch: # Allow manual triggering of the workflow
+  schedule:
+    - cron: "0 0 * * *" # Run at midnight UTC every day
+
+jobs:
+  build-and-test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - ubuntu-latest
+          - windows-latest
+          - macos-latest
+        python-version:
+          - "3.10"
+          - "3.13"
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - run: uv sync
+
+      - if: runner.os == 'Windows'
+        run: .\.venv\Scripts\mmg3d.exe -in tests/Mesh.mesh -out tests/output_exe.mesh
+      - if: runner.os != 'Windows'
+        run: .venv/bin/mmg3d -in tests/Mesh.mesh -out tests/output_exe.mesh
+
+      - run: uv run pytest

mmgpy-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,33 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  build-and-publish:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+
+    runs-on: ${{ matrix.os }}
+
+    permissions:
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Build package
+        run: uv build --no-sources
+
+      - name: Publish to PyPI
+        env:
+          UV_PUBLISH_TOKEN: ${{ secrets.PYPI_TOKEN }}
+        run: uv publish

mmgpy-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

mmgpy-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

mmgpy-0.1.0/CMakeLists.txt

@@ -0,0 +1,76 @@
+cmake_minimum_required(VERSION 3.15)
+
+# Set CMP0177 policy
+if(POLICY CMP0177)
+    cmake_policy(SET CMP0177 NEW)
+endif()
+
+project(mmgpy VERSION 0.1.0)
+
+# Find Python first
+find_package(Python COMPONENTS Interpreter Development REQUIRED)
+
+# Try to find system pybind11
+find_package(pybind11 QUIET)
+
+# If pybind11 was not found, try to find it via Python
+if(NOT pybind11_FOUND)
+    message(STATUS "pybind11 not found in system, trying to locate it via Python...")
+    
+    # Execute Python to find pybind11
+    execute_process(
+        COMMAND "${Python_EXECUTABLE}" -c "import pybind11; print(pybind11.get_cmake_dir())"
+        OUTPUT_VARIABLE PYBIND11_CMAKE_DIR
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        RESULT_VARIABLE PYBIND11_RESULT
+    )
+    
+    if(PYBIND11_RESULT EQUAL 0)
+        message(STATUS "Found pybind11 via Python at: ${PYBIND11_CMAKE_DIR}")
+        list(APPEND CMAKE_PREFIX_PATH "${PYBIND11_CMAKE_DIR}")
+        find_package(pybind11 REQUIRED)
+    else()
+        message(FATAL_ERROR "Could not find pybind11. Please install it with: pip install pybind11")
+    endif()
+endif()
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+# Build external dependencies (MMG)
+add_subdirectory(extern)
+
+# Add project source
+add_subdirectory(src)
+
+# Enable testing
+option(BUILD_TESTING "Build tests" ON)
+if(BUILD_TESTING)
+    enable_testing()
+    add_subdirectory(tests)
+endif()
+
+# Installation settings
+include(GNUInstallDirs)
+
+# Install the Python package
+install(
+    DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/src/mmgpy/"
+    DESTINATION "${Python_SITEARCH}/mmgpy"
+    FILES_MATCHING PATTERN "*.py"
+)
+
+# Install the compiled extension
+install(
+    TARGETS mmgpy
+    LIBRARY DESTINATION "${Python_SITEARCH}/mmgpy"
+)
+
+# Print status
+message(STATUS "")
+message(STATUS "MMGpy configuration summary:")
+message(STATUS "  Python executable: ${Python_EXECUTABLE}")
+message(STATUS "  Python version: ${Python_VERSION}")
+message(STATUS "  Install path: ${Python_SITEARCH}/mmgpy")
+message(STATUS "")

mmgpy-0.1.0/LICENSE

@@ -0,0 +1,19 @@
+# Project License
+
+This project is licensed under the GNU General Public License v3.0 or later (GPL-3.0+).
+
+## Dependencies
+
+mmg (https://www.mmgtools.org/)
+
+- Licensed under GNU Lesser General Public License v3.0 or later (LGPL-3.0+)
+- Copyright (c) Bx INP/Inria/UBordeaux/UPMC, 2004-
+
+Full license texts can be found in:
+
+- COPYING: GNU General Public License v3.0
+- COPYING.LESSER: GNU Lesser General Public License v3.0
+
+This project 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 General Public License for more details.

mmgpy-0.1.0/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.1
+Name: mmgpy
+Version: 0.1.0
+Summary: Python bindings for the MMG software
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# mmgpy
+
+This is a Python package that provides bindings for the [MMG software](https://www.mmgtools.org) for mesh generation and optimization.
+
+## Installation
+
+To install the package, run the following command:
+
+```bash
+pip install mmgpy
+```
+
+Or directly from this repository:
+
+```bash
+pip install git+https://github.com/kmarchais/mmgpy.git
+```
+
+for `uv` users:
+
+```bash
+uv pip install mmgpy
+```
+
+## Build dependencies
+
+- pybind11: Used for Python bindings
+
+  - BSD 3-Clause License
+  - Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+- CMake (>= 3.0): Build system
+
+  - BSD 3-Clause License
+  - Copyright 2000-2024 Kitware, Inc. and Contributors
+
+- scikit-build: Python build system integration
+
+  - MIT License
+  - Copyright (c) 2014 Mike Sarahan
+
+- pytest: Testing framework
+
+  - MIT License
+  - Copyright (c) 2004 Holger Krekel and others

mmgpy-0.1.0/README.md

@@ -0,0 +1,45 @@
+# mmgpy
+
+This is a Python package that provides bindings for the [MMG software](https://www.mmgtools.org) for mesh generation and optimization.
+
+## Installation
+
+To install the package, run the following command:
+
+```bash
+pip install mmgpy
+```
+
+Or directly from this repository:
+
+```bash
+pip install git+https://github.com/kmarchais/mmgpy.git
+```
+
+for `uv` users:
+
+```bash
+uv pip install mmgpy
+```
+
+## Build dependencies
+
+- pybind11: Used for Python bindings
+
+  - BSD 3-Clause License
+  - Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+- CMake (>= 3.0): Build system
+
+  - BSD 3-Clause License
+  - Copyright 2000-2024 Kitware, Inc. and Contributors
+
+- scikit-build: Python build system integration
+
+  - MIT License
+  - Copyright (c) 2014 Mike Sarahan
+
+- pytest: Testing framework
+
+  - MIT License
+  - Copyright (c) 2004 Holger Krekel and others

mmgpy-0.1.0/extern/CMakeLists.txt

@@ -0,0 +1,53 @@
+cmake_minimum_required(VERSION 3.15)
+
+include(FetchContent)
+
+# Set MMG version
+set(MMG_GIT_TAG "v5.8.0" CACHE STRING "MMG version to build")
+set(MMG_REPOSITORY "https://github.com/MmgTools/mmg.git" CACHE STRING "MMG repository URL")
+
+# Fetch MMG
+FetchContent_Declare(
+    mmg
+    GIT_REPOSITORY ${MMG_REPOSITORY}
+    GIT_TAG ${MMG_GIT_TAG}
+)
+
+# Configure MMG build options before making it available
+set(BUILD_SHARED_LIBS ON CACHE BOOL "Build shared libraries" FORCE)
+set(BUILD_TESTING OFF CACHE BOOL "Disable MMG testing" FORCE)
+set(BUILD_MMG ON CACHE BOOL "Build all MMG libraries" FORCE)
+set(BUILD_MMG2D ON CACHE BOOL "Build MMG2D library" FORCE)
+set(BUILD_MMG3D ON CACHE BOOL "Build MMG3D library" FORCE)
+set(BUILD_MMGS ON CACHE BOOL "Build MMGS library" FORCE)
+set(LIBMMG2D_SHARED ON CACHE BOOL "Build MMG2D shared library" FORCE)
+set(LIBMMG3D_SHARED ON CACHE BOOL "Build MMG3D shared library" FORCE)
+set(LIBMMGS_SHARED ON CACHE BOOL "Build MMGS shared library" FORCE)
+set(LIBMMG2D_STATIC OFF CACHE BOOL "Do not build static libraries" FORCE)
+set(LIBMMG3D_STATIC OFF CACHE BOOL "Do not build static libraries" FORCE)
+set(LIBMMGS_STATIC OFF CACHE BOOL "Do not build static libraries" FORCE)
+
+# Make MMG available
+FetchContent_MakeAvailable(mmg)
+
+# Set the correct library targets
+set(MMG_LIBRARIES 
+    libmmg2d_so 
+    libmmg3d_so 
+    libmmgs_so
+    CACHE INTERNAL ""
+)
+
+# Export MMG include directories
+set(MMG_INCLUDE_DIRS
+    ${mmg_SOURCE_DIR}/src/common
+    ${mmg_SOURCE_DIR}/src/mmg2d
+    ${mmg_SOURCE_DIR}/src/mmg3d
+    ${mmg_SOURCE_DIR}/src/mmgs
+    ${mmg_BINARY_DIR}/src/common
+    ${mmg_BINARY_DIR}/include/mmg/common
+    ${mmg_BINARY_DIR}/include/mmg/mmg2d
+    ${mmg_BINARY_DIR}/include/mmg/mmg3d
+    ${mmg_BINARY_DIR}/include/mmg/mmgs
+    CACHE INTERNAL ""
+)

mmgpy-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["scikit-build-core>=0.8.0", "pybind11"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "mmgpy"
+version = "0.1.0"
+description = "Python bindings for the MMG software"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = []
+
+[tool.scikit-build]
+build.verbose = true
+cmake.version = ">=3.15"
+sdist.include = ["CMakeLists.txt", "src/*", "extern/*"]
+wheel.packages = ["src/mmgpy"]
+
+[tool.scikit-build.cmake.define]
+BUILD_TESTING = "OFF"
+BUILD_SHARED_LIBS = "ON"
+
+[dependency-groups]
+dev = ["pytest>=8.3.4"]

mmgpy-0.1.0/src/CMakeLists.txt

@@ -0,0 +1,123 @@
+cmake_minimum_required(VERSION 3.15)
+# Create the core binding module
+pybind11_add_module(mmgpy
+    bindings/mmgs.cpp
+    bindings/mmg3d.cpp
+    bindings/mmg2d.cpp
+    bindings/bindings.cpp
+)
+# Set include directories
+target_include_directories(mmgpy
+    PRIVATE
+        ${MMG_INCLUDE_DIRS}
+        ${mmg_BINARY_DIR}/include
+        ${mmg_SOURCE_DIR}/include
+)
+# Link against MMG libraries
+target_link_libraries(mmgpy
+    PRIVATE
+        ${MMG_LIBRARIES}
+)
+# Handle compiler warnings
+if(MSVC)
+    target_compile_options(mmgpy PRIVATE /W4)
+else()
+    target_compile_options(mmgpy PRIVATE -Wall -Wextra -Wpedantic)
+endif()
+# Set the output name
+set_target_properties(mmgpy PROPERTIES
+    OUTPUT_NAME "_mmgpy"
+    PREFIX ""
+    SUFFIX "${PYTHON_MODULE_EXTENSION}"
+)
+
+if(UNIX)
+    # Set RPATH settings
+    set_target_properties(mmgpy PROPERTIES
+        INSTALL_RPATH "$ORIGIN"
+        BUILD_WITH_INSTALL_RPATH TRUE
+        SKIP_BUILD_RPATH FALSE
+    )
+endif()
+
+# Install the Python module
+install(TARGETS mmgpy DESTINATION mmgpy)
+
+if(WIN32)
+    # Windows-specific installation
+    if(CMAKE_BUILD_TYPE)
+        set(MMG_EXE_DIR "${mmg_BINARY_DIR}/bin/${CMAKE_BUILD_TYPE}")
+    else()
+        set(MMG_EXE_DIR "${mmg_BINARY_DIR}/bin/Release")
+    endif()
+    
+    install(TARGETS libmmg2d_so libmmg3d_so libmmgs_so 
+            DESTINATION mmgpy)
+    install(TARGETS libmmg2d_so libmmg3d_so libmmgs_so 
+            DESTINATION "${SKBUILD_SCRIPTS_DIR}")
+    install(FILES
+        "${MMG_EXE_DIR}/mmg2d.exe"
+        "${MMG_EXE_DIR}/mmg3d.exe"
+        "${MMG_EXE_DIR}/mmgs.exe"
+        DESTINATION "${SKBUILD_SCRIPTS_DIR}"
+    )
+else()
+    # Set RPATH settings for Python module
+    set_target_properties(mmgpy PROPERTIES
+        INSTALL_RPATH "$ORIGIN"
+        BUILD_WITH_INSTALL_RPATH TRUE
+        SKIP_BUILD_RPATH FALSE
+    )
+
+    # Install libraries
+    install(TARGETS libmmg2d_so libmmg3d_so libmmgs_so
+            DESTINATION mmgpy)
+    install(TARGETS libmmg2d_so libmmg3d_so libmmgs_so
+            DESTINATION "${SKBUILD_SCRIPTS_DIR}")
+
+    # Install executables with RPATH set
+    install(FILES
+        "${mmg_BINARY_DIR}/bin/mmg2d_O3"
+        DESTINATION "${SKBUILD_SCRIPTS_DIR}"
+        RENAME "mmg2d"
+        PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE
+                   GROUP_READ GROUP_EXECUTE
+                   WORLD_READ WORLD_EXECUTE
+    )
+    install(CODE "
+        execute_process(
+            COMMAND patchelf --set-rpath \"$ORIGIN\"
+            \"\${CMAKE_INSTALL_PREFIX}/${SKBUILD_SCRIPTS_DIR}/mmg2d\"
+        )
+    ")
+
+    install(FILES
+        "${mmg_BINARY_DIR}/bin/mmg3d_O3"
+        DESTINATION "${SKBUILD_SCRIPTS_DIR}"
+        RENAME "mmg3d"
+        PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE
+                   GROUP_READ GROUP_EXECUTE
+                   WORLD_READ WORLD_EXECUTE
+    )
+    install(CODE "
+        execute_process(
+            COMMAND patchelf --set-rpath \"$ORIGIN\"
+            \"\${CMAKE_INSTALL_PREFIX}/${SKBUILD_SCRIPTS_DIR}/mmg3d\"
+        )
+    ")
+
+    install(FILES
+        "${mmg_BINARY_DIR}/bin/mmgs_O3"
+        DESTINATION "${SKBUILD_SCRIPTS_DIR}"
+        RENAME "mmgs"
+        PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE
+                   GROUP_READ GROUP_EXECUTE
+                   WORLD_READ WORLD_EXECUTE
+    )
+    install(CODE "
+        execute_process(
+            COMMAND patchelf --set-rpath \"$ORIGIN\"
+            \"\${CMAKE_INSTALL_PREFIX}/${SKBUILD_SCRIPTS_DIR}/mmgs\"
+        )
+    ")
+endif()

mmgpy-0.1.0/src/bindings/bindings.cpp

@@ -0,0 +1,34 @@
+#include "bindings.h"
+
+#include "mmg/common/mmgversion.h"
+
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+PYBIND11_MODULE(_mmgpy, m) {
+    py::class_<mmg3d>(m, "mmg3d")
+        .def_static("remesh", remesh_3d,
+                    py::arg("input_mesh"),
+                    py::arg("input_sol") = "",
+                    py::arg("output_mesh") = "output.mesh",
+                    py::arg("output_sol") = "",
+                    py::arg("options") = py::dict());
+
+    py::class_<mmg2d>(m, "mmg2d")
+        .def_static("remesh", remesh_2d,
+                    py::arg("input_mesh"),
+                    py::arg("input_sol") = "",
+                    py::arg("output_mesh") = "output.mesh",
+                    py::arg("output_sol") = "",
+                    py::arg("options") = py::dict());
+
+    py::class_<mmgs>(m, "mmgs")
+        .def_static("remesh", remesh_s,
+                    py::arg("input_mesh"),
+                    py::arg("input_sol") = "",
+                    py::arg("output_mesh") = "output.mesh",
+                    py::arg("output_sol") = "",
+                    py::arg("options") = py::dict());
+
+    m.attr("MMG_VERSION") = MMG_VERSION_RELEASE;
+}

mmgpy-0.1.0/src/bindings/bindings.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <string>
+
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+namespace py = pybind11;
+
+class mmg3d {};
+class mmg2d {};
+class mmgs {};
+
+bool remesh_2d(const std::string& input_mesh, const std::string& input_sol, const std::string& output_mesh, const std::string& output_sol, py::dict options);
+
+bool remesh_3d(const std::string& input_mesh, const std::string& input_sol, const std::string& output_mesh, const std::string& output_sol, py::dict options);
+
+bool remesh_s(const std::string& input_mesh, const std::string& input_sol, const std::string& output_mesh, const std::string& output_sol, py::dict options);

mmgpy-0.1.0/src/bindings/mmg2d.cpp

@@ -0,0 +1,135 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include "mmg/mmg2d/libmmg2d.h"
+#include "mmg_common.hpp"
+#include "bindings.h"
+
+
+namespace py = pybind11;
+
+// Helper function to initialize MMG2D structures
+std::tuple<MMG5_pMesh, MMG5_pSol, MMG5_pSol, MMG5_pSol> init_mmg2d_structures() {
+    MMG5_pMesh mesh = nullptr;
+    MMG5_pSol met = nullptr, disp = nullptr, ls = nullptr;
+
+    MMG2D_Init_mesh(MMG5_ARG_start,
+                    MMG5_ARG_ppMesh, &mesh,
+                    MMG5_ARG_ppMet, &met,
+                    MMG5_ARG_ppLs, &ls,
+                    MMG5_ARG_ppDisp, &disp,
+                    MMG5_ARG_end);
+
+    return std::make_tuple(mesh, met, disp, ls);
+}
+
+// Helper function to cleanup MMG2D structures
+void cleanup_mmg2d_structures(MMG5_pMesh& mesh, MMG5_pSol& met, MMG5_pSol& disp, MMG5_pSol& ls) {
+    MMG2D_Free_all(MMG5_ARG_start,
+                   MMG5_ARG_ppMesh, &mesh,
+                   MMG5_ARG_ppMet, &met,
+                   MMG5_ARG_ppDisp, &disp,
+                   MMG5_ARG_ppLs, &ls,
+                   MMG5_ARG_end);
+}
+
+// Helper function to load mesh based on format
+int mmg2d_load_mesh(MMG5_pMesh mesh, MMG5_pSol met, MMG5_pSol sol, const std::string& filename) {
+    std::string ext = get_file_extension(filename);
+    if (ext == ".vtk") {
+        return MMG2D_loadVtkMesh(mesh, met, sol, filename.c_str());
+    } else if (ext == ".vtu") {
+        return MMG2D_loadVtuMesh(mesh, met, sol, filename.c_str());
+    } else if (ext == ".vtp") {
+        return MMG2D_loadVtpMesh(mesh, met, sol, filename.c_str());
+    } else {
+        return MMG2D_loadMesh(mesh, filename.c_str());
+    }
+}
+
+// Helper function to save mesh based on format
+int mmg2d_save_mesh(MMG5_pMesh mesh, MMG5_pSol met, const std::string& filename) {
+    std::string ext = get_file_extension(filename);
+    if (ext == ".vtk") {
+        return MMG2D_saveVtkMesh(mesh, met, filename.c_str());
+    } else if (ext == ".vtu") {
+        return MMG2D_saveVtuMesh(mesh, met, filename.c_str());
+    } else if (ext == ".vtp") {
+        return MMG2D_saveVtpMesh(mesh, met, filename.c_str());
+    } else {
+        return MMG2D_saveMesh(mesh, filename.c_str());
+    }
+}
+
+bool remesh_2d(const std::string& input_mesh, const std::string& input_sol, 
+            const std::string& output_mesh, const std::string& output_sol, 
+            py::dict options) {
+    // Initialize structures
+    auto [mesh, met, disp, ls] = init_mmg2d_structures();
+
+    // Set mesh names
+    MMG2D_Set_inputMeshName(mesh, input_mesh.c_str());
+    MMG2D_Set_outputMeshName(mesh, output_mesh.c_str());
+
+    if (!input_sol.empty()) {
+        MMG2D_Set_inputSolName(mesh, met, input_sol.c_str());
+    }
+    if (!output_sol.empty()) {
+        MMG2D_Set_outputSolName(mesh, met, output_sol.c_str());
+    }
+
+    try {
+        // Load mesh
+        if (mmg2d_load_mesh(mesh, met,
+                     (mesh->info.iso || mesh->info.isosurf) ? ls : met,
+                     input_mesh) != 1) {
+            throw std::runtime_error("Failed to load input mesh");
+        }
+
+        // Load solution if provided
+        if (!input_sol.empty()) {
+            if (MMG2D_loadSol(mesh, met, input_sol.c_str()) != 1) {
+                throw std::runtime_error("Failed to load solution file");
+            }
+        }
+
+        // Set all mesh options
+        set_mesh_options(mesh, met, options);
+
+        // Process mesh based on mode
+        int ret;
+        if (mesh->info.lag > -1) {
+            ret = MMG2D_mmg2dmov(mesh, met, disp);
+        } else if (mesh->info.iso || mesh->info.isosurf) {
+            ret = MMG2D_mmg2dls(mesh, ls, met);
+        } else if (!mesh->nt) {
+            // Mesh generation mode (no triangles in input mesh)
+            ret = MMG2D_mmg2dmesh(mesh, met);
+        } else {
+            // Standard remeshing mode
+            ret = MMG2D_mmg2dlib(mesh, met);
+        }
+
+        if (ret != MMG5_SUCCESS) {
+            throw std::runtime_error("Remeshing failed");
+        }
+
+        // Save mesh
+        if (mmg2d_save_mesh(mesh, met, output_mesh) != 1) {
+            throw std::runtime_error("Failed to save output mesh");
+        }
+
+        // Save solution if requested
+        if (!output_sol.empty()) {
+            if (MMG2D_saveSol(mesh, met, output_sol.c_str()) != 1) {
+                throw std::runtime_error("Failed to save output solution");
+            }
+        }
+
+        cleanup_mmg2d_structures(mesh, met, disp, ls);
+        return true;
+
+    } catch (const std::exception& e) {
+        cleanup_mmg2d_structures(mesh, met, disp, ls);
+        throw;
+    }
+}