ansys-fluent-core 0.35.dev0__py3-none-any.whl → 0.36.dev0__py3-none-any.whl

ansys/fluent/core/session_base_meshing.py

@@ -72,6 +72,7 @@ class BaseMeshing:
         self._fluent_version = fluent_version
         self._meshing_utilities = None
         self._old_workflow = None
+        self._meshing_workflow = None
         self._part_management = None
         self._pm_file_management = None
         self._preferences = None
@@ -127,6 +128,13 @@ class BaseMeshing:
             self._old_workflow = _make_datamodel_module(self, "workflow")
         return self._old_workflow
 
+    @property
+    def meshing_workflow(self):
+        """Full API to meshing and meshing_workflow."""
+        if self._meshing_workflow is None:
+            self._meshing_workflow = _make_datamodel_module(self, "meshing_workflow")
+        return self._meshing_workflow
+
     def watertight_workflow(self, initialize: bool = True):
         """Datamodel root of workflow."""
         self._current_workflow = WorkflowMode.WATERTIGHT_MESHING_MODE.value(

ansys/fluent/core/session_meshing.py

@@ -127,6 +127,11 @@ class Meshing(PureMeshing):
         """Workflow datamodel root."""
         return super(Meshing, self).workflow
 
+    @property
+    def meshing_workflow(self):
+        """Full API to meshing and meshing_workflow."""
+        return super(Meshing, self).meshing_workflow
+
     @property
     def PartManagement(self):
         """Part management datamodel root."""

ansys/fluent/core/session_pure_meshing.py

@@ -50,6 +50,7 @@ class PureMeshing(BaseSession):
 
     _rules = [
         "workflow",
+        "meshing_workflow",
         "meshing",
         "MeshingUtilities",
         "PartManagement",
@@ -146,6 +147,11 @@ class PureMeshing(BaseSession):
         """Datamodel root of workflow."""
         return self._base_meshing.workflow
 
+    @property
+    def meshing_workflow(self):
+        """Full API to meshing and meshing_workflow."""
+        return self._base_meshing.meshing_workflow
+
     def watertight(self):
         """Get a new watertight workflow."""
         return self._base_meshing.watertight_workflow()

ansys/fluent/core/session_pure_meshing.pyi

@@ -34,6 +34,9 @@ from ansys.fluent.core.generated.datamodel_252.preferences import (
     Root as preferences_root,
 )
 from ansys.fluent.core.generated.datamodel_252.workflow import Root as workflow_root
+from ansys.fluent.core.generated.datamodel_261.meshing_workflow import (
+    Root as meshing_workflow_root,
+)
 from ansys.fluent.core.generated.meshing.tui_252 import main_menu
 
 class PureMeshing:
@@ -45,6 +48,8 @@ class PureMeshing:
     def meshing_utilities(self) -> meshing_utilities_root: ...
     @property
     def workflow(self) -> workflow_root: ...
+    @property
+    def meshing_workflow(self) -> meshing_workflow_root: ...
     def watertight(self): ...
     def fault_tolerant(self): ...
     def two_dimensional_meshing(self): ...

ansys/fluent/core/session_solver.py

@@ -160,10 +160,11 @@ class Solver(BaseSession):
         )
         #: Manage Fluent's solution monitors.
         self.monitors = MonitorsManager(fluent_connection._id, monitors_service)
-        self.events.register_callback(
-            (SolverEvent.SOLUTION_INITIALIZED, SolverEvent.DATA_LOADED),
-            self.monitors.refresh,
-        )
+        if not pyfluent.config.disable_monitor_refresh_on_init:
+            self.events.register_callback(
+                (SolverEvent.SOLUTION_INITIALIZED, SolverEvent.DATA_LOADED),
+                self.monitors.refresh,
+            )
 
         fluent_connection.register_finalizer_cb(self.monitors.stop)
 

ansys/fluent/core/session_utilities.py

@@ -90,8 +90,9 @@ class SessionBase:
 
         Parameters
         ----------
-        ui_mode : UIMode
-            Defines the user interface mode for Fluent. Options correspond to values in the ``UIMode`` enum.
+        ui_mode : UIMode or str, optional
+            Defines the user interface mode for Fluent. Accepts either a ``UIMode`` value
+            or a corresponding string such as ``"no_gui"``, ``"hidden_gui"``, or ``"gui"``.
         graphics_driver : FluentWindowsGraphicsDriver or FluentLinuxGraphicsDriver
             Specifies the graphics driver for Fluent. Options are from the ``FluentWindowsGraphicsDriver`` enum
             (for Windows) or the ``FluentLinuxGraphicsDriver`` enum (for Linux).
@@ -194,8 +195,9 @@ class SessionBase:
 
         Parameters
         ----------
-        ui_mode : UIMode
-            Defines the user interface mode for Fluent. Options correspond to values in the ``UIMode`` enum.
+        ui_mode : UIMode or str, optional
+            Defines the user interface mode for Fluent. Accepts either a ``UIMode`` value
+            or a corresponding string such as ``"no_gui"``, ``"hidden_gui"``, or ``"gui"``.
         graphics_driver : FluentWindowsGraphicsDriver or FluentLinuxGraphicsDriver
             Specifies the graphics driver for Fluent. Options are from the ``FluentWindowsGraphicsDriver`` enum
             (for Windows) or the ``FluentLinuxGraphicsDriver`` enum (for Linux).
@@ -287,7 +289,8 @@ class SessionBase:
         Parameters
         ----------
         ui_mode : UIMode or str, optional
-            Defines the user interface mode for Fluent. Options correspond to values in the ``UIMode`` enum.
+            Defines the user interface mode for Fluent. Accepts either a ``UIMode`` value
+            or a corresponding string such as ``"no_gui"``, ``"hidden_gui"``, or ``"gui"``.
         graphics_driver : FluentWindowsGraphicsDriver or FluentLinuxGraphicsDriver
             Specifies the graphics driver for Fluent. Options are from the ``FluentWindowsGraphicsDriver`` enum
             (for Windows) or the ``FluentLinuxGraphicsDriver`` enum (for Linux).

ansys/fluent/core/solver/flobject.py

@@ -80,6 +80,7 @@ from ansys.fluent.core.variable_strategies import (
     FluentFieldDataNamingStrategy as naming_strategy,
 )
 import ansys.units
+from ansys.units import VariableDescriptor
 
 from . import _docstrings
 from ..pyfluent_warnings import warning_for_fluent_dev_version
@@ -676,7 +677,21 @@ class Textual(Property):
             Either str or VariableDescriptor.
         kwargs : Any
             Keyword arguments.
+
+        Raises
+        ------
+        TypeError
+            If state is not a string.
         """
+        allowed_types = (str, VariableDescriptor)
+
+        if not isinstance(state, allowed_types):
+            if self._has_migration_adapter:
+                return self.base_set_state(state=state, **kwargs)
+            raise TypeError(
+                f"Expected state to be {' or '.join(t.__name__ for t in allowed_types)}, "
+                f"got {type(state).__name__}."
+            )
         return self.base_set_state(state=_to_field_name_str(state), **kwargs)
 
 
@@ -2282,6 +2297,10 @@ def get_cls(name, info, parent=None, version=None, parent_taboo=None):
                 )
             cls._allowed_values = allowed_values
 
+        has_migration_adapter = info.get("has-migration-adapter?", False)
+        if has_migration_adapter:
+            cls._has_migration_adapter = True
+
     except Exception:
         print(
             f"Unable to construct class for '{name}' of "

ansys/fluent/core/solver/flunits.py

@@ -298,6 +298,8 @@ def get_si_unit_for_fluent_quantity(
     # attribute only for dimensionless variables
     if quantity is None:
         return ""
+    if isinstance(quantity, list):  # real vector
+        quantity = quantity[0]
     if not isinstance(quantity, str):
         raise InvalidQuantityType(quantity)
     try:

ansys/fluent/core/solver/function/reduction.py

@@ -211,6 +211,8 @@ def _eval_reduction(
         weight = "Weight=" + str(weight)
         locations = str(locations) + ", " + weight
 
+    if hasattr(expr, "definition"):
+        expr = expr.definition()
     expr_str = _expr_to_expr_str(naming_strategy().to_string(expr))
     if condition:
         expr_str = expr_str + ", " + condition

ansys/fluent/core/ui/__init__.py

@@ -0,0 +1,64 @@
+# Copyright (C) 2021 - 2025 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Public exposure of ui UI for PyFluent."""
+
+
+def in_jupyter():
+    """Checks if the library is being used in a Jupyter environment."""
+    try:
+        from IPython import get_ipython
+
+        return "IPKernelApp" in get_ipython().config
+    except (ImportError, AttributeError):
+        return False
+
+
+if in_jupyter():
+    from ansys.fluent.core.ui.jupyter_ui import (
+        set_auto_refresh,
+        settings_ui,
+    )
+else:
+    from ansys.fluent.core.ui.standalone_web_ui import (  # noqa: F401
+        build_settings_view,
+        set_auto_refresh,
+    )
+
+
+def ui(settings_obj):
+    """PyFluent ui UI wrapper."""
+    if in_jupyter():
+        import IPython
+        from IPython.display import display
+
+        if hasattr(IPython, "get_ipython") and "ZMQInteractiveShell" in str(
+            type(IPython.get_ipython())
+        ):
+            display(settings_ui(settings_obj))
+    else:
+        import panel as pn
+
+        pn.extension()
+        view = build_settings_view(settings_obj)
+        view.servable()
+        pn.serve(view)

ansys/fluent/core/ui/jupyter_ui.py

@@ -0,0 +1,203 @@
+# Copyright (C) 2021 - 2025 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Render ui UI in Jupyter notebook."""
+
+from ansys.fluent.core.ui.utils import (
+    _parse_path,
+    _render_widget_from_props_generic,
+    _safe_get_properties,
+)
+
+try:
+    import ipywidgets as widgets
+except ModuleNotFoundError as exc:
+    raise ModuleNotFoundError(
+        "Missing dependencies, use 'pip install ansys-fluent-core[ui-jupyter]' to install them."
+    ) from exc
+
+from ansys.fluent.core.solver.flobject import (
+    BaseCommand,
+    Group,
+    NamedObject,
+)
+
+
+def set_auto_refresh():
+    """Refreshes the UI w.r.t. server state for each command execution or parameter invocation."""
+    raise NotImplementedError("This is yet to be implemented in jupyter environment.")
+
+
+def _render_widgets_from_props(settings_obj, label, props):
+    """Render widget using pre-fetched props instead of repeated calls."""
+    return _render_widget_from_props_generic(settings_obj, label, props, widgets)
+
+
+def _param_ui(settings_obj, props):
+    label = props["python_name"].replace("_", " ").capitalize()
+
+    def get_fn():
+        try:
+            return getattr(props["parent"], props["python_name"])
+        except AttributeError:
+            return props["parent"][props["obj_name"]]
+
+    def set_fn(v):
+        return setattr(settings_obj.parent, props["python_name"], v)
+
+    widget = _render_widgets_from_props(get_fn(), label, props)
+    output = widgets.Output()
+    with output:
+        output.clear_output()
+        print(_parse_path(settings_obj))
+    if hasattr(widget, "_is_list_text"):
+        typ, parse_csv = widget._is_list_text
+
+        def commit_text_list(change):
+            if change["name"] == "value":
+                raw = change["new"]
+                vals = (
+                    [typ(v.strip()) for v in raw.split(",") if v.strip()]
+                    if parse_csv
+                    else list(change["new"])
+                )
+                with output:
+                    output.clear_output()
+                    set_fn(vals)
+                    print(f"{_parse_path(settings_obj)} = {vals}")
+
+        widget.observe(commit_text_list)
+    else:
+
+        def on_change(change):
+            if change["name"] == "value":
+                with output:
+                    output.clear_output()
+                    try:
+                        set_fn(change["new"])
+                        print(f"{_parse_path(settings_obj)} = {change['new']}")
+                    except Exception as e:
+                        print(f"Error setting {label}: {e}")
+
+        widget.observe(on_change)
+    return widgets.VBox([widget, output])
+
+
+def _command_ui(func, props):
+    """
+    Renders input widgets for function arguments based on .argument_names()
+    and executes func(**kwargs) on button click.
+    """
+
+    # Get argument names from the function object
+    if not hasattr(func, "argument_names"):
+        return widgets.HTML("Command has no 'argument_names()'.")
+
+    arg_names = func.argument_names
+    arg_widgets = {}
+    controls = []
+    for name in arg_names:
+        child_obj = getattr(func, name)
+        child_props = _safe_get_properties(child_obj)
+        widget = _render_widgets_from_props(child_obj, name, child_props)
+        arg_widgets[name] = widget
+        controls.append(widget)
+
+    # Run button
+    button = widgets.Button(
+        description=f"Run {props['python_name']}", button_style="success"
+    )
+    output = widgets.Output()
+    with output:
+        output.clear_output()
+        print(_parse_path(func))
+
+    def on_click(_):
+        kwargs = {name: w.value for name, w in arg_widgets.items()}
+        with output:
+            output.clear_output()
+            try:
+                func(**kwargs)
+                kwargs_str = "("
+                for k, v in kwargs.items():
+                    if type(v) is str:
+                        if v != "":
+                            kwargs_str += f"{k}='{v}', "
+                    else:
+                        kwargs_str += f"{k}={v}, "
+                print(f"{_parse_path(func)}" + kwargs_str.strip()[:-1] + ")")
+            except Exception as e:
+                print("Error:", e)
+
+    button.on_click(on_click)
+    return widgets.VBox(controls + [button, output])
+
+
+def settings_ui(obj, indent=0):
+    """Render settings objects into ui graphics."""
+    props = _safe_get_properties(obj)
+    if isinstance(obj, (Group, NamedObject)):
+        if isinstance(obj, Group):
+            command_names = obj.get_active_command_names()
+            child_names = obj.get_active_child_names() + command_names
+        else:
+            command_names = obj.command_names
+            child_names = list(obj) + command_names
+        accordions = []
+        for child_name in child_names:
+
+            def lazy_loader(name=child_name, parent=obj, lvl=indent + 1):
+                try:
+                    child_obj = getattr(parent, name)
+                except AttributeError:
+                    child_obj = parent[name]
+                return settings_ui(child_obj, lvl)
+
+            acc = widgets.Accordion(children=[widgets.HTML("Loading...")])
+            if child_name in command_names:
+                acc.set_title(0, f"⚡ {child_name}")
+            else:
+                acc.set_title(0, child_name)
+
+            def on_selected(change, loader=lazy_loader, accordion=acc):
+                if change["name"] == "selected_index" and change["new"] == 0:
+                    if isinstance(accordion.children[0], widgets.HTML):
+                        accordion.children = [loader()]
+
+            acc.observe(on_selected, names="selected_index")
+            accordions.append(acc)
+
+        return widgets.VBox(accordions)
+
+    else:
+        if isinstance(obj, BaseCommand):
+            return (
+                widgets.VBox([_command_ui(obj, props)])
+                if props["is_active"]
+                else widgets.HTML("")
+            )
+        else:
+            return (
+                widgets.VBox([_param_ui(obj, props)])
+                if props["is_active"]
+                else widgets.HTML("")
+            )