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

fiqus/geom_generators/GeometryMultipole.py

@@ -1,3 +1,5 @@
+import copy
+import logging
 import os
 import gmsh
 import numpy as np
@@ -14,6 +16,7 @@ from fiqus.data.DataRoxieParser import Corner
 from fiqus.data.DataRoxieParser import Coord
 import re
 
+logger = logging.getLogger('FiQuS')
 class Geometry:
     def __init__(self, data: dF.FDM() = None, geom: FiQuSGeometry() = None,
                  geom_folder: str = None, verbose: bool = False):
@@ -25,6 +28,11 @@ class Geometry:
         """
         self.data: dF.FDM() = data
         self.geom: FiQuSGeometry() = geom.Roxie_Data
+
+        # move cooling holes to a desired position
+        if self.data.magnet.solve.thermal.collar_cooling.move_cooling_holes:
+            self.geom.iron.key_points = self.move_keypoints(self.geom.iron.key_points, self.data.magnet.solve.thermal.collar_cooling.move_cooling_holes)
+
         self.geom_folder = geom_folder
         self.verbose: bool = verbose
 
@@ -40,6 +48,9 @@ class Geometry:
         self.ins_wire_lines = {}  # for meshed insulation
         self.block_coil_mid_pole_blks = {}
 
+        self.nc = {'collar': 'c', 'iron_yoke': 'i', 'poles': 'p'}
+        self.inv_nc = {v: k for k, v in self.nc.items()} #invert naming convention
+
         if self.data.magnet.geometry.electromagnetics.symmetry != 'none':
             self.symmetric_loop_lines = {'x': [], 'y': []}
             self.symmetric_bnds = {'x_p': {'pnts': [], 'line_pnts': []}, 'y_p': {'pnts': [], 'line_pnts': []},
@@ -54,8 +65,9 @@ class Geometry:
         if gui:
             self.gu.launch_interactive_GUI()
         else:
-            gmsh.clear()
-            gmsh.finalize()
+            if gmsh.isInitialized():
+                gmsh.clear()
+                gmsh.finalize()
 
     def saveHalfTurnCornerPositions(self):
         self.occ.synchronize()
@@ -74,8 +86,9 @@ class Geometry:
                 iL.append([ht.iL.x, ht.iL.y])
                 oH.append([ht.oH.x, ht.oH.y])
                 oL.append([ht.oL.x, ht.oL.y])
-        json.dump({'iH': iH, 'iL': iL, 'oH': oH, 'oL': oL,
-                   'iHr': iHr, 'iLr': iLr, 'oHr': oHr, 'oLr': oLr}, open(f"{self.model_file}.crns", 'w'))
+        with open(f"{self.model_file}.crns", 'w') as f:
+            json.dump({'iH': iH, 'iL': iL, 'oH': oH, 'oL': oL,
+                       'iHr': iHr, 'iLr': iLr, 'oHr': oHr, 'oLr': oLr}, f)
 
     def saveStrandPositions(self, run_type):
         symmetry = self.data.magnet.geometry.electromagnetics.symmetry if run_type == 'EM' else 'none'
@@ -108,9 +121,10 @@ class Geometry:
                 subdf = df[(condition[qdr][0] * df['parser_x'] < 0) & (condition[qdr][1] * df['parser_y'] < 0)]
                 for strand, x, y in zip(subdf.index, subdf['parser_x'], subdf['parser_y']):
                     mirrored[strand] = df[(df['parser_x'] == mrr[0] * x) & (df['parser_y'] == mrr[1] * y)].index.item()
-        json.dump({'x': parser_x, 'y': parser_y, 'block': blocks, 'ht': ht, 'mirrored': mirrored,
-                   'pole_1_blocks': pole_blocks, 'poles': len(self.geom.coil.coils[1].poles)},
-                  open(f"{self.model_file}_{run_type}.strs", 'w'))
+        with open(f"{self.model_file}_{run_type}.strs", 'w') as f:
+            json.dump({'x': parser_x, 'y': parser_y, 'block': blocks, 'ht': ht, 'mirrored': mirrored,
+                       'pole_1_blocks': pole_blocks, 'poles': len(self.geom.coil.coils[1].poles)},
+                      f)
 
     def saveBoundaryRepresentationFile(self, run_type):
         self.occ.synchronize()
@@ -206,7 +220,7 @@ class Geometry:
             elif 'current' in angles_to_correct:
                 if angle_next < np.pi / 2: angle_next += correction_angle
                 elif angle_next > np.pi * 3 / 2: angle_next = angle_next + correction_angle - 2 * np.pi
-            if abs(angle_curr - angle_next) < 1e-6:  # todo: check if needed
+            if abs(angle_curr - angle_next) < 1e-6:
                 thin_shell_endpoints[side], angles[side], which_block[side] = pnt_curr, angle_curr, 'current'
             elif angle_curr * (-1 if side == 'lower' else 1) < angle_next * (-1 if side == 'lower' else 1):
                 thin_shell_endpoints[side], angles[side], which_block[side] = pnt_curr, angle_curr, 'current'
@@ -215,11 +229,15 @@ class Geometry:
         if angles['higher'] < angles['lower']: return None
         else: return thin_shell_endpoints, which_block
 
-    def constructIronGeometry(self, symmetry):
+    def create_geom_dict(self, geometry_setting):
+        return {v: k in geometry_setting.areas for k, v in self.nc.items()}
+
+    def constructIronGeometry(self, symmetry, geometry_setting, run_type):
         """
             Generates points, hyper lines, and curve loops for the iron yoke
         """
-        iron = self.geom.iron
+        iron = self.geom.iron #roxie
+
         if symmetry == 'xy':
             self.md.geometries.iron.quadrants = {1: dM.Region()}
             list_bnds = ['x_p', 'y_p']
@@ -230,12 +248,16 @@ class Geometry:
             self.md.geometries.iron.quadrants = {1: dM.Region(), 4: dM.Region()}
             list_bnds = ['y_p', 'y_n']
         else:
-            self.md.geometries.iron.quadrants = {1: dM.Region(), 2: dM.Region(), 4: dM.Region(), 3: dM.Region()}
+            for k in self.nc.keys(): getattr(self.md.geometries, k).quadrants = {1: dM.Region(), 2: dM.Region(), 4: dM.Region(), 3: dM.Region()}
             list_bnds = []
-        quadrants = self.md.geometries.iron.quadrants
 
         lc = 1e-2
+        geom_dict = self.create_geom_dict(geometry_setting)
+
         for point_name, point in iron.key_points.items():
+            identifier = next((k for k in self.inv_nc.keys() if re.match(f'^{k}', point_name[2:])), None)
+            if not geom_dict.get(identifier, False): continue
+            quadrants = getattr(self.md.geometries, self.inv_nc[identifier]).quadrants #re.sub(r'\d+', '', point_name[2:])
             if symmetry in ['x', 'xy']:
                 if point.y == 0.:
                     self.symmetric_bnds['x_p']['pnts'].append([point_name, point.x])
@@ -273,6 +295,9 @@ class Geometry:
         symmetric_bnds_order = {'x': [], 'y': []}
         sym_lines_tags = {'x_p': [], 'y_p': [], 'x_n': [], 'y_n': []}
         for line_name, line in iron.hyper_lines.items():
+            identifier = next((k for k in self.inv_nc.keys() if re.match(f'^{k}', line_name[2:])), None)
+            if not geom_dict.get(identifier, False): continue
+            quadrants = getattr(self.md.geometries, self.inv_nc[identifier]).quadrants #re.sub(r'\d+', '', line_name[2:])
             pt1 = iron.key_points[line.kp1]
             pt2 = iron.key_points[line.kp2]
             if line.type == 'line':
@@ -359,7 +384,7 @@ class Geometry:
 
                 for quadrant, qq in quadrants.items():
                     qq.lines[line_name] = self.occ.addCircleArc(
-                        qq.points[line.kp1], qq.points[new_point_name], qq.points[line.kp2])
+                        qq.points[line.kp1], qq.points[line.kp3], qq.points[line.kp2], center=False)
 
             elif line.type == 'circle':
                 center = [(pt1.x + pt2.x) / 2, (pt1.y + pt2.y) / 2]
@@ -445,6 +470,7 @@ class Geometry:
                 raise ValueError('Hyper line {} not supported'.format(line.type))
 
         if symmetry != 'none':
+            quadrants = self.md.geometries.iron_yoke.quadrants
             indexes = {'x_p': 1, 'y_p': 1, 'x_n': 1, 'y_n': 1}
             self.md.geometries.air_inf.points['center'] = self.occ.addPoint(0, 0, 0)
             for sym in list_bnds:
@@ -479,12 +505,74 @@ class Geometry:
                 sym_lines_tags['y_p'].reverse()
                 self.symmetric_loop_lines['y'] = sym_lines_tags['y_p'] + sym_lines_tags['y_n']
 
-        for quadrant, qq in quadrants.items():
-            for area_name, area in iron.hyper_areas.items():
-                qq.areas[area_name] = dM.Area(loop=self.occ.addCurveLoop([qq.lines[line] for line in area.lines]))
-                if (iron.hyper_areas[area_name].material not in self.md.domains.groups_entities.iron and
-                        iron.hyper_areas[area_name].material != 'BH_air'):
-                    self.md.domains.groups_entities.iron[iron.hyper_areas[area_name].material] = []
+        # add all areas of each quadrant. Useful for brep curves and meshing
+        for key in geometry_setting.areas:  # only consider areas that are implemented
+            quadrants = getattr(self.md.geometries, key).quadrants
+            for quadrant, qq in quadrants.items():
+                for area_name, area in iron.hyper_areas.items(): ## all areas
+                    def _add_loop():
+                        # prevent additional curveloop generation when Enforcing the TSA mapping on the collar
+                        if (run_type == 'TH'
+                                and self.data.magnet.mesh.thermal.collar.Enforce_TSA_mapping
+                                and (area_name.startswith('arc') and not area_name.startswith('arch') or area_name.startswith('arp'))
+                        ): # need to disable the pole area too as it is linked to the same curve
+                            qq.areas[area_name] = dM.Area() ## initialise area without loop
+                        else:
+                            qq.areas[area_name] = dM.Area(
+                                loop=self.occ.addCurveLoop([qq.lines[line] for line in area.lines]))
+
+                        if iron.hyper_areas[area_name].material not in getattr(self.md.domains.groups_entities, key) and \
+                                iron.hyper_areas[area_name].material != 'BH_air': ## add the material to the keys
+                            # for the collar region, it is possible to overwrite the material -> intercept it here
+                            if key == 'collar' and (self.data.magnet.solve.collar.material != iron.hyper_areas[area_name].material) and self.data.magnet.solve.collar.material is not None:
+                                logger.warning("Overwriting the collar material for area {} to {} ".format(area_name, self.data.magnet.solve.collar.material))
+                                iron.hyper_areas[area_name].material = self.data.magnet.solve.collar.material
+                            getattr(self.md.domains.groups_entities, key)[iron.hyper_areas[area_name].material] = []
+
+                    identifier = next((k for k in geom_dict.keys() if re.match(f'^{k}', area_name[2:])),
+                                      None)  # match key from geom_dict to the area name (see naming convention)
+
+                    if key == self.inv_nc.get(identifier, None):  # re.sub(r'\d+', '', area_name[2:]),
+                        _add_loop() # adds arch to collar, because c is in the naming convention of the collar
+                    elif area_name.startswith('arh') and key == 'iron_yoke': # if not previous but it is a hole, assume iron
+                        _add_loop()
+
+        # define inner collar lines
+        def define_inner_collar():
+            """
+                Defines the inner collar line used for the thermal TSA + for the A projection
+            """
+            self.occ.synchronize()
+            # only works if the inner collar line is an arc -> just disable 'arc' and calc for all lines
+            # alternative method. Find all "arc" lines and then select the closest to the center
+            for quad, object in self.md.geometries.collar.quadrants.items():
+                arc_line_tags = [object.lines[name] for name in object.lines.keys() if
+                              self.geom.iron.hyper_lines[name].type == 'arc']
+                closest_dist = 1000.
+                for tag in arc_line_tags:
+                    x, y, _ = gmsh.model.getValue(1, tag, [0.5]) # pick one point on the arc
+                    dist = np.sqrt(x ** 2 + y ** 2)
+                    if dist < closest_dist:
+                        closest_dist = dist
+                        closest_line = tag ## assumes it is only one line per quadrant
+                self.md.geometries.collar.inner_boundary_tags[quad] = [closest_line]
+        def define_collar_cooling():
+            """
+                Defines the cooling holes in the collar
+            """
+            self.occ.synchronize()
+            line_names = [item for key in self.geom.iron.hyper_areas.keys() if 'ch' in key for item in self.geom.iron.hyper_areas[key].lines]
+            # line names are the same in each quadrant. Tags are unique
+            for quad, qq in self.md.geometries.collar.quadrants.items():
+                self.md.geometries.collar.cooling_tags.extend([qq.lines[line] for line in line_names])
+                # these tags are only used to be skipped for enfrocing_TSA_mapping
+
+        # we need the inner collar lines if we want to do TSA, so no need to define it
+        if run_type == 'TH' and self.data.magnet.geometry.thermal.use_TSA_new: define_inner_collar()
+        # we only need to specify the air holes if we want cooling OR if we enforce TSA nodes on the collar
+        if run_type == 'TH' and (self.data.magnet.solve.thermal.collar_cooling.enabled or self.data.magnet.mesh.thermal.collar.Enforce_TSA_mapping): define_collar_cooling()
+
+
 
     def constructWedgeGeometry(self, use_TSA):
         """
