fix: Missing input files when Fluent is launched in PIM Mode (#1189)

Co-authored-by: pyansys-ci-bot <92810346+pyansys-ci-bot@users.noreply.github.com>
(cherry picked from commit ccfb1e3)

Author: mhoeijm

.github/workflows/ci_cd_pr.yml

@@ -208,7 +208,7 @@ jobs:
   build-library:
     name: "Build library"
     runs-on: ubuntu-latest
-    needs: [wheelhouse, doc-build, tests]
+    # needs: [wheelhouse, doc-build, tests]
     steps:
       - uses: ansys/actions/build-library@8d3e4946f36c2a7d447b92e34b1022a5c9dc77a7 # v10.0.12
         with:

doc/source/changelog/1189.fixed.md

@@ -0,0 +1 @@
+Missing input files when Fluent is launched in PIM Mode

src/ansys/health/heart/pre/mesher.py

@@ -31,7 +31,9 @@
 import pyvista as pv
 
 import ansys.fluent.core as pyfluent
+from ansys.fluent.core.launcher.launch_options import LaunchMode
 from ansys.fluent.core.session_meshing import Meshing as MeshingSession
+import ansys.fluent.core.utils.file_transfer_service as file_transfer_service
 from ansys.health.heart import LOG as LOGGER
 from ansys.health.heart.exceptions import SupportedFluentVersionNotFoundError
 from ansys.health.heart.objects import Mesh, SurfaceMesh
@@ -45,17 +47,20 @@
 
 _supported_fluent_versions = ["25.2", "25.1", "24.2", "24.1"]
 """List of supported Fluent versions."""
+_supported_fluent_versions_container = ["25.2", "24.2", "24.1"]
+
 _num_cpus: bool = 2
 """Number of CPUs to use for meshing."""
 _extra_launch_kwargs = {}
 """Extra keyword arguments passed to ``pyfluent.launch_fluent()``."""
 _fluent_version = None
 """Global variable to explicitly override the Fluent version used."""
 
-# check whether containerized version of Fluent is used
-_uses_container = bool(int(os.getenv("PYFLUENT_LAUNCH_CONTAINER", False)))
-if _uses_container:
-    _supported_fluent_versions = ["25.2", "24.2", "24.1"]
+_launch_mode: LaunchMode = None
+"""Fluent Launch mode."""
+
+_uses_container: bool = False
+"""Global variable to switch to Fluent container mode."""
 
 _fluent_ui_mode = pyfluent.UIMode(os.getenv("PYFLUENT_UI_MODE", pyfluent.UIMode.HIDDEN_GUI))
 
@@ -238,20 +243,39 @@ def _get_cells_inside_wrapped_parts(model: _InputModel, mesh: _FluentMesh) -> pv
 
 def _get_fluent_meshing_session(working_directory: str | Path) -> MeshingSession:
     """Get a Fluent Meshing session."""
-    # NOTE: when using containerized version - we need to copy all the files
-    # to and from the mounted volume given by pyfluent.EXAMPLES_PATH (default)
-
     # NOTE: There are three launch modes Fluent can be launched in:
     # 1. LaunchMode.PIM: Fluent is launched using the Product Instance Management (PIM) service.
     # 2. LaunchMode.CONTAINER: Fluent is launched in a container. (containerized mode)
     # 3. LaunchMode.STANDALONE: Fluent is launched as a standalone application. (fallback mode)
+    # File transfer strategies are different for each mode.
+
+    # check whether containerized version of Fluent is used
+    global _uses_container
+    global _launch_mode
+    global _supported_fluent_versions
+
+    _uses_container = bool(int(os.getenv("PYFLUENT_LAUNCH_CONTAINER", False)))
+    if _uses_container:
+        _supported_fluent_versions = _supported_fluent_versions_container
+
+    num_cpus = int(os.getenv("PYANSYS_HEART_NUM_CPU", _num_cpus))
 
     if _fluent_version is None:
         product_version = _get_supported_fluent_version()
     else:
         product_version = _fluent_version
 
-    num_cpus = int(os.getenv("PYANSYS_HEART_NUM_CPU", _num_cpus))
+    # determine launch mode
+    if pypim.is_configured():
+        _launch_mode = LaunchMode.PIM
+        transfer_strategy = None
+
+    elif _uses_container:
+        _launch_mode = LaunchMode.CONTAINER
+        transfer_strategy = None
+    else:
+        _launch_mode = LaunchMode.STANDALONE
+        transfer_strategy = file_transfer_service.StandaloneFileTransferStrategy()
 
     LOGGER.info(f"Launching meshing session with {product_version}...")
 
@@ -261,22 +285,27 @@ def _get_fluent_meshing_session(working_directory: str | Path) -> MeshingSession
         "start_transcript": False,
         "product_version": product_version,
         "ui_mode": _fluent_ui_mode,
+        "file_transfer_service": transfer_strategy,
     }
 
