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

fiqus/getdp_runners/RunGetdpPancake3D.py

@@ -82,9 +82,13 @@ class Solve(Base):
                     "solution"
                 ][-_no_of_previous_solutions:]
 
+                if fdm.magnet.solve.time.start != parsed_init_res.solution["time_real"][0]:
+                    raise ValueError(f"Initial time {fdm.magnet.solve.time.start} does not match with the initFromPrevious res file time {parsed_init_res.solution['time_real'][0]}.")
+
                 self.res_file_without_previous_solutions = os.path.join(
                     self.solution_folder, self.magnet_name + ".res"
                 )
+
                 ParserRES(self.res_file_without_previous_solutions, parsed_init_res)
 
         # Create pro file:
@@ -92,7 +96,7 @@ class Solve(Base):
 
         # Start GMSH:
         self.gu = GmshUtils(self.mesh_folder)
-        self.gu.initialize()
+        self.gu.initialize(verbosity_Gmsh=fdm.run.verbosity_Gmsh)
 
         # Read regions model:
         self.rm = FilesAndFolders.read_data_from_yaml(self.regions_file, RegionsModel)
@@ -136,7 +140,12 @@ class Solve(Base):
         logger.info("Solving Pancake3D magnet has been started.")
         start_time = timeit.default_timer()
 
-        getdpArguments = ["-v2", "-mat_mumps_cntl_1", "0", "-verbose", "6"]
+        getdpArguments = ["-v2", "-verbose", str(self.dm.run.verbosity_GetDP)]
+
+        if self.dm.magnet.solve.EECircuit.enable:
+            getdpArguments += ["-mat_mumps_cntl_1", "1e-6"]
+        else:
+            getdpArguments += ["-mat_mumps_cntl_1", "0"]
 
         if self.dm.magnet.solve.initFromPrevious:
             getdpArguments.extend(
@@ -178,11 +187,23 @@ class Solve(Base):
 
         # Add pre-processing argument
         getdpArguments.extend(["-pre", f"RESOLUTION_{self.solve.type}"])
+        
 
         getdp_binary = self.GetDP_path
 
+        if self.solve.noOfMPITasks:
+            try:
+                import shutil
+                mpi_bin = shutil.which("mpiexec")
+                mpi_prefix = [mpi_bin, "-np", str(self.solve.noOfMPITasks)]
+            except:
+                logger.error("mpiexec not found. Running GetDP in serial mode.")
+                raise Exception("mpiexec not found. Running GetDP in serial mode.")
+        else:
+            mpi_prefix = []
+
         getdpProcess = subprocess.Popen(
-            [getdp_binary, self.pro_file] + getdpArguments,
+            mpi_prefix + [getdp_binary, self.pro_file] + getdpArguments,
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
         )
@@ -202,7 +223,7 @@ class Solve(Base):
                     logger.error(parsedLine)
                     logger.error("Solving Pancake3D magnet has failed.")
                     raise Exception(parsedLine)
-                elif "Critical" in line:
+                elif "Critical:" in line:
                     parsedLine = re.sub(r"Critical\s*:\s*", "", line)
                     if "Quench started!" in parsedLine:
                         logger.critical(r" _____ _  ___        ____ ")
@@ -214,8 +235,9 @@ class Solve(Base):
                         logger.critical("The coil has been quenched!")
                     else:
                         logger.critical(parsedLine)
-                # else:
-                #     logger.info(line)
+                    # this activates the debugging message mode
+                elif self.dm.run.verbosity_GetDP > 99:
+                        logger.info(line)
 
         getdpProcess.wait()
 

fiqus/mains/MainCCT.py

@@ -81,7 +81,7 @@ class MainCCT:
         os.chdir(self.solution_folder)
         gb = Generate_BREPs(fdm=self.fdm, verbose=self.verbose)
         gb.generate_regions_file()
-        rg = RunGetdpCCT(fdm=self.fdm, settings=self.settings)
+        rg = RunGetdpCCT(fdm=self.fdm, GetDP_path=self.GetDP_path)
         rg.assemble_pro()
         start_time = time.time()
         rg.solve_and_postprocess(gui=gui)
@@ -93,7 +93,7 @@ class MainCCT:
         os.chdir(self.solution_folder)
         gb = Generate_BREPs(fdm=self.fdm, verbose=self.verbose)
         gb.generate_regions_file()
-        rg = RunGetdpCCT(fdm=self.fdm, settings=self.settings)
+        rg = RunGetdpCCT(fdm=self.fdm, GetDP_path=self.GetDP_path)
         rg.assemble_pro()
         rg.postprocess(gui=gui)
         self.model_file = rg.model_file

fiqus/mains/MainConductorAC_Strand.py

@@ -1,133 +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):
+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/mains/MainMultipole.py

@@ -14,86 +14,129 @@ from fiqus.plotters.PlotPythonMultipole import PlotPythonMultipole
 
 
 class MainMultipole:
-    def __init__(self, fdm: dF.FDM = None, sdm: dF.FiQuSSettings = None, rgd_path: str = None,
-                 verbose: bool = None):
+    def __init__(self, fdm: dF.FDM = None, rgd_path: str = None, verbose: bool = None):
         """
         Main class for working with simulations for multipole type magnets
         :param fdm: FiQuS data model
         :param rgd_path: ROXIE geometry data path
-        :param sdm: settings data model
         :param verbose: if True, more info is printed in the console
         """
         self.fdm = fdm
-        self.sett = sdm
         self.rgd = rgd_path
         self.verbose = verbose
 
-        self.settings = None
+        self.GetDP_path = None
         self.geom_folder = None
         self.mesh_folder = None
         self.solution_folder = None
-        self.model_file = None
 
+    def force_symmetry(self):
+        fdm = self.fdm.__deepcopy__()
+        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)
-        gg = Geometry(data=self.fdm, geom=geom, sett=self.sett, geom_folder=self.geom_folder, verbose=self.verbose)
-        self.model_file = gg.model_file
-        gg.saveStrandPositions()
-        if self.fdm.magnet.geometry.with_iron_yoke:
-            gg.constructIronGeometry()
-        gg.constructWedgeGeometry()
-        gg.constructCoilGeometry()
-        gg.buildDomains()
-        gg.saveBoundaryRepresentationFile()
-        gg.loadBoundaryRepresentationFile()
-        gg.updateTags()
-        gg.saveAuxiliaryFile()
+        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)
+            plotter.plot_coil_wedges()
+        gg = Geometry(data=fdm, geom=geom, geom_folder=self.geom_folder, verbose=self.verbose)
+        gg.saveHalfTurnCornerPositions()
+        geometry_settings = {'EM': fdm.magnet.geometry.electromagnetics, 'TH': self.fdm.magnet.geometry.thermal}
+        geometry_type_list = []
+        if fdm.magnet.geometry.electromagnetics.create: geometry_type_list.append('EM')
+        if fdm.magnet.geometry.thermal.create: geometry_type_list.append('TH')
+        for geometry_type in geometry_type_list:
+            gg.saveStrandPositions(geometry_type)
+            if geometry_settings[geometry_type].with_iron_yoke:
+                gg.constructIronGeometry(geometry_settings[geometry_type].symmetry if geometry_type == 'EM' else 'none')
+            gg.constructCoilGeometry(geometry_type)
+            if geometry_settings[geometry_type].with_wedges:
+                gg.constructWedgeGeometry(geometry_settings[geometry_type].use_TSA if geometry_type == 'TH' else False)
+            gmsh.model.occ.synchronize()
+            if geometry_type == 'TH':
+                if geometry_settings[geometry_type].use_TSA:
+                    gg.constructThinShells(geometry_settings[geometry_type].with_wedges)
+                else:
+                    gg.constructInsulationGeometry()
+            gg.buildDomains(geometry_type, geometry_settings[geometry_type].symmetry if geometry_type == 'EM' else 'none')
+            if geometry_type == 'EM':
+                gg.fragment()
+            gg.saveBoundaryRepresentationFile(geometry_type)
+            gg.loadBoundaryRepresentationFile(geometry_type)
+            gg.updateTags(geometry_type, geometry_settings[geometry_type].symmetry if geometry_type == 'EM' else 'none')
+            gg.saveAuxiliaryFile(geometry_type)
+            gg.clear()
         gg.ending_step(gui)
 
     def load_geometry(self, gui: bool = False):
-        gu = GmshUtils(self.geom_folder, self.verbose)
-        gu.initialize()
-        self.model_file = f"{os.path.join(self.geom_folder, self.fdm.general.magnet_name)}.brep"
-        gmsh.option.setString('Geometry.OCCTargetUnit', 'M')  # set units to meters
-        gmsh.open(self.model_file)
-        if gui:
-            gu.launch_interactive_GUI()
+        pass
+        # gu = GmshUtils(self.geom_folder, self.verbose)
+        # gu.initialize(verbosity_Gmsh=self.fdm.run.verbosity_Gmsh)
+        # model_file = os.path.join(self.geom_folder, self.fdm.general.magnet_name)
+        # gmsh.option.setString(name='Geometry.OCCTargetUnit', value='M')  # set units to meters
+        # gmsh.open(model_file + '_EM.brep')
+        # gmsh.open(model_file + '_TH.brep')
+        # if gui: gu.launch_interactive_GUI()
 
     def pre_process(self, gui: bool = False):
         pass
 
+    def load_geometry_for_mesh(self, run_type):
+        gu = GmshUtils(self.geom_folder, self.verbose)
+        gu.initialize(verbosity_Gmsh=self.fdm.run.verbosity_Gmsh)
+        model_file = os.path.join(self.geom_folder, self.fdm.general.magnet_name)
+        gmsh.option.setString(name='Geometry.OCCTargetUnit', value='M')  # set units to meters
+        gmsh.open(model_file + f'_{run_type}.brep')
+
     def mesh(self, gui: bool = False):
-        mm = Mesh(data=self.fdm, sett=self.sett, mesh_folder=self.mesh_folder, verbose=self.verbose)
-        self.model_file = mm.model_file
-        mm.loadAuxiliaryFile()
-        mm.getIronCurvesTags()
-        mm.defineMesh()
-        mm.fragment()
-        mm.createPhysicalGroups()
-        mm.updateAuxiliaryFile()
-        mm.assignRegionsTags()
-        mm.saveRegionFile()
-        mm.setMeshOptions()
-        mm.generateMesh()
-        mm.checkMeshQuality()
-        mm.saveMeshFile()
+        mm = Mesh(data=self.fdm, mesh_folder=self.mesh_folder, verbose=self.verbose)
+        geom = Util.read_data_from_yaml(self.rgd, dF.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}
+        mesh_type_list = []
+        if fdm.magnet.mesh.electromagnetics.create: mesh_type_list.append('EM')
+        if fdm.magnet.mesh.thermal.create: mesh_type_list.append('TH')
+        for physics_solved in mesh_type_list:
+            self.load_geometry_for_mesh(physics_solved)
+            if physics_solved == 'TH' and self.fdm.magnet.geometry.thermal.use_TSA:
+                mm.loadStrandPositions(physics_solved)
+            mm.loadAuxiliaryFile(physics_solved)
+            if geometry_settings[physics_solved].with_iron_yoke:
+                mm.getIronCurvesTags()
+            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):
+                mm.rearrangeThinShellsData()
+            mm.assignRegionsTags(geometry_settings[physics_solved], mesh_settings[physics_solved])
+            mm.saveRegionFile(physics_solved)
+            mm.setMeshOptions(physics_solved)
+            mm.generateMesh()
+            mm.checkMeshQuality()
+            mm.saveMeshFile(physics_solved)
+            if geometry_settings[physics_solved].dict().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')
+                mm.saveRegionCoordinateFile(physics_solved)
+            mm.clear()
         mm.ending_step(gui)
         return mm.mesh_parameters
 
     def load_mesh(self, gui: bool = False):
         gu = GmshUtils(self.geom_folder, self.verbose)
-        gu.initialize()
-        self.model_file = f"{os.path.join(self.mesh_folder, self.fdm.general.magnet_name)}.msh"
-        gmsh.open(self.model_file)
-        if gui:
-            gu.launch_interactive_GUI()
+        gu.initialize(verbosity_Gmsh=self.fdm.run.verbosity_Gmsh)
+        gmsh.open(f"{os.path.join(self.mesh_folder, self.fdm.general.magnet_name)}.msh")
+        if gui: gu.launch_interactive_GUI()
 
     def solve_and_postprocess_getdp(self, gui: bool = False):
         an = AssignNaming(data=self.fdm)
-        rg = RunGetdpMultipole(data=an, sett=self.sett, solution_folder=self.solution_folder, settings=self.settings,
-                               verbose=self.verbose)
-        self.model_file = rg.model_file
-        rg.loadRegionFile()
+        rg = RunGetdpMultipole(data=an, solution_folder=self.solution_folder, GetDP_path=self.GetDP_path, verbose=self.verbose)
+        rg.loadRegionFiles()
+        if self.fdm.magnet.solve.thermal.solve_type and self.fdm.magnet.geometry.thermal.use_TSA:
+            rg.loadRegionCoordinateFile()
         rg.assemblePro()
         start_time = time.time()
         rg.solve_and_postprocess()
@@ -102,10 +145,10 @@ class MainMultipole:
 
     def post_process_getdp(self, gui: bool = False):
         an = AssignNaming(data=self.fdm)
-        rg = RunGetdpMultipole(data=an, sett=self.sett, solution_folder=self.solution_folder, settings=self.settings,
-                               verbose=self.verbose)
-        self.model_file = rg.model_file
-        rg.loadRegionFile()
+        rg = RunGetdpMultipole(data=an, solution_folder=self.solution_folder, GetDP_path=self.GetDP_path, verbose=self.verbose)
+        rg.loadRegionFiles()
+        if self.fdm.magnet.solve.thermal.solve_type and self.fdm.magnet.geometry.thermal.use_TSA:
+            rg.loadRegionCoordinateFile()
         rg.assemblePro()
         rg.postprocess()
         rg.ending_step(gui)
@@ -114,18 +157,26 @@ class MainMultipole:
         if self.fdm.run.type == 'post_process_python_only':
             an = AssignNaming(data=self.fdm)
             data = an.data
-        else:
-            data = self.fdm
-        pp = PostProcess(data=data, sett=self.sett, solution_folder=self.solution_folder, verbose=self.verbose)
-        self.model_file = pp.model_file
-        pp.loadStrandPositions()
-        if self.fdm.magnet.postproc.plot_all:
-            pp.loadHalfTurnCornerPositions()
-        pp.postProcess()
+        else: data = self.fdm
+
+        run_types = []
+        if self.fdm.magnet.solve.electromagnetics.solve_type: run_types.append('EM')
+        if self.fdm.magnet.solve.thermal.solve_type: run_types.append('TH')
+        pp_settings = {'EM': self.fdm.magnet.postproc.electromagnetics, 'TH': self.fdm.magnet.postproc.thermal}
+        pp = PostProcess(data=data, solution_folder=self.solution_folder, verbose=self.verbose)
+        for run_type in run_types:
+            pp.prepare_settings(pp_settings[run_type])
+            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()
+            pp.postProcess(pp_settings[run_type])
+            if run_type == 'EM' and self.fdm.magnet.geometry.electromagnetics.symmetry != 'none': pp.completeMap2d()
+            pp.clear()
         pp.ending_step(gui)
         return pp.postprocess_parameters
 
     def plot_python(self):
         os.chdir(self.solution_folder)
-        p = PlotPythonMultipole(self.fdm)
-        p.dummy_plot_func()
+        p = PlotPythonMultipole(self.fdm, self.fdm)
+        p.plot_coil_wedges()