@@ -689,6 +777,11 @@ class Geometry:
             wedge_reg.lines['l'] = self.occ.addLine(wedge_reg.points['il'], wedge_reg.points['ol'])
             wedge_reg.lines['i'] = self.occ.addCircleArc(wedge_reg.points['ih'], wedge_reg.points['inner_center'], wedge_reg.points['il'])
             wedge_reg.lines['o'] = self.occ.addCircleArc(wedge_reg.points['oh'], wedge_reg.points['outer_center'], wedge_reg.points['ol'])
+            """
+            logger.warning("Using straight wedge geometry") # required for the projection
+            wedge_reg.lines['i'] = self.occ.addLine(wedge_reg.points['ih'], wedge_reg.points['il'])
+            wedge_reg.lines['o'] = self.occ.addLine(wedge_reg.points['oh'], wedge_reg.points['ol'])
+            """
             wedge_reg.areas[str(wedge_nr)] = dM.Area(loop=self.occ.addCurveLoop(
                 [wedge_reg.lines['i'], wedge_reg.lines['l'], wedge_reg.lines['o'], wedge_reg.lines['h']]))
 
@@ -1412,9 +1505,49 @@ class Geometry:
                                         count_rest = -abs(indexes[0] - indexes[1]) if (case == 'beg' and i == 1) or (case == 'end' and i == 0) else 1 + abs(indexes[0] - indexes[1])
                                     else:
                                         count_rest = -abs(indexes[0] - indexes[1]) if case == 'beg' else 1 + abs(indexes[0] - indexes[1])
+
+                                    line_name = 'mid_layer_' + mid_l_name + ('b' if i == 1 else '') + (
+                                        '_l' if case == 'beg' else '_h')
+
+                                    gmsh.model.occ.synchronize()
+                                    """
+                                    The line that connects two layers may overlap with a new (pole) region. This can be avoided by 
+                                    modifying the line to be an L shape by adding an intermediate point.
+                                    We add the point along the upper half-turn radial direction towards the center.
+                                    """
+                                    p = ins_pnt[pnt_tag_name]  # point to be extended
+                                    linetag = gmsh.model.getAdjacencies(0, ins_pnt[pnt_tag_name])[0][0]  # line to be extended
+                                    # find the distance to move the point towards the center
+                                    coord1 = gmsh.model.getValue(0, p, [])
+                                    coord2 = gmsh.model.getValue(0, ins_pnt_prev[pnt_tag_name_opposite], [])
+                                    # this is the
+                                    r1 = np.sqrt(coord1[0] ** 2 + coord1[1] ** 2)
+                                    r2 = np.sqrt(coord2[0] ** 2 + coord2[1] ** 2)
+                                    distance = (r1 - r2) / 2
+
+                                    p1, p2 = [b[1] for b in gmsh.model.getBoundary([(1, linetag)], oriented=True)]
+                                    dir_vector = gmsh.model.getValue(0, p1, [])-gmsh.model.getValue(0, p2, [])
+                                    unit_vector = dir_vector / np.linalg.norm(dir_vector)
+                                    coord = gmsh.model.getValue(0, p, [])
+                                    X = self.occ.addPoint(
+                                        coord[0] + unit_vector[0] * distance,
+                                        coord[1] + unit_vector[1] * distance,
+                                        0)
+                                    gmsh.model.occ.synchronize()
+
+                                    ins_group.lines[line_name + "_A"] = self.occ.addLine(ins_pnt[pnt_tag_name], X)
+                                    ins_group.lines[line_name + "_B"] = self.occ.addLine(X, ins_pnt_prev[pnt_tag_name_opposite])
+
+                                    ordered_lines[group_nr].append(
+                                        [line_name+"_A", count + count_rest -1 if case == 'beg' else count + count_rest, ins_group.lines[line_name+"_A"]])
+                                    ordered_lines[group_nr].append(
+                                        [line_name+"_B", count + count_rest if case == 'beg' else count + count_rest -1, ins_group.lines[line_name+"_B"]])
+
+                                    """ # original code
                                     line_name = 'mid_layer_' + mid_l_name + ('b' if i == 1 else '') + ('_l' if case == 'beg' else '_h')
                                     ins_group.lines[line_name] = self.occ.addLine(ins_pnt[pnt_tag_name], ins_pnt_prev[pnt_tag_name_opposite])
                                     ordered_lines[group_nr].append([line_name, count + count_rest, ins_group.lines[line_name]])
+                                    """
                                     break
                                 # Create all edges of the first block sticking out completely todo: might have to be extended to multiple blocks
                                 if current_blk != first_block and current_blk not in past_blocks:
@@ -1490,11 +1623,430 @@ class Geometry:
                 else:
                     ins_group.areas[area_name].loop = self.occ.addCurveLoop([ins_group.lines[line] for line in [x[0] for x in ordered_lines[group_nr]]])
 
+    def constructThinShells_poles(self):
+        ts_layer = self.md.geometries.thin_shells.pole_layers
+        ts_av_ins_thick = self.md.geometries.thin_shells.ins_thickness.poles
+
+        def _construct_thin_shell_corners_to_line(pnt1, pnt2, pole_line, name):
+            # use gmsh to calculate  distance to a line
+            coord_a = gmsh.model.getClosestPoint(1, pole_line, coord=(pnt1[0], pnt1[1], 0))[0]
+            coord_b = gmsh.model.getClosestPoint(1, pole_line, coord=(pnt2[0], pnt2[1], 0))[0]
+            # draw new point at half the distance between iH and coord_a
+            new_i = self.occ.addPoint((pnt1[0] + coord_a[0]) / 2, (pnt1[1] + coord_a[1]) / 2, 0)
+            new_o = self.occ.addPoint((pnt2[0] + coord_b[0]) / 2, (pnt2[1] + coord_b[1]) / 2, 0)
+
+            ts_layer[name] = dM.Region()
+
+            self.occ.synchronize()
+            ts_layer[name].lines['1'] = self.occ.addLine(new_i, new_o)
+            self.occ.synchronize()
+
+            cond_name = next(iter(self.data.conductors.keys()))
+            other_material = 0.5*(self.data.conductors[cond_name].cable.th_insulation_along_height+self.data.conductors[cond_name].cable.th_insulation_along_width)#todo, better select which one
+            # distance -> Average between coord_a and iH and coord_b and oH AND remove the G10 thickness
+            ts_av_ins_thick[name] = float(0.5 * (np.sqrt((pnt1[0] - coord_a[0]) ** 2 + (pnt1[1] - coord_a[1]) ** 2) +
+                                           np.sqrt((pnt2[0] - coord_b[0]) ** 2 + (pnt2[1] - coord_b[1]) ** 2))) - other_material
+            return
+
+        def _find_line_closest_to_points(pnt1, pnt2, line_list_tags):
+            """
+            Should work for any (pole) geometry. Given the half turn corner points pnt1 = [x1, y1], pnt2 = [x2, y2],
+            and a list of pole line tags, we need to select which one is on the opposite side to construct the thin shell line
+            thus, we search the closest line(s) to each corner point and then take the intersection of those two sets
+            """
+            closest_lines = {0: [], 1: []}
+            for i, pnt in enumerate([pnt1, pnt2]):
+                min_dist = float('inf')
+                for line_tag in line_list_tags:
+                    tag1, tag2 = gmsh.model.getAdjacencies(1, line_tag)[1]
+                    start_pnt = gmsh.model.getValue(0, tag1, [])
+                    end_pnt = gmsh.model.getValue(0, tag2, [])
+                    v = end_pnt - start_pnt
+                    w = pnt - start_pnt
+                    c1 = np.dot(w, v)
+                    c2 = np.dot(v, v)
+                    # avoid extending the line
+                    if c1 <= 0:
+                        dist = np.linalg.norm(pnt - start_pnt)  # Closest to p1
+                    elif c2 <= c1:
+                        dist = np.linalg.norm(pnt - end_pnt)  # Closest to p2
+                    else:
+                        b = c1 / c2
+                        Pb = start_pnt + b * v
+                        dist = np.linalg.norm(pnt - Pb)
+
+                    if np.isclose(min_dist, dist):
+                        closest_lines[i].append(line_tag)  # add to list
+                    elif dist < min_dist:
+                        min_dist = dist
+                        closest_lines[i] = [line_tag]  # overwrite
+
+            # return the intersection of closest lines
+            return list(set(closest_lines[0]).intersection(set(closest_lines[1])))[0]  # should be only one line
+
+        def _split_lines_azimuthal_radial(line_tag_list):
+            alines = []
+            rlines = []
+            for tag in line_tag_list:
+                pointTags = gmsh.model.getAdjacencies(1, tag)[1] # get tag
+                p1 = gmsh.model.getValue(0, pointTags[0], [])
+                p2 = gmsh.model.getValue(0, pointTags[1], [])
+
+                dr = np.sqrt(p2[0] ** 2 + p2[1] ** 2) - np.sqrt(p1[0] ** 2 + p1[1] ** 2)
+                dt = (np.arctan2(p2[1], p2[0]) - np.arctan2(p1[1], p1[0])) * np.sqrt(p2[0] ** 2 + p2[1] ** 2) ## convert to length
+                if np.abs(dt)>np.abs(dr):
+                    alines.append(tag)
+                else:
+                    rlines.append(tag)
+            return alines, rlines
+
+        def _wedge_to_pole_lines():
+            """
+            These lines do not exist, those that already exist contain the G10 insulation so we need more.
+            """
+            for _, region in self.md.geometries.thin_shells.mid_layers_aux.items(): #those are the g10 layers, we need to duplicate this line to account for the kapton
+                # obtain the position of the lines and draw more on top of it
+                for name, line_tag in  region.lines.items():
+                    name = f"p{name}_r"  # all radial lines
+                    ts_layer[name] = dM.Region()
+
+                    point_tag = gmsh.model.getBoundary([(1, line_tag)], oriented=False)
+                    p1, p2 = point_tag[0][1], point_tag[1][1]
+                    x1, y1, _ = gmsh.model.getValue(0, p1, [])
+                    x2, y2, _ = gmsh.model.getValue(0, p2, [])
+                    # create new line
+                    p1_new = gmsh.model.occ.addPoint(x1, y1, 0.0)
+                    p2_new = gmsh.model.occ.addPoint(x2, y2, 0.0)
+                    self.occ.synchronize()
+                    ts_layer[name].lines['1'] = self.occ.addLine(p1_new, p2_new)
+                    self.occ.synchronize()
+
+                    # thickness = distance between the wedge and the pole - G10 thickness
+                    # how to approximate this thickness? -> use the same thickness as for the ht 108
+                    """
+                    cond_name = next(iter(self.data.conductors.keys()))
+                    other_material = 0.5 * (
+                                self.data.conductors[cond_name].cable.th_insulation_along_height + self.data.conductors[
+                            cond_name].cable.th_insulation_along_width)
+                    # distance -> Average between coord_a and iH and coord_b and oH AND remove the G10 thickness ?
+                    ts_av_ins_thick[name] = ???
+                    """
+                    ts_av_ins_thick[name] = ts_av_ins_thick['p108_a'] #@emma hardcoded thickness, use the same as for this ht
+
+        max_layer = max(self.geom.coil.coils[1].poles[1].layers.keys())
+        # first, the lines connecting hts to the pole
+        for coil_nr, coil in self.md.geometries.coil.anticlockwise_order.coils.items(): # coilnr is only 1 here
+            for layer_nr, layer in coil.layers.items(): # we need to add radial TS lines for both layers
+                for nr, blk_order in enumerate(layer):
+                    block = self.geom.coil.coils[coil_nr].poles[blk_order.pole].layers[
+                        layer_nr].windings[blk_order.winding].blocks[blk_order.block]
+                    ht_list = list(self.md.geometries.coil.coils[coil_nr].poles[blk_order.pole].layers[
+                                       layer_nr].windings[blk_order.winding].blocks[
+                                       blk_order.block].half_turns.areas.keys())
+
+                    blk_index_next = nr + 1 if nr + 1 < len(layer) else 0
+                    block_order_next = layer[blk_index_next]
+                    block_next = self.geom.coil.coils[coil_nr].poles[block_order_next.pole].layers[
+                        layer_nr].windings[block_order_next.winding].blocks[block_order_next.block]
+                    ht_list_next = list(self.md.geometries.coil.coils[coil_nr].poles[block_order_next.pole].layers[
+                                            layer_nr].windings[block_order_next.winding].blocks[
+                                            block_order_next.block].half_turns.areas.keys())
+                    ht_last = int(ht_list[-1])
+                    ht_next_first = int(ht_list_next[0])
+                    # if winding nr is the same and pole is the same -> pole connection
+
+                    if blk_order.pole == block_order_next.pole and blk_order.winding == block_order_next.winding:
+                        # Create radial lines for pole connection
+                        pole_lines_a, pole_lines_r = _split_lines_azimuthal_radial(
+                            [v for qq in self.md.geometries.poles.quadrants.keys() for v in
+                             self.md.geometries.poles.quadrants[qq].lines.values()])
+                        # todo maybe this can be speed up if we select the correct quadrant
+                        if layer_nr != max_layer:
+                            # add azimuthal thin shells at the ht side 'o' (normals radial)
+                            # Now we consider all the HT's from one block, this might not hold true in general
+
+                            for ht in map(int, ht_list):
+                                oH = [block.half_turns[ht].corners.bare.oH.x,
+                                      block.half_turns[ht].corners.bare.oH.y, 0.0]
+                                oL = [block.half_turns[ht].corners.bare.oL.x,
+                                      block.half_turns[ht].corners.bare.oL.y, 0.0]
+                                _construct_thin_shell_corners_to_line(
+                                    oH, oL,
+                                    _find_line_closest_to_points(oH, oL,  pole_lines_a),
+                                    name=f"p{ht}_r")
+
+                            for ht in map(int, ht_list_next):
+                                oH = [block_next.half_turns[ht].corners.bare.oH.x,
+                                      block_next.half_turns[ht].corners.bare.oH.y, 0.0]
+                                oL = [block_next.half_turns[ht].corners.bare.oL.x,
+                                      block_next.half_turns[ht].corners.bare.oL.y, 0.0]
+                                _construct_thin_shell_corners_to_line(
+                                    oH, oL,
+                                    _find_line_closest_to_points(oH, oL, pole_lines_a),
+                                    name=f"p{ht}_r")
+
+                        iH = [block.half_turns[ht_last].corners.bare.iH.x,
+                              block.half_turns[ht_last].corners.bare.iH.y, 0.0]
+                        oH = [block.half_turns[ht_last].corners.bare.oH.x,
+                              block.half_turns[ht_last].corners.bare.oH.y, 0.0]
+                        _construct_thin_shell_corners_to_line(
+                            iH, oH,
+                            _find_line_closest_to_points(iH, oH, pole_lines_r),
+                            name=f"p{ht_last}_a")
+
+                        iL = [block_next.half_turns[ht_next_first].corners.bare.iL.x,
+                              block_next.half_turns[ht_next_first].corners.bare.iL.y, 0.0]
+                        oL = [block_next.half_turns[ht_next_first].corners.bare.oL.x,
+                              block_next.half_turns[ht_next_first].corners.bare.oL.y, 0.0]
+                        _construct_thin_shell_corners_to_line(
+                            iL, oL,
+                            _find_line_closest_to_points(iL, oL, pole_lines_r),
+                            name=f"p{ht_next_first}_a")
+        # second, the lines connecting wedge to the pole
+        _wedge_to_pole_lines()
+    def constructAdditionalThinShells(self):
+        def _create_lines_ht_alignment(ohx, ohy, olx, oly, ihx, ihy, ilx, ily):
+            def __line_circle_intersection(p1, p2):
+                x1, y1 = p1
+                x2, y2 = p2
+                dx = x2 - x1
+                dy = y2 - y1
+
+                A = dx**2 + dy**2
+                B = 2 * (dx*x1 + dy*y1)
+                C = x1**2 + y1**2 - R**2 # R collar is known from outer scope
+
+                disc = B**2 - 4*A*C
+                if disc < 0:
+                    logger.warning(" No intersection between line and circle.")
+                    return []  # no intersection
+                else:
+                    sqrt_disc = np.sqrt(disc)
+                    t1 = (-B + sqrt_disc) / (2*A)
+                    t2 = (-B - sqrt_disc) / (2*A)
+                    return [(x1 + t1*dx, y1 + t1*dy),
+                            (x1 + t2*dx, y1 + t2*dy)]
+
+            mid_bare_o = np.mean([[ohx, ohy], [olx, oly]], axis=0)
+            mid_bare_i = np.mean([[ihx, ihy], [ilx, ily]], axis=0)
+            offsets = np.array([[ohx, ohy], [olx, oly]]) - mid_bare_o
+            quad = 1 if mid_bare_o[0] >= 0 and mid_bare_o[1] >= 0 else (
+                2 if mid_bare_o[0] <= 0 <= mid_bare_o[1] else (3 if mid_bare_o[0] <= 0 and mid_bare_o[1] <= 0 else 4))
+            inters = __line_circle_intersection(mid_bare_o, mid_bare_i)
+            quadrants = {
+                1: lambda x, y: x >= 0 and y >= 0,
+                2: lambda x, y: x <= 0 <= y,
+                3: lambda x, y: x <= 0 and y <= 0,
+                4: lambda x, y: x >= 0 >= y,
+            }
+            check = quadrants[quad]
+            for x, y in inters:
+                if check(x, y):  # select the correct intersection based on the quadrant
+                    xi, yi = x, y
+                    break
+
+            # add a point halfway between (x,y) and (xi, yi)
+            dr = float(np.sqrt((xi - mid_bare_o[0]) ** 2 + (yi - mid_bare_o[1]) ** 2))
+            new_point_coords = [mid_bare_o[0] + 0.5 * (xi - mid_bare_o[0]), mid_bare_o[1] + 0.5 * (yi - mid_bare_o[1])]
+            for offset in offsets:
+                point_tag_final = self.occ.addPoint(new_point_coords[0] + offset[0], new_point_coords[1] + offset[1], 0)
+            self.occ.synchronize()
+            return dr, point_tag_final
+        def _embed_points_to_collar_curve():
+            def __add_point_in_curve(points, curve_tag):
+                return self.occ.fragment([(0, k) for k in points], [(1, curve_tag)], removeObject=True)[0]
+
+            ### First, cut the collar line
+            self.occ.synchronize()
+            new_tags = {1: [], 2: [], 3: [], 4: []} # tuples
+            new_point_tags = {1: [], 2: [], 3: [], 4: []} # only tags
+            collar_size = self.data.magnet.mesh.thermal.collar.SizeMin
+            for ts_name, ts in self.md.geometries.thin_shells.collar_layers.items():
+                for name, line in ts.lines.items():
+                    coords = gmsh.model.getValue(1, line, [i[0] for i in gmsh.model.getParametrizationBounds(1, line)])
+                    t1 = np.arctan2(coords[0], coords[1])
+                    t2 = np.arctan2(coords[3], coords[4])
+                    quad = t1 // (np.pi / 2) + 1 if t1 > 0 else 4 + t1 // (np.pi / 2) + 1
+                    curve_tag = self.md.geometries.collar.inner_boundary_tags[quad][0]
+                    start, end = min(t1 % (np.pi / 2), t2 % (np.pi / 2)), max(t1 % (np.pi / 2),
+                                                                              t2 % (np.pi / 2))  # ensure start < end
+                    tmp_coords = gmsh.model.getValue(1, line, [i[0] for i in gmsh.model.getParametrizationBounds(1, line)])
+                    target_size = collar_size
+                    elements = max(1, round(Func.points_distance(tmp_coords[:2], tmp_coords[3:-1]) / target_size))+1
+                    if elements%2 == 1: elements += 1
+                    para_coords = np.linspace(start, end, elements, endpoint=True)
+
+                    for u in para_coords:
+                        if quad == 1 or quad == 3:
+                            u = np.pi / 2 - u  ## magic
+                        x, y, z = gmsh.model.getValue(1, curve_tag, [u])  # Evaluate point on curve
+                        new_point_tags[quad].append(self.occ.addPoint(x, y, z))  # Add point coordinates to the list
+
+            for q in new_point_tags.keys():
+                new_tags[q].extend(__add_point_in_curve(new_point_tags[q], self.md.geometries.collar.inner_boundary_tags[q][0]))
+            # so for occ the old curve no longer exists, but in the objects the tag is still there
+
+            REMOVED_TAGS = [self.md.geometries.collar.inner_boundary_tags[q][0] for q in new_tags.keys()]
+
+            # update boundary tags
+            for quad, taglist in new_tags.items():
+                curvelist = [tag[1] for tag in taglist if tag[0]==1 ] # select the curves only
+                self.md.geometries.collar.inner_boundary_tags[quad] = curvelist  # replace
+                for k, new_tag in enumerate(self.md.geometries.collar.inner_boundary_tags[quad]):
+                    self.md.geometries.collar.quadrants[quad].lines[str(k)] = new_tag ## adding new lines
+
+                # REDEFINE THE CURVELOOP
+                loop_list = []
+                tmpdict = copy.deepcopy(self.md.geometries.collar.quadrants[quad].lines)
+                for tag_name, tag in tmpdict.items():
+                    if tag in self.md.geometries.collar.cooling_tags: # skip holes
+                        continue
+                    if tag in REMOVED_TAGS:
+                        # remove from dictionary
+                        del self.md.geometries.collar.quadrants[quad].lines[tag_name]
+                        continue
+                    loop_list.append(tag)
+                self.occ.synchronize()
+
+                for area in self.md.geometries.collar.quadrants[quad].areas:
+                    if area.startswith('arc') and not area.startswith('arch'): #collar region, not the holes
+                        self.md.geometries.collar.quadrants[quad].areas[area] = dM.Area(
+                            loop=self.occ.addCurveLoop(loop_list))
+
+            # Cut the pole lines
+            """
+            idea, loop over the thin shell lines, then draw line from the HT corner to the line ends, then intersect it with the pole curve 
+            just find intersection and select the shortest one ?        
+            
+            # not implemented, maybe not necessary
+            """
+            for quad in [1, 2, 3, 4]:
+                # additionally add the pole area back
+                for area in self.md.geometries.poles.quadrants[quad].areas:
+                    if area.startswith('arp'):
+                        self.md.geometries.poles.quadrants[quad].areas[area] = dM.Area(
+                            loop=self.occ.addCurveLoop(list(self.md.geometries.poles.quadrants[quad].lines.values())))
+
+            self.occ.synchronize()
+
+        # point still needs to be added
+        ts_layer = self.md.geometries.thin_shells.collar_layers
+        ts_av_ins_thick = self.md.geometries.thin_shells.ins_thickness.collar
+        collar_tag_dict = self.md.geometries.collar.inner_boundary_tags
+        enforce_TSA_mapping_collar = self.data.magnet.mesh.thermal.collar.Enforce_TSA_mapping  # if True, cut the collar curve into segments, otherwise use the whole curve
+
+        center = self.occ.addPoint(0, 0, 0)
+        collar_x, collar_y, _ = gmsh.model.getValue(1, collar_tag_dict[1][0], [0])
+        R = np.sqrt(collar_x ** 2 + collar_y ** 2)  # radius of collar curve
+
+        alignment = ['radial', 'ht'][1] # pick ht alignment
+
+        # COLLAR
+        for pid, pole in self.geom.coil.coils[1].poles.items():
+            layer_num = max(pole.layers.keys()) # outside layer
+            for wid, winding in pole.layers[layer_num].windings.items():
+                for block_idx in winding.blocks.keys():
+                    block = winding.blocks[block_idx]
+                    ht_nr_area = list(self.md.geometries.coil.coils[1].poles[pid].layers[layer_num].windings[wid].blocks[block_idx].half_turns.areas.keys())
+                    i = 0
+                    for ht_nr, ht in block.half_turns.items(): #ht_idx is not the same as number
+                        ht_old = ht_nr_area[i]
+                        i+=1
+                        dr = 0.
+                        if alignment == 'radial':
+                            for (x, y), (x1, y1) in zip([[ht.corners.bare.oH.x, ht.corners.bare.oH.y], [ht.corners.bare.oL.x, ht.corners.bare.oL.y]],
+                                                        [[ht.corners.bare.iH.x, ht.corners.bare.iH.y], [ht.corners.bare.iL.x, ht.corners.bare.iL.y]]): # uses the bare coordinates of the HT
+                                t = np.arctan2(y, x)
+                                quad = t // (np.pi / 2) + 1 if t > 0 else 4 + t // (np.pi / 2) + 1
+                                collar_idx = collar_tag_dict[quad][0]  # get the (debug: ONE) collar curve tag for the quadrant
+
+                                dr_prev = dr
+
+                                dummy = self.occ.addPoint(x, y, 0)
+                                dr = self.occ.get_distance(0, dummy,  1, collar_idx)[0]
+                                self.occ.synchronize()
+                                self.occ.remove([(0, dummy)])
+                                point_tag_final = self.occ.addPoint(x + 0.5 * dr * np.cos(t), y + 0.5 * dr * np.sin(t), 0)
+
+                        elif alignment == 'ht': # distance to the next half turn (more relevant for coil to coil distances)
+                            dr, point_tag_final = _create_lines_ht_alignment(ohx = ht.corners.bare.oH.x, ohy=ht.corners.bare.oH.y,
+                                                                                 olx = ht.corners.bare.oL.x, oly=ht.corners.bare.oL.y,
+                                                                                 ihx = ht.corners.bare.iH.x, ihy=ht.corners.bare.iH.y,
+                                                                                 ilx = ht.corners.bare.iL.x, ily=ht.corners.bare.iL.y)
+                        # save the line
+                        name = f'{ht_nr}_x'
+                        ts_layer[name] = dM.Region()
+                        self.occ.synchronize()
+                        ts_layer[name].lines['1'] = self.occ.addLine(point_tag_final-1, point_tag_final)
+                        cond_name = next(iter(self.data.conductors.keys()))
+                        if alignment == 'radial':
+                            ts_av_ins_thick[name] = 0.5*(dr+dr_prev) - self.data.conductors[cond_name].cable.th_insulation_along_width # approx thickness, average - insulation
+                        elif alignment == 'ht':
+                            ts_av_ins_thick[name] = dr - self.data.conductors[cond_name].cable.th_insulation_along_width
+        self.occ.synchronize()
+
+        # WEDGES
+        if self.data.magnet.geometry.thermal.with_wedges:
+            for wedge_idx, wedge in self.md.geometries.wedges.coils[1].layers[max(self.md.geometries.wedges.coils[1].layers.keys())].wedges.items():
+                    dr=0.
+                    if alignment == 'radial':
+                        raise NotImplementedError("Wedge radial alignment not implemented")
+
+                    elif alignment == 'ht':  # distance to the next half turn (more relevant for coil to coil distances)
+                        ohx, ohy, _ = gmsh.model.getValue(0, wedge.points['oh'], [])
+                        olx, oly, _ = gmsh.model.getValue(0, wedge.points['ol'], [])
+                        ihx, ihy, _ = gmsh.model.getValue(0, wedge.points['ih'], [])
+                        ilx, ily, _ = gmsh.model.getValue(0, wedge.points['il'], [])
+                        dr, point_tag_final = _create_lines_ht_alignment(ohx=ohx, ohy=ohy, olx=olx, oly=oly,
+                                                                             ihx=ihx, ihy=ihy, ilx=ilx, ily=ily)
+
+                    # find the smallest thickness
+                    dr_b = 0.0
+                    for x, y in [[ohx, ohy],
+                                 [olx, oly]]:
+                        dummy = self.occ.addPoint(x, y, 0)
+                        dr_a = dr_b
+                        t = np.arctan2(y, x)
+                        quad = t // (np.pi / 2) + 1 if t > 0 else 4 + t // (np.pi / 2) + 1
+                        collar_idx = collar_tag_dict[quad][0]
+                        dr_b = self.occ.get_distance(0, dummy, 1, collar_idx)[0]
+                        self.occ.remove([(0, dummy)])
+
+                    # save line
+                    name = f'w{wedge_idx}_x'
+                    ts_layer[name] = dM.Region()
+                    ts_layer[name].lines['1'] = self.occ.addLine(point_tag_final - 1, point_tag_final) # make index line trivial (no distinction)
+
+                    cond_name = next(iter(self.data.conductors.keys()))
+                    #### ts_av_ins_thick[name] = dr - self.data.conductors[cond_name].cable.th_insulation_along_width
+                    # This overshoots the thickness. The wedges are curved and the center between the corners (straight line) is further away from the collar than the curved wedge boundary.
+                    # Maybe one could use gmsh to obtain the distance between the outer curve and the collar, but this should be close to taking the minimum distance of the cornerpoints as both curves are
+                    # circle segments of (approximately) two concentric circles around the centre
+
+                    logger = logging.getLogger('FiQuS')
+                    logger.warning("Using alternative wedge insulation thickness approximation ")
+                    ts_av_ins_thick[name] = min(dr_a,dr_b)- self.data.conductors[cond_name].cable.th_insulation_along_width  # approx thickness, average - insulation
+
+        # POLES
+        if 'poles' in self.data.magnet.geometry.thermal.areas:
+            # generate additional thin shell lines
+            self.constructThinShells_poles()
+
+        #gmsh.fltk.run() constructed correctly
+
+        if enforce_TSA_mapping_collar:
+            self.occ.synchronize()
+            _embed_points_to_collar_curve() ## both coils and wedges
+
+        self.occ.remove([(0, center)]) # remove center point
+        self.occ.synchronize()
     def constructThinShells(self, with_wedges):
