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

fiqus/mains/MainConductorAC_Strand.py

@@ -1,133 +1,141 @@
-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
+import os, cProfile
+
+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, BatchPostProcess
+
+
+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.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):
+        # os.chdir(self.solution_folder)
+        postProc = PostProcess(self.fdm, self.outputs_folder_path)
+
+        if self.fdm.magnet.postproc.plot_instantaneous_power:
+            postProc.instantaneous_loss()
+
+        if self.fdm.magnet.postproc.plot_flux.show:
+            postProc.internal_flux()
+
+        postProc.plotter.show()
+
+        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.
+        """
+        BatchPostProc = BatchPostProcess(self.fdm, 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()
+            BatchPostProc.plotter.create_lossMap()
+
+        if self.fdm.magnet.postproc.batch_postproc.loss_map.cross_section.plot_cross_section:
+            BatchPostProc.plotter.plot_lossMap_crossSection()
+
+        if self.fdm.magnet.postproc.batch_postproc.loss_map.cross_section_sweep.animate_cross_section_sweep:
+            BatchPostProc.plotter.animate_lossMap_crossSection()
+
+        if self.fdm.magnet.postproc.batch_postproc.plot2d.produce_plot2d:
+            BatchPostProc.plotter.plot2d()
+
+        if self.fdm.magnet.postproc.batch_postproc.rohf_on_grid.fit_rohf or self.fdm.magnet.postproc.batch_postproc.rohf_on_grid.produce_error_map:
+            BatchPostProc.rohf_on_grid()
+
+

fiqus/mains/MainMultipole.py

@@ -5,6 +5,7 @@ import time
 from fiqus.utils.Utils import GmshUtils
 from fiqus.utils.Utils import FilesAndFolders as Util
 from fiqus.data import DataFiQuS as dF
+from fiqus.data.DataRoxieParser import FiQuSGeometry
 from fiqus.geom_generators.GeometryMultipole import Geometry
 from fiqus.mesh_generators.MeshMultipole import Mesh
 from fiqus.getdp_runners.RunGetdpMultipole import RunGetdpMultipole
@@ -35,7 +36,7 @@ class MainMultipole:
         fdm.magnet.geometry.electromagnetics.symmetry = 'x'
         return fdm
     def generate_geometry(self, gui: bool = False):
-        geom = Util.read_data_from_yaml(self.rgd, dF.FiQuSGeometry)
+        geom = Util.read_data_from_yaml(self.rgd, FiQuSGeometry)
         fdm = self.force_symmetry() if 'solenoid' in geom.Roxie_Data.coil.coils[1].type else self.fdm  # todo: this should be handled by pydantic
         if self.fdm.magnet.geometry.plot_preview:
             plotter = PlotPythonMultipole(geom, self.fdm)
@@ -91,7 +92,7 @@ class MainMultipole:
 
     def mesh(self, gui: bool = False):
         mm = Mesh(data=self.fdm, mesh_folder=self.mesh_folder, verbose=self.verbose)
-        geom = Util.read_data_from_yaml(self.rgd, dF.FiQuSGeometry)
+        geom = Util.read_data_from_yaml(self.rgd, FiQuSGeometry)
         fdm = self.force_symmetry() if 'solenoid' in geom.Roxie_Data.coil.coils[1].type else self.fdm
         geometry_settings = {'EM': fdm.magnet.geometry.electromagnetics, 'TH': self.fdm.magnet.geometry.thermal}
         mesh_settings = {'EM': fdm.magnet.mesh.electromagnetics, 'TH': fdm.magnet.mesh.thermal}
@@ -108,7 +109,7 @@ class MainMultipole:
             mm.defineMesh(geometry_settings[physics_solved], mesh_settings[physics_solved], physics_solved)
             mm.createPhysicalGroups(geometry_settings[physics_solved])
             mm.updateAuxiliaryFile(physics_solved)
-            if geometry_settings[physics_solved].dict().get('use_TSA', False):
+            if geometry_settings[physics_solved].model_dump().get('use_TSA', False):
                 mm.rearrangeThinShellsData()
             mm.assignRegionsTags(geometry_settings[physics_solved], mesh_settings[physics_solved])
             mm.saveRegionFile(physics_solved)
@@ -116,7 +117,7 @@ class MainMultipole:
             mm.generateMesh()
             mm.checkMeshQuality()
             mm.saveMeshFile(physics_solved)
-            if geometry_settings[physics_solved].dict().get('use_TSA', False):
+            if geometry_settings[physics_solved].model_dump().get('use_TSA', False):
                 mm.saveClosestNeighboursList()
                 if self.fdm.magnet.mesh.thermal.isothermal_conductors: mm.selectMeshNodes(elements='conductors')
                 if self.fdm.magnet.geometry.thermal.with_wedges and self.fdm.magnet.mesh.thermal.isothermal_wedges: mm.selectMeshNodes(elements='wedges')
@@ -169,7 +170,7 @@ class MainMultipole:
             pp.loadStrandPositions(run_type)
             pp.loadAuxiliaryFile(run_type)
             if pp_settings[run_type].plot_all != 'False': pp.loadHalfTurnCornerPositions()
-            if pp_settings[run_type].dict().get('take_average_conductor_temperature', False): pp.loadRegionFile()
+            if pp_settings[run_type].model_dump().get('take_average_conductor_temperature', False): pp.loadRegionFile()
             pp.postProcess(pp_settings[run_type])
             if run_type == 'EM' and self.fdm.magnet.geometry.electromagnetics.symmetry != 'none': pp.completeMap2d()
             pp.clear()

fiqus/mains/MainPancake3D.py

@@ -111,7 +111,6 @@ from fiqus.mesh_generators.MeshPancake3D import Mesh
 from fiqus.getdp_runners.RunGetdpPancake3D import Solve
 from fiqus.post_processors.PostProcessPancake3D import Postprocess
 from fiqus.data.DataFiQuS import FDM
-from fiqus.data.DataFiQuS import PowerSupply
 
 
 class MainPancake3D:
@@ -409,13 +408,13 @@ class MainPancake3D:
                     0.1 + estimated_time_constant * 8 + 0.001
                 )
                 new_solve_object_for_inductance_and_time_constant["winding"] = (
-                    copy_fdm.magnet.solve.winding.dict()
+                    copy_fdm.magnet.solve.winding.model_dump()
                 )
                 new_solve_object_for_inductance_and_time_constant["contactLayer"] = (
-                    copy_fdm.magnet.solve.contactLayer.dict()
+                    copy_fdm.magnet.solve.contactLayer.model_dump()
                 )
                 new_solve_object_for_inductance_and_time_constant["terminals"] = (
-                    copy_fdm.magnet.solve.terminals.dict()
+                    copy_fdm.magnet.solve.terminals.model_dump()
                 )
                 solve_object = Pancake3DSolve(
                     **new_solve_object_for_inductance_and_time_constant