ansys-fluent-core 0.20.dev5__py3-none-any.whl → 0.20.dev6__py3-none-any.whl

ansys/fluent/core/meshing/watertight.py

@@ -1,46 +1,32 @@
 """Watertight workflow module."""
 
-from ansys.fluent.core.launcher.launcher import launch_fluent
-from ansys.fluent.core.launcher.launcher_utils import FluentMode
+from typing import Optional, Union
 
-from .meshing_workflow import EnhancedMeshingWorkflow
+from ..session_meshing import Meshing
+from ..session_pure_meshing import PureMeshing
+from .meshing_workflow import WatertightMeshingWorkflow
 
 
-def watertight_workflow(geometry_file_name, **launch_args) -> EnhancedMeshingWorkflow:
+def watertight_workflow(
+    session: Union[Meshing, PureMeshing], geometry_file_name: Optional[str] = None
+) -> WatertightMeshingWorkflow:
     """Meshing workflow wrapper, initialized as watertight.
 
     Parameters
     ----------
-    geometry_file_name : str
+    session: Union[Meshing, PureMeshing]
+        Meshing session object.
+    geometry_file_name : Optional[str]
         The path of a valid geometry file to import. Can be unset.
-    launch_args
-        Additional arguments forwarded to the launch_fluent function.
 
     Returns
     -------
-    EnhancedMeshingWorkflow
-        Meshing workflow wrapper.
+    WatertightMeshingWorkflow
+        Watertight meshing workflow wrapper.
     """
-    dynamic_interface = True
-    if "dynamic_interface" in launch_args:
-        dynamic_interface = launch_args["dynamic_interface"]
-        del launch_args["dynamic_interface"]
-    if "session" in launch_args:
-        session = launch_args["session"]
-    else:
-        args = dict(mode=FluentMode.PURE_MESHING_MODE)
-        args.update(launch_args)
-        try:
-            session = launch_fluent(**args)
-        except Exception:
-            args["mode"] = FluentMode.MESHING_MODE
-            session = launch_fluent(**args)
-    meshing_workflow = session.watertight(dynamic_interface=dynamic_interface)
+    watertight = session.watertight()
     if geometry_file_name:
-        import_geometry = meshing_workflow.import_geometry
-        # change it so we can do this:
-        # import_geometry.arguments.FileName = geometry_file_name
-        # or import_geometry.FileName = geometry_file_name
-        import_geometry.arguments.update_dict(dict(file_name=geometry_file_name))
+        import_geometry = watertight.import_geometry
+        import_geometry.file_name = geometry_file_name
         import_geometry()
-    return meshing_workflow
+    return watertight

ansys/fluent/core/session.py

@@ -21,8 +21,6 @@ from ansys.fluent.core.streaming_services.events_streaming import EventsManager
 from ansys.fluent.core.streaming_services.field_data_streaming import FieldDataStreaming
 from ansys.fluent.core.streaming_services.monitor_streaming import MonitorsManager
 from ansys.fluent.core.streaming_services.transcript_streaming import Transcript
-from ansys.fluent.core.utils.file_transfer_service import PimFileTransferService
-import ansys.platform.instancemanagement as pypim
 
 from .rpvars import RPVars
 
@@ -90,8 +88,6 @@ class BaseSession:
         Close the Fluent connection and exit Fluent.
     """
 
-    _pim_methods = ["upload", "download"]
-
     def __init__(
         self,
         fluent_connection: FluentConnection,
@@ -279,43 +275,27 @@ class BaseSession:
         """Terminate Docker container session."""
         self.fluent_connection.force_exit_container()
 
-    def upload(self, file_name: str, remote_file_name: Optional[str] = None):
-        """Upload a file to the server supported by `PyPIM<https://pypim.docs.pyansys.com/version/stable/>`.
+    def upload(self, file_name: str):
+        """Upload a file to the server.
 
         Parameters
         ----------
         file_name : str
             Name of the local file to upload to the server.
-        remote_file_name : str, optional
-            Name of the file to be created on the server.
-            If omitted, will maintain the file name from parameter ``file_name``.
-            Directory specification is not supported.
         """
-        return PimFileTransferService(
-            self.fluent_connection._remote_instance
-        ).upload_file(file_name, remote_file_name)
+        return self._file_transfer_service.upload_file(file_name)
 
     def download(self, file_name: str, local_directory: Optional[str] = "."):
