ansys-fluent-core 0.33.dev0__py3-none-any.whl → 0.33.1__py3-none-any.whl

ansys/fluent/core/services/solution_variables.py

@@ -92,7 +92,7 @@ class SolutionVariableInfo:
     >>> print(solution_variable_info_centroid)
     >>> name:SV_CENTROID dimension:3 field_type:<class 'numpy.float64'>
     >>> zones_info = solution_variable_info.get_zones_info()
-    >>> print(zones_info.zones)
+    >>> print(zones_info.zone_names)
     >>> ['fluid', 'wall', 'symmetry', 'pressure-outlet-7', 'velocity-inlet-6', 'velocity-inlet-5', 'default-interior']
     >>> zone_info = zones_info['wall']
     >>> print(zone_info)
@@ -208,7 +208,16 @@ class SolutionVariableInfo:
             return self._zones_info.get(name, None)
 
         @property
-        def zones(self) -> List[str]:
+        def zones(self):
+            """Get zone names."""
+            warnings.warn(
+                "'zones' is deprecated, use 'zone_names' instead",
+                PyFluentDeprecationWarning,
+            )
+            return self.zone_names
+
+        @property
+        def zone_names(self) -> List[str]:
             """Get zone names."""
             return list(self._zones_info.keys())
 
@@ -290,16 +299,15 @@ class SolutionVariableInfo:
         return SolutionVariableInfo.ZonesInfo(response.zonesInfo, response.domainsInfo)
 
 
-class SvarError(ValueError):
+class InvalidSolutionVariableNameError(ValueError):
     """Exception class for errors in solution variable name."""
 
-    def __init__(self, solution_variable_name: str, allowed_values: List[str]):
-        """Initialize SvarError."""
-        self.solution_variable_name = solution_variable_name
+    def __init__(self, variable_name: str, allowed_values: List[str]):
+        """Initialize InvalidSolutionVariableNameError."""
         super().__init__(
             allowed_name_error_message(
                 context="solution variable",
-                trial_name=solution_variable_name,
+                trial_name=variable_name,
                 allowed_values=allowed_values,
             )
         )
@@ -337,18 +345,16 @@ class _AllowedSvarNames:
 
     def is_valid(
         self,
-        solution_variable_name,
+        variable_name,
         zone_names: List[str],
         domain_name: str | None = "mixture",
     ):
         """Check whether solution variable name is valid or not."""
-        return solution_variable_name in self(
-            zone_names=zone_names, domain_name=domain_name
-        )
+        return variable_name in self(zone_names=zone_names, domain_name=domain_name)
 
     def valid_name(
         self,
-        solution_variable_name,
+        variable_name,
         zone_names: List[str],
         domain_name: str | None = "mixture",
     ):
@@ -356,18 +362,18 @@ class _AllowedSvarNames:
 
         Raises
         ------
-        SvarError
+        InvalidSolutionVariableNameError
             If the given solution variable name is invalid.
         """
-        solution_variable_name = _to_field_name_str(solution_variable_name)
+        variable_name = _to_field_name_str(variable_name)
         if not self.is_valid(
-            solution_variable_name, zone_names=zone_names, domain_name=domain_name
+            variable_name, zone_names=zone_names, domain_name=domain_name
         ):
-            raise SvarError(
-                solution_variable_name=solution_variable_name,
+            raise InvalidSolutionVariableNameError(
+                variable_name=variable_name,
                 allowed_values=self(zone_names=zone_names, domain_name=domain_name),
             )
-        return solution_variable_name
+        return variable_name
 
 
 class _AllowedZoneNames(_AllowedNames):
@@ -375,7 +381,7 @@ class _AllowedZoneNames(_AllowedNames):
         self._zones_info = solution_variable_info.get_zones_info()
 
     def __call__(self) -> List[str]:
-        return self._zones_info.zones
+        return self._zones_info.zone_names
 
     def valid_name(self, zone_name):
         """Get a valid zone name.
@@ -491,10 +497,10 @@ class SolutionVariableData:
     Examples
     --------
     >>> solution_variable_data = solver_session.fields.solution_variable_data
-    >>> sv_t_wall_fluid=solver_session.fields.solution_variable_data.get_data(solution_variable_name="SV_T", domain_name="mixture", zone_names=["fluid", "wall"])
+    >>> sv_t_wall_fluid=solver_session.fields.solution_variable_data.get_data(variable_name="SV_T", domain_name="mixture", zone_names=["fluid", "wall"])
     >>> print(sv_t_wall_fluid.domain)
     >>> 'mixture'
-    >>> print(sv_t_wall_fluid.zones)
+    >>> print(sv_t_wall_fluid.zone_names)
     >>> ['fluid', 'wall']
     >>> fluid_temp = sv_t_wall_fluid['fluid']
     >>> print(fluid_temp.size)
@@ -507,8 +513,8 @@ class SolutionVariableData:
     >>> fluid_temp_array =solution_variable_data.create_empty_array("SV_T", "fluid")
     >>> wall_temp_array[:]= 500
     >>> fluid_temp_array[:]= 600
-    >>> zone_names_to_solution_variable_data = {'wall':wall_temp_array, 'fluid':fluid_temp_array}
-    >>> solution_variable_data.set_data(solution_variable_name="SV_T", domain_name="mixture", zone_names_to_solution_variable_data=zone_names_to_solution_variable_data)
+    >>> zone_names_to_data = {'wall':wall_temp_array, 'fluid':fluid_temp_array}
+    >>> solution_variable_data.set_data(variable_name="SV_T", domain_name="mixture", zone_names_to_data=zone_names_to_data)
     """
 
     class Data:
@@ -529,7 +535,16 @@ class SolutionVariableData:
 
         @property
         def zones(self):
-            """Zone name."""
+            """Zone names."""
+            warnings.warn(
+                "'zones' is deprecated, use 'zone_names' instead",
+                PyFluentDeprecationWarning,
+            )
+            return self.zone_names
+
+        @property
+        def zone_names(self):
+            """Zone names."""
             return list(self._data.keys())
 
         @property
@@ -568,7 +583,7 @@ class SolutionVariableData:
 
     def create_empty_array(
         self,
-        solution_variable_name: str,
+        variable_name: str,
         zone_name: str,
         domain_name: str | None = "mixture",
     ) -> np.zeros:
@@ -579,20 +594,20 @@ class SolutionVariableData:
         self._update_solution_variable_info()
 
         zones_info = self._solution_variable_info.get_zones_info()
-        if zone_name in zones_info.zones:
+        if zone_name in zones_info.zone_names:
             solution_variables_info = self._solution_variable_info.get_variables_info(
                 zone_names=[zone_name], domain_name=domain_name
             )
-            if solution_variable_name in solution_variables_info.solution_variables:
+            if variable_name in solution_variables_info.solution_variables:
                 return np.zeros(
                     zones_info[zone_name].count
-                    * solution_variables_info[solution_variable_name].dimension,
-                    dtype=solution_variables_info[solution_variable_name].field_type,
+                    * solution_variables_info[variable_name].dimension,
+                    dtype=solution_variables_info[variable_name].field_type,
                 )
 
     def get_data(
         self,
-        solution_variable_name: str,
+        variable_name: str,
         zone_names: List[str],
         domain_name: str | None = "mixture",
     ) -> Data:
@@ -600,10 +615,10 @@ class SolutionVariableData:
 
         Parameters
         ----------
-        solution_variable_name : str
-            Name of the SVAR.
+        variable_name : str
+            Name of the solution variable.
         zone_names: List[str]
-            Zone names list for SVAR data.
+            Zone names list for solution variable data.
         domain_name : str, optional
             Domain name. The default is ``mixture``.
 
@@ -619,7 +634,7 @@ class SolutionVariableData:
         )
         svars_request.domainId = self._allowed_domain_names.valid_name(domain_name)
         svars_request.name = self._allowed_solution_variable_names.valid_name(
-            solution_variable_name,
+            variable_name,
             zone_names,
             domain_name,
         )
@@ -637,7 +652,7 @@ class SolutionVariableData:
 
     def get_svar_data(
         self,
-        svar_name: str,
+        variable_name: str,
         zone_names: List[str],
         domain_name: str | None = "mixture",
     ) -> Data:
@@ -647,25 +662,25 @@ class SolutionVariableData:
             PyFluentDeprecationWarning,
         )
         return self.get_data(
-            solution_variable_name=svar_name,
+            variable_name=variable_name,
             zone_names=zone_names,
             domain_name=domain_name,
         )
 
     def set_data(
         self,
-        solution_variable_name: str,
-        zone_names_to_solution_variable_data: Dict[str, np.array],
+        variable_name: str,
+        zone_names_to_data: Dict[str, np.array],
         domain_name: str | None = "mixture",
     ) -> None:
         """Set SVAR data on zones.
 
         Parameters
         ----------
-        solution_variable_name : str
-            Name of the SVAR.
-        zone_names_to_solution_variable_data: Dict[str, np.array]
-            Dictionary containing zone names for SVAR data.
+        variable_name : str
+            Name of the solution variable.
+        zone_names_to_data: Dict[str, np.array]
+            Dictionary containing zone names for solution variable data.
         domain_name : str, optional
             Domain name. The default is ``mixture``.
 
@@ -677,7 +692,7 @@ class SolutionVariableData:
         domain_id = self._allowed_domain_names.valid_name(domain_name)
         zone_ids_to_svar_data = {
             self._allowed_zone_names.valid_name(zone_name): solution_variable_data
-            for zone_name, solution_variable_data in zone_names_to_solution_variable_data.items()
+            for zone_name, solution_variable_data in zone_names_to_data.items()
         }
 
         def generate_set_data_requests():
@@ -686,7 +701,7 @@ class SolutionVariableData:
             set_data_requests.append(
                 SvarProtoModule.SetSvarDataRequest(
                     header=SvarProtoModule.SvarHeader(
-                        name=solution_variable_name, domainId=domain_id
+                        name=variable_name, domainId=domain_id
                     )
                 )
             )
@@ -754,17 +769,17 @@ class SolutionVariableData:
 
     def set_svar_data(
         self,
-        svar_name: str,
-        zone_names_to_svar_data: List[str],
+        variable_name: str,
+        zone_names_to_svar_data: Dict[str, np.array],
         domain_name: str | None = "mixture",
-    ) -> Data:
+    ) -> None:
         """Set solution variable data."""
         warnings.warn(
             "set_svar_data is deprecated, use set_data instead",
             PyFluentDeprecationWarning,
         )
         return self.set_data(
-            solution_variable_name=svar_name,
-            zone_names_to_solution_variable_data=zone_names_to_svar_data,
+            variable_name=variable_name,
+            zone_names_to_data=zone_names_to_svar_data,
             domain_name=domain_name,
         )

ansys/fluent/core/session.py

@@ -221,36 +221,7 @@ class BaseSession:
             FieldDataService, self._error_state
         )
 
-        class Fields:
-            """Container for field and solution variables."""
-
-            def __init__(self, _session):
-                """Initialize Fields."""
-                self._is_solution_data_valid = (
-                    _session._app_utilities.is_solution_data_available
-                )
-                self.field_info = service_creator("field_info").create(
-                    _session._field_data_service,
-                    self._is_solution_data_valid,
-                )
-                self.field_data = service_creator("field_data").create(
-                    _session._field_data_service,
-                    self.field_info,
-                    self._is_solution_data_valid,
-                    _session.scheme,
-                    get_zones_info,
-                )
-                self.field_data_streaming = FieldDataStreaming(
-                    _session._fluent_connection._id, _session._field_data_service
-                )
-                self.field_data_old = service_creator("field_data_old").create(
-                    _session._field_data_service,
-                    self.field_info,
-                    self._is_solution_data_valid,
-                    _session.scheme,
-                )
-
-        self.fields = Fields(self)
+        self.fields = Fields(self, get_zones_info)
 
         self._settings_service = service_creator("settings").create(
             fluent_connection._channel,
@@ -283,6 +254,7 @@ class BaseSession:
         """Provides access to Fluent field information."""
         return self.scheme
 
+    @property
     @deprecated(version="0.32", reason="Use ``session.is_server_healthy``.")
     def health_check(self):
         """Provides access to Health Check service."""
@@ -482,3 +454,37 @@ class BaseSession:
             "stop_journal",
         }
         return sorted(dir_list)
+
+
+class Fields:
+    """Container for field and solution variables."""
+
+    def __init__(
+        self,
+        _session: BaseSession,
+        get_zones_info: weakref.WeakMethod[Callable[[], list[ZoneInfo]]] | None = None,
+    ):
+        """Initialize Fields."""
+        self._is_solution_data_valid = (
+            _session._app_utilities.is_solution_data_available
+        )
+        self.field_info = service_creator("field_info").create(
+            _session._field_data_service,
+            self._is_solution_data_valid,
+        )
+        self.field_data = service_creator("field_data").create(
+            _session._field_data_service,
+            self.field_info,
+            self._is_solution_data_valid,
+            _session.scheme,
+            get_zones_info,
+        )
+        self.field_data_streaming = FieldDataStreaming(
+            _session._fluent_connection._id, _session._field_data_service
+        )
+        self.field_data_old = service_creator("field_data_old").create(
+            _session._field_data_service,
+            self.field_info,
+            self._is_solution_data_valid,
+            _session.scheme,
+        )

ansys/fluent/core/session_base_meshing.py

@@ -24,7 +24,6 @@
 
 import logging
 
-import ansys.fluent.core as pyfluent
 from ansys.fluent.core.fluent_connection import FluentConnection
 from ansys.fluent.core.meshing.meshing_workflow import (
     CreateWorkflow,
@@ -32,9 +31,7 @@ from ansys.fluent.core.meshing.meshing_workflow import (
     WorkflowMode,
     name_to_identifier_map,
 )
-from ansys.fluent.core.services.datamodel_se import PyMenuGeneric
 from ansys.fluent.core.session_shared import (
-    _CODEGEN_MSG_DATAMODEL,
     _make_datamodel_module,
     _make_tui_module,
 )
@@ -113,27 +110,8 @@ class BaseMeshing:
     @property
     def _meshing_utilities_root(self):
         """Datamodel root of meshing_utilities."""
-        try:
-            if self.get_fluent_version() >= FluentVersion.v242:
-                from ansys.fluent.core import CODEGEN_OUTDIR
-
-                meshing_utilities_module = pyfluent.utils.load_module(
-                    f"meshing_utilities_{self._version}",
-                    CODEGEN_OUTDIR
-                    / f"datamodel_{self._version}"
-                    / "meshing_utilities.py",
-                )
-                meshing_utilities_root = meshing_utilities_module.Root(
-                    self._se_service, "MeshingUtilities", []
-                )
-        except (ImportError, FileNotFoundError):
-            datamodel_logger.warning("Generated API not found for MeshingUtilities.")
-            datamodel_logger.warning(_CODEGEN_MSG_DATAMODEL)
-            if self.get_fluent_version() >= FluentVersion.v242:
-                meshing_utilities_root = PyMenuGeneric(
-                    self._se_service, "MeshingUtilities"
-                )
-        return meshing_utilities_root
+        if self.get_fluent_version() >= FluentVersion.v242:
+            return _make_datamodel_module(self, "MeshingUtilities")
 
     @property
     def meshing_utilities(self):

ansys/fluent/core/session_shared.py

@@ -25,6 +25,7 @@
 import logging
 
 import ansys.fluent.core as pyfluent
+from ansys.fluent.core.pyfluent_warnings import warning_for_fluent_dev_version
 from ansys.fluent.core.services.datamodel_se import PyMenuGeneric
 from ansys.fluent.core.services.datamodel_tui import TUIMenu
 
@@ -52,6 +53,7 @@ def _make_tui_module(session, module_name):
             f"{module_name}_tui_{session._version}",
             CODEGEN_OUTDIR / module_name / f"tui_{session._version}.py",
         )
+        warning_for_fluent_dev_version(session._version)
         return tui_module.main_menu(
             session._tui_service, session._version, module_name, []
         )
@@ -63,13 +65,14 @@ def _make_tui_module(session, module_name):
 def _make_datamodel_module(session, module_name):
     try:
         from ansys.fluent.core import CODEGEN_OUTDIR
-        from ansys.fluent.core.codegen.datamodelgen import meshing_rule_file_names
+        from ansys.fluent.core.codegen.datamodelgen import datamodel_file_name_map
 
-        file_name = meshing_rule_file_names[module_name]
+        file_name = datamodel_file_name_map[module_name]
         module = pyfluent.utils.load_module(
             f"{module_name}_{session._version}",
             CODEGEN_OUTDIR / f"datamodel_{session._version}" / f"{file_name}.py",
         )
+        warning_for_fluent_dev_version(session._version)
         return module.Root(session._se_service, module_name, [])
     except (ImportError, FileNotFoundError):
         datamodel_logger.warning("Generated API not found for %s.", module_name)

ansys/fluent/core/session_solver.py

@@ -117,6 +117,7 @@ class Solver(BaseSession):
             event_type=SolverEvent,
             get_zones_info=weakref.WeakMethod(self._get_zones_info),
         )
+        self._settings = None
         self._build_from_fluent_connection(fluent_connection, scheme_eval)
 
     def _build_from_fluent_connection(
@@ -132,15 +133,6 @@ class Solver(BaseSession):
         self._system_coupling = None
         self._fluent_version = None
         self._bg_session_threads = []
-
-        #: Root settings object.
-        self.settings = flobject.get_root(
-            flproxy=self._settings_service,
-            version=self._version,
-            interrupt=Solver._interrupt,
-            file_transfer_service=self._file_transfer_service,
-            scheme_eval=self.scheme.eval,
-        )
         self._solution_variable_service = service_creator("svar").create(
             fluent_connection._channel, fluent_connection._metadata
         )
@@ -182,6 +174,20 @@ class Solver(BaseSession):
             self._solution_variable_service, self.fields.solution_variable_info
         )
 
+    @property
+    def settings(self):
+        """Settings root handle."""
+        if self._settings is None:
+            #: Root settings object.
+            self._settings = flobject.get_root(
+                flproxy=self._settings_service,
+                version=self._version,
+                interrupt=Solver._interrupt,
+                file_transfer_service=self._file_transfer_service,
+                scheme_eval=self.scheme.eval,
+            )
+        return self._settings
+
     @property
     def svar_data(self):
         """``SolutionVariableData`` handle."""

ansys/fluent/core/solver/__init__.py

@@ -27,4 +27,4 @@ try:
 except (ImportError, AttributeError, SyntaxError):
     pass
 
-from ansys.fluent.core.utils.context_managers import ReadCase, using  # noqa: F401
+from ansys.fluent.core.utils.context_managers import using  # noqa: F401