ansys-fluent-core 0.31.dev1__py3-none-any.whl → 0.32.dev0__py3-none-any.whl

ansys/fluent/core/services/reduction.py

@@ -36,6 +36,9 @@ from ansys.fluent.core.services.interceptors import (
     GrpcErrorInterceptor,
     TracingInterceptor,
 )
+from ansys.fluent.core.variable_strategies import (
+    FluentExprNamingStrategy as naming_strategy,
+)
 
 Path = List[Tuple[str, str]]
 
@@ -273,6 +276,7 @@ class Reduction:
         """__init__ method of Reduction class."""
         self.service = service
         self.ctxt = weakref.proxy(ctxt)
+        self._to_str = naming_strategy().to_string if naming_strategy else lambda s: s
 
     def _validate_str_location(self, loc: str):
         if all(
@@ -295,174 +299,159 @@ class Reduction:
         except BadReductionRequest:
             return locations
 
+    def _make_request(
+        self,
+        requestName,
+        locations,
+        ctxt=None,
+        expression=None,
+        weight=None,
+        condition=None,
+    ) -> Any:
+        request = getattr(ReductionProtoModule, requestName)()
+        if expression is not None:
+            request.expression = self._to_str(expression)
+        if weight is not None:
+            request.weight = weight
+        if condition is not None:
+            request.condition = condition
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        return request
+
     def area(self, locations, ctxt=None) -> Any:
         """Get area."""
-        request = ReductionProtoModule.AreaRequest()
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("AreaRequest", locations, ctxt)
         response = self.service.area(request)
         return _convert_variant_to_value(response.value)
 
     def area_average(self, expression, locations, ctxt=None) -> Any:
         """Get area average."""
-        request = ReductionProtoModule.AreaAveRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("AreaAveRequest", locations, ctxt, expression)
         response = self.service.area_average(request)
         return _convert_variant_to_value(response.value)
 
     def area_integral(self, expression, locations, ctxt=None) -> Any:
         """Get area integral."""
-        request = ReductionProtoModule.AreaIntRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("AreaIntRequest", locations, ctxt, expression)
         response = self.service.area_integral(request)
         return _convert_variant_to_value(response.value)
 
     def centroid(self, locations, ctxt=None) -> Any:
         """Get centroid."""
-        request = ReductionProtoModule.CentroidRequest()
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("CentroidRequest", locations, ctxt)
         response = self.service.centroid(request)
         return (response.value.x, response.value.y, response.value.z)
 
     def count(self, locations, ctxt=None) -> Any:
-        """Get count."""
-        request = ReductionProtoModule.CountRequest()
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        """Count the number of faces or cells within the locations."""
+        request = self._make_request("CountRequest", locations, ctxt)
         response = self.service.count(request)
         return _convert_variant_to_value(response.value)
 
     def count_if(self, condition, locations, ctxt=None) -> Any:
-        """Get count if a particular condition satisfies."""
-        request = ReductionProtoModule.CountIfRequest()
-        request.expression = condition
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        """Count the number of faces or cells where the specified condition is satisfied."""
+        request = self._make_request(
+            "CountIfRequest", locations, ctxt, condition=condition
+        )
         response = self.service.count_if(request)
         return _convert_variant_to_value(response.value)
 
     def force(self, locations, ctxt=None) -> Any:
         """Get force."""
-        request = ReductionProtoModule.ForceRequest()
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("ForceRequest", locations, ctxt)
         response = self.service.force(request)
         return (response.value.x, response.value.y, response.value.z)
 
     def mass_average(self, expression, locations, ctxt=None) -> Any:
         """Get mass average."""
-        request = ReductionProtoModule.MassAveRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("MassAveRequest", locations, ctxt, expression)
         response = self.service.mass_average(request)
         return _convert_variant_to_value(response.value)
 
     def mass_flow_average(self, expression, locations, ctxt=None) -> Any:
         """Get mass flow average."""
-        request = ReductionProtoModule.MassFlowAveRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("MassFlowAveRequest", locations, ctxt, expression)
         response = self.service.mass_flow_average(request)
         return _convert_variant_to_value(response.value)
 
     def mass_flow_average_absolute(self, expression, locations, ctxt=None) -> Any:
-        """Get absolute mass flow average."""
-        request = ReductionProtoModule.MassFlowAveAbsRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        """Compute the mass flow average of the absolute value of the given expression."""
+        request = self._make_request(
+            "MassFlowAveAbsRequest", locations, ctxt, expression
+        )
         response = self.service.mass_flow_average_absolute(request)
         return _convert_variant_to_value(response.value)
 
     def mass_flow_integral(self, expression, locations, ctxt=None) -> Any:
         """Get mass flow integral."""
-        request = ReductionProtoModule.MassFlowIntRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("MassFlowIntRequest", locations, ctxt, expression)
         response = self.service.mass_flow_integral(request)
         return _convert_variant_to_value(response.value)
 
     def mass_integral(self, expression, locations, ctxt=None) -> Any:
         """Get mass integral."""
-        request = ReductionProtoModule.MassIntRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("MassIntRequest", locations, ctxt, expression)
         response = self.service.mass_integral(request)
         return _convert_variant_to_value(response.value)
 
     def maximum(self, expression, locations, ctxt=None) -> Any:
         """Get maximum."""
-        request = ReductionProtoModule.MaximumRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("MaximumRequest", locations, ctxt, expression)
         response = self.service.maximum(request)
         return _convert_variant_to_value(response.value)
 
     def minimum(self, expression, locations, ctxt=None) -> Any:
         """Get minimum."""
-        request = ReductionProtoModule.MinimumRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("MinimumRequest", locations, ctxt, expression)
         response = self.service.minimum(request)
         return _convert_variant_to_value(response.value)
 
     def pressure_force(self, locations, ctxt=None) -> Any:
         """Get pressure force."""
-        request = ReductionProtoModule.PressureForceRequest()
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("PressureForceRequest", locations, ctxt)
         response = self.service.pressure_force(request)
         return (response.value.x, response.value.y, response.value.z)
 
     def viscous_force(self, locations, ctxt=None) -> Any:
         """Get viscous force."""
-        request = ReductionProtoModule.ViscousForceRequest()
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("ViscousForceRequest", locations, ctxt)
         response = self.service.viscous_force(request)
         return (response.value.x, response.value.y, response.value.z)
 
     def volume(self, locations, ctxt=None) -> Any:
         """Get volume."""
-        request = ReductionProtoModule.VolumeRequest()
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("VolumeRequest", locations, ctxt)
         response = self.service.volume(request)
         return _convert_variant_to_value(response.value)
 
     def volume_average(self, expression, locations, ctxt=None) -> Any:
         """Get volume average."""
-        request = ReductionProtoModule.VolumeAveRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("VolumeRequest", locations, ctxt, expression)
         response = self.service.volume_average(request)
         return _convert_variant_to_value(response.value)
 
     def volume_integral(self, expression, locations, ctxt=None) -> Any:
         """Get volume integral."""
-        request = ReductionProtoModule.VolumeIntRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("VolumeIntRequest", locations, ctxt, expression)
         response = self.service.volume_integral(request)
         return _convert_variant_to_value(response.value)
 
     def moment(self, expression, locations, ctxt=None) -> Any:
         """Get moment."""
-        request = ReductionProtoModule.MomentRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
+        request = self._make_request("MomentRequest", locations, ctxt, expression)
         response = self.service.moment(request)
         return (response.value.x, response.value.y, response.value.z)
 
     def sum(self, expression, locations, weight, ctxt=None) -> Any:
         """Get sum."""
-        request = ReductionProtoModule.SumRequest()
-        request.expression = expression
-        request.locations.extend(self._get_location_string(locations, ctxt))
-        request.weight = weight
+        request = self._make_request("SumRequest", locations, ctxt, expression, weight)
         response = self.service.sum(request)
         return _convert_variant_to_value(response.value)
 
     def sum_if(self, expression, condition, locations, weight, ctxt=None) -> Any:
-        """Get sum if a particular condition satisfies."""
-        request = ReductionProtoModule.SumIfRequest()
-        request.expression = expression
-        request.condition = condition
-        request.locations.extend(self._get_location_string(locations, ctxt))
-        request.weight = weight
+        """Compute the weighted sum of the expression at locations where the given condition is satisfied."""
+        request = self._make_request(
+            "SumIfRequest", locations, ctxt, expression, weight, condition
+        )
         response = self.service.sum_if(request)
         return _convert_variant_to_value(response.value)

ansys/fluent/core/services/solution_variables.py

@@ -42,6 +42,11 @@ from ansys.fluent.core.services.interceptors import (
     TracingInterceptor,
 )
 from ansys.fluent.core.solver.error_message import allowed_name_error_message
+from ansys.fluent.core.variable_strategies import (
+    FluentSVarNamingStrategy as naming_strategy,
+)
+
+_to_field_name_str = naming_strategy().to_string if naming_strategy else lambda s: s
 
 
 class SolutionVariableService:
@@ -354,6 +359,7 @@ class _AllowedSvarNames:
         SvarError
             If the given solution variable name is invalid.
         """
+        solution_variable_name = _to_field_name_str(solution_variable_name)
         if not self.is_valid(
             solution_variable_name, zone_names=zone_names, domain_name=domain_name
         ):
@@ -613,7 +619,9 @@ 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, zone_names, domain_name
+            solution_variable_name,
+            zone_names,
+            domain_name,
         )
         zone_id_name_map = {}
         for zone_name in zone_names:

ansys/fluent/core/session.py

@@ -29,8 +29,11 @@ from typing import Any, Callable, Dict
 import warnings
 import weakref
 
+from deprecated.sphinx import deprecated
+
 from ansys.fluent.core.fluent_connection import FluentConnection
 from ansys.fluent.core.journaling import Journal
+from ansys.fluent.core.launcher.launcher_utils import is_compose
 from ansys.fluent.core.pyfluent_warnings import (
     PyFluentDeprecationWarning,
     PyFluentUserWarning,
@@ -149,6 +152,7 @@ class BaseSession:
             event_type,
             get_zones_info,
         )
+        self.register_finalizer_callback = fluent_connection.register_finalizer_cb
 
     def _build_from_fluent_connection(
         self,
@@ -270,30 +274,23 @@ class BaseSession:
         return True if self._fluent_connection else False
 
     @property
+    @deprecated(version="0.20.dev9", reason="Use ``session.fields.field_info``.")
     def field_info(self):
         """Provides access to Fluent field information."""
-        warnings.warn(
-            "field_info is deprecated. Use fields.field_info instead.",
-            PyFluentDeprecationWarning,
-        )
         return self.fields.field_info
 
     @property
+    @deprecated(version="0.20.dev9", reason="Use ``session.fields.field_data``.")
     def field_data(self):
         """Fluent field data on surfaces."""
-        warnings.warn(
-            "field_data is deprecated. Use fields.field_data instead.",
-            PyFluentDeprecationWarning,
-        )
         return self.fields.field_data
 
     @property
+    @deprecated(
+        version="0.20.dev9", reason="Use ``session.fields.field_data_streaming``."
+    )
     def field_data_streaming(self):
         """Field gRPC streaming service of Fluent."""
-        warnings.warn(
-            "field_data_streaming is deprecated. Use fields.field_data_streaming instead.",
-            PyFluentDeprecationWarning,
-        )
         return self.fields.field_data_streaming
 
     @property
@@ -369,15 +366,21 @@ class BaseSession:
         """Gets and returns the fluent version."""
         return FluentVersion(self.scheme_eval.version)
 
+    def _exit_compose_service(self):
+        if self._fluent_connection._container and is_compose():
+            self._fluent_connection._container.stop()
+
     def exit(self, **kwargs) -> None:
         """Exit session."""
         logger.debug("session.exit() called")
         if self._fluent_connection:
+            self._exit_compose_service()
             self._fluent_connection.exit(**kwargs)
             self._fluent_connection = None
 
     def force_exit(self) -> None:
         """Forces the Fluent session to exit, losing unsaved progress and data."""
+        self._exit_compose_service()
         self._fluent_connection.force_exit()
 
     def file_exists_on_remote(self, file_name: str) -> bool:

ansys/fluent/core/session_meshing.py

@@ -89,6 +89,9 @@ class Meshing(PureMeshing):
             file_transfer_service=self._file_transfer_service,
         )
         self._fluent_connection = None
+        self.__doc__ = (
+            "The meshing session is no longer usable after switching to solution mode."
+        )
         return solver_session
 
     def __getattribute__(self, item: str):

ansys/fluent/core/session_solver.py

@@ -77,19 +77,6 @@ def _set_state_safe(obj: SettingsBase, state: StateType):
             datamodel_logger.debug(f"set_state failed at {obj.path}")
 
 
-def _import_settings_root(root):
-    _class_dict = {}
-    api_keys = []
-    if hasattr(root, "child_names"):
-        api_keys = root.child_names
-
-    for root_item in api_keys:
-        _class_dict[root_item] = root.__dict__[root_item]
-
-    settings_api_root = type("SettingsRoot", (object,), _class_dict)
-    return settings_api_root()
-
-
 class Solver(BaseSession):
     """Encapsulates a Fluent solver session.
 
@@ -143,9 +130,17 @@ class Solver(BaseSession):
         self._tui = None
         self._workflow = None
         self._system_coupling = None
-        self._settings_root = 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.scheme_eval,
+        )
         self._solution_variable_service = service_creator("svar").create(
             fluent_connection._channel, fluent_connection._metadata
         )
@@ -161,12 +156,12 @@ class Solver(BaseSession):
             )
         else:
             self.fields.reduction = reduction_old
-        self._settings_api_root = None
         self.fields.solution_variable_data = self._solution_variable_data()
 
         monitors_service = service_creator("monitors").create(
             fluent_connection._channel, fluent_connection._metadata, self._error_state
         )
+        #: Manage Fluent's solution monitors.
         self.monitors = MonitorsManager(fluent_connection._id, monitors_service)
         self.events.register_callback(
             (SolverEvent.SOLUTION_INITIALIZED, SolverEvent.DATA_LOADED),
@@ -269,19 +264,6 @@ class Solver(BaseSession):
             if command.path in interruptible_commands:
                 command._root.solution.run_calculation.interrupt()
 
-    @property
-    def settings(self):
-        """Root settings object."""
-        if self._settings_root is None:
-            self._settings_root = 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.scheme_eval,
-            )
-        return self._settings_root
-
     @property
     def system_coupling(self):
         """System coupling object."""
@@ -351,28 +333,23 @@ class Solver(BaseSession):
     def __call__(self):
         return self.get_state()
 
-    def _populate_settings_api_root(self):
-        if not self._settings_api_root:
-            self._settings_api_root = _import_settings_root(self.settings)
-
-    def __getattr__(self, attr):
-        self._populate_settings_api_root()
-        if attr in [x for x in dir(self._settings_api_root) if not x.startswith("_")]:
-            if self.get_fluent_version() > FluentVersion.v242:
+    def __getattr__(self, name):
+        try:
+            return super().__getattribute__(name)
+        except AttributeError as ex:
+            if name in self.settings.child_names:
                 warnings.warn(
-                    f"'{attr}' is deprecated. Use 'settings.{attr}' instead.",
+                    f"'{name}' is deprecated. Use 'settings.{name}' instead.",
                     DeprecatedSettingWarning,
                 )
-        return getattr(self._settings_api_root, attr)
+                return getattr(self.settings, name)
+            else:
+                raise ex
 
     def __dir__(self):
         if self._fluent_connection is None:
             return ["is_active"]
-        settings_dir = []
-        if self.get_fluent_version() <= FluentVersion.v242:
-            self._populate_settings_api_root()
-            settings_dir = dir(self._settings_api_root)
-        dir_list = set(list(self.__dict__.keys()) + dir(type(self)) + settings_dir) - {
+        dir_list = set(list(self.__dict__.keys()) + dir(type(self))) - {
             "svar_data",
             "svar_info",
             "reduction",