-        """Download a file from the server supported by `PyPIM<https://pypim.docs.pyansys.com/version/stable/>`.
+        """Download a file from the server.
 
         Parameters
         ----------
         file_name : str
-            Name of the file to download from the server, directory specification is not supported.
+            Name of the file to download from the server.
         local_directory : str, optional
-            Local destination directory, by default current working directory.
+            Local destination directory. The default is the current working directory.
         """
-        return PimFileTransferService(
-            self.fluent_connection._remote_instance
-        ).download_file(file_name, local_directory)
-
-    def __dir__(self):
-        returned_list = sorted(set(list(self.__dict__.keys()) + dir(type(self))))
-        if not pypim.is_configured():
-            for method in BaseSession._pim_methods:
-                if method in returned_list:
-                    returned_list.remove(method)
-        return returned_list
+        return self._file_transfer_service.download_file(file_name, local_directory)
 
     def __enter__(self):
         return self

ansys/fluent/core/session_base_meshing.py

@@ -4,7 +4,8 @@ import logging
 from ansys.fluent.core.fluent_connection import FluentConnection
 from ansys.fluent.core.meshing.meshing_workflow import (
     ClassicMeshingWorkflow,
-    EnhancedMeshingWorkflow,
+    FaultTolerantMeshingWorkflow,
+    WatertightMeshingWorkflow,
 )
 from ansys.fluent.core.services.datamodel_se import PyMenuGeneric
 from ansys.fluent.core.services.datamodel_tui import TUIMenu
@@ -42,7 +43,8 @@ class BaseMeshing:
         self._fluent_version = fluent_version
         self._meshing_utilities = None
         self._old_workflow = None
-        self._new_workflow = None
+        self._wt_workflow = None
+        self._ft_workflow = None
         self._part_management = None
         self._pm_file_management = None
         self._preferences = None
@@ -146,16 +148,26 @@ class BaseMeshing:
         return self._old_workflow
 
     @property
-    def new_workflow(self):
+    def watertight_workflow(self):
         """Datamodel root of workflow exposed in object-oriented manner."""
-        if not self._new_workflow:
-            self._new_workflow = EnhancedMeshingWorkflow(
+        if not self._wt_workflow:
+            self._wt_workflow = WatertightMeshingWorkflow(
+                self._workflow_se,
+                self.meshing,
+            )
+        return self._wt_workflow
+
+    @property
+    def fault_tolerant_workflow(self):
+        """Datamodel root of workflow exposed in object-oriented manner."""
+        if not self._ft_workflow:
+            self._ft_workflow = FaultTolerantMeshingWorkflow(
                 self._workflow_se,
                 self.meshing,
                 self.PartManagement,
                 self.PMFileManagement,
             )
-        return self._new_workflow
+        return self._ft_workflow
 
     @property
     def PartManagement(self):

ansys/fluent/core/session_pure_meshing.py

@@ -107,15 +107,15 @@ class PureMeshing(BaseSession):
         """Datamodel root of workflow."""
         return self._base_meshing.workflow
 
-    def watertight(self, dynamic_interface=True):
+    def watertight(self):
         """Get a new watertight workflow."""
-        self._base_meshing.new_workflow.watertight(dynamic_interface)
-        return self._base_meshing.new_workflow
+        self._base_meshing.watertight_workflow.reinitialize()
+        return self._base_meshing.watertight_workflow
 
-    def fault_tolerant(self, dynamic_interface=True):
+    def fault_tolerant(self):
         """Get a new fault-tolerant workflow."""
-        self._base_meshing.new_workflow.fault_tolerant(dynamic_interface)
-        return self._base_meshing.new_workflow
+        self._base_meshing.fault_tolerant_workflow.reinitialize()
+        return self._base_meshing.fault_tolerant_workflow
 
     @property
     def PartManagement(self):

ansys/fluent/core/session_pure_meshing.pyi

@@ -19,8 +19,8 @@ class PureMeshing:
     def meshing_utilities(self) -> meshing_utilities_root: ...
     @property
     def workflow(self) -> workflow_root: ...
-    def watertight(self, dynamic_interface: bool): ...
-    def fault_tolerant(self, dynamic_interface: bool): ...
+    def watertight(self): ...
+    def fault_tolerant(self): ...
     @property
     def PartManagement(self) -> partmanagement_root: ...
     @property