fiqus 2025.11.0__py3-none-any.whl → 2026.1.0__py3-none-any.whl

fiqus/getdp_runners/RunGetdpHomogenizedConductor.py

@@ -0,0 +1,178 @@
+import os, re, subprocess, logging, timeit
+import pandas as pd
+import gmsh
+
+from fiqus.data.DataFiQuSConductor import Conductor, SolutionParameters
+from fiqus.data.RegionsModelFiQuS import RegionsModel
+from fiqus.utils.Utils import GmshUtils, FilesAndFolders
+
+from fiqus.pro_assemblers.ProAssembler import ASS_PRO
+
+logger = logging.getLogger('FiQuS')
+
+class Solve:
+    def __init__(self, fdm, GetDP_path, geometry_folder, mesh_folder, verbose=True):
+        self.fdm = fdm
+        self.GetDP_path = GetDP_path
+
+        self.solution_folder = os.path.join(os.getcwd())
+        self.geometry_folder = geometry_folder
+        self.mesh_folder = mesh_folder
+
+        self.mesh_file = os.path.join(self.mesh_folder, f"{self.fdm.general.magnet_name}.msh")
+        self.pro_file = os.path.join(self.solution_folder, f"{self.fdm.general.magnet_name}.pro")
+        self.regions_file = os.path.join(mesh_folder, f"{self.fdm.general.magnet_name}.regions")
+        
+        self.verbose = verbose
+        self.gu = GmshUtils(self.solution_folder, self.verbose)
+        self.gu.initialize(verbosity_Gmsh=fdm.run.verbosity_Gmsh)
+
+        self.ass_pro = ASS_PRO(os.path.join(self.solution_folder, self.fdm.general.magnet_name))
+        self.regions_model = FilesAndFolders.read_data_from_yaml(self.regions_file, RegionsModel)
+        self.material_properties_model = None
+
+        self.ed = {} # excitation dictionary
+        self.rohm = {} # rohm parameter dictionary
+        self.rohf = {} # rohf parameter dictionary
+
+        gmsh.option.setNumber("General.Terminal", verbose)
+
+    def read_ro_parameters(self, inputs_folder_path):
+        """
+        Function for reading the CSV files containing the reduced order parameters for ROHF and ROHM.
+        The function expects CSV files with an descriptive first header row (i.e. 'alphas,kappas,taus') and following rows with comma seperated parameter values for each cell starting from cell 1. 
+
+        :param inputs_folder_path: The full path to the folder with input files
+        """
+        class reduced_order_params:
+            " This structure is used to access the parameter dictionaries inside the pro template with a convenient syntax 'mp.rohf' or 'mp.rohm'."
+            def __init__(self, rohf_dict=None, rohm_dict=None):
+                self.rohf = rohf_dict
+                self.rohm = rohm_dict
+
+        if self.fdm.magnet.solve.rohm.enable and self.fdm.magnet.solve.rohm.parameter_csv_file:
+            parameter_file = os.path.join(inputs_folder_path, self.fdm.magnet.solve.rohm.parameter_csv_file)
+            df = pd.read_csv(parameter_file, delimiter=',', engine='python')
+            df.index += 1
+            logger.info(f'Using ROHM parameters from file: {parameter_file}:')
+            logger.info(df)
+            self.rohm = df.to_dict(orient='dict')
+
+        if self.fdm.magnet.solve.rohf.enable and self.fdm.magnet.solve.rohf.parameter_csv_file:
+            parameter_file = os.path.join(inputs_folder_path, self.fdm.magnet.solve.rohf.parameter_csv_file)
+            df = pd.read_csv(parameter_file, delimiter=',', engine='python')
+            df.index += 1
+            logger.info(f'Using ROHF parameters from file: {parameter_file}:')
+            logger.info(df)
+            self.rohf = df.to_dict(orient='dict')
+
+        # For the moment the reduced order parameters are treated as material properties mp structure.
+        self.material_properties_model = reduced_order_params(rohf_dict=self.rohf, rohm_dict=self.rohm)
+
+    def read_excitation(self, inputs_folder_path):
+        """
+        Function for reading a CSV file for the 'from_file' excitation case.
+
+        :param inputs_folder_path: The full path to the folder with input files.
+        :type inputs_folder_path: str
+        """
+        if self.fdm.magnet.solve.source_parameters.source_type == 'piecewise' and self.fdm.magnet.solve.source_parameters.piecewise.source_csv_file:
+            input_file = os.path.join(inputs_folder_path, self.fdm.magnet.solve.source_parameters.piecewise.source_csv_file)
+            logger.info(f'Using excitation from file: {input_file}')
+            df = pd.read_csv(input_file, delimiter=',', engine='python')
+            excitation_time = df['time'].to_numpy(dtype='float').tolist()
+            self.ed['time'] = excitation_time
+            excitation_value = df['value'].to_numpy(dtype='float').tolist()
+            self.ed['value'] = excitation_value
+                
+    def assemble_pro(self):
+        logger.info("Assembling .pro file")
+        self.ass_pro.assemble_combined_pro(template = self.fdm.magnet.solve.pro_template, rm = self.regions_model, dm = self.fdm, ed=self.ed, mp=self.material_properties_model)
+
+    def run_getdp(self, solve = True, postOperation = True, gui = False):
+
+        command = ["-v2", "-verbose", "3", "-mat_mumps_icntl_14","100"]
+        if solve: 
+            command += ["-solve", "MagDyn"]
+        command += ["-pos", "MagDyn"]
+
+        if self.fdm.magnet.solve.general_parameters.noOfMPITasks:
+            mpi_prefix = ["mpiexec", "-np", str(self.fdm.magnet.solve.general_parameters.noOfMPITasks)]
+        else:
+            mpi_prefix = []
+
+        startTime = timeit.default_timer()
+
+        getdpProcess = subprocess.Popen(mpi_prefix + [self.GetDP_path, self.pro_file, "-msh", self.mesh_file] + command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+
+        with getdpProcess.stdout:
+            for line in iter(getdpProcess.stdout.readline, b""):
+                line = line.decode("utf-8").rstrip()
+                line = line.split("\r")[-1]
+                if not "Test" in line:
+                    if line.startswith("Info"):
+                        parsedLine = re.sub(r"Info\s+:\s+", "", line)
+                        logger.info(parsedLine)
+                    elif line.startswith("Warning"):
+                        parsedLine = re.sub(r"Warning\s+:\s+", "", line)
+                        logger.warning(parsedLine)
+                    elif line.startswith("Error"):
+                        parsedLine = re.sub(r"Error\s+:\s+", "", line)
+                        logger.error(parsedLine)
+                        logger.error("Solving HomogenizedConductor failed.")
+                        # raise Exception(parsedLine)
+                    elif re.match("##", line):
+                        logger.critical(line)
+                    else:
+                        logger.info(line)
+        
+        simulation_time = timeit.default_timer()-startTime
+        # Save simulation time:
+        if solve:
+            logger.info(f"Solving HomogenizedConductor has finished in {round(simulation_time, 3)} seconds.")
+            with open(os.path.join(self.solution_folder, 'txt_files', 'simulation_time.txt'), 'w') as file:
+                file.write(str(simulation_time))
+
+
+        if gui and ((postOperation and not solve) or (solve and postOperation and self.fdm.magnet.postproc.generate_pos_files)):
+            # gmsh.option.setNumber("Geometry.Volumes", 1)
+            # gmsh.option.setNumber("Geometry.Surfaces", 1)
+            # gmsh.option.setNumber("Geometry.Curves", 1)
+            # gmsh.option.setNumber("Geometry.Points", 0)
+            posFiles = [
+                fileName
+                for fileName in os.listdir(self.solution_folder)
+                if fileName.endswith(".pos")
+            ]
+            for posFile in reversed(posFiles):
+                gmsh.open(os.path.join(self.solution_folder, posFile))
+            self.gu.launch_interactive_GUI()
+        else:
+            if gmsh.isInitialized():
+                gmsh.clear()
+                gmsh.finalize()
+
+    def cleanup(self):
+        """
+            This funtion is used to remove .msh, .pre and .res files from the solution folder, as they may be large and not needed.
+        """
+        magnet_name = self.fdm.general.magnet_name
+        cleanup = self.fdm.magnet.postproc.cleanup
+
+        if cleanup.remove_res_file:
+            res_file_path = os.path.join(self.solution_folder, f"{magnet_name}.res")
+            if os.path.exists(res_file_path):
+                os.remove(res_file_path)
+                logger.info(f"Removed {magnet_name}.res")
+        
+        if cleanup.remove_pre_file:
+            pre_file_path = os.path.join(self.solution_folder, f"{magnet_name}.pre")
+            if os.path.exists(pre_file_path):
+                os.remove(pre_file_path)
+                logger.info(f"Removed {magnet_name}.pre")
+
+        if cleanup.remove_msh_file:
+            msh_file_path = os.path.join(self.mesh_folder, f"{magnet_name}.msh")
+            if os.path.exists(msh_file_path):
+                os.remove(msh_file_path)
+                logger.info(f"Removed {magnet_name}.msh")

fiqus/mains/MainConductorAC_CC.py

@@ -0,0 +1,148 @@
+
+"""MainConductorAC_CC.py:"""
+
+import os
+import sys
+
+from fiqus.geom_generators.GeometryConductorAC_CC import Generate_geometry
+from fiqus.mesh_generators.MeshConductorAC_CC import Mesh
+from fiqus.getdp_runners.RunGetdpConductorAC_CC import Solve
+from fiqus.post_processors.PostProcessAC_CC import Post_Process
+
+if len(sys.argv) == 3:
+    sys.path.insert(0, os.path.join(os.getcwd(), 'steam-fiqus-dev'))
+from fiqus.data.DataFiQuS import FDM
+
+class MainConductorAC_CC:
+    def __init__(self, fdm, inputs_folder_path='', verbose=True):
+        """
+        Main class for working with simulations for CAC_CC type magnets
+        :param fdm: FiQuS data model
+        :type fdm: FDM
+        :param inputs_folder_path: full path to folder with input files, i.e. conductor and STEP files
+        :type inputs_folder_path: str
+        :param verbose: if True, more info is printed in the console
+        :type verbose: bool
+        :return: nothing, only saves files on disk
+        :rtype: none
+        """
+        self.verbose = verbose
+        self.fdm = fdm
+        self.inputs_folder_path = inputs_folder_path
+        self.GetDP_path = None
+        self.geom_folder = None
+        self.mesh_folder = None
+        self.solution_folder = None
+        self.model_file = None
+        self.model_folder = None
+
+    def generate_geometry(self, gui=False):
+        """
+        Main method for loading the geometry of CAC_CC models
+        :param gui: if true, graphical user interface (gui) of Gmsh is opened at the end
+        :type gui: bool
+        :return: nothing, only saves files on disk
+        :rtype: none
+        """
+        os.chdir(self.geom_folder)
+        gg = Generate_geometry(fdm=self.fdm, inputs_folder_path=self.inputs_folder_path, verbose=self.verbose)
+        gg.generate_HTS_layer()        
+        gg.generate_silver_top_layer()              
+        gg.generate_substrate_layer()        
+        gg.generate_copper_top_layer()
+        gg.generate_silver_bottom_layer()        
+        gg.generate_copper_bottom_layer()
+        gg.generate_copper_left_layer()
+        gg.generate_copper_right_layer()        
+        gg.generate_air_region()
+        gg.finalize_and_write()
+
+    def load_geometry(self, gui=False):
+        """
+        Main method for loading the geometry of CAC_CC models
+        """
+        os.chdir(self.geom_folder)
+        gg = Generate_geometry(fdm=self.fdm, inputs_folder_path=self.inputs_folder_path, verbose=self.verbose)
+        self.geometry = gg
+        gg.load_geometry(gui=gui)
+
+    def pre_process(self, gui=False):
+        """
+        Main method for preprocessing of CAC_CC models
+        :param gui: if true, graphical user interface (gui) of Gmsh is opened at the end
+        :type gui: bool
+        :return: nothing, only saves files on disk
+        :rtype: none
+        """
+        os.chdir(self.geom_folder)
+
+
+    def mesh(self, gui=False):
+        """
+        Main method for building the mesh of CAC_CC models
+        :param gui: if true, graphical user interface (gui) of Gmsh is opened at the end
+        :type gui: bool
+        :return: dictionary with mesh quality stats
+        :rtype: dict
+        """
+        os.chdir(self.mesh_folder)
+        m = Mesh(self.fdm)
+        m.generate_mesh(self.geom_folder)
+        return {"gamma": 0}
+
+
+    def load_mesh(self, gui=False):
+        """
+        Main method for loading the mesh of CAC_CC models
+        :param gui: if true, graphical user interface (gui) of Gmsh is opened at the end
+        :type gui: bool
+        :return: Nothing, only saves files on disk
+        :rtype: none
+        """
+        os.chdir(self.mesh_folder)
+
+    def solve_and_postprocess_getdp(self, gui: bool = False):
+        """
+        Assembles the .pro-file from the template, then runs the simulation and the post-processing steps using GetDP.
+        """
+        os.chdir(self.solution_folder)
+
+        s = Solve(self.fdm, self.GetDP_path, self.geom_folder, self.mesh_folder, self.verbose)
+        s.read_excitation(inputs_folder_path=self.inputs_folder_path)
+        s.assemble_pro()
+        s.run_getdp(solve = True, postOperation = True, gui = gui)
+    
+    def post_process_getdp(self, gui: bool = False):
+        """ 
+        Runs the post-processing steps trough GetDP.
+        """
+        os.chdir(self.solution_folder)
+
+        s = Solve(self.fdm, self.GetDP_path, self.geom_folder, self.mesh_folder, self.verbose)
+        s.read_excitation(inputs_folder_path=self.inputs_folder_path)
+        s.assemble_pro()
+        s.run_getdp(solve = False, postOperation = True, gui = gui)
+
+    def post_process_python(self, gui=False):
+        """
+        Main method for postprocessing using python (without solving) of CAC_CC models
+        :param gui: if true, graphical user interface (gui) of Gmsh is opened at the end
+        :type gui: bool
+        :return: Nothing, only saves files on disk
+        :rtype: none
+        """
+        os.chdir(self.solution_folder)
+        p=Post_Process(self.fdm, verbose=self.verbose)
+        p.cleanup()
+        return {'overall_error': 0}
+
+    def plot_python(self, gui=False):
+        """
+        Main method for making python plots related to CAC_CC models
+        :param gui: if true, graphical user interface (gui) of Gmsh is opened at the end
+        :type gui: bool
+        :return: Nothing, only saves files on disk
+        :rtype: none
+        """
+        os.chdir(self.solution_folder)
+

fiqus/mains/MainConductorAC_Rutherford.py

@@ -0,0 +1,76 @@
+import math
+import os
+
+from fiqus.geom_generators.GeometryConductorAC_Rutherford import Geometry
+from fiqus.mesh_generators.MeshConductorAC_Rutherford import CableMesh
+from fiqus.getdp_runners.RunGetdpConductorAC_Rutherford import Solve
+from fiqus.post_processors.PostProcessAC_Rutherford import PostProcess
+from fiqus.plotters.PlotPythonConductorAC import PlotPythonConductorAC
+
+from fiqus.mains.MainConductorAC_Strand import MainConductorAC_Strand
+
+class MainConductorAC_Rutherford(MainConductorAC_Strand):
+
+    def generate_geometry(self, gui=False):
+        """
+        Generates the cable geometry.
+        """
+        os.chdir(self.geom_folder)
+        g = Geometry(fdm=self.fdm, inputs_folder_path=self.inputs_folder_path, verbose=self.verbose)
+        g.generate_cable_geometry(gui)
+
+
+
+    def mesh(self, gui: bool = False):
+        """ 
+        Generates the mesh for the cable geometry.
+        """
+        os.chdir(self.mesh_folder)
+
+        m = CableMesh(fdm=self.fdm, verbose=self.verbose)
+        m.generate_mesh(self.geom_folder)
+        m.generate_cuts()
+        m.generate_regions_file()
+        m.save_mesh(gui)
+
+        return {"test": 0}
+    
+    def solve_and_postprocess_getdp(self, gui: bool = False):
+        """
+        Assembles the .pro-file from the template, then runs the simulation and the post-processing steps using GetDP.
+        """
+        os.chdir(self.solution_folder)
+
+        # Checks if the strand type in the conductor data model is 'Homogenized', other types are not allowed (e.g., round) to avoid confusion as inputs in them won't be used
+        if self.fdm.conductors[self.fdm.magnet.solve.conductor_name].strand.type != 'Homogenized':
+            raise Exception(f"The strand type must be 'Homogenized' in the conductors section of the input .yaml file, any other type is not allowed.")
+
+        s = Solve(self.fdm, self.GetDP_path, self.geom_folder, self.mesh_folder, self.verbose)
+        s.read_excitation(inputs_folder_path=self.inputs_folder_path)
+        # s.get_solution_parameters_from_yaml(inputs_folder_path=self.inputs_folder_path)
+        s.assemble_pro()
+        s.run_getdp(solve = True, postOperation = True, gui = gui)
+        s.cleanup()
+    
+    def post_process_getdp(self, gui: bool = False):
+        """ 
+        Runs the post-processing steps trough GetDP.
+        """
+        os.chdir(self.solution_folder)
+
+        s = Solve(self.fdm, self.GetDP_path, self.geom_folder, self.mesh_folder, self.verbose)
+        s.read_excitation(inputs_folder_path=self.inputs_folder_path)
+        # s.get_solution_parameters_from_yaml(inputs_folder_path=self.inputs_folder_path)
+        s.assemble_pro()
+        s.run_getdp(solve = False, postOperation = True, gui = gui)
+
+    def post_process_python(self, gui: bool = False):
+        """ 
+        Runs the post-processing steps in the python PostProccess class.
+        """
+        os.chdir(self.solution_folder)
+
+        p = PostProcess(self.solution_folder)
+        p.show()
+
+        return {'test': 0}

fiqus/mains/MainHomogenizedConductor.py

@@ -0,0 +1,112 @@
+import os, cProfile
+
+from fiqus.geom_generators.GeometryHomogenizedConductor import Geometry
+from fiqus.mesh_generators.MeshHomogenizedConductor import Mesh
+from fiqus.getdp_runners.RunGetdpHomogenizedConductor import Solve
+from fiqus.post_processors.PostProcessHomogenizedConductor import PostProcess
+
+class MainHomogenizedConductor:
+    def __init__(self, fdm, inputs_folder_path='', outputs_folder_path='', verbose=True):
+        """
+        Main class for working with simulations for the homogenized conductor model.
+        :param fdm: FiQuS data model
+        :param inputs_folder_path: full path to folder with input files
+        :param verbose: if True, more info is printed in the console
+        """
+        self.verbose = verbose
+        self.fdm = fdm
+        self.inputs_folder_path = inputs_folder_path
+        self.outputs_folder_path = outputs_folder_path
+        self.GetDP_path = None
+        self.geom_folder = None
+        self.mesh_folder = None
+        self.solution_folder = None
+        self.model_file = None
+        self.model_folder = None
+        
+
+    def generate_geometry(self, gui=False):
+        """ 
+        Generates the conductor geometry. 
+        """
+        os.chdir(self.geom_folder)
+        g = Geometry(fdm=self.fdm, inputs_folder_path=self.inputs_folder_path, verbose=self.verbose)
+        g.generate_geometry()
+        g.generate_vi_file(gui)
+
+
+    def load_geometry(self, gui: bool = False):
+        """
+        Loads the previously generated geometry from the .brep file.
+        """
+        os.chdir(self.geom_folder)
+        g = Geometry(fdm=self.fdm, inputs_folder_path=self.inputs_folder_path, verbose=self.verbose)
+        g.load_geometry()
+        # self.model_file = g.model_file
+
+    def pre_process(self, gui=False):
+        pass
+
+    def mesh(self, gui: bool = False):
+        """ 
+        Generates the mesh for the geometry.
+        """
+        os.chdir(self.mesh_folder)
+
+        m = Mesh(fdm=self.fdm, verbose=self.verbose)
+        m.generate_mesh()
+        m.generate_cuts()
+        m.generate_regions_file()
+        m.save_mesh(gui)
+
+        return {"test": 0}
+
+    def load_mesh(self, gui=False):
+        """
+        Loads the previously generated mesh from the MSH file.
+        """
+        os.chdir(self.mesh_folder)
+        m = Mesh(fdm=self.fdm, verbose=self.verbose)
+        m.load_mesh(gui)
+
+        # self.model_file = m.mesh_file
+
+    def solve_and_postprocess_getdp(self, gui: bool = False):
+        """
+        Assembles the .pro-file from the template, then runs the simulation and the post-processing steps using GetDP.
+        """
+        os.chdir(self.solution_folder)
+
+        s = Solve(self.fdm, self.GetDP_path, self.geom_folder, self.mesh_folder, self.verbose)
+        s.read_excitation(inputs_folder_path=self.inputs_folder_path)
+        s.read_ro_parameters(inputs_folder_path=self.inputs_folder_path)    
+        s.assemble_pro()
+        s.run_getdp(solve = True, postOperation = True, gui = gui)
+        s.cleanup()
+
+    def post_process_getdp(self, gui: bool = False):
+        """ 
+        Runs the post-processing steps trough GetDP.
+        """
+        os.chdir(self.solution_folder)
+
+        s = Solve(self.fdm, self.GetDP_path, self.geom_folder, self.mesh_folder, self.verbose)
+        s.read_excitation(inputs_folder_path=self.inputs_folder_path)
+        s.read_ro_parameters(inputs_folder_path=self.inputs_folder_path) 
+        s.assemble_pro()
+        s.run_getdp(solve = False, postOperation = True, gui = gui)
+
+    def post_process_python(self, gui: bool = False):
+        """
+        Runs the post-processing steps in the python PostProcess class.
+        """
+
+        postProc = PostProcess(self.fdm, self.solution_folder)
+        postProc.show()
+
+        return {'test': 0}
+
+    def batch_post_process_python(self, gui: bool = False):
+        pass
+
+