ansys-fluent-core 0.27.dev1__py3-none-any.whl → 0.28.dev0__py3-none-any.whl

ansys/fluent/core/solver/settings_external.py

@@ -1,8 +1,5 @@
 """Miscellaneous utility functions."""
 
-import os
-import re
-
 
 def expand_api_file_argument(command_name, value, kwargs):
     """Expand API file argument."""
@@ -14,28 +11,3 @@ def expand_api_file_argument(command_name, value, kwargs):
         return [value, data_file]
     else:
         return [value]
-
-
-def use_search(codegen_outdir: str, version: str):
-    """Whether to use ``_search()`` in the error handling.
-
-    Parameters
-    ----------
-    codegen_outdir: str
-        Codegen directory.
-    version: str
-        Fluent version.
-    """
-    fluent_version_str = version
-    fluent_version_int = int(fluent_version_str.replace(".", "")[0:3])
-    api_tree_files = [
-        file for file in os.listdir(codegen_outdir) if file.endswith("pickle")
-    ]
-    api_tree_file_versions = [
-        int(re.findall(r"\d+", file)[0]) for file in api_tree_files
-    ]
-    latest_api_tree_version = max(api_tree_file_versions)
-    if len(api_tree_files) == 1 and fluent_version_int == latest_api_tree_version:
-        return True
-    else:
-        return False

ansys/fluent/core/streaming_services/field_data_streaming.py

@@ -19,6 +19,7 @@ class FieldDataStreaming(StreamingService):
     """
 
     def __init__(self, session_id: str, service):
+        """Initialize FieldDataStreaming."""
         super().__init__(
             stream_begin_method="BeginFieldsStreaming",
             target=FieldDataStreaming._process_streaming,

ansys/fluent/core/streaming_services/monitor_streaming.py

@@ -188,7 +188,6 @@ class MonitorsManager(StreamingService):
             try:
                 data_received = {}
                 response = next(responses)
-                x_axis_type = response.xaxisdata.xaxistype
                 x_axis_index = response.xaxisdata.xaxisindex
                 data_received["xvalues"] = x_axis_index
                 for y_axis_value in response.yaxisvalues:

ansys/fluent/core/systemcoupling.py

@@ -38,21 +38,31 @@ class SystemCoupling:
 
     Methods
     -------
-    __getattr__
-    get_variables
-    get_regions
-    get_analysis_type
-    connect
-    solve
+    get_variables()
+        Get variables
+    get_regions()
+        Get regions
+    get_analysis_type()
+        Get analysis type
+    connect()
+        Connect parallelly
+    solve()
+        Initialize and solve
     """
 
     def __init__(self, solver):
+        """Initialize SystemCoupling."""
         self._solver = solver
         # version check - this requires Fluent 2024 R1 or newer.
         if self._solver.get_fluent_version() < FluentVersion.v241:
             raise RuntimeError(
                 f"Using {str(self._solver.get_fluent_version())}. PySystemCoupling integration requires {str(FluentVersion.v241)} or later."
             )
+        if self._solver.get_fluent_version() >= FluentVersion.v251:
+            # enable feature to be able to make System Coupling settings APIs calls
+            self._solver.scheme_eval.scheme_eval(
+                "(enable-feature 'sc/participant-info)"
+            )
 
     @property
     def participant_type(self) -> str:
@@ -61,36 +71,157 @@ class SystemCoupling:
 
     def get_variables(self) -> List[Variable]:
         """Get variables."""
-        return self.__get_syc_setup()["variables"]
+
+        if self._solver.get_fluent_version() >= FluentVersion.v251:
+            variables = list()
+            region_names = (
+                self._solver.settings.setup.models.system_coupling.get_all_regions()
+            )
+            variable_names = set()
+            for region_name in region_names:
+                in_var_names = self._get_list(
+                    self._solver.settings.setup.models.system_coupling.get_input_vars(
+                        region_name=region_name
+                    )
+                )
+                out_var_names = self._get_list(
+                    self._solver.settings.setup.models.system_coupling.get_output_vars(
+                        region_name=region_name
+                    )
+                )
+                variable_names.update(in_var_names)
+                variable_names.update(out_var_names)
+            variable_names = sorted(list(variable_names))
+            for variable_name in variable_names:
+                variables.append(
+                    Variable(
+                        name=variable_name,
+                        display_name=self._get_display_name(variable_name),
+                        tensor_type=self._solver.settings.setup.models.system_coupling.get_tensor_type(
+                            variable_name=variable_name
+                        ),
+                        is_extensive=self._solver.settings.setup.models.system_coupling.is_extensive_var(
+                            variable_name=variable_name
+                        ),
+                        location=self._solver.settings.setup.models.system_coupling.get_data_location(
+                            variable_name=variable_name
+                        ),
+                        quantity_type=self._get_quantity_type(variable_name),
+                    )
+                )
+            return variables
+        else:
+            # maintains back-compatibility for 24.1 and 24.2
+            return self.__get_syc_setup()["variables"]
 
     def get_regions(self) -> List[Region]:
         """Get regions."""
-        return self.__get_syc_setup()["regions"]
+
+        if self._solver.get_fluent_version() >= FluentVersion.v251:
+            region_names = (
+                self._solver.settings.setup.models.system_coupling.get_all_regions()
+            )
+            regions = list()
+            for region_name in region_names:
+                regions.append(
+                    Region(
+                        name=region_name,
+                        display_name=self._get_display_name(region_name),
+                        topology=self._solver.settings.setup.models.system_coupling.get_topology(
+                            region_name=region_name
+                        ),
+                        input_variables=self._get_list(
+                            self._solver.settings.setup.models.system_coupling.get_input_vars(
+                                region_name=region_name
+                            )
+                        ),
+                        output_variables=self._get_list(
+                            self._solver.settings.setup.models.system_coupling.get_output_vars(
+                                region_name=region_name
+                            )
+                        ),
+                    )
+                )
+            return regions
+        else:
+            # maintains back-compatibility for 24.1 and 24.2
+            return self.__get_syc_setup()["regions"]
 
     def get_analysis_type(self) -> str:
         """Get analysis type."""
-        return self.__get_syc_setup()["analysis-type"]
+        if self._solver.get_fluent_version() >= FluentVersion.v251:
+            return (
+                self._solver.settings.setup.models.system_coupling.get_analysis_type()
+            )
+        else:
+            # maintains back-compatibility for 24.1 and 24.2
+            return self.__get_syc_setup()["analysis-type"]
 
     def connect(self, host: str, port: int, name: str) -> None:
-        """Connect parallelly."""
-        self._solver.setup.models.system_coupling.connect_parallel(
+        """Connect to System Coupling."""
+        self._solver.settings.setup.models.system_coupling.connect_parallel(
             schost=host, scport=port, scname=name
         )
 
     def solve(self) -> None:
         """Initialize and solve."""
-        self._solver.setup.models.system_coupling.init_and_solve()
+        self._solver.settings.setup.models.system_coupling.init_and_solve()
+
+    @staticmethod
+    def _get_quantity_type(variable_name: str) -> str:
+        """
+        For some variables, System Coupling should know the quantity type.
+        """
+        if variable_name in {"force", "lorentz-force"}:
+            return "Force"
+        elif variable_name in {"heatflow", "heatrate"}:
+            return "Heat Rate"
+        elif variable_name == "displacement":
+            return "Incremental Displacement"
+        elif variable_name == "temperature":
+            return "Temperature"
+        elif variable_name == "heat-transfer-coefficient":
+            return "Heat Transfer Coefficient"
+        elif variable_name == "near-wall-temperature":
+            return "Convection Reference Temperature"
+        elif variable_name == "electrical-conductivity":
+            return "Electrical Conductivity"
+        else:
+            return "Unspecified"
+
+    @staticmethod
+    def _get_display_name(internal_name: str) -> str:
+        """
+        Display names should not contain dashes.
+        """
+        return internal_name.replace("-", " ")
+
+    @staticmethod
+    def _get_list(value: list | None) -> list:
+        if isinstance(value, list):
+            return value
+        elif value is None:
+            return list()
+        raise TypeError(f"_get_list unexpected type of {value}")
 
     def __get_syc_setup(self) -> dict:
+        """
+        This function is for backward-compatibility reasons for 24.1 and 24.2 versions.
+        It tells Fluent to write the SCP file and then parses it to get the setup
+        information. The SCP file is then deleted.
+        With newer versions, settings APIs can be used directly, without having
+        to write the SCP file at all.
+        """
+
         def get_scp_string() -> str:
             """Get the SCP file contents in the form of an XML string."""
 
             scp_file_name = "fluent.scp"
-            self._solver.setup.models.system_coupling.write_scp_file(
+            self._solver.settings.setup.models.system_coupling.write_scp_file(
                 file_name=scp_file_name
             )
 
-            if self._solver._fluent_connection._remote_instance != None:
+            if self._solver._fluent_connection._remote_instance is not None:
                 # download the file locally in case Fluent is remote
                 # assume file transfer service is configured - download the file
                 self._solver.download(scp_file_name)

ansys/fluent/core/utils/__init__.py

@@ -2,11 +2,12 @@
 
 import importlib.util
 import logging
+from pathlib import Path
 import sys
 
-logger = logging.getLogger("pyfluent.general")
+from ansys.fluent.core.search import search  # noqa: F401
 
-from ansys.fluent.core.search import _search  # noqa: F401
+logger = logging.getLogger("pyfluent.general")
 
 
 def load_module(module_name, file_path):
@@ -17,3 +18,18 @@ def load_module(module_name, file_path):
     spec.loader.exec_module(module)
     logger.info(f"Loaded module {module_name} from {file_path}")
     return module
+
+
+def get_examples_download_dir():
+    """Return the path to the examples download directory."""
+    parent_path = Path.home() / "Downloads"
+    parent_path.mkdir(exist_ok=True)
+    return parent_path / "ansys_fluent_core_examples"
+
+
+def get_user_data_dir():
+    """Return the path to the user data directory."""
+    if sys.platform == "win32":
+        return Path.home() / "AppData" / "Local" / "Ansys" / "ansys_fluent_core"
+    else:
+        return Path.home() / ".local" / "share" / "Ansys" / "ansys_fluent_core"

ansys/fluent/core/utils/dump_session_data.py

@@ -104,6 +104,7 @@ class DumpDataReader:
     """Reads dump data."""
 
     def __init__(self, file_name: str):
+        """Initialize DumpDataReader."""
         with open(
             str(Path(file_name).resolve()),
             "rb",
@@ -114,7 +115,7 @@ class DumpDataReader:
         """Get session data."""
         return self._session_data
 
-    def get_surface_data(self, surface_ids, data_types) -> list[np.array | None]:
+    def get_surface_data(self, surface_ids, data_types) -> list[np.ndarray | None]:
         """Get surface data."""
         tag_id = (("type", "surface-data"),)
 
@@ -130,7 +131,7 @@ class DumpDataReader:
 
     def get_scalar_field_data(
         self, surface_ids, data_location, provide_boundary_values, field_names
-    ) -> list[np.array | None]:
+    ) -> list[np.ndarray | None]:
         """Get scalar field data."""
         tag_id = (
             ("type", "scalar-field"),
@@ -146,7 +147,9 @@ class DumpDataReader:
 
         return scalar_field_data
 
-    def get_vector_field_data(self, surface_ids, field_names) -> list[np.array | None]:
+    def get_vector_field_data(
+        self, surface_ids, field_names
+    ) -> list[np.ndarray | None]:
         """Get vector field data."""
         tag_id = (("type", "vector-field"),)
 
@@ -163,7 +166,7 @@ class DumpDataReader:
 
     def get_pathlines_data(
         self, surface_ids, field_names, key
-    ) -> list[np.array | None]:
+    ) -> list[np.ndarray | None]:
         """Get pathlines data."""
         pathlines_data = []
         for surface_id in surface_ids:

ansys/fluent/core/utils/execution.py

@@ -33,8 +33,8 @@ def asynchronous(f: Callable) -> Callable:
     >>> asynchronous_solve(solver_session_1, 100).result()
     >>> asynchronous(solver_session_2.tui.solve.iterate)(100).result()
 
-    .. _Future: https://docs.python.org/3/library/asyncio-future.html#future-object  # noqa: E501
-    .. _result(): https://docs.python.org/3/library/asyncio-future.html#asyncio.Future.result  # noqa: E501
+    .. _Future: https://docs.python.org/3/library/asyncio-future.html#future-object
+    .. _result(): https://docs.python.org/3/library/asyncio-future.html#asyncio.Future.result
     """
 
     @functools.wraps(f)

ansys/fluent/core/utils/file_transfer_service.py

@@ -1,32 +1,26 @@
 """Provides a module for file transfer service."""
 
-import logging
 import os
 import pathlib
 import random
 import shutil
-from typing import Any, Callable, List, Protocol  # noqa: F401
+from typing import Any, Protocol
 import warnings
 
-import platformdirs
-
+from ansys.fluent.core.utils import get_user_data_dir
 from ansys.fluent.core.utils.deprecate import deprecate_argument
 from ansys.fluent.core.warnings import PyFluentUserWarning
 import ansys.platform.instancemanagement as pypim
 
-logger = logging.getLogger("pyfluent.file_transfer_service")
-
-
 # Host path which is mounted to the file-transfer-service container
-MOUNT_SOURCE = platformdirs.user_data_dir(
-    appname="ansys_fluent_core", appauthor="Ansys"
-)
+MOUNT_SOURCE = str(get_user_data_dir())
 
 
 class PyPIMConfigurationError(ConnectionError):
     """Raised when `PyPIM<https://pypim.docs.pyansys.com/version/stable/>` is not configured."""
 
     def __init__(self):
+        """Initialize PyPIMConfigurationError."""
         super().__init__("PyPIM is not configured.")
 
 
@@ -394,6 +388,13 @@ class PimFileTransferService:
     """
 
     def __init__(self, pim_instance: Any | None = None):
+        """Initialize PimFileTransferService.
+
+        Parameters
+        ----------
+        pim_instance: Any, optional
+            PIM instance.
+        """
         self.pim_instance = pim_instance
         self.upload_server = None
         self.file_service = None
@@ -482,23 +483,20 @@ class PimFileTransferService:
         """
         files = [file_name] if isinstance(file_name, str) else file_name
         if self.is_configured():
-            from alive_progress import alive_bar
-
-            with alive_bar(len(files), title="Uploading...") as bar:
-                for file in files:
-                    if os.path.isfile(file):
-                        if not self.file_service.file_exist(os.path.basename(file)):
-                            self.upload_file(
-                                file_name=file, remote_file_name=remote_file_name
-                            )
-                            bar()
-                        else:
-                            warnings.warn(
-                                f"\n{file} with the same name exists at the remote location.\n",
-                                PyFluentUserWarning,
-                            )
-                    elif not self.file_service.file_exist(os.path.basename(file)):
-                        raise FileNotFoundError(f"{file} does not exist.")
+            for file in files:
+                if os.path.isfile(file):
+                    if not self.file_service.file_exist(os.path.basename(file)):
+                        self.upload_file(
+                            file_name=file, remote_file_name=remote_file_name
+                        )
+                        print(f"\n{os.path.basename(file_name)} uploaded.\n")
+                    else:
+                        warnings.warn(
+                            f"\n{file} with the same name exists at the remote location.\n",
+                            PyFluentUserWarning,
+                        )
+                elif not self.file_service.file_exist(os.path.basename(file)):
+                    raise FileNotFoundError(f"{file} does not exist.")
 
     def download_file(self, file_name: str, local_directory: str | None = None):
         """Download a file from the server supported by `PyPIM<https://pypim.docs.pyansys.com/version/stable/>`.
@@ -537,21 +535,18 @@ class PimFileTransferService:
         """
         files = [file_name] if isinstance(file_name, str) else file_name
         if self.is_configured():
-            from alive_progress import alive_bar
-
-            with alive_bar(len(files), title="Downloading...") as bar:
-                for file in files:
-                    if os.path.isfile(file):
-                        warnings.warn(
-                            f"\nFile already exists. File path:\n{file}\n",
-                            PyFluentUserWarning,
-                        )
-                    else:
-                        self.download_file(
-                            file_name=os.path.basename(file),
-                            local_directory=local_directory,
-                        )
-                        bar()
+            for file in files:
+                if os.path.isfile(file):
+                    warnings.warn(
+                        f"\nFile already exists. File path:\n{file}\n",
+                        PyFluentUserWarning,
+                    )
+                else:
+                    self.download_file(
+                        file_name=os.path.basename(file),
+                        local_directory=local_directory,
+                    )
+                    print(f"\n{os.path.basename(file_name)} downloaded.\n")
 
     def __call__(self, pim_instance: Any | None = None):
         self.pim_instance = pim_instance

ansys/fluent/core/utils/fluent_version.py

@@ -5,7 +5,7 @@ from functools import total_ordering
 import os
 
 import ansys.fluent.core as pyfluent
-from ansys.fluent.core._version import fluent_release_version
+from ansys.fluent.core._version import fluent_dev_version, fluent_release_version
 
 
 class AnsysVersionNotFound(RuntimeError):
@@ -18,8 +18,9 @@ class ComparisonError(RuntimeError):
     """Raised when a comparison can't be completed."""
 
     def __init__(self):
+        """Initialize ComparisonError."""
         super().__init__(
-            f"Comparison operations are only supported between two members of 'FluentVersion'."
+            "Comparison operations are only supported between two members of 'FluentVersion'."
         )
 
 
@@ -52,6 +53,7 @@ class FluentVersion(Enum):
     FluentVersion.v232.awp_var == 'AWP_ROOT232'
     """
 
+    v252 = "25.2.0"
     v251 = "25.1.0"
     v242 = "24.2.0"
     v241 = "24.1.0"
@@ -109,6 +111,17 @@ class FluentVersion(Enum):
         """
         return cls(fluent_release_version)
 
+    @classmethod
+    def current_dev(cls):
+        """Return the version member of the current development version.
+
+        Returns
+        -------
+        FluentVersion
+            FluentVersion member corresponding to the latest development version.
+        """
+        return cls(fluent_dev_version)
+
     @property
     def awp_var(self):
         """Get the Fluent version in AWP environment variable format."""
@@ -119,6 +132,11 @@ class FluentVersion(Enum):
         """Get the Fluent version as a plain integer."""
         return int(self.value.replace(".", "")[:-1])
 
+    @property
+    def docker_image_tag(self):
+        """Get the Fluent version as a Docker image tag."""
+        return f"v{self.value}"
+
     def __lt__(self, other):
         if isinstance(other, FluentVersion):
             return self.value < other.value

ansys/fluent/core/utils/networking.py

@@ -4,6 +4,7 @@ from concurrent import futures
 import logging
 import socket
 from typing import Any
+import urllib.request
 
 import grpc
 from grpc_health.v1 import health_pb2, health_pb2_grpc
@@ -68,7 +69,7 @@ def find_remoting_ip() -> str:
         ip = addrinfo[-1][0]
         port = get_free_port()
         address = f"{ip}:{port}"
-        with _GrpcServer(address) as server:
+        with _GrpcServer(address):
             with grpc.insecure_channel(address) as channel:
                 stub = health_pb2_grpc.HealthStub(channel)
                 try:
@@ -83,3 +84,40 @@ def find_remoting_ip() -> str:
                         return ip
                 except Exception:
                     network_logger.debug(f"Cannot use {ip} as remoting ip")
+
+
+def check_url_exists(url: str) -> bool:
+    """Check if a URL exists.
+
+    Parameters
+    ----------
+    url : str
+        URL to check
+
+    Returns
+    -------
+    bool
+        True if the URL exists, False otherwise
+    """
+    try:
+        with urllib.request.urlopen(url) as response:
+            return response.status == 200
+    except Exception:
+        return False
+
+
+def get_url_content(url: str) -> str:
+    """Get the content of a URL.
+
+    Parameters
+    ----------
+    url : str
+        URL to get content from
+
+    Returns
+    -------
+    str
+        content of the URL
+    """
+    with urllib.request.urlopen(url) as response:
+        return response.read()

ansys/fluent/core/workflow.py

@@ -24,6 +24,7 @@ class CommandInstanceCreationError(RuntimeError):
     """Raised when an attempt to create an instance of a task command fails."""
 
     def __init__(self, task_name):
+        """Initialize CommandInstanceCreationError."""
         super().__init__(f"Could not create command instance for task {task_name}.")
 
 
@@ -223,19 +224,6 @@ class BaseTask:
             attr="requiredInputs", other_attr="outputs"
         )
 
-    def get_direct_upstream_tasks(self) -> list:
-        """Get the list of tasks upstream of this one and directly connected by a data
-        dependency.
-
-        Returns
-        -------
-        list
-            Upstream task list.
-        """
-        return self._tasks_with_matching_attributes(
-            attr="requiredInputs", other_attr="outputs"
-        )
-
     def get_direct_downstream_tasks(self) -> list:
         """Get the list of tasks downstream of this one and directly connected by a data
         dependency.
@@ -631,7 +619,7 @@ class TaskContainer(PyCallableStateObject):
         Iterator[BaseTask]
             Iterator of child objects.
         """
-        for name in self._get_child_object_display_names():
+        for name in self.get_object_names():
             yield self[name]
 
     def __getitem__(self, name):
@@ -987,7 +975,7 @@ class CommandTask(BaseTask):
 
     def _cmd_sub_items_read_only(self, cmd, cmd_state):
         for key, value in cmd_state.items():
-            if type(value) == dict:
+            if isinstance(value, dict):
                 setattr(
                     cmd, key, self._cmd_sub_items_read_only(getattr(cmd, key), value)
                 )