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

ansys/fluent/core/data_model_cache.py

@@ -5,7 +5,7 @@ from contextlib import contextmanager
 import copy
 from enum import Enum
 from threading import RLock
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
 from ansys.api.fluent.v0.variant_pb2 import Variant
 from ansys.fluent.core.utils.fluent_version import FluentVersion
@@ -31,8 +31,8 @@ class NameKey(Enum):
     DISPLAY = "_name_"
 
     def __invert__(self):
-        l = list(NameKey)
-        return l[~l.index(self)]
+        lst = list(NameKey)
+        return lst[~lst.index(self)]
 
 
 class _CacheImpl:
@@ -136,6 +136,7 @@ class DataModelCache:
     use_display_name = False
 
     def __init__(self):
+        """Initialize datamodel cache."""
         self.rules_str_to_cache = defaultdict(dict)
         self.rules_str_to_config = {}
         self._locks = {}
@@ -205,28 +206,34 @@ class DataModelCache:
         source: Dict[str, StateType],
         key: str,
         state: Variant,
-        updaterFn,
+        updater_fn,
         rules_str: str,
         version,
     ):
-        if state.HasField("bool_state"):
-            updaterFn(source, key, state.bool_state)
-        elif state.HasField("int64_state"):
-            updaterFn(source, key, state.int64_state)
-        elif state.HasField("double_state"):
-            updaterFn(source, key, state.double_state)
-        elif state.HasField("string_state"):
-            updaterFn(source, key, state.string_state)
-        elif state.HasField("bool_vector_state"):
-            updaterFn(source, key, state.bool_vector_state.item)
-        elif state.HasField("int64_vector_state"):
-            updaterFn(source, key, state.int64_vector_state.item)
-        elif state.HasField("double_vector_state"):
-            updaterFn(source, key, state.double_vector_state.item)
-        elif state.HasField("string_vector_state"):
-            updaterFn(source, key, state.string_vector_state.item)
-        elif state.HasField("variant_vector_state"):
-            updaterFn(source, key, [])
+        # Helper function to update the source with the state value
+        def update_source_with_state(state_field):
+            if state.HasField(state_field):
+                updater_fn(source, key, getattr(state, state_field))
+                return True
+            return False
+
+        # Check for basic state types
+        for state_type in [
+            "bool_state",
+            "int64_state",
+            "double_state",
+            "string_state",
+            "bool_vector_state",
+            "int64_vector_state",
+            "double_vector_state",
+            "string_vector_state",
+        ]:
+            if update_source_with_state(state_type):
+                return
+
+        # Handle variant vector state
+        if state.HasField("variant_vector_state"):
+            updater_fn(source, key, [])
             for item in state.variant_vector_state.item:
                 self._update_cache_from_variant_state(
                     rules,
@@ -237,34 +244,28 @@ class DataModelCache:
                     rules_str + "/" + key.split(":", maxsplit=1)[0],
                     version,
                 )
-        elif state.HasField("variant_map_state"):
+            return
+
+        # Handle variant map state
+        if state.HasField("variant_map_state"):
             internal_names_as_keys = (
                 self.get_config(rules, "name_key") == NameKey.INTERNAL
             )
+
+            # Determine the appropriate key
             if ":" in key:
                 type_, iname = key.split(":", maxsplit=1)
-                for k1, v1 in source.items():
-                    if (internal_names_as_keys and k1 == key) or (
-                        (not internal_names_as_keys)
-                        and isinstance(v1, dict)
-                        and v1.get(NameKey.INTERNAL.value) == iname
-                    ):
-                        key = k1
-                        break
-                else:  # new named object
-                    if internal_names_as_keys:
-                        source[key] = {}
-                    else:
-                        name = state.variant_map_state.item[
-                            NameKey.DISPLAY.value
-                        ].string_state
-                        key = f"{type_}:{name}"
-                        source[key] = {NameKey.INTERNAL.value: iname}
+                key = self._determine_key(
+                    source, internal_names_as_keys, key, state, type_, iname
+                )
             else:
                 if key not in source:
                     source[key] = {}
+
             if version and _is_dict_parameter_type(version, rules, rules_str):
                 source[key] = {}
+
+            # Update the source with items from the variant map state
             if state.variant_map_state.item:
                 source = source[key]
                 for k, v in state.variant_map_state.item.items():
@@ -279,8 +280,40 @@ class DataModelCache:
                     )
             else:
                 source[key] = {}
+
+        # Default case when no fields are matched
         else:
-            updaterFn(source, key, None)
+            updater_fn(source, key, None)
+
+    def _determine_key(
+        self,
+        source: Dict[str, StateType],
+        internal_names_as_keys: bool,
+        key: str,
+        state: Variant,
+        type_: str,
+        iname: str,
+    ) -> str:
+        """Determine the appropriate key based on internal naming conventions."""
+        for k1, v1 in source.items():
+            if (internal_names_as_keys and k1 == key) or (
+                (not internal_names_as_keys)
+                and isinstance(v1, dict)
+                and v1.get(NameKey.INTERNAL.value) == iname
+            ):
+                return k1  # Found a matching key
+
+        # If no match found and internal naming is used
+        if internal_names_as_keys:
+            source[key] = {}
+            return key
+
+        # If no match found and external naming is used
+        name = state.variant_map_state.item[NameKey.DISPLAY.value].string_state
+        new_key = f"{type_}:{name}"
+        source[new_key] = {NameKey.INTERNAL.value: iname}
+
+        return new_key
 
     def update_cache(
         self, rules: str, state: Variant, deleted_paths: List[str], version=None
@@ -299,37 +332,16 @@ class DataModelCache:
             Fluent version
         """
         cache = self.rules_str_to_cache[rules]
+
         with self._with_lock(rules):
             internal_names_as_keys = (
                 self.get_config(rules, "name_key") == NameKey.INTERNAL
             )
-            for deleted_path in deleted_paths:
-                comps = [x for x in deleted_path.split("/") if x]
-                sub_cache = cache
-                for i, comp in enumerate(comps):
-                    if ":" in comp:
-                        _, iname = comp.split(":", maxsplit=1)
-                        key_to_del = None
-                        for k, v in sub_cache.items():
-                            if (internal_names_as_keys and k == comp) or (
-                                (not internal_names_as_keys)
-                                and isinstance(v, dict)
-                                and v.get(NameKey.INTERNAL.value) == iname
-                            ):
-                                if i == len(comps) - 1:
-                                    key_to_del = k
-                                else:
-                                    sub_cache = v
-                                break
-                        else:
-                            break
-                        if key_to_del:
-                            del sub_cache[key_to_del]
-                    else:
-                        if comp in sub_cache:
-                            sub_cache = sub_cache[comp]
-                        else:
-                            break
+
+            # Process deleted paths
+            self._process_deleted_paths(cache, deleted_paths, internal_names_as_keys)
+
+            # Update cache with new state items
             for k, v in state.variant_map_state.item.items():
                 self._update_cache_from_variant_state(
                     rules,
@@ -341,6 +353,56 @@ class DataModelCache:
                     version,
                 )
 
+    def _process_deleted_paths(
+        self,
+        cache: Dict[str, Any],
+        deleted_paths: List[str],
+        internal_names_as_keys: bool,
+    ):
+        """Process and delete paths from the cache based on the deleted paths list."""
+        for deleted_path in deleted_paths:
+            comps = [x for x in deleted_path.split("/") if x]
+            self._delete_from_cache(cache, comps, internal_names_as_keys)
+
+    def _delete_from_cache(
+        self, sub_cache: Dict[str, Any], comps: List[str], internal_names_as_keys: bool
+    ):
+        """Recursively delete components from the cache."""
+        for i, comp in enumerate(comps):
+            if ":" in comp:
+                _, iname = comp.split(":", maxsplit=1)
+                key_to_del = self._find_key_to_delete(
+                    sub_cache, comp, iname, i == len(comps) - 1, internal_names_as_keys
+                )
+                if key_to_del:
+                    del sub_cache[key_to_del]
+                    return  # Exit after deletion
+            else:
+                if comp in sub_cache:
+                    sub_cache = sub_cache[comp]
+                else:
+                    break
+
+    def _find_key_to_delete(
+        self,
+        sub_cache: Dict[str, Any],
+        comp: str,
+        iname: str,
+        is_last_component: bool,
+        internal_names_as_keys: bool,
+    ) -> Optional[str]:
+        """Find the key to delete from the sub-cache."""
+        for k, v in sub_cache.items():
+            if (internal_names_as_keys and k == comp) or (
+                (not internal_names_as_keys)
+                and isinstance(v, dict)
+                and v.get(NameKey.INTERNAL.value) == iname
+            ):
+                return (
+                    k if is_last_component else None
+                )  # Return key if it's the last component
+        return None  # No key found to delete
+
     @staticmethod
     def _dm_path_comp(comp):
         return ":".join(comp) if comp[1] else comp[0]
@@ -367,11 +429,11 @@ class DataModelCache:
 
         Returns
         -------
-        state : Any
+        Any
             cached state
         """
         name_key_in_config = self.get_config(rules, "name_key")
-        if name_key == None:
+        if name_key is None:
             name_key = name_key_in_config
         cache = self.rules_str_to_cache[rules]
         with self._with_lock(rules):

ansys/fluent/core/docs/README.rst

@@ -67,7 +67,7 @@ To reach the project support team, email `pyansys.core@ansys.com <pyansys.core@a
 Installation
 ------------
 The ``ansys-fluent-core`` package supports Python 3.9 through Python
-3.12 on Windows and Linux.
+3.13 on Windows and Linux.
 
 Install the latest release from `PyPI
 <https://pypi.org/project/ansys-fluent-core/>`_ with:
@@ -99,7 +99,7 @@ example, the installer automatically sets the ``AWP_ROOT232`` environment variab
 to ``C:\Program Files\ANSYS Inc\v232``.
 
 On Linux, the required environment variable is not set automatically, and can be set for the
-current user in the current shell session, using Fluent 2023 R1 in the default installation
+current user in the current shell session, using Fluent 2023 R2 in the default installation
 directory as an example, before running PyFluent, with:
 
 .. code:: console

ansys/fluent/core/examples/downloads.py

@@ -7,9 +7,8 @@ import re
 import shutil
 import zipfile
 
-import requests
-
 import ansys.fluent.core as pyfluent
+from ansys.fluent.core.utils.networking import check_url_exists, get_url_content
 
 logger = logging.getLogger("pyfluent.networking")
 
@@ -86,7 +85,7 @@ def _retrieve_file(
 
     # Download file
     logger.info(f'Downloading URL: "{url}"')
-    content = requests.get(url).content
+    content = get_url_content(url)
     with open(local_path, "wb") as f:
         f.write(content)
 
@@ -166,8 +165,7 @@ def download_file(
                 return_without_path = True
 
     url = _get_file_url(file_name, directory)
-    head = requests.head(f"{url}")
-    if not head.ok:
+    if not check_url_exists(url):
         raise RemoteFileNotFoundError(url)
     return _retrieve_file(url, file_name, save_path, return_without_path)
 

ansys/fluent/core/exceptions.py

@@ -14,6 +14,7 @@ class DisallowedValuesError(ValueError):
         name: Any | None = None,
         allowed_values: Any | None = None,
     ):
+        """Initialize DisallowedValuesError."""
         super().__init__(
             allowed_name_error_message(
                 context=context, trial_name=name, allowed_values=allowed_values

ansys/fluent/core/file_session.py

@@ -9,13 +9,7 @@ from ansys.api.fluent.v0.field_data_pb2 import DataLocation
 from ansys.fluent.core import PyFluentDeprecationWarning
 from ansys.fluent.core.filereader.case_file import CaseFile
 from ansys.fluent.core.filereader.data_file import DataFile
-from ansys.fluent.core.services.field_data import (
-    FacesConnectivity,
-    ScalarFieldData,
-    SurfaceDataType,
-    VectorFieldData,
-    Vertices,
-)
+from ansys.fluent.core.services.field_data import SurfaceDataType
 from ansys.fluent.core.utils.deprecate import deprecate_argument, deprecate_arguments
 
 
@@ -23,6 +17,7 @@ class InvalidMultiPhaseFieldName(ValueError):
     """Raised when multi-phase field name is inappropriate."""
 
     def __init__(self):
+        """Initialize InvalidMultiPhaseFieldName."""
         super().__init__("Multi-phase field name should start with 'phase-'.")
 
 
@@ -30,6 +25,7 @@ class InvalidFieldName(ValueError):
     """Raised when a field name is inappropriate."""
 
     def __init__(self):
+        """Initialize InvalidFieldName."""
         super().__init__("The only allowed field is 'velocity'.")
 
 
@@ -350,6 +346,7 @@ class FileFieldData:
     """File field data."""
 
     def __init__(self, file_session, field_info):
+        """Initialize FileFieldData."""
         self._file_session = file_session
         self._field_info = field_info
 
@@ -411,48 +408,32 @@ class FileFieldData:
         )
 
         if SurfaceDataType.Vertices in data_types:
-            if len(surfaces) == 1 and isinstance(surfaces[0], str):
-                surface_ids = self._field_info.get_surfaces_info()[surfaces[0]][
-                    "surface_id"
-                ]
-                return Vertices(
-                    surface_ids[0],
-                    self._file_session._case_file.get_mesh().get_vertices(
-                        surface_ids[0]
-                    ),
-                )
-            else:
-                return {
-                    surface_id: Vertices(
-                        surface_id,
-                        self._file_session._case_file.get_mesh().get_vertices(
-                            surface_id
-                        ),
-                    )
-                    for surface_id in surface_ids
-                }
+            return {
+                surface: self._file_session._case_file.get_mesh()
+                .get_vertices(surface_ids[count])
+                .reshape(-1, 3)
+                for count, surface in enumerate(surfaces)
+            }
 
         if SurfaceDataType.FacesConnectivity in data_types:
-            if len(surfaces) == 1 and isinstance(surfaces[0], str):
-                surface_ids = self._field_info.get_surfaces_info()[surfaces[0]][
-                    "surface_id"
-                ]
-                return FacesConnectivity(
-                    surface_ids[0],
+            return {
+                surface: self._get_faces_connectivity_data(
                     self._file_session._case_file.get_mesh().get_connectivity(
-                        surface_ids[0]
-                    ),
-                )
-            else:
-                return {
-                    surface_id: FacesConnectivity(
-                        surface_id,
-                        self._file_session._case_file.get_mesh().get_connectivity(
-                            surface_id
-                        ),
+                        surface_ids[count]
                     )
-                    for surface_id in surface_ids
-                }
+                )
+                for count, surface in enumerate(surfaces)
+            }
+
+    @staticmethod
+    def _get_faces_connectivity_data(data):
+        faces_data = []
+        i = 0
+        while i < len(data):
+            end = i + 1 + data[i]
+            faces_data.append(data[i + 1 : end])
+            i = end
+        return faces_data
 
     @deprecate_argument(
         old_arg="surface_name",
@@ -504,53 +485,24 @@ class FileFieldData:
             field_info=self._field_info,
             surfaces=surfaces,
         )
-        if len(surfaces) == 1 and isinstance(surfaces[0], str):
-            surface_ids = self._field_info.get_surfaces_info()[surfaces[0]][
-                "surface_id"
-            ]
-            if len(self._file_session._data_file.get_phases()) > 1:
-                if not field_name.startswith("phase-"):
-                    raise InvalidMultiPhaseFieldName()
-                return ScalarFieldData(
-                    surface_ids[0],
-                    self._file_session._data_file.get_face_scalar_field_data(
-                        field_name.split(":")[0],
-                        field_name.split(":")[1],
-                        surface_ids[0],
-                    ),
-                )
-            else:
-                return ScalarFieldData(
-                    surface_ids[0],
-                    self._file_session._data_file.get_face_scalar_field_data(
-                        "phase-1", field_name, surface_ids[0]
-                    ),
+        if len(self._file_session._data_file.get_phases()) > 1:
+            if not field_name.startswith("phase-"):
+                raise InvalidMultiPhaseFieldName()
+            return {
+                surface: self._file_session._data_file.get_face_scalar_field_data(
+                    field_name.split(":")[0],
+                    field_name.split(":")[1],
+                    surface_ids[count],
                 )
+                for count, surface in enumerate(surfaces)
+            }
         else:
-            if len(self._file_session._data_file.get_phases()) > 1:
-                if not field_name.startswith("phase-"):
-                    raise InvalidMultiPhaseFieldName()
-                return {
-                    surface_id: ScalarFieldData(
-                        surface_id,
-                        self._file_session._data_file.get_face_scalar_field_data(
-                            field_name.split(":")[0],
-                            field_name.split(":")[1],
-                            surface_id,
-                        ),
-                    )
-                    for surface_id in surface_ids
-                }
-            else:
-                return {
-                    surface_id: ScalarFieldData(
-                        surface_id,
-                        self._file_session._data_file.get_face_scalar_field_data(
-                            "phase-1", field_name, surface_id
-                        ),
-                    )
-                    for surface_id in surface_ids
-                }
+            return {
+                surface: self._file_session._data_file.get_face_scalar_field_data(
+                    "phase-1", field_name, surface_ids[count]
+                )
+                for count, surface in enumerate(surfaces)
+            }
 
     @deprecate_argument(
         old_arg="surface_name",
@@ -602,47 +554,22 @@ class FileFieldData:
         ):
             raise InvalidFieldName()
 
-        if len(surfaces) == 1 and isinstance(surfaces[0], str):
-            surface_ids = self._field_info.get_surfaces_info()[surfaces[0]][
-                "surface_id"
-            ]
-            if len(self._file_session._data_file.get_phases()) > 1:
-                if not field_name.startswith("phase-"):
-                    raise InvalidMultiPhaseFieldName()
-                vector_data = self._file_session._data_file.get_face_vector_field_data(
-                    field_name.split(":")[0], surface_ids[0]
-                )
-            else:
-                vector_data = self._file_session._data_file.get_face_vector_field_data(
-                    "phase-1", surface_ids[0]
-                )
-
-            return VectorFieldData(surface_ids[0], vector_data, scale=1.0)
+        if len(self._file_session._data_file.get_phases()) > 1:
+            if not field_name.startswith("phase-"):
+                raise InvalidMultiPhaseFieldName()
+            return {
+                surface: self._file_session._data_file.get_face_vector_field_data(
+                    field_name.split(":")[0], surface_ids[count]
+                ).reshape(-1, 3)
+                for count, surface in enumerate(surfaces)
+            }
         else:
-            if len(self._file_session._data_file.get_phases()) > 1:
-                if not field_name.startswith("phase-"):
-                    raise InvalidMultiPhaseFieldName()
-                return {
-                    surface_id: VectorFieldData(
-                        surface_id,
-                        self._file_session._data_file.get_face_vector_field_data(
-                            field_name.split(":")[0], surface_id
-                        ),
-                        scale=1.0,
-                    )
-                    for surface_id in surface_ids
-                }
-            else:
-                return {
-                    surface_id: VectorFieldData(
-                        surface_id,
-                        self._file_session._data_file.get_face_vector_field_data(
-                            "phase-1", surface_id
-                        ),
-                        scale=1.0,
-                    )
-                    for surface_id in surface_ids
-                }
+            return {
+                surface: self._file_session._data_file.get_face_vector_field_data(
+                    "phase-1", surface_ids[count]
+                ).reshape(-1, 3)
+                for count, surface in enumerate(surfaces)
+            }
 
     @deprecate_argument(
         old_arg="surface_name",
@@ -683,6 +610,7 @@ class FileFieldInfo:
     """File field info."""
 
     def __init__(self, file_session):
+        """Initialize FileFieldInfo."""
         self._file_session = file_session
 
     def get_scalar_field_range(
@@ -871,4 +799,4 @@ def _get_surface_ids(
             surface_ids.extend(field_info.get_surfaces_info()[surf]["surface_id"])
         else:
             surface_ids.append(surf)
-    return list(set(surface_ids))
+    return surface_ids

ansys/fluent/core/filereader/case_file.py

@@ -234,15 +234,15 @@ class Mesh:
     Methods
     -------
 
-    get_surface_ids
+    get_surface_ids()
         Get a list of surface ids.
-    get_surface_names
+    get_surface_names()
         Get a list of surface names.
-    get_surface_locs
+    get_surface_locs(surface_id)
         Get the min and max location index of surface.
-    get_connectivity
+    get_connectivity(surface_id)
         Get the surface connectivity.
-    get_vertices
+    get_vertices(surface_id)
         Get list of vertices of the surface.
     """
 
@@ -326,35 +326,35 @@ class RPVarProcessor:
 
     Methods
     -------
-    input_parameters
+    input_parameters()
         Get a list of input parameter objects
-    output_parameters
+    output_parameters()
         Get a list of output parameter objects
-    num_dimensions
+    num_dimensions()
         Get the dimensionality of the case (2 or 3)
-    precision
+    precision()
         Get the precision (1 or 2 for 1D of 2D)
-    iter_count
+    iter_count()
         Get the number of iterations
-    rp_vars
+    rp_vars()
         Get dictionary of all RP vars
-    rp_var
+    rp_var(name)
         Get specific RP var by name, either by providing
         the Scheme name:
             `reader.rp_var("rad/enable-netm?")`
         or a pythonic version:
             `reader.rp_var.rad.enable_netm__q()`
-    has_rp_var
+    has_rp_var(name)
         Whether case has particular RP var
-    config_vars
+    config_vars()
         Get dictionary of all RP vars
-    config_var
+    config_var(name)
         Get specific config var by name, either by providing
         the Scheme name:
             `reader.config_var("rp-3d?")`
         or a pythonic version:
             `reader.config_var.rp_3d__q()`
-    has_config_var
+    has_config_var(name)
         Whether case has particular config var
     """
 
@@ -567,7 +567,7 @@ class CaseFile(RPVarProcessor):
 
     Methods
     -------
-    get_mesh
+    get_mesh()
         Get the mesh data.
     """