fiqus 2024.5.2__py3-none-any.whl → 2024.7.0__py3-none-any.whl

fiqus/getdp_runners/RunGetdpConductorAC_Strand.py

@@ -0,0 +1,202 @@
+import timeit
+import logging
+import os
+import subprocess
+import re
+import pandas as pd
+import pickle
+import numpy as np
+
+import gmsh
+
+from fiqus.utils.Utils import GmshUtils, FilesAndFolders
+from fiqus.data.RegionsModelFiQuS import RegionsModel
+import fiqus.data.DataFiQuSConductor as geom
+from fiqus.geom_generators.GeometryConductorAC_Strand import TwistedStrand
+
+from fiqus.pro_assemblers.ProAssembler import ASS_PRO
+
+logger = logging.getLogger(__name__)
+
+class Solve:
+    def __init__(self, fdm, GetDP_path, geometry_folder, mesh_folder, verbose=True):
+        self.fdm = fdm
+        self.cacdm = fdm.magnet
+        self.GetDP_path = GetDP_path
+        self.solution_folder = os.path.join(os.getcwd())
+        self.magnet_name = fdm.general.magnet_name
+        self.geometry_folder = geometry_folder
+        self.mesh_folder = mesh_folder
+        self.mesh_file = os.path.join(self.mesh_folder, f"{self.magnet_name}.msh")
+        self.pro_file = os.path.join(self.solution_folder, f"{self.magnet_name}.pro")
+        self.regions_file = os.path.join(mesh_folder, f"{self.magnet_name}.regions")
+        
+        self.verbose = verbose
+        self.gu = GmshUtils(self.solution_folder, self.verbose)
+        self.gu.initialize()
+
+        self.ass_pro = ASS_PRO(os.path.join(self.solution_folder, self.magnet_name))
+        self.regions_model = FilesAndFolders.read_data_from_yaml(self.regions_file, RegionsModel)
+        self.material_properties_model = None
+
+        self.ed = {} # excitation dictionary
+
+        gmsh.option.setNumber("General.Terminal", verbose)
+
+    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.cacdm.solve.source_parameters.source_type == 'piecewise' and self.cacdm.solve.source_parameters.piecewise.source_csv_file:
+            input_file = os.path.join(inputs_folder_path, self.cacdm.solve.source_parameters.piecewise.source_csv_file)
+            print(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 get_solution_parameters_from_yaml(self, inputs_folder_path):
+        """
+        Function for reading material properties from the geometry YAML file.
+
+        This reads the 'solution' section of the YAML file and stores it in the solution folder.
+        This could also be a place to change the material properties in the future.
+
+        :param inputs_folder_path: The full path to the folder with input files.
+        :type inputs_folder_path: str
+        """
+        if self.cacdm.geometry.io_settings.load.load_from_yaml:
+            #load the geometry class from the pkl file
+            geom_save_file = os.path.join(self.geometry_folder, f'{self.magnet_name}.pkl')
+            with open(geom_save_file, "rb") as geom_save_file: 
+                geometry_class: TwistedStrand = pickle.load(geom_save_file)
+            
+            input_yaml_file = os.path.join(inputs_folder_path, self.cacdm.geometry.io_settings.load.filename)
+            Conductor_dm = FilesAndFolders.read_data_from_yaml(input_yaml_file, geom.Conductor)
+            solution_parameters = Conductor_dm.Solution
+
+            # The geometry YAML file lists surfaces to exclude from the TI problem by their IDs. Here we convert these IDs to Gmsh physical surface tags.
+            # This is done by comparing the outer boundary points of the surfaces to exclude with the outer boundary points of the matrix partitions.
+            surfaces_excluded_from_TI_tags = []
+
+            for surface_ID in solution_parameters.Surfaces_excluded_from_TI: # 1) Find the outer boundary points of the surfaces to exclude
+                outer_boundary_points_a = []
+                outer_boundary_curves_a = Conductor_dm.Geometry.Areas[surface_ID].Boundary
+                for curve_ID in outer_boundary_curves_a:
+                    curve = Conductor_dm.Geometry.Curves[curve_ID]
+                    for point_ID in curve.Points:
+                        point = Conductor_dm.Geometry.Points[point_ID]
+                        outer_boundary_points_a.append(tuple(point.Coordinates))
+                
+                for matrix_partition in geometry_class.matrix: # 2) Find the outer boundary points of the matrix partitions
+                    outer_boundary_points_b = []
+                    outer_boundary_curves_b = matrix_partition.boundary_curves
+                    if len(outer_boundary_curves_b) == len(outer_boundary_curves_a): # If the number of boundary curves is different, the surfaces are not the same
+                        for curve in outer_boundary_curves_b:
+                            for point in curve.points:
+                                outer_boundary_points_b.append(tuple(point.pos))
+                        
+                        if np.allclose(sorted(outer_boundary_points_a), sorted(outer_boundary_points_b)): # If the outer boundary points are the same, the surfaces are the same
+                            surfaces_excluded_from_TI_tags.append(matrix_partition.physical_surface_tag) # 3) Add the physical surface tag to the list of surfaces to exclude
+                            break
+            
+            solution_parameters.Surfaces_excluded_from_TI = surfaces_excluded_from_TI_tags # Replace the surface IDs with the physical surface tags
+
+            FilesAndFolders.write_data_to_yaml(os.path.join(self.solution_folder, "MaterialProperties.yaml"), solution_parameters.dict())
+            self.material_properties_model = solution_parameters
+
+        
+
+
+    def assemble_pro(self):
+        print("Assembling .pro file")
+        self.ass_pro.assemble_combined_pro(template = self.cacdm.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"]
+        if solve: 
+            command += ["-solve", "MagDyn"]
+        if self.cacdm.solve.formulation_parameters.dynamic_correction:
+            command += ["-pos", "MagDyn", "MagDyn_dynCorr"]
+        else:
+            command += ["-pos", "MagDyn"]
+
+
+        startTime = timeit.default_timer()
+        getdpProcess = subprocess.Popen([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 CAC 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 CAC_1 has finished in {round(simulation_time, 3)} seconds.")
+            with open(os.path.join(self.solution_folder, 'test_temporary', 'simulation_time.txt'), 'w') as file:
+                file.write(str(simulation_time))
+
+
+        if gui and ((postOperation and not solve) or (solve and postOperation and self.cacdm.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 posFiles:
+                gmsh.open(os.path.join(self.solution_folder, posFile))
+            self.gu.launch_interactive_GUI()
+        else:
+            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.cacdm.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/getdp_runners/RunGetdpMultipole.py

@@ -59,12 +59,12 @@ class RunGetdpMultipole:
         self.rm = Util.read_data_from_yaml(f"{os.path.join(self.mesh_folder, self.data.general.magnet_name)}.reg", rM)
 
     def assemblePro(self):
-        self.rm.powered.vol.currents = []
-        for name in self.rm.powered.vol.names:
+        self.rm.powered['Multipole'].vol.currents = []
+        for name in self.rm.powered['Multipole'].vol.names:
             if name[-3:] == 'pos':
-                self.rm.powered.vol.currents.append(self.II)
+                self.rm.powered['Multipole'].vol.currents.append(self.II)
             else:
-                self.rm.powered.vol.currents.append(-self.II)
+                self.rm.powered['Multipole'].vol.currents.append(-self.II)
 
         ap = aP(file_base_path=os.path.join(self.solution_folder, self.data.general.magnet_name),
                 naming_conv=self.naming_conv)

fiqus/mains/MainConductorAC_Strand.py

@@ -0,0 +1,133 @@
+import os
+
+from fiqus.geom_generators.GeometryConductorAC_Strand import Geometry
+from fiqus.mesh_generators.MeshConductorAC_Strand import Mesh, StrandMesh
+from fiqus.getdp_runners.RunGetdpConductorAC_Strand import Solve
+from fiqus.post_processors.PostProcessConductorAC import PostProcess
+from fiqus.plotters.PlotPythonConductorAC import PlotPython
+
+class MainConductorAC_Strand:
+    def __init__(self, fdm, inputs_folder_path='', outputs_folder_path='', verbose=True):
+        """
+        Main class for working with simulations for the Conductor AC 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 strand geometry. 
+        """
+        os.chdir(self.geom_folder)
+        g = Geometry(fdm=self.fdm, inputs_folder_path=self.inputs_folder_path, verbose=self.verbose)
+        g.generate_strand_geometry(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_conductor_geometry(gui)
+        # self.model_file = g.model_file
+
+    def pre_process(self, gui=False):
+        pass
+
+    def mesh(self, gui: bool = False):
+        """ 
+        Generates the mesh for the strand geometry.
+        """
+        os.chdir(self.mesh_folder)
+
+        m = StrandMesh(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 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.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 pre_process(self):
+    #     os.chdir(self.solution_folder)
+
+    #     s = Solve(self.fdm, self.GetDP_path, self.mesh_folder, self.verbose)
+
+    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: bool = False):
+        # os.chdir(self.solution_folder)
+        postProc = PostProcess(self.fdm, self.outputs_folder_path)
+        postProc.plot_instantaneous_loss()
+
+        return {'test': 0}
+
+    def batch_post_process_python(self, gui: bool = False):
+        """ 
+        Runs batch post-processing steps using Python. 
+        Used for gathering, analysing, comparing and plotting data from multiple simulations.
+        """
+        plotter = PlotPython(self.fdm, csv_filename=self.fdm.magnet.postproc.batch_postproc.postProc_csv, lossMap_gridData_folder=None, inputs_folder_path=self.inputs_folder_path, outputs_folder_path=self.outputs_folder_path)
+
+        if self.fdm.magnet.postproc.batch_postproc.loss_map.produce_loss_map:
+            # plotter.save_lossMap_gridData()
+            # plotter.save_magnetization()
+            plotter.create_lossMap()
+
+        if self.fdm.magnet.postproc.batch_postproc.loss_map.cross_section.plot_cross_section:
+            plotter.plot_lossMap_crossSection()
+
+        if self.fdm.magnet.postproc.batch_postproc.loss_map.cross_section_sweep.animate_cross_section_sweep:
+            plotter.animate_lossMap_crossSection()
+
+        if self.fdm.magnet.postproc.batch_postproc.plot2d.produce_plot2d:
+            plotter.plot2d()
+
+    
+    # def plot_python(self):
+    #     pass

fiqus/mesh_generators/MeshCCT.py

@@ -52,7 +52,7 @@ class Mesh:
         r_types = ['w' for _ in self.cctwi.w_names] + ['f' for _ in self.cctwi.f_names]  # needed for picking different pow_surf later on
         vol_max_loop = 0
 
-        for i, (f_name, r_type, r_name, r_tag) in enumerate(zip(self.cctwi.w_names + self.cctwi.f_names, r_types, self.cctrm.powered.vol.names, self.cctrm.powered.vol.numbers)):
+        for i, (f_name, r_type, r_name, r_tag) in enumerate(zip(self.cctwi.w_names + self.cctwi.f_names, r_types, self.cctrm.powered['cct'].vol.names, self.cctrm.powered['cct'].vol.numbers)):
             vol_dict = json.load(open(f"{os.path.join(self.geom_folder, f_name)}.vi"))
             volumes_file = np.array(vol_dict['all'])
             vol_max_file = np.max(volumes_file)
@@ -63,15 +63,15 @@ class Mesh:
             gmsh.model.addPhysicalGroup(dim=3, tags=v_tags, tag=r_tag)
             gmsh.model.setPhysicalName(dim=3, tag=r_tag, name=r_name)
             powered_in_surf = self._find_surf(v_tags[0])
-            gmsh.model.addPhysicalGroup(dim=2, tags=[powered_in_surf], tag=self.cctrm.powered.surf_in.numbers[i])
-            gmsh.model.setPhysicalName(dim=2, tag=self.cctrm.powered.surf_in.numbers[i], name=self.cctrm.powered.surf_in.names[i])
+            gmsh.model.addPhysicalGroup(dim=2, tags=[powered_in_surf], tag=self.cctrm.powered['cct'].surf_in.numbers[i])
+            gmsh.model.setPhysicalName(dim=2, tag=self.cctrm.powered['cct'].surf_in.numbers[i], name=self.cctrm.powered['cct'].surf_in.names[i])
             powered_out_surf = self._find_surf(v_tags[-1])
-            gmsh.model.addPhysicalGroup(dim=2, tags=[powered_out_surf], tag=self.cctrm.powered.surf_out.numbers[i])
-            gmsh.model.setPhysicalName(dim=2, tag=self.cctrm.powered.surf_out.numbers[i], name=self.cctrm.powered.surf_out.names[i])
+            gmsh.model.addPhysicalGroup(dim=2, tags=[powered_out_surf], tag=self.cctrm.powered['cct'].surf_out.numbers[i])
+            gmsh.model.setPhysicalName(dim=2, tag=self.cctrm.powered['cct'].surf_out.numbers[i], name=self.cctrm.powered['cct'].surf_out.names[i])
 
         vol_max_loop = v_tags[-1]
 
-        for r_name, r_tag in zip(self.cctrm.induced.vol.names, self.cctrm.induced.vol.numbers):
+        for r_name, r_tag in zip(self.cctrm.induced['cct'].vol.names, self.cctrm.induced['cct'].vol.numbers):
             vol_max_loop += 1
             self.formers.append(vol_max_loop)
             gmsh.model.addPhysicalGroup(dim=3, tags=[vol_max_loop], tag=r_tag)
@@ -180,9 +180,9 @@ class Mesh:
         if self.verbose:
             print('Generating Cuts Started')
             start_time = timeit.default_timer()
-        for vol, surf_in, surf_out in zip(self.cctrm.powered.vol.numbers, self.cctrm.powered.surf_in.numbers, self.cctrm.powered.surf_out.numbers):
+        for vol, surf_in, surf_out in zip(self.cctrm.powered['cct'].vol.numbers, self.cctrm.powered['cct'].surf_in.numbers, self.cctrm.powered['cct'].surf_out.numbers):
             gmsh.model.mesh.addHomologyRequest("Cohomology", domainTags=[vol], subdomainTags=[surf_in, surf_out], dims=[1, 2, 3])
-        for vol in self.cctrm.induced.vol.numbers:
+        for vol in self.cctrm.induced['cct'].vol.numbers:
             gmsh.model.mesh.addHomologyRequest("Cohomology", domainTags=[vol], dims=[1, 2, 3])
         gmsh.model.mesh.computeHomology()
         if self.verbose: