ansys-mechanical-core 0.10.11__py3-none-any.whl → 0.11.12__py3-none-any.whl

ansys/mechanical/core/embedding/app_libraries.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2022 - 2024 ANSYS, Inc. and/or its affiliates.
+# Copyright (C) 2022 - 2025 ANSYS, Inc. and/or its affiliates.
 # SPDX-License-Identifier: MIT
 #
 #
@@ -74,7 +74,7 @@ def add_mechanical_python_libraries(app_or_version):
     elif isinstance(app_or_version, App):
         installdir.append(os.environ[f"AWP_ROOT{app_or_version.version}"])
     else:
-        raise ValueError(f"Invalid input: expected an integer (version) or an instance of App().")
+        raise ValueError("Invalid input: expected an integer (version) or an instance of App().")
 
     location = os.path.join(installdir[0], "Addins", "ACT", "libraries", "Mechanical")
     sys.path.append(location)

ansys/mechanical/core/embedding/appdata.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2022 - 2024 ANSYS, Inc. and/or its affiliates.
+# Copyright (C) 2022 - 2025 ANSYS, Inc. and/or its affiliates.
 # SPDX-License-Identifier: MIT
 #
 #
@@ -31,21 +31,28 @@ import warnings
 class UniqueUserProfile:
     """Create Unique User Profile (for AppData)."""
 
-    def __init__(self, profile_name: str, dry_run: bool = False):
+    def __init__(self, profile_name: str, copy_profile: bool = True, dry_run: bool = False):
         """Initialize UniqueUserProfile class."""
         self._default_profile = os.path.expanduser("~")
         self._location = os.path.join(self._default_profile, "PyMechanical-AppData", profile_name)
         self._dry_run = dry_run
+        self.copy_profile = copy_profile
         self.initialize()
 
     def initialize(self) -> None:
-        """Initialize the new profile location."""
+        """
+        Initialize the new profile location.
+
+        Args:
+            copy_profile (bool): If False, the copy_profile method will be skipped.
+        """
         if self._dry_run:
             return
         if self.exists():
             self.cleanup()
         self.mkdirs()
-        self.copy_profiles()
+        if self.copy_profile:
+            self.copy_profiles()
 
     def cleanup(self) -> None:
         """Cleanup unique user profile."""

ansys/mechanical/core/embedding/background.py

@@ -0,0 +1,106 @@
+# Copyright (C) 2022 - 2025 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Class for running Mechanical on a background thread."""
+
+import atexit
+import threading
+import time
+import typing
+
+import ansys.mechanical.core as mech
+from ansys.mechanical.core.embedding import initializer
+from ansys.mechanical.core.embedding.poster import Poster
+import ansys.mechanical.core.embedding.utils as utils
+
+
+def _exit(background_app: "BackgroundApp"):
+    """Stop the thread serving the Background App."""
+    background_app.stop()
+
+
+class BackgroundApp:
+    """Background App."""
+
+    __app: mech.App = None
+    __app_thread: threading.Thread = None
+    __stopped: bool = False
+    __stop_signaled: bool = False
+    __poster: Poster = None
+
+    def __init__(self, **kwargs):
+        """Construct an instance of BackgroundApp."""
+        if BackgroundApp.__app_thread is None:
+            initializer.initialize(kwargs.get("version"))
+            BackgroundApp.__app_thread = threading.Thread(
+                target=self._start_app, kwargs=kwargs, daemon=True
+            )
+            BackgroundApp.__app_thread.start()
+
+            while BackgroundApp.__poster is None:
+                time.sleep(0.05)
+                continue
+        else:
+            if BackgroundApp.__stopped:
+                raise RuntimeError("Cannot initialize a BackgroundApp once it has been stopped!")
+
+            def new():
+                BackgroundApp.__app.new()
+
+            self.post(new)
+
+    @property
+    def app(self) -> mech.App:
+        """Get the App instance of the background thread.
+
+        It is not meant to be used aside from passing to methods using `post`.
+        """
+        return BackgroundApp.__app
+
+    def post(self, callable: typing.Callable):
+        """Post callable method to the background app thread."""
+        if BackgroundApp.__stopped:
+            raise RuntimeError("Cannot use BackgroundApp after stopping it.")
+        return BackgroundApp.__poster.post(callable)
+
+    def stop(self) -> None:
+        """Stop the background app thread."""
+        if BackgroundApp.__stopped:
+            return
+        BackgroundApp.__stop_signaled = True
+        while True:
+            time.sleep(0.05)
+            if BackgroundApp.__stopped:
+                break
+
+    def _start_app(self, **kwargs) -> None:
+        BackgroundApp.__app = mech.App(**kwargs)
+        BackgroundApp.__poster = BackgroundApp.__app.poster
+        atexit.register(_exit, self)
+        while True:
+            if BackgroundApp.__stop_signaled:
+                break
+            try:
+                utils.sleep(40)
+            except:
+                raise Exception("BackgroundApp cannot sleep.")  # pragma: no cover
+        BackgroundApp.__stopped = True

ansys/mechanical/core/embedding/cleanup_gui.py

@@ -0,0 +1,61 @@
+# Copyright (C) 2022 - 2025 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+"""Clean up temporary mechdb files after GUI is closed."""
+
+from pathlib import Path
+import shutil
+import sys
+import time
+
+import psutil
+
+
+def cleanup_gui(pid, temp_mechdb) -> None:
+    """Remove the temporary mechdb file after it is closed.
+
+    Parameters
+    ----------
+    pid: int
+        The process ID of the open temporary mechdb file.
+    temp_mechdb: Path
+        The path of the temporary mechdb file.
+    """
+    # While the pid exists, sleep
+    while psutil.pid_exists(pid):
+        time.sleep(1)
+
+    # Delete the temporary mechdb file once the GUI is closed
+    temp_mechdb.unlink()
+
+    # Delete the temporary mechdb Mech_Files folder
+    temp_folder_path = temp_mechdb.parent / f"{temp_mechdb.name.split('.')[0]}_Mech_Files"
+    shutil.rmtree(temp_folder_path)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    """Get the process ID and temporary file path to monitor and delete files after use."""
+    # Convert the process id (pid) argument into an integer
+    pid = int(sys.argv[1])
+    # Convert the temporary mechdb path into a Path
+    temp_mechdb_path = Path(sys.argv[2])
+    # Remove the temporary mechdb file when the GUI is closed
+    cleanup_gui(pid, temp_mechdb_path)

ansys/mechanical/core/embedding/enum_importer.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2022 - 2024 ANSYS, Inc. and/or its affiliates.
+# Copyright (C) 2022 - 2025 ANSYS, Inc. and/or its affiliates.
 # SPDX-License-Identifier: MIT
 #
 #
@@ -33,5 +33,5 @@ clr.AddReference("Ansys.ACT.Interfaces")
 
 from Ansys.ACT.Interfaces.Common import *  # noqa isort: skip
 from Ansys.Mechanical.DataModel.Enums import *  # noqa isort: skip
-
+from Ansys.ACT.Interfaces.Analysis import *  # noqa isort: skip
 import Ansys  # noqa  isort: skip

ansys/mechanical/core/embedding/imports.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2022 - 2024 ANSYS, Inc. and/or its affiliates.
+# Copyright (C) 2022 - 2025 ANSYS, Inc. and/or its affiliates.
 # SPDX-License-Identifier: MIT
 #
 #
@@ -24,20 +24,28 @@
 import typing
 
 
+def global_entry_points(app: "ansys.mechanical.core.App") -> typing.Dict:
+    """Return the global entry points of the application."""
+    vars = {}
+    vars["ExtAPI"] = app.ExtAPI
+    vars["DataModel"] = app.DataModel
+    vars["Model"] = app.DataModel.Project.Model
+    vars["Tree"] = app.DataModel.Tree
+    vars["Graphics"] = app.ExtAPI.Graphics
+    return vars
+
+
 def global_variables(app: "ansys.mechanical.core.App", enums: bool = False) -> typing.Dict:
     """Return the Mechanical scripting global variables as a dict.
 
     It can be used to add all of these as global variables in python
     with this command:
-        `globals().update(global_variables(embedded_app))`
+
+    ``globals().update(global_variables(embedded_app))``
 
     To also import all the enums, set the parameter enums to true.
     """
-    vars = {}
-    vars["ExtAPI"] = app.ExtAPI
-    vars["DataModel"] = app.DataModel
-    vars["Model"] = app.DataModel.Project.Model
-    vars["Tree"] = app.DataModel.Tree
+    vars = global_entry_points(app)
     import clr  # isort: skip
 
     clr.AddReference("System.Collections")
@@ -45,8 +53,12 @@ def global_variables(app: "ansys.mechanical.core.App", enums: bool = False) -> t
     clr.AddReference("Ansys.Mechanical.DataModel")
     # from Ansys.ACT.Mechanical import Transaction
     # When ansys-pythonnet issue #14 is fixed, uncomment above
+    from Ansys.ACT.Core.Math import Point2D, Point3D
+    from Ansys.ACT.Math import Vector3D
+    from Ansys.ACT.Mechanical.Fields import VariableDefinitionType
     from Ansys.Core.Units import Quantity
     from Ansys.Mechanical.DataModel import MechanicalEnums