-    if pypim.is_configured():
-        session = pyfluent.PureMeshing.from_pim(**launch_config, **_extra_launch_kwargs)
-
-    elif _uses_container:
-        custom_config = {
-            "mount_source": f"{working_directory}",
-            "mount_target": "/mnt/pyfluent/meshing",
-        }
-        launch_config["ui_mode"] = pyfluent.UIMode.NO_GUI_OR_GRAPHICS
-        launch_config.update({"container_dict": custom_config})
-        session = pyfluent.PureMeshing.from_container(**launch_config, **_extra_launch_kwargs)
-
-    else:
-        session = pyfluent.PureMeshing.from_install(**launch_config, **_extra_launch_kwargs)
+    match _launch_mode:
+        case LaunchMode.PIM:
+            launch_config["ui_mode"] = None
+            LOGGER.info(f"Launching Fluent in PIM-mode with config: {launch_config}")
+            session = pyfluent.PureMeshing.from_pim(**launch_config, **_extra_launch_kwargs)
+
+        case LaunchMode.CONTAINER:
+            LOGGER.info(f"Launching Fluent in Container mode with config: {launch_config}")
+            launch_config["container_dict"] = {
+                "mount_source": f"{working_directory}",
+                "mount_target": "/mnt/pyfluent/meshing",
+            }
+            launch_config["ui_mode"] = pyfluent.UIMode.NO_GUI_OR_GRAPHICS
+            session = pyfluent.PureMeshing.from_container(**launch_config, **_extra_launch_kwargs)
+
+        case LaunchMode.STANDALONE:
+            LOGGER.info(f"Launching Fluent in Standalone mode with config: {launch_config}")
+            session = pyfluent.PureMeshing.from_install(**launch_config, **_extra_launch_kwargs)
 
     return session
 
@@ -521,12 +550,20 @@ def _mesh_fluid_cavities(
 
     session = _get_fluent_meshing_session(work_dir_meshing)
 
-    # import all stls
-    if _uses_container:
+    if _launch_mode == LaunchMode.PIM:
+        # Upload files to session if in PIM or Container modes.
+        LOGGER.info(f"Uploading files to session with working directory {work_dir_meshing}...")
+        files = glob.glob(os.path.join(work_dir_meshing, "*.stl"))
+        for file in files:
+            session.upload(file)
+        # In PIM mode files are uploaded to the Fluents working directory.
+        work_dir_meshing = "."
+
+    elif _launch_mode == LaunchMode.CONTAINER:
         # NOTE: when using a Fluent container visible files
-        # will be in /mnt/pyfluent. So need to use relative paths
-        # or replace dirname by /mnt/pyfluent as prefix
+        # will be in /mnt/pyfluent. (equal to mount target)
         work_dir_meshing = "/mnt/pyfluent/meshing"
+
     session.tui.file.import_.cad(f"no {work_dir_meshing} *.stl")
 
     # merge objects
@@ -642,11 +679,18 @@ def mesh_from_manifold_input_model(
             os.path.join(work_dir_meshing, "fluent_meshing.log"), write_to_stdout=False
         )
 
-        # import files
-        if _uses_container:
+        if _launch_mode == LaunchMode.PIM:
+            # Upload files to session if in PIM or Container modes.
+            LOGGER.info(f"Uploading files to session with working directory {work_dir_meshing}...")
+            files = glob.glob(os.path.join(work_dir_meshing, "*.stl"))
+            for file in files:
+                session.upload(file)
+            # In PIM mode files are uploaded to the Fluents working directory.
+            work_dir_meshing = "."
+
+        elif _launch_mode == LaunchMode.CONTAINER:
             # NOTE: when using a Fluent container visible files
-            # will be in /mnt/pyfluent. So need to use relative paths
-            # or replace dirname by /mnt/pyfluent as prefix
+            # will be in /mnt/pyfluent. (equal to mount target)
             work_dir_meshing = "/mnt/pyfluent/meshing"
 
         session.tui.file.import_.cad('no "' + work_dir_meshing + '" "*.stl" yes 40 yes mm')
@@ -706,17 +750,28 @@ def mesh_from_manifold_input_model(
 
         session.tui.mesh.prepare_for_solve("yes")
 
-        # write to file
+        LOGGER.info(f"Writing mesh to {path_to_output}...")
 
-        if _uses_container:
+        if _launch_mode in [LaunchMode.CONTAINER, LaunchMode.PIM]:
             session.tui.file.write_mesh(os.path.basename(path_to_output))
         else:
             session.tui.file.write_mesh('"' + path_to_output + '"')
-        session.exit()
 
-        if path_to_output != path_to_output_old:
+        LOGGER.info(f"Copying {path_to_output} to {path_to_output_old}...")
+
+        if _launch_mode == LaunchMode.PIM:
+            session.download(os.path.basename(path_to_output), path_to_output_old)
+        else:
             shutil.copy(path_to_output, path_to_output_old)
 
+        if not os.path.isfile(path_to_output_old):
+            raise FileNotFoundError(
+                f"Failed to copy {os.path.basename(path_to_output)} to {path_to_output_old}. "
+                "Please check the Fluent meshing log for errors."
+            )
+
+        session.exit()
+
         path_to_output = path_to_output_old
     else:
         LOGGER.info(f"Reusing: {path_to_output}")
@@ -867,15 +922,24 @@ def mesh_from_non_manifold_input_model(
         # launch pyfluent
         session = _get_fluent_meshing_session(work_dir_meshing)
 
+        LOGGER.info(f"Starting Fluent Meshing in mode: {_launch_mode}")
+
         session.transcript.start(
             os.path.join(work_dir_meshing, "fluent_meshing.log"), write_to_stdout=False
         )
 
-        # # import stls
-        if _uses_container:
+        if _launch_mode == LaunchMode.PIM:
+            # Upload files to session if in PIM or Container modes.
+            LOGGER.info(f"Uploading files to session with working directory {work_dir_meshing}...")
+            files = glob.glob(os.path.join(work_dir_meshing, "*.stl"))
+            for file in files:
+                session.upload(file)
+            # In PIM mode files are uploaded to the Fluents working directory.
+            work_dir_meshing = "."
+
+        elif _launch_mode == LaunchMode.CONTAINER:
             # NOTE: when using a Fluent container visible files
-            # will be in /mnt/pyfluent. So need to use relative paths
-            # or replace dirname by /mnt/pyfluent as prefix
+            # will be in /mnt/pyfluent. (equal to mount target)
             work_dir_meshing = "/mnt/pyfluent/meshing"
 
         session.tui.file.import_.cad("no", work_dir_meshing, "*.stl", "yes", 40, "yes", "mm")
@@ -969,13 +1033,26 @@ def mesh_from_non_manifold_input_model(
             os.remove(path_to_output)
 
         LOGGER.info(f"Writing mesh to {path_to_output}...")
-        if _uses_container:
+
+        if _launch_mode in [LaunchMode.CONTAINER, LaunchMode.PIM]:
             session.tui.file.write_mesh(os.path.basename(path_to_output))
         else:
             session.tui.file.write_mesh('"' + path_to_output + '"')
-        session.exit()
 
-        shutil.copy(path_to_output, path_to_output_old)
+        LOGGER.info(f"Copying {path_to_output} to {path_to_output_old}...")
+
+        if _launch_mode == LaunchMode.PIM:
+            session.download(os.path.basename(path_to_output), path_to_output_old)
+        else:
+            shutil.copy(path_to_output, path_to_output_old)
+
+        if not os.path.isfile(path_to_output_old):
+            raise FileNotFoundError(
+                f"Failed to copy {os.path.basename(path_to_output)} to {path_to_output_old}. "
+                "Please check the Fluent meshing log for errors."
+            )
+
+        session.exit()
 
         path_to_output = path_to_output_old
     else: