From 0c3e918c30a81e05e61e2d16f83d48440bc29284 Mon Sep 17 00:00:00 2001 From: "ANSYS\\spearson" Date: Tue, 13 Sep 2022 17:28:06 +0100 Subject: [PATCH 1/4] mesh transfer --- src/ansys/fluent/core/session.py | 24 ++++---- src/ansys/fluent/core/session_pure_meshing.py | 61 +++++++++++++++++++ 2 files changed, 73 insertions(+), 12 deletions(-) diff --git a/src/ansys/fluent/core/session.py b/src/ansys/fluent/core/session.py index 9ddf309ebc48..d80cbd41be22 100644 --- a/src/ansys/fluent/core/session.py +++ b/src/ansys/fluent/core/session.py @@ -434,13 +434,11 @@ class _Uploader: def __init__(self, pim_instance): self.pim_instance = pim_instance - + self.file_service = None try: upload_server = self.pim_instance.services["http-simple-upload-server"] - except AttributeError: - LOG.error("PIM is not installed or not authorized.") - except KeyError: - self.file_service = None + except (AttributeError, KeyError): + pass else: from simple_upload_server.client import Client @@ -450,13 +448,15 @@ def __init__(self, pim_instance): def upload(self, file_path: str, remote_file_name: str = None): """Uploads a file on the server.""" - expanded_file_path = os.path.expandvars(file_path) - upload_file_name = remote_file_name or os.path.basename(expanded_file_path) - self.file_service.upload_file(expanded_file_path, upload_file_name) + if self.file_service: + expanded_file_path = os.path.expandvars(file_path) + upload_file_name = remote_file_name or os.path.basename(expanded_file_path) + self.file_service.upload_file(expanded_file_path, upload_file_name) def download(self, file_name: str, local_file_path: str = None): """Downloads a file from the server.""" - if self.file_service.file_exist(file_name): - self.file_service.download_file(file_name, local_file_path) - else: - raise FileNotFoundError("Remote file does not exist.") + if self.file_service: + if self.file_service.file_exist(file_name): + self.file_service.download_file(file_name, local_file_path) + else: + raise FileNotFoundError("Remote file does not exist.") diff --git a/src/ansys/fluent/core/session_pure_meshing.py b/src/ansys/fluent/core/session_pure_meshing.py index bff499f7700c..fc27f5ab7b72 100644 --- a/src/ansys/fluent/core/session_pure_meshing.py +++ b/src/ansys/fluent/core/session_pure_meshing.py @@ -3,9 +3,13 @@ **********PRESENTLY SAME AS MESHING WITHOUT THE SWITCH TO SOLVER*********** """ +import os +import time + from ansys.fluent.core.fluent_connection import _FluentConnection from ansys.fluent.core.session import _BaseSession from ansys.fluent.core.session_base_meshing import _BaseMeshing +from ansys.fluent.core.utils.async_execution import asynchronous class PureMeshing(_BaseSession): @@ -50,3 +54,60 @@ def PMFileManagement(self): def preferences(self): """preferences datamodel root.""" return self._base_meshing.preferences + + def transfer_mesh_to_solvers( + self, + solvers, + file_name_stem=None, + num_files_to_try=1, + clean_up_mesh_file=True, + sleep_time=0, + ): + _transfer_mesh_from_meshing_to_solvers( + self, + solvers, + file_name_stem, + num_files_to_try, + clean_up_mesh_file, + sleep_time, + ) + + +@asynchronous +def _read_mesh_into_solver(file_name, solver, sleep_time): + print("read in solver") + solver.upload(file_name) + time.sleep(sleep_time) + solver.tui.file.read_case(file_name) # make this asynchronous + print("have read in solver") + + +def _read_mesh_into_solvers(file_name, solvers, sleep_time): + reads = [] + for solver in solvers: + reads.append(_read_mesh_into_solver(file_name, solver, sleep_time)) + for r in reads: + r.result() + + +def _transfer_mesh_from_meshing_to_solvers( + meshing, solvers, file_name_stem, num_files_to_try, clean_up_mesh_file, sleep_time +): + file_ext = ".msh.cas.h5" + for idx in range(num_files_to_try): + file_name = (file_name_stem or "fluent_mesh_") + "_" + str(idx) + file_ext + folder = os.getenv("TMP", os.getenv("TMPDIR", ".")) + file_name = os.path.join(folder, file_name) + print(file_name) + if not os.path.isfile(file_name): + print("save mesh from meshing") + meshing.tui.file.write_case(file_name) + time.sleep(sleep_time) + meshing.download(file_name, ".") + time.sleep(sleep_time) + print("saved mesh from meshing") + _read_mesh_into_solvers(file_name, solvers, sleep_time) + if clean_up_mesh_file: + os.remove(file_name) + return + raise RuntimeError("Could not write mesh to transfer") From 4f4749fc98ad95a3a892dbf381683df355876582 Mon Sep 17 00:00:00 2001 From: "ANSYS\\spearson" Date: Tue, 13 Sep 2022 18:00:23 +0100 Subject: [PATCH 2/4] mesh transfer --- src/ansys/fluent/core/session_pure_meshing.py | 42 ++++++++++--------- 1 file changed, 22 insertions(+), 20 deletions(-) diff --git a/src/ansys/fluent/core/session_pure_meshing.py b/src/ansys/fluent/core/session_pure_meshing.py index fc27f5ab7b72..d00308bf3a9b 100644 --- a/src/ansys/fluent/core/session_pure_meshing.py +++ b/src/ansys/fluent/core/session_pure_meshing.py @@ -4,12 +4,12 @@ """ import os -import time from ansys.fluent.core.fluent_connection import _FluentConnection from ansys.fluent.core.session import _BaseSession from ansys.fluent.core.session_base_meshing import _BaseMeshing from ansys.fluent.core.utils.async_execution import asynchronous +from ansys.fluent.core.utils.logging import LOG class PureMeshing(_BaseSession): @@ -61,7 +61,7 @@ def transfer_mesh_to_solvers( file_name_stem=None, num_files_to_try=1, clean_up_mesh_file=True, - sleep_time=0, + overwrite_previous=True, ): _transfer_mesh_from_meshing_to_solvers( self, @@ -69,45 +69,47 @@ def transfer_mesh_to_solvers( file_name_stem, num_files_to_try, clean_up_mesh_file, - sleep_time, + overwrite_previous, ) @asynchronous -def _read_mesh_into_solver(file_name, solver, sleep_time): - print("read in solver") +def _read_mesh_into_solver(file_name, solver): + LOG.info(f"Trying to read mesh in solver: {file_name}") solver.upload(file_name) - time.sleep(sleep_time) - solver.tui.file.read_case(file_name) # make this asynchronous - print("have read in solver") + solver.tui.file.read_case(file_name) + LOG.info(f"Have read mesh in solver: {file_name}") -def _read_mesh_into_solvers(file_name, solvers, sleep_time): +def _read_mesh_into_solvers(file_name, solvers): reads = [] for solver in solvers: - reads.append(_read_mesh_into_solver(file_name, solver, sleep_time)) + reads.append(_read_mesh_into_solver(file_name, solver)) for r in reads: r.result() def _transfer_mesh_from_meshing_to_solvers( - meshing, solvers, file_name_stem, num_files_to_try, clean_up_mesh_file, sleep_time + meshing, + solvers, + file_name_stem, + num_files_to_try, + clean_up_mesh_file, + overwrite_previous, ): file_ext = ".msh.cas.h5" for idx in range(num_files_to_try): file_name = (file_name_stem or "fluent_mesh_") + "_" + str(idx) + file_ext folder = os.getenv("TMP", os.getenv("TMPDIR", ".")) file_name = os.path.join(folder, file_name) - print(file_name) - if not os.path.isfile(file_name): - print("save mesh from meshing") - meshing.tui.file.write_case(file_name) - time.sleep(sleep_time) + LOG.info(f"Trying to save mesh from meshing session: {file_name}") + if overwrite_previous or not os.path.isfile(file_name): + LOG.info(f"Saving mesh from meshing session: {file_name}") + meshing.tui.file.write_case(file_name, "y") meshing.download(file_name, ".") - time.sleep(sleep_time) - print("saved mesh from meshing") - _read_mesh_into_solvers(file_name, solvers, sleep_time) + LOG.info(f"Saved mesh from meshing session: {file_name}") + _read_mesh_into_solvers(file_name, solvers) if clean_up_mesh_file: os.remove(file_name) return - raise RuntimeError("Could not write mesh to transfer") + raise RuntimeError("Could not write mesh from meshing session.") From cddf72715dc2c63add75093553fae5aadcc839fc Mon Sep 17 00:00:00 2001 From: "ANSYS\\spearson" Date: Thu, 15 Sep 2022 15:20:12 +0100 Subject: [PATCH 3/4] data transfer --- src/ansys/fluent/core/launcher/launcher.py | 9 ++- src/ansys/fluent/core/session_pure_meshing.py | 50 ++-------------- src/ansys/fluent/core/utils/data_transfer.py | 60 +++++++++++++++++++ 3 files changed, 72 insertions(+), 47 deletions(-) create mode 100644 src/ansys/fluent/core/utils/data_transfer.py diff --git a/src/ansys/fluent/core/launcher/launcher.py b/src/ansys/fluent/core/launcher/launcher.py index 68132d2a80ca..1d96ab0f7bd0 100644 --- a/src/ansys/fluent/core/launcher/launcher.py +++ b/src/ansys/fluent/core/launcher/launcher.py @@ -420,7 +420,14 @@ def launch_fluent( if (show_gui is False) or ( show_gui is None and (os.getenv("PYFLUENT_SHOW_SERVER_GUI") != "1") ): - launch_string += " -hidden" + aargs = additional_arguments + if ( + "-g " not in aargs + and "-gu " not in aargs + and not aargs.endswith("-g") + and not aargs.endswith("-gu") + ): + launch_string += " -hidden" LOG.info("Launching Fluent with cmd: %s", launch_string) sifile_last_mtime = Path(server_info_filepath).stat().st_mtime if env is None: diff --git a/src/ansys/fluent/core/session_pure_meshing.py b/src/ansys/fluent/core/session_pure_meshing.py index d00308bf3a9b..b6e1cf08a07e 100644 --- a/src/ansys/fluent/core/session_pure_meshing.py +++ b/src/ansys/fluent/core/session_pure_meshing.py @@ -3,13 +3,11 @@ **********PRESENTLY SAME AS MESHING WITHOUT THE SWITCH TO SOLVER*********** """ -import os from ansys.fluent.core.fluent_connection import _FluentConnection from ansys.fluent.core.session import _BaseSession from ansys.fluent.core.session_base_meshing import _BaseMeshing -from ansys.fluent.core.utils.async_execution import asynchronous -from ansys.fluent.core.utils.logging import LOG +from ansys.fluent.core.utils.data_transfer import transfer_case class PureMeshing(_BaseSession): @@ -58,58 +56,18 @@ def preferences(self): def transfer_mesh_to_solvers( self, solvers, + mesh_only=False, file_name_stem=None, num_files_to_try=1, clean_up_mesh_file=True, overwrite_previous=True, ): - _transfer_mesh_from_meshing_to_solvers( + transfer_case( self, solvers, + mesh_only, file_name_stem, num_files_to_try, clean_up_mesh_file, overwrite_previous, ) - - -@asynchronous -def _read_mesh_into_solver(file_name, solver): - LOG.info(f"Trying to read mesh in solver: {file_name}") - solver.upload(file_name) - solver.tui.file.read_case(file_name) - LOG.info(f"Have read mesh in solver: {file_name}") - - -def _read_mesh_into_solvers(file_name, solvers): - reads = [] - for solver in solvers: - reads.append(_read_mesh_into_solver(file_name, solver)) - for r in reads: - r.result() - - -def _transfer_mesh_from_meshing_to_solvers( - meshing, - solvers, - file_name_stem, - num_files_to_try, - clean_up_mesh_file, - overwrite_previous, -): - file_ext = ".msh.cas.h5" - for idx in range(num_files_to_try): - file_name = (file_name_stem or "fluent_mesh_") + "_" + str(idx) + file_ext - folder = os.getenv("TMP", os.getenv("TMPDIR", ".")) - file_name = os.path.join(folder, file_name) - LOG.info(f"Trying to save mesh from meshing session: {file_name}") - if overwrite_previous or not os.path.isfile(file_name): - LOG.info(f"Saving mesh from meshing session: {file_name}") - meshing.tui.file.write_case(file_name, "y") - meshing.download(file_name, ".") - LOG.info(f"Saved mesh from meshing session: {file_name}") - _read_mesh_into_solvers(file_name, solvers) - if clean_up_mesh_file: - os.remove(file_name) - return - raise RuntimeError("Could not write mesh from meshing session.") diff --git a/src/ansys/fluent/core/utils/data_transfer.py b/src/ansys/fluent/core/utils/data_transfer.py new file mode 100644 index 000000000000..83d5a73814e2 --- /dev/null +++ b/src/ansys/fluent/core/utils/data_transfer.py @@ -0,0 +1,60 @@ +from functools import partial +import os + +from ansys.fluent.core.utils.async_execution import asynchronous +from ansys.fluent.core.utils.logging import LOG + + +@asynchronous +def read_case_into(target, mesh_only, file_name): + LOG.info(f"Trying to read case: {file_name}") + target.upload(file_name) + target.file.read(file_name=file_name, file_type="mesh" if mesh_only else "case") + LOG.info(f"Have read case: {file_name}") + + +def read_case_into_each(targets, mesh_only, file_name): + reads = [] + for target in targets: + reads.append(read_case_into(target, mesh_only, file_name)) + for r in reads: + r.result() + + +def transfer_case( + source, + targets, + mesh_only, + file_name_stem, + num_files_to_try, + clean_up_temp_file, + overwrite_previous, +): + for idx in range(num_files_to_try): + file_name = (file_name_stem or "temp_case_file_") + "_" + str(idx) + folder = os.getenv("TMP", os.getenv("TMPDIR", ".")) + file_name = os.path.join(folder, file_name) + LOG.info(f"Trying to save mesh from meshing session: {file_name}") + if overwrite_previous or not os.path.isfile(file_name): + LOG.info(f"Saving mesh from meshing session: {file_name}") + file_menu = source.tui.file + writer = partial( + file_menu.write_mesh if mesh_only else file_menu.write_case, file_name + ) + if os.path.isfile(file_name): + writer("y") + else: + writer() + full_file_name = file_name + "." + ("msh.h5" if mesh_only else "cas.h5") + source.download(full_file_name, ".") + LOG.info(f"Saved mesh from meshing session: {full_file_name}") + read_case_into_each(targets, mesh_only, full_file_name) + if clean_up_temp_file: + try: + os.remove(full_file_name) + except BaseException as ex: + LOG.warn( + f"Encountered exception while cleaning up during case transfer {ex}" + ) + return + raise RuntimeError("Could not write mesh from meshing session.") From 1afb8c1f05074b3a4a34a65ed7f6792afc689c94 Mon Sep 17 00:00:00 2001 From: "ANSYS\\spearson" Date: Thu, 15 Sep 2022 21:04:51 +0100 Subject: [PATCH 4/4] data transfer --- src/ansys/fluent/core/session_pure_meshing.py | 34 ++++++++++-- src/ansys/fluent/core/utils/data_transfer.py | 55 ++++++++++++++----- 2 files changed, 69 insertions(+), 20 deletions(-) diff --git a/src/ansys/fluent/core/session_pure_meshing.py b/src/ansys/fluent/core/session_pure_meshing.py index b6e1cf08a07e..b6b8b7bbee70 100644 --- a/src/ansys/fluent/core/session_pure_meshing.py +++ b/src/ansys/fluent/core/session_pure_meshing.py @@ -56,16 +56,38 @@ def preferences(self): def transfer_mesh_to_solvers( self, solvers, - mesh_only=False, - file_name_stem=None, - num_files_to_try=1, - clean_up_mesh_file=True, - overwrite_previous=True, + file_type: str = "case", + file_name_stem: str = None, + num_files_to_try: int = 1, + clean_up_mesh_file: bool = True, + overwrite_previous: bool = True, ): + """Transfer mesh to Fluent solver instances. + + Parameters + ---------- + solvers : iterable + Sequence of solver instances + file_type : str, default "case" + "case" or "mesh" + file_name_stem : str + Optional file name stem + num_files_to_try : int, default 1 + Optional number of files to try to write, + each with a different generated name. + Defaults to 1 + clean_up_mesh_file: bool, default True + Whether to remove the file at the end + overwrite_previous: bool, default True + Whether to overwrite the file if it already exists + Returns + ------- + None + """ transfer_case( self, solvers, - mesh_only, + file_type, file_name_stem, num_files_to_try, clean_up_mesh_file, diff --git a/src/ansys/fluent/core/utils/data_transfer.py b/src/ansys/fluent/core/utils/data_transfer.py index 83d5a73814e2..8cf83d208a79 100644 --- a/src/ansys/fluent/core/utils/data_transfer.py +++ b/src/ansys/fluent/core/utils/data_transfer.py @@ -6,30 +6,54 @@ @asynchronous -def read_case_into(target, mesh_only, file_name): +def read_case_into(solver, file_type, file_name): LOG.info(f"Trying to read case: {file_name}") - target.upload(file_name) - target.file.read(file_name=file_name, file_type="mesh" if mesh_only else "case") + solver.upload(file_name) + solver.file.read(file_name=file_name, file_type=file_type) LOG.info(f"Have read case: {file_name}") -def read_case_into_each(targets, mesh_only, file_name): +def read_case_into_each(solvers, file_type, file_name): reads = [] - for target in targets: - reads.append(read_case_into(target, mesh_only, file_name)) + for solver in solvers: + reads.append(read_case_into(solver, file_type, file_name)) for r in reads: r.result() def transfer_case( - source, - targets, - mesh_only, + source_instance, + solvers, + file_type, file_name_stem, num_files_to_try, clean_up_temp_file, overwrite_previous, ): + """Transfer case between instances. + + Parameters + ---------- + source_instance : object + Fluent instance (tested for meshing instance) + solvers : iterable + Sequence of solver instances + file_type : str + "case" or "mesh" + file_name_stem : str + Optional file name stem + num_files_to_try : int + Optional number of files to try to write, + each with a different generated name. + Defaults to 1 + clean_up_mesh_file: bool + Whether to remove the file at the end + overwrite_previous: bool + Whether to overwrite the file if it already exists + Returns + ------- + None + """ for idx in range(num_files_to_try): file_name = (file_name_stem or "temp_case_file_") + "_" + str(idx) folder = os.getenv("TMP", os.getenv("TMPDIR", ".")) @@ -37,18 +61,21 @@ def transfer_case( LOG.info(f"Trying to save mesh from meshing session: {file_name}") if overwrite_previous or not os.path.isfile(file_name): LOG.info(f"Saving mesh from meshing session: {file_name}") - file_menu = source.tui.file + file_menu = source_instance.tui.file writer = partial( - file_menu.write_mesh if mesh_only else file_menu.write_case, file_name + file_menu.write_mesh if file_type == "mesh" else file_menu.write_case, + file_name, ) if os.path.isfile(file_name): writer("y") else: writer() - full_file_name = file_name + "." + ("msh.h5" if mesh_only else "cas.h5") - source.download(full_file_name, ".") + full_file_name = ( + file_name + "." + ("msh.h5" if file_type == "mesh" else "cas.h5") + ) + source_instance.download(full_file_name, ".") LOG.info(f"Saved mesh from meshing session: {full_file_name}") - read_case_into_each(targets, mesh_only, full_file_name) + read_case_into_each(solvers, file_type, full_file_name) if clean_up_temp_file: try: os.remove(full_file_name)