+        # default
         ins_th = self.md.geometries.thin_shells.ins_thickness
         mid_pole_ts = self.md.geometries.thin_shells.mid_poles
         mid_winding_ts = self.md.geometries.thin_shells.mid_windings
         mid_turn_ts = self.md.geometries.thin_shells.mid_turn_blocks
+        # not default
         mid_layer_ts = self.md.geometries.thin_shells.mid_layers_ht_to_ht
         mid_layer_ts_aux = self.md.geometries.thin_shells.mid_layers_aux
 
@@ -1520,6 +2072,7 @@ class Geometry:
                     oH = [block.half_turns[ht_last].corners.bare.oH.x, block.half_turns[ht_last].corners.bare.oH.y]
                     oL = [block_next.half_turns[ht_next_first].corners.bare.oL.x, block_next.half_turns[ht_next_first].corners.bare.oL.y]
                     ts_name = str(blk_order.block) + '_' + str(block_order_next.block)
+
                     for ts, th, condition in zip([mid_pole_ts, mid_winding_ts], [ins_th.mid_pole, ins_th.mid_winding],
                                                  # ['_ly' + str(layer_nr), '_wd' + str(blk_order.winding) + '_wd' + str(block_order_next.winding)],
                                                  [self.geom.coil.coils[coil_nr].type == 'cos-theta' and block_order_next.pole != blk_order.pole,
@@ -1596,7 +2149,18 @@ class Geometry:
                                 line_name = pnt_current[:-1] + '_' + ordered_pnts[iter_nr][0][:-1]
                     else:
                         line_name = pnt_current[:-1] + '_' + pnt_next[:-1]
-                    ts.mid_layers.lines[line_name] = self.occ.addLine(pnt[2], ordered_pnts[nr + 1][2])
+
+                    # TODO look into why this exception handling is needed for SMC magnet with ESC coils - the following meshing stage does not work
+                    try:
+                        tag = self.occ.addLine(pnt[2], ordered_pnts[nr + 1][2])
+                        ts.mid_layers.lines[line_name] = tag
+                    except Exception as e:
+                        ts.mid_layers.lines[line_name] = tag    # this will be the last tag, i.e. from previously created line
+                        x1, y1, z1 = gmsh.model.occ.getBoundingBox(1, pnt[2])[:3]
+                        x2, y2, z2 = gmsh.model.occ.getBoundingBox(1, ordered_pnts[nr + 1][2])[:3]
+                        distance = np.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2 + (z2 - z1) ** 2)
+                        logger.info(f"{e} {line_name} between point tags {pnt[2], ordered_pnts[nr + 1][2]} and distance between points {distance}")
+
             if ts_name in mid_layer_ts_aux:
                 aux_pnt = list(mid_layer_ts_aux[ts_name].points.keys())[0]
                 other_pnt = ordered_pnts[0 if aux_pnt[-1] == 'l' else -1]
@@ -1736,26 +2300,28 @@ class Geometry:
         """
         iron = self.geom.iron
         gm = self.md.geometries
-        with_iron_yoke = self.data.magnet.geometry.electromagnetics.with_iron_yoke if run_type == 'EM'\
-            else self.data.magnet.geometry.thermal.with_iron_yoke
-        with_wedges = self.data.magnet.geometry.electromagnetics.with_wedges if run_type == 'EM' \
-            else self.data.magnet.geometry.thermal.with_wedges
-
-        # Build iron yoke domains
-        if with_iron_yoke:
-            for quadrant, qq in gm.iron.quadrants.items():
+        geometry_setting = self.data.magnet.geometry.electromagnetics if run_type == 'EM' \
+            else self.data.magnet.geometry.thermal
+
+        with_wedges = geometry_setting.with_wedges
+
+        inv_nc = {v: k for k, v in self.nc.items()} #invert naming convention
+        for a in geometry_setting.areas: # a in ['iron_yoke', 'collar', ...]:
+            for quadrant, qq in getattr(gm, a).quadrants.items():
                 for area_name, area in qq.areas.items():
-                    build = True
-                    loops = [area.loop]
-                    for hole_key, hole in iron.hyper_holes.items():
-                        if area_name == hole.areas[1]:
-                            loops.append(qq.areas[hole.areas[0]].loop)
-                        elif area_name == hole.areas[0]:  # or iron.hyper_areas[area_name].material == 'BH_air':
-                            build = False
-                    if build:
-                        area.surface = self.occ.addPlaneSurface(loops)
-                        # Group areas per material type
-                        self.md.domains.groups_entities.iron[iron.hyper_areas[area_name].material].append(area.surface)
+                    identifier = next((k for k in self.inv_nc.keys() if (k in area_name[2:])), None)#re.sub(r'\d+', '',area_name[2:])
+                    if a == inv_nc.get(identifier, None): # ensure it is part of the iron yoke or collar (iron, collar)
+                        build = True
+                        loops = [area.loop]
+                        for hole_key, hole in iron.hyper_holes.items():
+                            if area_name == hole.areas[1]:
+                                loops.append(qq.areas[hole.areas[0]].loop)
+                            elif area_name == hole.areas[0]: #skip holes
+                                area.surface = self.occ.addPlaneSurface(loops) # also build the holes. An existing curveloop without area is very annoying
+                                build = False
+                        if build:
+                            area.surface = self.occ.addPlaneSurface(loops)
+                            getattr(self.md.domains.groups_entities, a)[iron.hyper_areas[area_name].material].append(area.surface) ## save the material
 
         # Build coil domains
         for coil_nr, coil in gm.coil.coils.items():
@@ -1774,7 +2340,7 @@ class Geometry:
                         wedge.areas[str(wedge_nr)].surface = self.occ.addPlaneSurface([wedge.areas[str(wedge_nr)].loop])
 
         # Build insulation domains
-        if run_type == 'TH' and not self.data.magnet.geometry.thermal.use_TSA:
+        if run_type == 'TH' and not geometry_setting.use_TSA:
             for coil_nr, coil in gm.insulation.coils.items():
                 for group_nr, group in coil.group.items():
                     holes = []
@@ -1794,10 +2360,10 @@ class Geometry:
 
         # Create and build air far field
         if run_type == 'EM':
-            if self.data.magnet.geometry.electromagnetics.with_iron_yoke:
+            if 'iron_yoke' in geometry_setting.areas:
                 for i in iron.key_points:
-                    gm.iron.max_radius = max(gm.iron.max_radius, max(iron.key_points[i].x, iron.key_points[i].y))
-                greatest_radius = gm.iron.max_radius
+                    gm.iron_yoke.max_radius = max(gm.iron_yoke.max_radius, max(iron.key_points[i].x, iron.key_points[i].y)) # this also contains other regions, e.g. collar but this has no effect
+                greatest_radius = gm.iron_yoke.max_radius
             else:  # no iron yoke data available
                 for coil_nr, coil in self.geom.coil.coils.items():
                     for pole_nr, pole in coil.poles.items():
@@ -1807,8 +2373,8 @@ class Geometry:
                                                  abs(pole.layers[len(pole.layers)].windings[first_winding].blocks[first_block].block_corners.oL.y),
                                                  gm.coil.max_radius)
                 greatest_radius = gm.coil.max_radius
-            radius_in = greatest_radius * (2.5 if self.data.magnet.geometry.electromagnetics.with_iron_yoke else 6)
-            radius_out = greatest_radius * (3.2 if self.data.magnet.geometry.electromagnetics.with_iron_yoke else 8)
+            radius_in = greatest_radius * (2.5 if 'iron_yoke' in geometry_setting.areas else 6)
+            radius_out = greatest_radius * (3.2 if 'iron_yoke' in geometry_setting.areas else 8)
             air_inf_center_x, air_inf_center_y = 0, 0
             for coil_nr, coil in self.md.geometries.coil.coils.items():
                 air_inf_center_x += coil.bore_center.x
@@ -1859,8 +2425,8 @@ class Geometry:
             # self.md.domains.groups_entities.air_inf = [gm.air_inf.areas['outer'].surface]
             gm.air_inf.areas['inner'].surface = self.occ.addPlaneSurface([gm.air_inf.areas['inner'].loop])
 
-        # self.occ.synchronize()
-        # self.gu.launch_interactive_GUI()
+        self.occ.synchronize()
+        #self.gu.launch_interactive_GUI()
 
     def fragment(self):
         """
@@ -1869,9 +2435,14 @@ class Geometry:
         # Collect surfaces to be subtracted by background air
         holes = []
 
-        # Iron
-        for group_name, surfaces in self.md.domains.groups_entities.iron.items():
-            holes.extend([(2, s) for s in surfaces])
+        # iron yoke and collar
+        group_keys = self.nc.keys()
+
+        for key in group_keys:
+            group = getattr(self.md.domains.groups_entities, key)
+            for _, surfaces in group.items():
+                holes.extend([(2, s) for s in surfaces])
+
         # Coils
         for coil_nr, coil in self.md.geometries.coil.coils.items():
             for pole_nr, pole in coil.poles.items():
@@ -1904,7 +2475,6 @@ class Geometry:
                 self.md.domains.groups_entities.air.append(e[1])
 
     def updateTags(self, run_type, symmetry):
-
         # Update half turn line tags
         for coil_nr, coil in self.md.geometries.coil.coils.items():
             for pole_nr, pole in coil.poles.items():
@@ -1921,7 +2491,108 @@ class Geometry:
                                 hts.lines[ht_nr + 'o'] = first_tag + 2
                                 hts.lines[ht_nr + 'h'] = first_tag + 3
 
-        # Update insulation line tags
+        # Update collar tags
+        if run_type == "TH" and 'collar' in self.data.magnet.geometry.thermal.areas:
+            for quad, old_tags in self.md.geometries.collar.quadrants.items():
+                self.md.geometries.collar.inner_boundary_tags[quad] = [] # reset the inner boundary tags
+                new_tags = []
+                for name, area in  self.md.geometries.collar.quadrants[quad].areas.items(): # arcol contains the boundaries of the holes too
+                    if not re.match(r"^ar.h", name):
+                        # the issue is that you don't know which line is which, e.g. which is the inner collar line
+                        new_tags.extend([int(k) for k in gmsh.model.getAdjacencies(2, area.surface)[1]])
+
+                for k, name in enumerate(self.md.geometries.collar.quadrants[quad].lines.keys()):
+                    self.md.geometries.collar.quadrants[quad].lines[name] = new_tags[k]
+
+                # Update inner collar tags
+                collar_lines = [self.md.geometries.collar.quadrants[quad].lines[name] for name in self.md.geometries.collar.quadrants[quad].lines.keys()]
+                closest_dist = 1000.
+                closest_lines = []
+                max_dist = 0.0
+                max_lines = []
+                # We assume that the middle of the curve of the collar is the closest one to the centre (0,0)
+                for tag in collar_lines:
+                    ##x, y, _ = gmsh.model.getValue(1, tag, [0.0])  # pick one point on the line
+                    curve_type = gmsh.model.getType(1, tag)
+                    if curve_type == 'Line': # find the middle of the line
+                        tag1, tag2 = gmsh.model.getAdjacencies(1, tag)[1]
+                        x1, y1, z1 = gmsh.model.getValue(0, tag1, [])
+                        x2, y2, z2 = gmsh.model.getValue(0, tag2, [])
+                        x = 0.5 * (x1 + x2)
+                        y = 0.5 * (y1 + y2)
+                        # take the average of the end points
+                        dist = np.sqrt(x ** 2 + y ** 2)
+                    elif curve_type == "Circle": # use any point on the circle (same distance because concentric with origin)
+                        x, y, z = gmsh.model.getValue(1, tag, [0.5])
+                        dist = np.sqrt(x ** 2 + y ** 2)
+
+                    if dist < closest_dist+1e-10:
+                        if dist < closest_dist-1e-10: # clear if new min is found
+                            closest_dist = dist
+                            closest_lines = []
+                        closest_lines.append(tag)
+                    if dist > max_dist-1e-10:
+                        if dist > max_dist+1e-10: # clear if new max is found
+                            max_dist = dist
+                            max_lines = []
+                        max_lines.append(tag)
+                self.md.geometries.collar.inner_boundary_tags[quad] = closest_lines
+                self.md.geometries.collar.outer_boundary_tags[quad] = max_lines
+
+                # outer collar tags, does not work because geom.iron has the old tags and this is not accurate anymore
+                """
+                outer = [old_tags.lines[name] for name in old_tags.lines.keys() if
+                        self.geom.iron.hyper_lines[name].type == 'line']
+                logger.info("outer tags", outer)
+                self.md.geometries.collar.outer_boundary_tags[quad] = outer
+                """
+
+        # concerning the TSL, it seems impossible to get the tags of the lines, as they are not adjacent to a surface nor (yet) grouped in a physical group
+        # only way to ensure equal tags is by creating them in the same way as gmsh orders the lines. (e.g. all at the start or all at the end would work)
+        # we cannot swap order... soo lets hope that just a shift in numbers is sufficient
+        if run_type == 'TH' and self.data.magnet.geometry.thermal.use_TSA_new and self.data.magnet.mesh.thermal.collar.Enforce_TSA_mapping:
+            shift = len(self.md.geometries.collar.inner_boundary_tags[1])*4 -4
+
+            if 'poles' in self.data.magnet.geometry.thermal.areas:
+                shift -= (1*4) # we shifted too much
+
+            ## update TSA collar lines
+            for _, ts in self.md.geometries.thin_shells.collar_layers.items():
+                ts.lines['1'] += shift
+            for _, ts in self.md.geometries.thin_shells.pole_layers.items():
+                ts.lines['1'] += shift
+
+            atts = ['mid_layers_ht_to_ht', 'mid_layers_wdg_to_ht', 'mid_layers_ht_to_wdg', 'mid_layers_wdg_to_wdg', 'mid_poles', 'mid_windings', 'mid_turn_blocks' , 'mid_wedge_turn']
+            for at in atts:
+                for _, ts_region in getattr(self.md.geometries.thin_shells, at).items():
+                    try: ts_region = ts_region.mid_layers
+                    except AttributeError: pass
+                    for key in ts_region.lines.keys():
+                        ts_region.lines[key] += shift
+
+        # Update coil cooling tags
+        ### no consistent way to get the tags of the cooling lines, so we assume that they are ordered in the same way as gmsh orders the lines
+        if self.data.magnet.solve.thermal.collar_cooling.enabled:
+            tags =[]
+            ## if we want all cooling holes
+            if self.data.magnet.solve.thermal.collar_cooling.which == 'all':
+                for quad, region in self.md.geometries.collar.quadrants.items():
+                    for name, area in region.areas.items():
+                        if re.match(r"^ar.h", name):
+                            tags.extend([int(k) for k in gmsh.model.getAdjacencies(2, area.surface)[1]])
+            else:
+                nr_applied_cooling = self.data.magnet.solve.thermal.collar_cooling.which
+                nr = 1
+                for _, quad_data in self.md.geometries.collar.quadrants.items():
+                    for name, area in quad_data.areas.items():
+                        if re.match(r"^ar.h", name):
+                            if nr in nr_applied_cooling:
+                                tags.extend([int(k) for k in gmsh.model.getAdjacencies(2, area.surface)[1]])
+                            nr += 1
+            self.md.geometries.collar.cooling_tags = tags
+
+
+                # Update insulation line tags
         if run_type == 'TH' and not self.data.magnet.geometry.thermal.use_TSA:
             pass  # todo
 
@@ -1984,5 +2655,31 @@ class Geometry:
                 corner_max = [tol, y_coord + tol, tol]
                 self.md.domains.groups_entities.symmetric_boundaries.y = _get_bnd_lines()
 
-        # self.occ.synchronize()
-        # self.gu.launch_interactive_GUI()
+    def move_keypoints(self, keypoints, displacement, keypoint_names=None):
+        if keypoint_names is None:
+            keypoint_names = []
+            for name, hole in self.geom.iron.hyper_areas.items():
+                if not 'ch' in name: # ch -> collar hole
+                    continue
+                line_names = hole.lines
+                keypoint_names.append(list(set([getattr(self.geom.iron.hyper_lines[line], kp_name)
+                                      for line in line_names for kp_name in ['kp1', 'kp2', 'kp3']])))
+        if type(displacement) == list:
+            list_displacement = displacement
+        elif str(displacement) == "0":
+            list_displacement = [[0.0, 0.0], [0.0, 0.0]]
+        elif str(displacement) == "1":
+            list_displacement = [[0.004, -0.015], [0.03, -0.025]]
+        elif str(displacement) == "2":
+            list_displacement = [[0.004, -0.015], [0.0, 0.0]]
+        elif str(displacement) == "3":
+            list_displacement = [[-0.035, 0.045], [-0.004, -0.0015]]
+        else:
+            raise ValueError("displacement_type not recognized")
+        for i, hole in enumerate(keypoint_names):
+            for name in hole:
+                if name is None:
+                    continue
+                keypoints[name].x += list_displacement[i][0]
+                keypoints[name].y += list_displacement[i][1]
+        return keypoints