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

fiqus/getdp_runners/RunGetdpMultipole.py

@@ -4,6 +4,7 @@ import subprocess
 import logging
 import timeit
 import re
+import pandas as pd
 
 import gmsh
 from fiqus.pro_assemblers.ProAssembler import ASS_PRO as aP
@@ -13,8 +14,9 @@ from fiqus.data import DataFiQuS as dF
 from fiqus.data import RegionsModelFiQuS as rM
 from fiqus.data import DataMultipole as dM
 
-logger = logging.getLogger(__name__)
+logger = logging.getLogger('FiQuS')
 
+trigger_time_deactivated = 99999
 
 class AssignNaming:
     def __init__(self, data: dF.FDM() = None):
@@ -24,16 +26,30 @@ class AssignNaming:
         """
         self.data: dF.FDM() = data
 
-        self.naming_conv = {'omega': 'Omega', 'boundary': 'Bd_', 'powered': '_p', 'induced': '_i', 'air': '_a',
-                            'air_far_field': '_aff', 'iron': '_bh', 'conducting': '_c', 'insulator': '_ins', 'terms': 'Terms'}
+        self.naming_conv = {'omega': 'Omega',
+                            'boundary': 'Bnd_',
+                            'powered': '_p', 'induced': '_i',
+                            'air': '_a',
+                            'air_far_field': '_aff',
+                            'conducting': '_c',
+                            'insulator': '_ins',
+                            'terms': 'Terms',
+                            'iron_yoke': '_bh', #todo: consider renaming this
+                            'collar': '_collar',
+                            'ref_mesh': '_refmesh',
+                            'poles': '_poles'}
+
         self.data.magnet.postproc.electromagnetics.volumes = \
-            [self.naming_conv['omega'] + (self.naming_conv[var] if var != 'omega' else '') for var in self.data.magnet.postproc.electromagnetics.volumes]
+            [self.naming_conv['omega'] + (self.naming_conv[var] if var != 'omega' else '') for var in
+             self.data.magnet.postproc.electromagnetics.volumes]
         self.data.magnet.postproc.thermal.volumes = \
-            [self.naming_conv['omega'] + (self.naming_conv[var] if var != 'omega' else '') for var in self.data.magnet.postproc.thermal.volumes]
+            [self.naming_conv['omega'] + (self.naming_conv[var] if var != 'omega' else '') for var in
+             self.data.magnet.postproc.thermal.volumes]
 
 
 class RunGetdpMultipole:
-    def __init__(self, data: AssignNaming = None, solution_folder: str = None, GetDP_path: str = None, verbose: bool = False):
+    def __init__(self, data: AssignNaming = None, solution_folder: str = None, GetDP_path: str = None,
+                 verbose: bool = False):
         """
         Class to solve pro file
         :param data: FiQuS data model
@@ -48,62 +64,116 @@ class RunGetdpMultipole:
         self.solution_folder = solution_folder
         self.GetDP_path = GetDP_path
         self.verbose: bool = verbose
-        self.call_method = 'subprocess'  # or onelab
+        self.call_method = 'subprocess'  # or onelab or subprocess or alt_solver
 
         self.rm_EM = rM.RegionsModel()
         self.rm_TH = rM.RegionsModel()
-        self.rc = dM.MultipoleRegionCoordinate()\
+        self.aux = {
+            "half_turns": {
+                "ht": {},  # Dictionary to store half-turn data
+                "max_reg": None,  # Maximum region number to avoid overlaps of physical regions
+                "block": {}  # Dictionary that stores the relation between magnet blocks(groups) and half-turn areas
+
+            },
+            "e_cliq": {},  # Dictionary that stores the E-CLIQ source current LUTs from a csv
+            "tsa_collar": {},
+            "sim_info": {
+                'date': '',
+                'author': ''
+            }
+        }
+        self.material_properties_model = None
+        self.rohm = {}  # rohm parameter dictionary
+        self.rohf = {}  # rohf parameter dictionary
+        self.rc = dM.MultipoleRegionCoordinate() \
             if self.data.magnet.mesh.thermal.isothermal_conductors and self.data.magnet.solve.thermal.solve_type else None
 
         self.gu = GmshUtils(self.solution_folder, self.verbose)
         self.gu.initialize(verbosity_Gmsh=self.data.run.verbosity_Gmsh)
         self.occ = gmsh.model.occ
         self.mesh = gmsh.model.mesh
-
-        self.brep_iron_curves = {1: set(), 2: set(), 3: set(), 4: set()}
+        self.brep_curves = {}
+        for name in self.data.magnet.geometry.electromagnetics.areas:
+            self.brep_curves[name] = {1: set(), 2: set(), 3: set(), 4: set()}
         self.mesh_files = os.path.join(os.path.dirname(self.solution_folder), self.data.general.magnet_name)
         self.model_file = os.path.join(self.solution_folder, 'Center_line.csv')
 
         self.mf = {'EM': f"{self.mesh_files}_EM.msh", 'TH': f"{self.mesh_files}_TH.msh"}
 
     def loadRegionFiles(self):
+        """
+        Read the regions' files and store the information in a variable. used for extracting the maximum region number.
+        :param
+        :return: Data from the regions files
+        """
         if self.data.magnet.solve.electromagnetics.solve_type:
             self.rm_EM = Util.read_data_from_yaml(f"{self.mesh_files}_EM.reg", rM.RegionsModel)
         if self.data.magnet.solve.thermal.solve_type:
             self.rm_TH = Util.read_data_from_yaml(f"{self.mesh_files}_TH.reg", rM.RegionsModel)
 
     def loadRegionCoordinateFile(self):
+        """
+        Read the reco file and store the information in a variable.
+        :param
+        :return: Data from the reco file
+        """
         self.rc = Util.read_data_from_yaml(f"{self.mesh_files}_TH.reco", dM.MultipoleRegionCoordinate)
 
     def assemblePro(self):
+        """
+        Assemble the .pro file using the right template depending on the inputs from the yaml
+        :param
+        :return: Assembled .pro file
+        """
         logger.info(f"Assembling pro file...")
         start_time = timeit.default_timer()
-        ap = aP(file_base_path=os.path.join(self.solution_folder, self.data.general.magnet_name), naming_conv=self.naming_conv)
-        BH_curves_path = os.path.join(pathlib.Path(os.path.dirname(__file__)).parent, 'pro_material_functions', 'ironBHcurves.pro')
-        ap.assemble_combined_pro(template='Multipole_template.pro', rm_EM=self.rm_EM, rm_TH=self.rm_TH, rc=self.rc, dm=self.data, mf=self.mf, BH_curves_path=BH_curves_path)
+        ap = aP(file_base_path=os.path.join(self.solution_folder, self.data.general.magnet_name),
+                naming_conv=self.naming_conv)
+        BH_curves_path = os.path.join(pathlib.Path(os.path.dirname(__file__)).parent, 'pro_material_functions',
+                                      'ironBHcurves.pro')
+        template = 'Multipole_template.pro'
+        ap.assemble_combined_pro(template=template, rm_EM=self.rm_EM, rm_TH=self.rm_TH, rc=self.rc, dm=self.data,
+                                 mf=self.mf, BH_curves_path=BH_curves_path, aux=self.aux)
         logger.info(
             f"Assembling pro file took"
             f" {timeit.default_timer() - start_time:.2f} s."
         )
 
     def solve_and_postprocess(self):
+        """
+        Generates the necessary GetDP commands to solve and postprocess the model, and runs them.
+        :param
+        :return: None
+        """
         commands = None
         if self.call_method == 'onelab':
             commands = f"-solve -v2 -pos -verbose {self.data.run.verbosity_GetDP}"
         elif self.call_method == 'subprocess':
-            commands = []
-            commands.append(["-solve", 'resolution', "-v2", "-pos", "Dummy", "-verbose", str(self.data.run.verbosity_GetDP)])
-
+            commands = [["-solve", 'resolution', "-v2", "-pos", "Dummy", "-verbose", str(self.data.run.verbosity_GetDP),
+                         "-mat_mumps_icntl_14", "250"]]
         self._run(commands=commands)
 
     def postprocess(self):
+        """
+        Generates the necessary GetDP commands to postprocess the model, and runs them.
+        :param
+        :return: None
+        """
         if self.call_method == 'onelab':
-            command = "-v2 -pos -verbose {self.data.run.verbosity_GetDP}"
+            commands = f"-v2 -pos -verbose {self.data.run.verbosity_GetDP}"
         elif self.call_method == 'subprocess':
-            command = [["-v2", "-pos", "-verbose", str(self.data.run.verbosity_GetDP)]]
-        self._run(commands=command)
+            commands = [["-v2", "-pos", "Dummy", "-verbose", str(self.data.run.verbosity_GetDP)]]
+        elif self.call_method == 'alt_solver':
+            commands = [["-solve", 'resolution', "-v2", "-pos", "Dummy"]]
+
+        self._run(commands=commands)
 
     def _run(self, commands):
+        """
+        runs GetDP with the specified commands. Additionally it captures and logs the output.
+        :param commands: List of commands to run GetDP with
+        :return: None
+        """
         logger.info("Solving...")
         start_time = timeit.default_timer()
         if self.call_method == 'onelab':
@@ -111,7 +181,7 @@ class RunGetdpMultipole:
                 gmsh.onelab.run(f"{self.data.general.magnet_name}",
                                 f"{self.GetDP_path} {os.path.join(self.solution_folder, self.data.general.magnet_name)}.pro {command}")
             gmsh.onelab.setChanged("GetDP", 0)
-        elif self.call_method == 'subprocess':
+        elif self.call_method == 'subprocess' or self.call_method == 'alt_solver':
             # subprocess.call([f"{self.GetDP_path}", f"{os.path.join(self.solution_folder, self.data.general.magnet_name)}.pro"] + command + ["-msh", f"{self.mesh_files}.msh"])
 
             # view_tag = gmsh.view.getTags()  # this should be b
@@ -122,14 +192,26 @@ class RunGetdpMultipole:
                 mpi_prefix = ["mpiexec", "-np", str(self.data.magnet.solve.noOfMPITasks)]
             else:
                 mpi_prefix = []
-            
+
             for command in commands:
-                getdpProcess = subprocess.Popen(
-                    mpi_prefix + [f"{self.GetDP_path}", f"{os.path.join(self.solution_folder, self.data.general.magnet_name)}.pro"] +
-                    command,
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.STDOUT,
-                )
+                use_predefined_pro = False  # If True, one can use a predefined .pro file
+                if use_predefined_pro:
+                    logger.warning("Using predefined .pro file")
+                    getdpProcess = subprocess.Popen(
+                        mpi_prefix + [f"{self.GetDP_path}",
+                                      f"{os.path.join(os.path.abspath(os.path.join(self.solution_folder, '..', '..', '..')), '_out/TEST')}.pro"] +
+                        command,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.STDOUT,
+                    )
+                else:
+                    getdpProcess = subprocess.Popen(
+                        mpi_prefix + [f"{self.GetDP_path}",
+                                      f"{os.path.join(self.solution_folder, self.data.general.magnet_name)}.pro"] +
+                        command,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.STDOUT,
+                    )
                 with getdpProcess.stdout:
                     for line in iter(getdpProcess.stdout.readline, b""):
                         line = line.decode("utf-8").rstrip()
@@ -139,8 +221,7 @@ class RunGetdpMultipole:
                             logger.info(parsedLine)
                         elif "Warning" in line:
                             parsedLine = re.sub(r"Warning\s*:\s*", "", line)
-                            if "Unknown" not in parsedLine:
-                                logger.warning(parsedLine)
+                            logger.warning(parsedLine)
                         elif "Error" in line:
                             parsedLine = re.sub(r"Error\s*:\s*", "", line)
                             logger.error(parsedLine)
@@ -163,8 +244,77 @@ class RunGetdpMultipole:
         )
 
     def ending_step(self, gui: bool = False):
+        """
+        Finalize the GetDP runner, either by launching the GUI or finalizing gmsh.
+        :param gui: If True, launches the interactive GUI; otherwise finalizes gmsh.
+        :return: None
+        """
         if gui:
             self.gu.launch_interactive_GUI()
         else:
-            gmsh.clear()
-            gmsh.finalize()
+            if gmsh.isInitialized():
+                gmsh.clear()
+                gmsh.finalize()
+
+    def read_aux_file(self, aux_file_path):
+        """
+        Read the auxiliary file and store the information in a variable. Necessary to extract half-turn information from blocks.
+        :param aux_file_path: Path to the auxiliary file
+        :return: Data from the auxiliary file
+        """
+        try:
+            self.aux_data = Util.read_data_from_yaml(aux_file_path, dM.MultipoleData)
+            logger.info(f"Auxiliary data loaded from {aux_file_path}")
+        except FileNotFoundError:
+            logger.error(f"Auxiliary file not found: {aux_file_path}")
+        except Exception as e:
+            logger.error(f"Error reading auxiliary file: {e}")
+
+    def extract_half_turn_blocks(self):
+        """
+        Extract a dictionary from the .aux file where the keys are integers corresponding to the block number
+        and the dictionary entries for these keys are a list of all the half-turn areas included in that block.
+        :return: Dictionary with block numbers as keys and lists of half-turn areas as values
+        """
+        aux_data = self.aux_data
+
+        half_turn_areas = {}
+        info_block = {}
+        coils = aux_data.geometries.coil.coils
+        for coil_nr, coil_data in coils.items():
+            poles = coil_data.poles
+            for pole_nr, pole_data in poles.items():
+                layers = pole_data.layers
+                for layer_nr, layer_data in layers.items():
+                    windings = layer_data.windings
+                    for winding_nr, winding_data in windings.items():
+                        blocks = winding_data.blocks
+                        for block_nr, block_data in blocks.items():
+                            half_turns = block_data.half_turns.areas
+                            info_block[block_nr] = [int(area) for area in half_turns.keys()]
+                            half_turn_areas[int(block_nr)] = [int(area) for area in half_turns.keys()]
+
+        self.aux["half_turns"]["ht"] = half_turn_areas
+        self.aux["half_turns"]["block"] = info_block
+        pass
+
+    def extract_specific_TSA_lines(self):
+        """
+        Extract a dictionary from the thermal .aux file, collects the outer lines of the half-turns and wedges used for the TSA collar
+        """
+        aux_data = self.aux_data
+        pg = aux_data.domains.physical_groups
+        max_layer = len([k for k in self.aux_data.geometries.coil.coils[1].poles[1].layers.keys()])  # todo : more elegant way ? @emma
+        tags = []
+        for block in pg.blocks.values():
+            for ht in block.half_turns.values():
+                if ht.group[-1] == str(max_layer):  # r1_a2 or r2_a2
+                    tags.append(ht.lines['o'])
+        self.aux["tsa_collar"]['ht_lines'] = tags
+
+        tags = []
+        for wedge in pg.wedges.values():
+            if wedge.group[-1] == str(max_layer):  # r1_a2 or r2_a2
+                tags.append(wedge.lines['o'])
+        self.aux["tsa_collar"]['wedge_lines'] = tags
+        pass

fiqus/mains/MainMultipole.py

@@ -1,7 +1,9 @@
+import logging
 import os
 import gmsh
 import time
 
+from fiqus.plotters.PlotPythonMultipole import PlotPythonMultipole
 from fiqus.utils.Utils import GmshUtils
 from fiqus.utils.Utils import FilesAndFolders as Util
 from fiqus.data import DataFiQuS as dF
@@ -11,11 +13,10 @@ from fiqus.mesh_generators.MeshMultipole import Mesh
 from fiqus.getdp_runners.RunGetdpMultipole import RunGetdpMultipole
 from fiqus.getdp_runners.RunGetdpMultipole import AssignNaming
 from fiqus.post_processors.PostProcessMultipole import PostProcess
-from fiqus.plotters.PlotPythonMultipole import PlotPythonMultipole
 
 
 class MainMultipole:
-    def __init__(self, fdm: dF.FDM = None, rgd_path: str = None, verbose: bool = None):
+    def __init__(self, fdm: dF.FDM = None, rgd_path: str = None, verbose: bool = None, inputs_folder_path = None):
         """
         Main class for working with simulations for multipole type magnets
         :param fdm: FiQuS data model
@@ -30,11 +31,13 @@ class MainMultipole:
         self.geom_folder = None
         self.mesh_folder = None
         self.solution_folder = None
+        self.inputs_folder_path = inputs_folder_path
 
     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, 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
@@ -43,14 +46,16 @@ class MainMultipole:
             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')
+
+        if geometry_settings['EM'].create: geometry_type_list.append('EM')
+        if geometry_settings['TH'].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')
+            if any(geometry_settings[geometry_type].areas):
+                gg.constructIronGeometry(geometry_settings[geometry_type].symmetry if geometry_type == 'EM' else 'none', geometry_settings[geometry_type], run_type = geometry_type)
             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)
@@ -60,9 +65,17 @@ class MainMultipole:
                     gg.constructThinShells(geometry_settings[geometry_type].with_wedges)
                 else:
                     gg.constructInsulationGeometry()
+                if geometry_settings[geometry_type].use_TSA_new:
+                    gg.constructAdditionalThinShells()
+
             gg.buildDomains(geometry_type, geometry_settings[geometry_type].symmetry if geometry_type == 'EM' else 'none')
             if geometry_type == 'EM':
                 gg.fragment()
+            if geometry_type =='TH' and 'poles' in geometry_settings[geometry_type].areas:
+                # make sure geometry is connected
+                gmsh.model.occ.removeAllDuplicates()
+                gmsh.model.occ.synchronize()
+
             gg.saveBoundaryRepresentationFile(geometry_type)
             gg.loadBoundaryRepresentationFile(geometry_type)
             gg.updateTags(geometry_type, geometry_settings[geometry_type].symmetry if geometry_type == 'EM' else 'none')
@@ -91,29 +104,84 @@ class MainMultipole:
         gmsh.open(model_file + f'_{run_type}.brep')
 
     def mesh(self, gui: bool = False):
-        mm = Mesh(data=self.fdm, mesh_folder=self.mesh_folder, verbose=self.verbose)
+        def _create_physical_group_for_reference(self):
+            """
+                This code generates the reference models for the FALCOND_C
+            """
+            ### hardcoded, we need only one reference
+            if self.fdm.general.magnet_name == 'TEST_MULTIPOLE_FALCOND_C_TSA_COLLAR_POLE':
+                CUT_REFERENCE = True # self specify loop and surf
+
+                L_col = [56, 57, 58, 35, 16, 49, 48, 47]
+                l1 = gmsh.model.occ.addLine(746,48)
+                l2 = gmsh.model.occ.addLine(41,691)
+                L_inner = list(range(854, 754-1, -1))
+                loop1 = gmsh.model.occ.addCurveLoop([l1] + L_col + [l2] + L_inner)
+
+                R_col = [52, 53, 54, 26, 6, 45, 44, 43]
+                r1 = gmsh.model.occ.addLine(38,902)
+                r2 = gmsh.model.occ.addLine(847,45)
+                R_inner = list(range(910, 1010+1))
+                loop2 = gmsh.model.occ.addCurveLoop([r2]+ R_col + [r1] + R_inner)
+
+                surf1 = gmsh.model.occ.addPlaneSurface([loop1])
+                surf2 = gmsh.model.occ.addPlaneSurface([loop2])
+                surf = [surf1, surf2]  # tag
+
+            else: raise Exception("Reference meshing is not implemented for this magnet.")
+            gmsh.model.occ.synchronize()
+
+            #add to physical groups / domains -> write to aux file
+            file = os.path.join(self.geom_folder, self.fdm.general.magnet_name + '_TH.aux')
+            with open(file) as f:
+                lines = f.readlines()
+            updated_lines = []
+            flag = 0
+            for line in lines:
+                updated_lines.append(line)
+                if flag == 0 and 'groups_entities:' in line:
+                    flag = 1
+                if flag==1 and ('ref_mesh: {}' in line):
+                    if type(surf) == list:
+                        updated_lines[-1] = f'    ref_mesh:\n      {self.fdm.magnet.solve.thermal.insulation_TSA.between_collar.material}: {surf}\n'
+                    else:
+                        updated_lines[-1] = f'    ref_mesh:\n      {self.fdm.magnet.solve.thermal.insulation_TSA.between_collar.material}: [{surf}]\n'
+                        #if not CUT_REFERENCE else f'    ref_mesh:\n      {self.fdm.magnet.solve.thermal.insulation_TSA.between_collar.material}: '+ str(surf) +'\n'
+                    flag = -1
+
+            with open(file, 'w') as f:
+                f.writelines(updated_lines)
+            logger = logging.getLogger('FiQuS')
+            logger.warning("Overwrite the .aux file to include the new domain")
+
+        mm = Mesh(data=self.fdm, mesh_folder=self.mesh_folder, verbose=self.verbose) ## same mesh object is used for both thermal and EM
         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}
+
         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')
+        if mesh_settings['EM'].create: mesh_type_list.append('EM')
+        if mesh_settings['TH'].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)
+            if physics_solved == 'TH' and mesh_settings['TH'].reference.enabled and 'collar' in geometry_settings['TH'].areas:
+                if self.fdm.magnet.geometry.thermal.use_TSA_new or self.fdm.magnet.geometry.thermal.use_TSA:
+                    raise Exception('Reference solution is not implemented for collar with TSA')
+                if 'iron_yoke' in geometry_settings['TH'].areas:
+                    raise Exception('Reference solution is intended (read: hardcoded) without iron yoke')
+                _create_physical_group_for_reference(self)
             mm.loadAuxiliaryFile(physics_solved)
-            if geometry_settings[physics_solved].with_iron_yoke:
-                mm.getIronCurvesTags()
+            if any(geometry_settings[physics_solved].areas):
+                mm.getIronCurvesTags(physics_solved)
             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].model_dump().get('use_TSA', False):
-                mm.rearrangeThinShellsData()
+                mm.rearrangeThinShellsData() # rearrange data for the pro file, technically optional
             mm.assignRegionsTags(geometry_settings[physics_solved], mesh_settings[physics_solved])
             mm.saveRegionFile(physics_solved)
-            mm.setMeshOptions(physics_solved)
+            mm.setMeshOptions()
             mm.generateMesh()
             mm.checkMeshQuality()
             mm.saveMeshFile(physics_solved)
@@ -121,7 +189,10 @@ class MainMultipole:
                 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)
+            if geometry_settings[physics_solved].model_dump().get('use_TSA_new', False):
+                mm.saveClosestNeighboursList_new_TSA()
+            mm.saveHalfTurnCornerPositions()
+            mm.saveRegionCoordinateFile(physics_solved)
             mm.clear()
         mm.ending_step(gui)
         return mm.mesh_parameters
@@ -134,16 +205,37 @@ class MainMultipole:
 
     def solve_and_postprocess_getdp(self, gui: bool = False):
         an = AssignNaming(data=self.fdm)
-        rg = RunGetdpMultipole(data=an, solution_folder=self.solution_folder, GetDP_path=self.GetDP_path, verbose=self.verbose)
+        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()
+        rg.ending_step(gui)
+        return time.time() - start_time
+
+    def solve_and_postprocess_getdp(self, gui: bool = False):
+        an = AssignNaming(data=self.fdm)
+        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.read_aux_file(os.path.join(self.mesh_folder, f"{self.fdm.general.magnet_name}_EM.aux"))
+            rg.extract_half_turn_blocks()
+        if self.fdm.magnet.geometry.thermal.use_TSA_new:
+            rg.read_aux_file(os.path.join(self.mesh_folder,
+                                          f"{self.fdm.general.magnet_name}_TH.aux"))  # now load the thermal aux file
+            rg.extract_specific_TSA_lines()
         rg.assemblePro()
         start_time = time.time()
         rg.solve_and_postprocess()
         rg.ending_step(gui)
         return time.time() - start_time
 
+
     def post_process_getdp(self, gui: bool = False):
         an = AssignNaming(data=self.fdm)
         rg = RunGetdpMultipole(data=an, solution_folder=self.solution_folder, GetDP_path=self.GetDP_path, verbose=self.verbose)