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

fiqus/geom_generators/GeometryHomogenizedConductor.py

@@ -0,0 +1,183 @@
+import os, json, gmsh, logging
+
+from fiqus.utils.Utils import GmshUtils
+from typing import Tuple
+
+logger = logging.getLogger('FiQuS')
+
+class Rectangle:
+    """ A class to represent a rectangular surface in gmsh. """
+    def __init__( self, x_center, y_center, z_center, width, height, name) -> None:
+        self.name = name
+
+        self.x_center = x_center
+        self.y_center = y_center
+        self.z_center = z_center
+        self.width = width
+        self.height = height
+
+        self.tag = gmsh.model.occ.addRectangle(x_center-width/2, y_center-height/2, z_center, width, height)
+        self.dimTag: Tuple = (2, self.tag)            
+
+
+class Circle:
+    """ A class to represent a circle surface in gmsh. """
+    def __init__(self, x_center, y_center, z_center, radius, name) -> None:
+        self.name = name
+
+        self.x_center = x_center
+        self.y_center = y_center
+        self.z_center = z_center
+        self.radius = radius
+
+        self.tag = gmsh.model.occ.addDisk(self.x_center, self.y_center, self.z_center, radius, radius)
+        self.dimTag: Tuple = (2, self.tag)
+
+
+class HomogenizedConductor:
+    """
+    A class representing the geometry of a 2D cross section containing multiple cables and excitation coils in an isolating medium.
+
+    :ivar cables: list of surfaces representing the cable cross sections.
+    :vartype cables: list[list[Surface]]
+    :ivar excitation_coils: list of surfaces representing the excitation coils cross sections.
+    :vartype excitation_coils: list[list[Surface]]
+    :ivar Air: Surrounding surface representing the air region.
+    :vartype Air: Surface
+    """
+    def __init__(self, fdm) -> None:
+        """
+        Initializes the HomogenizedConductor object.
+        """
+        self.fdm = fdm
+
+        self.cables = self.generate_cables()
+        self.excitation_coils = self.generate_excitation_coils()
+        self.air = self.generate_air()
+
+    def generate_cables(self):
+        """ 
+        This function generates a list of rectangular surfaces according to the specifications of the cables within the yaml.
+
+        :return: List of rectangle surfaces
+        """
+        cables = []
+        for idx, cable in enumerate(self.fdm.magnet.geometry.cables_definition):
+            cables.append(Rectangle(cable.center_position[0],cable.center_position[1],cable.center_position[2], 
+                                        cable.width, cable.height, name='Cable'+str(idx+1)))
+        return cables
+
+    def generate_excitation_coils(self):
+        """ 
+        This function generates a list of rectangular surfaces according to the specifications of the excitation coils within the yaml.
+
+        :return: List of rectangle surfaces
+        """
+        excitation_coils = []
+        for idx, excitation_coil in enumerate(self.fdm.magnet.geometry.excitation_coils):
+            excitation_coils.append(Rectangle(excitation_coil.center_position[0],excitation_coil.center_position[1],excitation_coil.center_position[2], 
+                                        excitation_coil.width, excitation_coil.height, name='Coil'+str(idx+1)))
+        return excitation_coils
+
+    def generate_air(self):
+        """
+        This function generates the surrounding air surface by fragmenting a base surface with the previously defined cable surfaces.
+
+        :raises ValueError: 'circle' is the only defined air surface form
+        :return: fragmented air surface
+        """
+        if self.fdm.magnet.geometry.air_form == 'circle':
+            air_pos = self.fdm.magnet.geometry.air.center_position
+            air = Circle(air_pos[0],air_pos[1],air_pos[2],
+                                self.fdm.magnet.geometry.air.radius, name='Air')
+        else:
+            raise ValueError('Undefined air_form.')
+        # fragment air with cables and excitation coils
+        gmsh.model.occ.synchronize()
+        outDimTags, outDimTagsMap = gmsh.model.occ.fragment([(2, air.tag)], [cable.dimTag for cable in self.cables] + [excitation_coil.dimTag for excitation_coil in self.excitation_coils])
+        return air
+    
+    def get_vi_dictionary(self):
+        """ 
+        This function dumps the dimTags of all surfaces into one dictionary, which can be used to generate the volume information file.
+
+        :return: dictionary with volume information
+        """
+        vi_dictionary = {}
+        # add all cables
+        for cable in self.cables:
+            vi_dictionary.update({str(cable.name):list(cable.dimTag)})
+        # add all excitation coils
+        for excitation_coil in self.excitation_coils:
+            vi_dictionary.update({str(excitation_coil.name):list(excitation_coil.dimTag)})
+        # add air
+        vi_dictionary.update({str(self.air.name):list(self.air.dimTag)})
+        return vi_dictionary
+
+
+class Geometry:
+    def __init__(self, fdm, inputs_folder_path, verbose=True) -> None:
+        """ 
+        Initializes the Geometry class.
+        
+        :param fdm: The fiqus data model.
+        :type fdm: object
+        :param inputs_folder_path: The full path to the folder with input files, i.e., conductor and STEP files.
+        :type inputs_folder_path: str
+        :param verbose: If True, more information is printed in the Python console. Defaults to True.
+        :type verbose: bool, optional
+        """
+        self.fdm = fdm
+        self.inputs_folder = inputs_folder_path
+        self.geom_folder = os.path.join(os.getcwd())
+        self.geom_file = os.path.join(self.geom_folder, f'{fdm.general.magnet_name}.brep')
+        self.vi_file = os.path.join(self.geom_folder, f'{fdm.general.magnet_name}.vi')
+        self.verbose = verbose
+        # start GMSH
+        self.gu = GmshUtils(self.geom_folder, self.verbose)
+        self.gu.initialize(verbosity_Gmsh=fdm.run.verbosity_Gmsh)
+        # To see the surfaces in a better way in GUI:
+        gmsh.option.setNumber("Geometry.SurfaceType", 2)
+
+    def generate_geometry(self):
+        """
+        Generates the geometry of conductors within a surrounding air region as specified in the yaml.
+
+        :param gui: If True, launches an interactive GUI after generating the geometry. Default is False.
+        :type gui: bool, optional
+        :return: None
+        """
+        logger.info("Generating geometry")
+        
+        # 1) Either load the geometry from a yaml file or create the model from scratch
+        self.geometry = HomogenizedConductor(fdm=self.fdm)
+        
+        gmsh.model.occ.synchronize()
+        logger.info("Writing geometry")
+        gmsh.write(self.geom_file) # Write the geometry to a .brep file
+
+    def load_geometry(self):
+        """ Loads geometry from .brep file. """
+        logger.info("Loading geometry")
+
+        gmsh.clear()
+        gmsh.model.occ.importShapes(self.geom_file, format="brep")
+        gmsh.model.occ.synchronize()
+
+    def generate_vi_file(self, gui=False):
+        """
+        Generates volume information file. Volume information file stores dimTags of all
+        the stored volumes. Since this model is 2D, those volumes are equivalent to simple surfaces.
+        """
+
+        dimTagsDict = self.geometry.get_vi_dictionary()
+        with open(self.vi_file, 'w') as f:
+            json.dump(dimTagsDict, f)
+
+        if gui:
+            #self.generate_physical_groups()
+            self.gu.launch_interactive_GUI()
+        else:
+            if gmsh.isInitialized():
+                gmsh.clear()
+                gmsh.finalize()

fiqus/getdp_runners/RunGetdpConductorAC_CC.py

@@ -0,0 +1,123 @@
+import timeit
+import logging
+from enum import Enum
+import os
+import subprocess
+import re
+import pandas as pd
+
+import gmsh
+import numpy as np
+
+#from fiqus.data import RegionsModelFiQuS
+from fiqus.utils.Utils import GmshUtils, FilesAndFolders
+from fiqus.data.RegionsModelFiQuS import RegionsModel
+# import fiqus.data.DataConductorACGeom as geom
+
+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.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(verbosity_Gmsh=fdm.run.verbosity_Gmsh)
+
+        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 assemble_pro(self):
+        logger.info("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 read_excitation(self, inputs_folder_path):
+        """
+        Function for reading a CSV file for the 'piecewise' 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)
+            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_b = df['b'].to_numpy(dtype='float').tolist()
+            self.ed['b'] = excitation_b
+            excitation_I = df['I'].to_numpy(dtype='float').tolist()
+            self.ed['I'] = excitation_I
+
+    def run_getdp(self, solve = True, postOperation = True, gui = False):
+        command = ["-v2", "-verbose", "3"]
+        if solve: 
+            command += ["-solve", "MagDyn", "-mat_mumps_icntl_14","100"] # icntl for mumps just by precaution
+        command += ["-pos", "MagDyn"]
+
+        logger.info(f"Running GetDP with command: {command}")
+        startTime = timeit.default_timer()
+
+        if self.cacdm.solve.general_parameters.noOfMPITasks:
+            mpi_prefix = ["mpiexec", "-np", str(self.cacdm.solve.general_parameters.noOfMPITasks)]
+        else:
+            mpi_prefix = []
+
+        getdpProcess = subprocess.Popen(mpi_prefix + [self.GetDP_path] + [self.pro_file] + command + ["-msh"] + [self.mesh_file], 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
+        
+        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:
+            if gmsh.isInitialized():
+                gmsh.clear()
+                gmsh.finalize()

fiqus/getdp_runners/RunGetdpConductorAC_Rutherford.py

@@ -0,0 +1,200 @@
+import timeit
+import json
+import logging
+import math
+from enum import Enum
+import operator
+import itertools
+import os
+import pickle
+import subprocess
+import re
+import pandas as pd
+
+import gmsh
+import numpy as np
+
+from fiqus.data import RegionsModelFiQuS
+from fiqus.utils.Utils import GmshUtils, FilesAndFolders
+from fiqus.data.RegionsModelFiQuS import RegionsModel
+# import fiqus.data.DataConductorACGeom as geom
+
+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.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(verbosity_Gmsh=fdm.run.verbosity_Gmsh)
+
+        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 csv for the 'from_file' excitation case
+        :type inputs_folder_path: str
+        """
+        # if self.cacdm.solve.source_parameters.source_type == 'from_file':
+        #     input_file = os.path.join(inputs_folder_path, self.cacdm.solve.source_parameters.source_csv_file)
+        #     logger.info(f'Getting applied field and transport current 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_b = df['b'].to_numpy(dtype='float').tolist()
+        #     self.ed['b'] = excitation_b
+        #     excitation_I = df['I'].to_numpy(dtype='float').tolist()
+        #     self.ed['I'] = excitation_I
+
+        if self.cacdm.solve.source_parameters.excitation_coils.enable and self.cacdm.solve.source_parameters.excitation_coils.source_csv_file:
+            input_file = os.path.join(inputs_folder_path, self.cacdm.solve.source_parameters.excitation_coils.source_csv_file)
+            logger.info(f'Getting excitation coils currents from file: {input_file}')
+            df = pd.read_csv(input_file, delimiter=',', engine='python')
+            
+            if( len(df.columns) != len(self.cacdm.geometry.excitation_coils.centers)+1):
+                logger.warning('Number of excitation coils in geometry ('+ str(len(self.cacdm.geometry.excitation_coils.centers))+') and input source file ('+str(len(df.columns))+') not compatible')
+
+            excitation_time = df['time'].to_numpy(dtype='float').tolist()
+            self.ed['time'] = excitation_time
+            for i in range(1, len(df.columns)):
+                Istr = 'I'+str(i)
+                excitation_value = df[Istr].to_numpy(dtype='float').tolist()
+                self.ed[Istr] = excitation_value
+
+    # def get_material_properties(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.
+    #     """
+    #     if self.cacdm.geometry.io_settings.load.load_from_yaml:
+    #         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
+    #         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):
+        logger.info("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):
+
+        # f = self.cacdm.solve.source_parameters.frequency
+        # bmax = self.cacdm.solve.source_parameters.applied_field_amplitude
+        # Imax_ratio = self.cacdm.solve.source_parameters.ratio_of_max_imposed_current_amplitude
+
+        command = ["-v2", "-verbose", "3"]
+        if solve: 
+            # command += ["-solve", "js_to_hs_2"] if not self.cacdm.solve.frequency_domain_solver.enable else ["-solve", "MagDyn_freq"] # for debugging purposes
+            command += ["-solve", "MagDyn"] if not self.cacdm.solve.frequency_domain_solver.enable else ["-solve", "MagDyn_freq"] 
+        # Solve_only seems to always call postproc, here we only save .pos-files if specified in input file
+        # if (postOperation and not solve) or (solve and postOperation and self.cacdm.postproc.generate_pos_files): 
+        # if self.cacdm.solve.formulation_parameters.dynamic_correction:
+        #     command += " -pos MagDyn MagDyn_dynCorr"
+        # else:
+        command += ["-pos", "MagDyn"]
+
+        logger.info(f"Running GetDP with command: {command}")
+        startTime = timeit.default_timer()
+        # subprocess.run(f"{self.GetDP_path} {self.pro_file} {command} -msh {self.mesh_file}")
+
+        if self.cacdm.solve.general_parameters.noOfMPITasks:
+            mpi_prefix = ["mpiexec", "-np", str(self.cacdm.solve.general_parameters.noOfMPITasks)]
+        else:
+            mpi_prefix = []
+
+        getdpProcess = subprocess.Popen(mpi_prefix + [self.GetDP_path] + [self.pro_file] + command + ["-msh"] + [self.mesh_file], 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 Rutherford has finished in {round(simulation_time, 3)} seconds.")
+            with open(self.solution_folder+f'\\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.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:
+            if gmsh.isInitialized():
+                gmsh.clear()
+                gmsh.finalize()
+
+    def cleanup(self):
+        """
+            This funtion is used to remove .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")