+    from Ansys.Mechanical.Graphics import Point, SectionPlane
 
     import System  # isort: skip
     import Ansys  # isort: skip
@@ -56,6 +68,14 @@ def global_variables(app: "ansys.mechanical.core.App", enums: bool = False) -> t
     vars["Ansys"] = Ansys
     vars["Transaction"] = Transaction
     vars["MechanicalEnums"] = MechanicalEnums
+    # Graphics
+    vars["Point"] = Point
+    vars["SectionPlane"] = SectionPlane
+    # Math
+    vars["Point2D"] = Point2D
+    vars["Point3D"] = Point3D
+    vars["Vector3D"] = Vector3D
+    vars["VariableDefinitionType"] = VariableDefinitionType
 
     if enums:
         vars.update(get_all_enums())

ansys/mechanical/core/embedding/initializer.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2022 - 2024 ANSYS, Inc. and/or its affiliates.
+# Copyright (C) 2022 - 2025 ANSYS, Inc. and/or its affiliates.
 # SPDX-License-Identifier: MIT
 #
 #
@@ -28,13 +28,19 @@ import platform
 import sys
 import warnings
 
-import ansys.tools.path as atp
-
 from ansys.mechanical.core.embedding.loader import load_clr
 from ansys.mechanical.core.embedding.resolver import resolve
 
 INITIALIZED_VERSION = None
-SUPPORTED_MECHANICAL_EMBEDDING_VERSIONS_WINDOWS = {241: "2024R1", 232: "2023R2", 231: "2023R1"}
+"""Constant for the initialized version."""
+
+SUPPORTED_MECHANICAL_EMBEDDING_VERSIONS = {
+    251: "2025R1",
+    242: "2024R2",
+    241: "2024R1",
+    232: "2023R2",
+}
+"""Supported Mechanical embedding versions on Windows."""
 
 
 def __add_sys_path(version: int) -> str:
@@ -44,15 +50,6 @@ def __add_sys_path(version: int) -> str:
     sys.path.append(str(bin_path.resolve()))
 
 
-def __disable_sec() -> None:
-    """SEC is part of RSM and is unstable with embedding.
-
-    I'm not going to debug why that is since we are planning to support
-    DCS/REP in the future instead of RSM.
-    """
-    os.environ["ANSYS_MECHANICAL_EMBEDDING_NO_SEC"] = "1"
-
-
 def __workaround_material_server(version: int) -> None:
     """Workaround material server bug in 2024 R1.
 
@@ -65,48 +62,68 @@ def __workaround_material_server(version: int) -> None:
         os.environ["ENGRDATA_SERVER_SERIAL"] = "1"
 
 
-def _get_default_linux_version() -> int:
-    """Try to get the active linux version from the environment.
+def __check_for_supported_version(version) -> None:
+    """Check if Mechanical version is supported with current version of PyMechanical.
 
-    On linux, embedding is only possible by setting environment variables before starting python.
-    The version will then be fixed  to a specific version, based on those env vars.
-    The documented way to set those variables is to run python using the ``mechanical-env`` script,
-    which can be used after installing the ``ansys-mechanical-env`` package with this command:
-    ``pip install ansys-mechanical-env``. The script takes user input of a version. If the user
-    does not provide a version, the ``find_mechanical()`` function from the ``ansys-tools-path``
-    package is used to find a version of Mechanical.
+    If specific environment variable is enabled, then users can overwrite the supported versions.
+    However, using unsupported versions may cause issues.
     """
-    supported_versions = [232, 241]
-    awp_roots = {ver: os.environ.get(f"AWP_ROOT{ver}", "") for ver in supported_versions}
-    installed_versions = {
-        ver: path for ver, path in awp_roots.items() if path and os.path.isdir(path)
-    }
-    assert len(installed_versions) == 1, "multiple AWP_ROOT environment variables found!"
-    return next(iter(installed_versions))
+    allow_old_version = os.getenv("ANSYS_MECHANICAL_EMBEDDING_SUPPORT_OLD_VERSIONS") == "1"
+
+    # Check if the version is supported
+    if not allow_old_version and version < min(SUPPORTED_MECHANICAL_EMBEDDING_VERSIONS):
+        raise ValueError(f"Mechanical version {version} is not supported.")
+
+    return version
+
 
+def _get_latest_default_version() -> int:
+    """Try to get the latest Mechanical version from the environment.
 
-def _get_default_version() -> int:
-    if os.name == "posix":
-        return _get_default_linux_version()
+    Checks if multiple versions of Mechanical found in system.
+    For Linux it will be only one since ``mechanical-env`` takes care of that.
+    If multiple versions are detected, select the latest one, as no specific version is provided.
+    """
+    awp_roots = [value for key, value in os.environ.items() if key.startswith("AWP_ROOT")]
 
-    if os.name != "nt":  # pragma: no cover
-        raise Exception("Unexpected platform!")
+    if not awp_roots:
+        raise Exception("No Mechanical installations found.")
 
-    _, version = atp.find_mechanical(
-        supported_versions=SUPPORTED_MECHANICAL_EMBEDDING_VERSIONS_WINDOWS
-    )
+    versions_found = []
+    for path in awp_roots:
+        folder = os.path.basename(os.path.normpath(path))
+        version = folder.split("v")[-1]
+        versions_found.append(int(version))
+    latest_version = max(versions_found)
 
-    # version is of the form 23.2
-    int_version = int(str(version).replace(".", ""))
-    return int_version
+    if len(awp_roots) > 1:
+        warnings.warn(
+            f"Multiple versions of Mechanical found! Using latest version {latest_version} ..."
+        )
 
+    return latest_version
 
-def __check_python_interpreter_architecture():
+
+def __check_python_interpreter_architecture() -> None:
     """Embedding support only 64 bit architecture."""
     if platform.architecture()[0] != "64bit":
         raise Exception("Mechanical Embedding requires a 64-bit Python environment.")
 
 
+def __set_environment(version: int) -> None:
+    """Set environment variables to configure embedding."""
+    if os.name == "nt":  # pragma: no cover
+        if version < 251:
+            os.environ["MECHANICAL_STARTUP_UNOPTIMIZED"] = "1"
+
+    # Set an environment variable to use the custom CLR host
+    # for embedding.
+    # In the future (>251), it would always be used.
+    if version == 251:
+        if "PYMECHANICAL_NO_CLR_HOST_LITE" not in os.environ:
+            os.environ["ANSYS_MECHANICAL_EMBEDDING_CLR_HOST"] = "1"
+
+
 def __check_for_mechanical_env():
     """Embedding in linux platform must use mechanical-env."""
     if platform.system() == "Linux" and os.environ.get("PYMECHANICAL_EMBEDDING") != "TRUE":
@@ -119,22 +136,57 @@ def __check_for_mechanical_env():
         )
 
 
+def __is_lib_loaded(libname: str):  # pragma: no cover
+    """Return whether a library is loaded."""
+    import ctypes
+
+    RTLD_NOLOAD = 4
+    try:
+        ctypes.CDLL(libname, RTLD_NOLOAD)
+    except OSError:
+        return False
+    return True
+
+
+def __check_loaded_libs(version: int = None):  # pragma: no cover
+    """Ensure that incompatible libraries aren't loaded prior to PyMechanical load."""
+    if platform.system() != "Linux":
+        return
+
+    if version < 251:
+        return
+
+    # For 2025 R1, PyMechanical will crash on shutdown if libX11.so is already loaded
+    # before starting Mechanical
+    if __is_lib_loaded("libX11.so"):
+        warnings.warn(
+            "libX11.so is loaded prior to initializing the Embedded Instance of Mechanical.\
+                      Python will crash on shutdown..."
+        )
+
+
 def initialize(version: int = None):
     """Initialize Mechanical embedding."""
-    __check_python_interpreter_architecture()  # blocks 32 bit python
-    __check_for_mechanical_env()  # checks for mechanical-env in linux embedding
-
     global INITIALIZED_VERSION
-    if INITIALIZED_VERSION != None:
-        assert INITIALIZED_VERSION == version
-        return
+    if version is None:
+        version = _get_latest_default_version()
 
-    if version == None:
-        version = _get_default_version()
+    version = __check_for_supported_version(version=version)
 
-    INITIALIZED_VERSION = version
+    if INITIALIZED_VERSION is not None:
+        if INITIALIZED_VERSION != version:
+            raise ValueError(
+                f"Initialized version {INITIALIZED_VERSION} "
+                f"does not match the expected version {version}."
+            )
+        return INITIALIZED_VERSION
 
-    __disable_sec()
+    __check_python_interpreter_architecture()  # blocks 32 bit python
+    __check_for_mechanical_env()  # checks for mechanical-env in linux embedding
+
+    __set_environment(version)
+
+    __check_loaded_libs(version)
 
     __workaround_material_server(version)
 
@@ -163,4 +215,5 @@ def initialize(version: int = None):
     # attach the resolver
     resolve(version)
 
+    INITIALIZED_VERSION = version
     return version

ansys/mechanical/core/embedding/loader.py

@@ -1,4 +1,4 @@
-# Copyright (C) 2022 - 2024 ANSYS, Inc. and/or its affiliates.
+# Copyright (C) 2022 - 2025 ANSYS, Inc. and/or its affiliates.
 # SPDX-License-Identifier: MIT
 #
 #