fiqus 2024.6.0__py3-none-any.whl → 2024.12.0__py3-none-any.whl

fiqus/mesh_generators/MeshPancake3D.py

@@ -107,7 +107,7 @@ class regions:
         # Initialize the regions model:
         self.rm = RegionsModelFiQuS.RegionsModel()
 
-        # This is used because self.rm.powered is not initialized in
+        # This is used because self.rm.powered["Pancake3D"] is not initialized in
         # RegionsModelFiQuS.RegionsModel. It should be fixed in the future.
         self.rm.powered["Pancake3D"] = RegionsModelFiQuS.Powered()
 
@@ -254,12 +254,12 @@ class curve:
             boundingbox = list(map(operator.add, boundingbox1, boundingbox2))
             self.points.append(list(map(operator.truediv, boundingbox, (2, 2, 2))))
 
-        # Round the point positions to the nearest multiple of self.geo.dimTol to avoid
+        # Round the point positions to the nearest multiple of self.geo.dimensionTolerance to avoid
         # numerical errors:
         for i in range(len(self.points)):
             for coord in range(3):
                 self.points[i][coord] = (
-                    round(self.points[i][coord] / self.geo.dimTol) * self.geo.dimTol
+                    round(self.points[i][coord] / self.geo.dimensionTolerance) * self.geo.dimensionTolerance
                 )
 
         if self.isCircle():
@@ -297,11 +297,11 @@ class curve:
             # Calculate starting turn number (n1, float) and ending turn number (n2,
             # float): (note that they are float modulos of 1, and not the exact turn
             # numbers)
-            self.n1 = (theta1 - self.geo.wi.theta_i) / 2 / math.pi
-            self.n1 = round(self.n1 / self.geo.wi.turnTol) * self.geo.wi.turnTol
+            self.n1 = (theta1 - self.geo.winding.theta_i) / 2 / math.pi
+            self.n1 = round(self.n1 / self.geo.winding.turnTol) * self.geo.winding.turnTol
 
-            self.n2 = (theta2 - self.geo.wi.theta_i) / 2 / math.pi
-            self.n2 = round(self.n2 / self.geo.wi.turnTol) * self.geo.wi.turnTol
+            self.n2 = (theta2 - self.geo.winding.theta_i) / 2 / math.pi
+            self.n2 = round(self.n2 / self.geo.winding.turnTol) * self.geo.winding.turnTol
 
     def isAxial(self):
         """
@@ -312,7 +312,7 @@ class curve:
         :rtype: bool
         """
         return not math.isclose(
-            self.points[0][2], self.points[1][2], abs_tol=self.geo.dimTol
+            self.points[0][2], self.points[1][2], abs_tol=self.geo.dimensionTolerance
         )
 
     def isHorizontal(self):
@@ -329,8 +329,8 @@ class curve:
         xcm = (self.points[0][0] + self.points[1][0]) / 2
         ycm = (self.points[0][1] + self.points[1][1]) / 2
 
-        return math.isclose(cm[0], xcm, abs_tol=self.geo.dimTol) and math.isclose(
-            cm[1], ycm, abs_tol=self.geo.dimTol
+        return math.isclose(cm[0], xcm, abs_tol=self.geo.dimensionTolerance) and math.isclose(
+            cm[1], ycm, abs_tol=self.geo.dimensionTolerance
         )
 
     def isCircle(self):
@@ -461,7 +461,7 @@ class Mesh(Base):
 
         # Start GMSH:
         self.gu = GmshUtils(self.mesh_folder)
-        self.gu.initialize()
+        self.gu.initialize(verbosity_Gmsh=fdm.run.verbosity_Gmsh)
 
         self.contactLayerAndWindingRadialLines = []  # Store for strucured terminals
 
@@ -480,12 +480,12 @@ class Mesh(Base):
         # =============================================================================
         allWindingAndCLSurfaceTags = []
         allWindingAndCLLineTags = []
-        for i in range(self.geo.N):
+        for i in range(self.geo.numberOfPancakes):
             # Get the volume tags:
-            windingVolumeDimTags = self.dimTags[self.geo.wi.name + str(i + 1)]
+            windingVolumeDimTags = self.dimTags[self.geo.winding.name + str(i + 1)]
             windingVolumeTags = [dimTag[1] for dimTag in windingVolumeDimTags]
 
-            contactLayerVolumeDimTags = self.dimTags[self.geo.ii.name + str(i + 1)]
+            contactLayerVolumeDimTags = self.dimTags[self.geo.contactLayer.name + str(i + 1)]
             contactLayerVolumeTags = [dimTag[1] for dimTag in contactLayerVolumeDimTags]
 
             # Get the surface and line tags:
@@ -523,7 +523,7 @@ class Mesh(Base):
             if lineTag not in allWindingAndCLLineTags:
                 gmsh.model.mesh.setTransfiniteCurve(lineTag, 1)
 
-        recombine = self.mesh.wi.elementType[0] in ["hexahedron", "prism"]
+        recombine = self.mesh.winding.elementType[0] in ["hexahedron", "prism"]
         for surfaceTag in notchSurfaceTags:
             if surfaceTag not in allWindingAndCLSurfaceTags:
                 gmsh.model.mesh.setTransfiniteSurface(surfaceTag)
@@ -548,32 +548,32 @@ class Mesh(Base):
         # Winding and contact layer extrusions of the air:
         # Get the volume tags:
         airTopWindingExtrusionVolumeDimTags = self.dimTags[
-            self.geo.ai.name + "-TopPancakeWindingExtursion"
+            self.geo.air.name + "-TopPancakeWindingExtursion"
         ]
 
         airTopContactLayerExtrusionVolumeDimTags = self.dimTags[
-            self.geo.ai.name + "-TopPancakeContactLayerExtursion"
+            self.geo.air.name + "-TopPancakeContactLayerExtursion"
         ]
 
         airTopTerminalsExtrusionVolumeDimTags = self.dimTags[
-            self.geo.ai.name + "-TopTerminalsExtrusion"
+            self.geo.air.name + "-TopTerminalsExtrusion"
         ]
 
         airBottomWindingExtrusionVolumeDimTags = self.dimTags[
-            self.geo.ai.name + "-BottomPancakeWindingExtursion"
+            self.geo.air.name + "-BottomPancakeWindingExtursion"
         ]
 
         airBottomContactLayerExtrusionVolumeDimTags = self.dimTags[
-            self.geo.ai.name + "-BottomPancakeContactLayerExtursion"
+            self.geo.air.name + "-BottomPancakeContactLayerExtursion"
         ]
 
         airBottomTerminalsExtrusionVolumeDimTags = self.dimTags[
-            self.geo.ai.name + "-BottomTerminalsExtrusion"
+            self.geo.air.name + "-BottomTerminalsExtrusion"
         ]
 
         removedAirVolumeDimTags = []
         newAirVolumeDimTags = []
-        if self.mesh.ai.structured:
+        if self.mesh.air.structured:
             # Then it means air type is cuboid!
             airTopWindingExtrusionVolumeTags = [
                 dimTag[1] for dimTag in airTopWindingExtrusionVolumeDimTags
@@ -589,9 +589,9 @@ class Mesh(Base):
             ]
 
             # Calcualte axial number of elements for air:
-            axialElementsPerLengthForWinding = min(self.mesh.wi.axne) / self.geo.wi.h
+            axialElementsPerLengthForWinding = min(self.mesh.winding.axialNumberOfElements) / self.geo.winding.height
             axneForAir = round(
-                axialElementsPerLengthForWinding * self.geo.ai.margin + 1e-6
+                axialElementsPerLengthForWinding * self.geo.air.axialMargin + 1e-6
             )
 
             # Get the surface and line tags:
@@ -615,7 +615,7 @@ class Mesh(Base):
                 airTopContactLayerExtrusionVolumeTags,
                 airTopContactLayerExtrusionSurfaceTags,
                 airTopContactLayerExtrusionLineTags,
-                meshSettingIndex=self.geo.N - 1,  # The last pancake coil
+                meshSettingIndex=self.geo.numberOfPancakes - 1,  # The last pancake coil
                 axialNumberOfElements=axneForAir,
                 bumpCoefficient=1,
             )
@@ -647,18 +647,18 @@ class Mesh(Base):
             )
 
             # Structure tubes of the air:
-            airOuterTubeVolumeDimTags = self.dimTags[self.geo.ai.name + "-OuterTube"]
+            airOuterTubeVolumeDimTags = self.dimTags[self.geo.air.name + "-OuterTube"]
             airOuterTubeVolumeTags = [dimTag[1] for dimTag in airOuterTubeVolumeDimTags]
 
             airTopTubeTerminalsVolumeDimTags = self.dimTags[
-                self.geo.ai.name + "-TopTubeTerminalsExtrusion"
+                self.geo.air.name + "-TopTubeTerminalsExtrusion"
             ]
             airTopTubeTerminalsVolumeTags = [
                 dimTag[1] for dimTag in airTopTubeTerminalsVolumeDimTags
             ]
 
             airBottomTubeTerminalsVolumeDimTags = self.dimTags[
-                self.geo.ai.name + "-BottomTubeTerminalsExtrusion"
+                self.geo.air.name + "-BottomTubeTerminalsExtrusion"
             ]
             airBottomTubeTerminalsVolumeTags = [
                 dimTag[1] for dimTag in airBottomTubeTerminalsVolumeDimTags
@@ -666,7 +666,7 @@ class Mesh(Base):
 
             # Structure inner cylinder of the air:
             airInnerCylinderVolumeDimTags = self.dimTags[
-                self.geo.ai.name + "-InnerCylinder"
+                self.geo.air.name + "-InnerCylinder"
             ]
             airInnerCylinderVolumeTags = [
                 dimTag[1] for dimTag in airInnerCylinderVolumeDimTags
@@ -674,19 +674,19 @@ class Mesh(Base):
 
             airTubesAndCylinders = airOuterTubeVolumeTags + airInnerCylinderVolumeTags
 
-            if self.geo.ai.shellTransformation:
-                shellVolumes = self.dimTags[self.geo.ai.shellVolumeName]
+            if self.geo.air.shellTransformation:
+                shellVolumes = self.dimTags[self.geo.air.shellVolumeName]
                 shellVolumeTags = [dimTag[1] for dimTag in shellVolumes]
                 airTubesAndCylinders.extend(shellVolumeTags)
 
-            airRadialElementMultiplier = 1 / self.mesh.ai.radialElementSize
+            airRadialElementMultiplier = 1 / self.mesh.air.radialElementSize
             self.structure_tubes_and_cylinders(
                 airTubesAndCylinders,
                 radialElementMultiplier=airRadialElementMultiplier,
             )
 
-            if self.mesh.ti.structured:
-                terminalsRadialElementMultiplier = 1 / self.mesh.ti.radialElementSize
+            if self.mesh.terminals.structured:
+                terminalsRadialElementMultiplier = 1 / self.mesh.terminals.radialElementSize
 
                 self.structure_tubes_and_cylinders(
                     airTopTubeTerminalsVolumeTags + airBottomTubeTerminalsVolumeTags,
@@ -747,9 +747,9 @@ class Mesh(Base):
 
             # Fuse inner cylinder and outer tube part of air:
             airInnerCylinderVolumeDimTags = self.dimTags[
-                self.geo.ai.name + "-InnerCylinder"
+                self.geo.air.name + "-InnerCylinder"
             ]
-            if self.geo.N > 1:
+            if self.geo.numberOfPancakes > 1:
                 # Fuse the first two and the last two volumes separately (due to cuts):
                 firstTwoVolumes = airInnerCylinderVolumeDimTags[0:2]
                 lastTwoVolumes = airInnerCylinderVolumeDimTags[-2:]
@@ -771,20 +771,20 @@ class Mesh(Base):
                 removedAirVolumeDimTags.extend(
                     airInnerCylinderVolumeDimTags + firstTwoVolumes + lastTwoVolumes
                 )
-                self.dimTags[self.geo.ai.name + "-InnerCylinder"] = [
+                self.dimTags[self.geo.air.name + "-InnerCylinder"] = [
                     airInnerCylinderVolumeDimTag,
                     airInnerCylinderVolumeDimTagFirst,
                     airInnerCylinderVolumeDimTagLast,
                 ]
             else:
                 pass
-                # self.dimTags[self.geo.ai.name + "-InnerCylinder"] = [
-                #     self.dimTags[self.geo.ai.name + "-InnerCylinder"][1],
-                #     self.dimTags[self.geo.ai.name + "-InnerCylinder"][0],
-                #     self.dimTags[self.geo.ai.name + "-InnerCylinder"][2],
+                # self.dimTags[self.geo.air.name + "-InnerCylinder"] = [
+                #     self.dimTags[self.geo.air.name + "-InnerCylinder"][1],
+                #     self.dimTags[self.geo.air.name + "-InnerCylinder"][0],
+                #     self.dimTags[self.geo.air.name + "-InnerCylinder"][2],
                 # ]
 
-            airOuterTubeVolumeDimTags = self.dimTags[self.geo.ai.name + "-OuterTube"]
+            airOuterTubeVolumeDimTags = self.dimTags[self.geo.air.name + "-OuterTube"]
             airOuterTubeVolumeDimTag = Mesh.fuse_volumes(
                 airOuterTubeVolumeDimTags,
                 fuseSurfaces=True,
@@ -792,13 +792,13 @@ class Mesh(Base):
             )
             newAirOuterTubeVolumeDimTag = airOuterTubeVolumeDimTag
             removedAirVolumeDimTags.extend(airOuterTubeVolumeDimTags)
-            self.dimTags[self.geo.ai.name + "-OuterTube"] = [newAirOuterTubeVolumeDimTag]
+            self.dimTags[self.geo.air.name + "-OuterTube"] = [newAirOuterTubeVolumeDimTag]
 
-            if self.geo.ai.shellTransformation:
+            if self.geo.air.shellTransformation:
                 # Fuse air shell volumes:
-                if self.geo.ai.type == "cylinder":
+                if self.geo.air.type == "cylinder":
                     removedShellVolumeDimTags = []
-                    shellVolumeDimTags = self.dimTags[self.geo.ai.shellVolumeName]
+                    shellVolumeDimTags = self.dimTags[self.geo.air.shellVolumeName]
                     shellVolumeDimTag = Mesh.fuse_volumes(
                         shellVolumeDimTags,
                         fuseSurfaces=True,
@@ -807,41 +807,41 @@ class Mesh(Base):
                     removedShellVolumeDimTags.extend(shellVolumeDimTags)
                     newShellVolumeDimTags = [shellVolumeDimTag]
                     for removedDimTag in removedShellVolumeDimTags:
-                        self.dimTags[self.geo.ai.shellVolumeName].remove(removedDimTag)
-                elif self.geo.ai.type == "cuboid":
+                        self.dimTags[self.geo.air.shellVolumeName].remove(removedDimTag)
+                elif self.geo.air.type == "cuboid":
                     # Unfortunately, surfaces cannot be combined for the cuboid type of air.
                     # However, it doesn't affect the mesh quality that much.
                     newShellVolumeDimTags = []
 
                     shellPart1VolumeDimTag = Mesh.fuse_volumes(
-                        self.dimTags[self.geo.ai.shellVolumeName + "-Part1"],
+                        self.dimTags[self.geo.air.shellVolumeName + "-Part1"],
                         fuseSurfaces=False,
                     )
-                    self.dimTags[self.geo.ai.shellVolumeName + "-Part1"] = [
+                    self.dimTags[self.geo.air.shellVolumeName + "-Part1"] = [
                         shellPart1VolumeDimTag
                     ]
 
                     shellPart2VolumeDimTag = Mesh.fuse_volumes(
-                        self.dimTags[self.geo.ai.shellVolumeName + "-Part2"],
+                        self.dimTags[self.geo.air.shellVolumeName + "-Part2"],
                         fuseSurfaces=False,
                     )
-                    self.dimTags[self.geo.ai.shellVolumeName + "-Part2"] = [
+                    self.dimTags[self.geo.air.shellVolumeName + "-Part2"] = [
                         shellPart2VolumeDimTag
                     ]
 
                     shellPart3VolumeDimTag = Mesh.fuse_volumes(
-                        self.dimTags[self.geo.ai.shellVolumeName + "-Part3"],
+                        self.dimTags[self.geo.air.shellVolumeName + "-Part3"],
                         fuseSurfaces=False,
                     )
-                    self.dimTags[self.geo.ai.shellVolumeName + "-Part3"] = [
+                    self.dimTags[self.geo.air.shellVolumeName + "-Part3"] = [
                         shellPart3VolumeDimTag
                     ]
 
                     shellPart4VolumeDimTag = Mesh.fuse_volumes(
-                        self.dimTags[self.geo.ai.shellVolumeName + "-Part4"],
+                        self.dimTags[self.geo.air.shellVolumeName + "-Part4"],
                         fuseSurfaces=False,
                     )
-                    self.dimTags[self.geo.ai.shellVolumeName + "-Part4"] = [
+                    self.dimTags[self.geo.air.shellVolumeName + "-Part4"] = [
                         shellPart4VolumeDimTag
                     ]
 
@@ -849,7 +849,7 @@ class Mesh(Base):
                 # surface and that surface should be combined as well for high quality mesh.
                 # However, it can be only done for cylinder type of air for now.
                 # Get the combined boundary surfaces:
-                if self.geo.ai.type == "cylinder":
+                if self.geo.air.type == "cylinder":
                     (
                         newAirOuterTubeVolumeDimTag,
                         newShellVolumeDimTag,
@@ -859,18 +859,19 @@ class Mesh(Base):
                         fuseOtherSurfaces=False,
                         surfacesArePlane=False,
                     )
-                    self.dimTags[self.geo.ai.name + "-OuterTube"] = [newAirOuterTubeVolumeDimTag]
+                    self.dimTags[self.geo.air.name + "-OuterTube"] = [newAirOuterTubeVolumeDimTag]
+
                     airOuterTubeVolumeDimTag = newAirOuterTubeVolumeDimTag
-                    self.dimTags[self.geo.ai.shellVolumeName].append(
+                    self.dimTags[self.geo.air.shellVolumeName].append(
                         newShellVolumeDimTag
                     )
 
             newAirVolumeDimTags.append(newAirOuterTubeVolumeDimTag)
 
             # Update volume tags dictionary of air:
-            self.dimTags[self.geo.ai.name] = list(
+            self.dimTags[self.geo.air.name] = list(
                 (
-                    set(self.dimTags[self.geo.ai.name]) - set(removedAirVolumeDimTags)
+                    set(self.dimTags[self.geo.air.name]) - set(removedAirVolumeDimTags)
                 ).union(set(newAirVolumeDimTags))
             )
 
@@ -881,18 +882,18 @@ class Mesh(Base):
         # ==============================================================================
         # MESHING TERMINALS STARTS =====================================================
         # ==============================================================================
-        if self.mesh.ti.structured:
+        if self.mesh.terminals.structured:
             # Structure tubes of the terminals:
-            terminalOuterTubeVolumeDimTags = self.dimTags[self.geo.ti.o.name + "-Tube"]
+            terminalOuterTubeVolumeDimTags = self.dimTags[self.geo.terminals.outer.name + "-Tube"]
             terminalOuterTubeVolumeTags = [
                 dimTag[1] for dimTag in terminalOuterTubeVolumeDimTags
             ]
-            terminalInnerTubeVolumeDimTags = self.dimTags[self.geo.ti.i.name + "-Tube"]
+            terminalInnerTubeVolumeDimTags = self.dimTags[self.geo.terminals.inner.name + "-Tube"]
             terminalInnerTubeVolumeTags = [
                 dimTag[1] for dimTag in terminalInnerTubeVolumeDimTags
             ]
 
-            terminalsRadialElementMultiplier = 1 / self.mesh.ti.radialElementSize
+            terminalsRadialElementMultiplier = 1 / self.mesh.terminals.radialElementSize
             self.structure_tubes_and_cylinders(
                 terminalOuterTubeVolumeTags + terminalInnerTubeVolumeTags,
                 radialElementMultiplier=terminalsRadialElementMultiplier,
@@ -900,13 +901,13 @@ class Mesh(Base):
 
             # Structure nontube parts of the terminals:
             terminalOuterNonTubeVolumeDimTags = self.dimTags[
-                self.geo.ti.o.name + "-Touching"
+                self.geo.terminals.outer.name + "-Touching"
             ]
             terminalOuterNonTubeVolumeTags = [
                 dimTag[1] for dimTag in terminalOuterNonTubeVolumeDimTags
             ]
             terminalInnerNonTubeVolumeDimTags = self.dimTags[
-                self.geo.ti.i.name + "-Touching"
+                self.geo.terminals.inner.name + "-Touching"
             ]
             terminalInnerNonTubeVolumeTags = [
                 dimTag[1] for dimTag in terminalInnerNonTubeVolumeDimTags
@@ -928,7 +929,7 @@ class Mesh(Base):
         # Mesh fields for the air:
         # Meshes will grow as they get further from the field surfaces:
         fieldSurfacesDimTags = gmsh.model.getBoundary(
-            self.dimTags[self.geo.wi.name], oriented=False, combined=True
+            self.dimTags[self.geo.winding.name], oriented=False, combined=True
         )
         fieldSurfacesTags = [dimTag[1] for dimTag in fieldSurfacesDimTags]
 
@@ -1032,19 +1033,19 @@ class Mesh(Base):
         # Create cuts:
         # This is required to make the air a simply connected domain. This is required
         # for the solution part. You can read more about Homology in GMSH documentation.
-        airTags = [dimTag[1] for dimTag in self.dimTags[self.geo.ai.name]]
+        airTags = [dimTag[1] for dimTag in self.dimTags[self.geo.air.name]]
 
-        if self.geo.ai.shellTransformation:
+        if self.geo.air.shellTransformation:
             shellTags = [
-                dimTag[1] for dimTag in self.dimTags[self.geo.ai.shellVolumeName]
+                dimTag[1] for dimTag in self.dimTags[self.geo.air.shellVolumeName]
             ]
             airTags.extend(shellTags)
 
         dummyAirRegion = gmsh.model.addPhysicalGroup(dim=3, tags=airTags)
         dummyAirRegionDimTag = (3, dummyAirRegion)
 
-        innerCylinderTags = [self.dimTags[self.geo.ai.name + "-InnerCylinder"][0][1]]
-        gapTags = [dimTag[1] for dimTag in self.dimTags[self.geo.ai.name + "-Gap"]]
+        innerCylinderTags = [self.dimTags[self.geo.air.name + "-InnerCylinder"][0][1]]
+        gapTags = [dimTag[1] for dimTag in self.dimTags[self.geo.air.name + "-Gap"]]
         # Only remove every second gap:
         gapTags = gapTags[1::2]
 
@@ -1056,15 +1057,15 @@ class Mesh(Base):
             dummyAirRegionWithoutInnerCylinder,
         )
 
-        windingTags = [dimTag[1] for dimTag in self.dimTags[self.geo.wi.name]]
+        windingTags = [dimTag[1] for dimTag in self.dimTags[self.geo.winding.name]]
         dummyWindingRegion = gmsh.model.addPhysicalGroup(dim=3, tags=windingTags)
         dummyWindingRegionDimTag = (3, dummyWindingRegion)
 
-        if self.geo.ii.tsa:
+        if self.geo.contactLayer.thinShellApproximation:
             # Find all the contact layer surfaces:
             allWindingDimTags = []
-            for i in range(self.geo.N):
-                windingDimTags = self.dimTags[self.geo.wi.name + str(i + 1)]
+            for i in range(self.geo.numberOfPancakes):
+                windingDimTags = self.dimTags[self.geo.winding.name + str(i + 1)]
                 allWindingDimTags.extend(windingDimTags)
 
             windingBoundarySurfaces = gmsh.model.getBoundary(
@@ -1096,7 +1097,7 @@ class Mesh(Base):
 
             # Get rid of surfaces that touch terminals:
             terminalSurfaces = gmsh.model.getBoundary(
-                self.dimTags[self.geo.ti.o.name] + self.dimTags[self.geo.ti.i.name],
+                self.dimTags[self.geo.terminals.outer.name] + self.dimTags[self.geo.terminals.inner.name],
                 combined=False,
                 oriented=False,
             )
@@ -1111,11 +1112,11 @@ class Mesh(Base):
             dummyContactLayerRegionDimTag = (2, dummyContactLayerRegion)
 
         else:
-            contactLayerTags = [dimTag[1] for dimTag in self.dimTags[self.geo.ii.name]]
+            contactLayerTags = [dimTag[1] for dimTag in self.dimTags[self.geo.contactLayer.name]]
 
             # get rid of volumes that touch terminals:
             terminalSurfaces = gmsh.model.getBoundary(
-                self.dimTags[self.geo.ti.o.name] + self.dimTags[self.geo.ti.i.name],
+                self.dimTags[self.geo.terminals.outer.name] + self.dimTags[self.geo.terminals.inner.name],
                 combined=False,
                 oriented=False,
             )
@@ -1146,40 +1147,41 @@ class Mesh(Base):
             dims=[1],
         )
 
-        # Second cohomology request (insulated cut for insulated coils):
-        if self.geo.N > 1:
-            gmsh.model.mesh.addHomologyRequest(
-                "Cohomology",
-                domainTags=[
-                    dummyAirRegionWithoutInnerCylinder,
-                    dummyContactLayerRegion,
-                ],
-                subdomainTags=[],
-                dims=[1],
-            )
-        else:
+        if self.mesh.computeCohomologyForInsulating:
+            # Second cohomology request (insulated cut for insulated coils):
+            if self.geo.numberOfPancakes > 1:
+                gmsh.model.mesh.addHomologyRequest(
+                    "Cohomology",
+                    domainTags=[
+                        dummyAirRegionWithoutInnerCylinder,
+                        dummyContactLayerRegion,
+                    ],
+                    subdomainTags=[],
+                    dims=[1],
+                )
+            else:
+                gmsh.model.mesh.addHomologyRequest(
+                    "Cohomology",
+                    domainTags=[
+                        dummyAirRegion,
+                        dummyContactLayerRegion,
+                    ],
+                    subdomainTags=[],
+                    dims=[1],
+                )
+
+            # Third cohomology request (for cuts between pancake coils):
             gmsh.model.mesh.addHomologyRequest(
                 "Cohomology",
                 domainTags=[
                     dummyAirRegion,
                     dummyContactLayerRegion,
+                    dummyWindingRegion,
                 ],
                 subdomainTags=[],
                 dims=[1],
             )
 
-        # Third cohomology request (for cuts between pancake coils):
-        gmsh.model.mesh.addHomologyRequest(
-            "Cohomology",
-            domainTags=[
-                dummyAirRegion,
-                dummyContactLayerRegion,
-                dummyWindingRegion,
-            ],
-            subdomainTags=[],
-            dims=[1],
-        )
-
         # Start logger:
         gmsh.logger.start()
 
@@ -1194,15 +1196,15 @@ class Mesh(Base):
                 logger.warning(re.sub(r"Warning:\s+", "", line))
         gmsh.logger.stop()
 
-        if self.geo.N > 1:
+        if self.geo.numberOfPancakes > 1:
             cutsDictionary = {
-                "H^1{1}": self.geo.ai.cutName,
+                "H^1{1}": self.geo.air.cutName,
                 "H^1{1,4,3}": "CutsBetweenPancakes",
                 "H^1{2,4}": "CutsForPerfectInsulation",
             }
         else:
             cutsDictionary = {
-                "H^1{1}": self.geo.ai.cutName,
+                "H^1{1}": self.geo.air.cutName,
                 "H^1{1,4,3}": "CutsBetweenPancakes",
                 "H^1{1,4}": "CutsForPerfectInsulation",
             }
@@ -1272,25 +1274,25 @@ class Mesh(Base):
         """
         # Transfinite settings:
         # Arc lenght of the innermost one turn of spiral:
-        if self.geo.ii.tsa:
+        if self.geo.contactLayer.thinShellApproximation:
             oneTurnSpiralLength = curve.calculateSpiralArcLength(
-                self.geo.wi.r_i,
-                self.geo.wi.r_i
-                + self.geo.wi.t
-                + self.geo.ii.t * (self.geo.N - 1) / self.geo.N,
+                self.geo.winding.innerRadius,
+                self.geo.winding.innerRadius
+                + self.geo.winding.thickness
+                + self.geo.contactLayer.thickness * (self.geo.numberOfPancakes - 1) / self.geo.numberOfPancakes,
                 0,
                 2 * math.pi,
             )
         else:
             oneTurnSpiralLength = curve.calculateSpiralArcLength(
-                self.geo.wi.r_i,
-                self.geo.wi.r_i + self.geo.wi.t,
+                self.geo.winding.innerRadius,
+                self.geo.winding.innerRadius + self.geo.winding.thickness,
                 0,
                 2 * math.pi,
             )
 
         # Arc length of one element:
-        arcElementLength = oneTurnSpiralLength / self.mesh.wi.ane[meshSettingIndex]
+        arcElementLength = oneTurnSpiralLength / self.mesh.winding.azimuthalNumberOfElementsPerTurn[meshSettingIndex]
 
         # Number of azimuthal elements per turn:
         arcNumElementsPerTurn = round(oneTurnSpiralLength / arcElementLength)
@@ -1303,17 +1305,17 @@ class Mesh(Base):
                 if lineObject.type is curveType.horizontal:
                     # The curve is horizontal, so radialNumberOfElementsPerTurn entry is
                     # used.
-                    if self.geo.ii.tsa:
-                        numNodes = self.mesh.wi.rne[meshSettingIndex] + 1
+                    if self.geo.contactLayer.thinShellApproximation:
+                        numNodes = self.mesh.winding.radialNumberOfElementsPerTurn[meshSettingIndex] + 1
 
                     else:
                         if j == 0:
                             # This line is the winding's horizontal line:
-                            numNodes = self.mesh.wi.rne[meshSettingIndex] + 1
+                            numNodes = self.mesh.winding.radialNumberOfElementsPerTurn[meshSettingIndex] + 1
 
                         else:
                             # This line is the contact layer's horizontal line:
-                            numNodes = self.mesh.ii.rne[meshSettingIndex] + 1
+                            numNodes = self.mesh.contactLayer.radialNumberOfElementsPerTurn[meshSettingIndex] + 1
 
                     # Set transfinite curve:
                     self.contactLayerAndWindingRadialLines.append(lineTag)
@@ -1322,12 +1324,12 @@ class Mesh(Base):
                 elif lineObject.type is curveType.axial:
                     # The curve is axial, so axialNumberOfElements entry is used.
                     if axialNumberOfElements is None:
-                        numNodes = self.mesh.wi.axne[meshSettingIndex] + 1
+                        numNodes = self.mesh.winding.axialNumberOfElements[meshSettingIndex] + 1
                     else:
                         numNodes = axialNumberOfElements + 1
 
                     if bumpCoefficient is None:
-                        bumpCoefficient = self.mesh.wi.axbc[meshSettingIndex]
+                        bumpCoefficient = self.mesh.winding.axialDistributionCoefficient[meshSettingIndex]
                     gmsh.model.mesh.setTransfiniteCurve(
                         lineTag, numNodes, meshType="Bump", coef=bumpCoefficient
                     )
@@ -1345,7 +1347,7 @@ class Mesh(Base):
                         lengthInTurns = 1 - lengthInTurns
 
                     lengthInTurns = (
-                        round(lengthInTurns / self.geo.wi.turnTol) * self.geo.wi.turnTol
+                        round(lengthInTurns / self.geo.winding.turnTol) * self.geo.winding.turnTol
                     )
 
                     arcNumEl = round(arcNumElementsPerTurn * lengthInTurns)
@@ -1360,10 +1362,10 @@ class Mesh(Base):
                 # Make all the surfaces transfinite:
                 gmsh.model.mesh.setTransfiniteSurface(surfTag)
 
-                if self.mesh.wi.elementType[meshSettingIndex] == "hexahedron":
+                if self.mesh.winding.elementType[meshSettingIndex] == "hexahedron":
                     # If the element type is hexahedron, recombine all the surfaces:
                     gmsh.model.mesh.setRecombine(2, surfTag)
-                elif self.mesh.wi.elementType[meshSettingIndex] == "prism":
+                elif self.mesh.winding.elementType[meshSettingIndex] == "prism":
                     # If the element type is prism, recombine only the side surfaces:
                     surfaceNormal = list(gmsh.model.getNormal(surfTag, [0.5, 0.5]))
                     if abs(surfaceNormal[2]) < 1e-6:
@@ -1379,9 +1381,9 @@ class Mesh(Base):
         self, volumeTags, terminalNonTubeParts=False, radialElementMultiplier=1
     ):
         # Number of azimuthal elements per quarter:
-        arcNumElementsPerQuarter = int(self.mesh.wi.ane[0] / 4)
+        arcNumElementsPerQuarter = int(self.mesh.winding.azimuthalNumberOfElementsPerTurn[0] / 4)
         radialNumberOfElementsPerLength = (
-            self.mesh.wi.rne[0] / self.geo.wi.t * radialElementMultiplier
+            self.mesh.winding.radialNumberOfElementsPerTurn[0] / self.geo.winding.thickness * radialElementMultiplier
         )
 
         surfacesDimTags = gmsh.model.getBoundary(
@@ -1419,7 +1421,7 @@ class Mesh(Base):
                     if terminalNonTubeParts:
                         if curveTag not in self.contactLayerAndWindingRadialLines:
                             numNodes = (
-                                round(radialNumberOfElementsPerLength * self.geo.ti.i.t)
+                                round(radialNumberOfElementsPerLength * self.geo.terminals.inner.thickness)
                                 + 1
                             )
                             # Set transfinite curve:
@@ -1434,10 +1436,10 @@ class Mesh(Base):
 
             elif curveObject.type is curveType.axial:
                 # The curve is axial, so axialNumberOfElements entry is used.
-                if math.isclose(curveObject.length, self.geo.wi.h, rel_tol=1e-7):
-                    numNodes = min(self.mesh.wi.axne) + 1
+                if math.isclose(curveObject.length, self.geo.winding.height, rel_tol=1e-7):
+                    numNodes = min(self.mesh.winding.axialNumberOfElements) + 1
                 else:
-                    axialElementsPerLength = min(self.mesh.wi.axne) / self.geo.wi.h
+                    axialElementsPerLength = min(self.mesh.winding.axialNumberOfElements) / self.geo.winding.height
                     numNodes = (
                         round(axialElementsPerLength * curveObject.length + 1e-6) + 1
                     )
@@ -1452,7 +1454,7 @@ class Mesh(Base):
                     lengthInTurns = 1 - lengthInTurns
 
                 lengthInTurns = (
-                    round(lengthInTurns / self.geo.wi.turnTol) * self.geo.wi.turnTol
+                    round(lengthInTurns / self.geo.winding.turnTol) * self.geo.winding.turnTol
                 )
 
                 arcNumEl = round(arcNumElementsPerQuarter * 4 * lengthInTurns)
@@ -1466,10 +1468,10 @@ class Mesh(Base):
         for surfaceTag in surfacesTags:
             # Make all the surfaces transfinite:
 
-            if self.mesh.wi.elementType[0] == "hexahedron":
+            if self.mesh.winding.elementType[0] == "hexahedron":
                 # If the element type is hexahedron, recombine all the surfaces:
                 gmsh.model.mesh.setRecombine(2, surfaceTag)
-            elif self.mesh.wi.elementType[0] == "prism":
+            elif self.mesh.winding.elementType[0] == "prism":
                 # If the element type is prism, recombine only the side surfaces:
                 surfaceNormal = list(gmsh.model.getNormal(surfaceTag, [0.5, 0.5]))
                 if abs(surfaceNormal[2]) < 1e-5:
@@ -2076,10 +2078,12 @@ class Mesh(Base):
             return [(2, newSurfaceTag)]
         else:
             # Create a new single surface:
+            # The order of tags seems to be important for the fuse method to work
+            # and not crash with a segmentation fault.
             try:
                 fuseResults = gmsh.model.occ.fuse(
-                    [oldSurfaceDimTags[-1]],
-                    oldSurfaceDimTags[0:-1],
+                    [oldSurfaceDimTags[0]],
+                    oldSurfaceDimTags[1:],
                     removeObject=False,
                     removeTool=False,
                 )
@@ -2144,16 +2148,16 @@ class Mesh(Base):
         # ==============================================================================
         # WINDING AND CONTACT LAYER REGIONS START =========================================
         # ==============================================================================
-        if not self.geo.ii.tsa:
-            windingTags = [dimTag[1] for dimTag in self.dimTags[self.geo.wi.name]]
+        if not self.geo.contactLayer.thinShellApproximation:
+            windingTags = [dimTag[1] for dimTag in self.dimTags[self.geo.winding.name]]
             self.regions.addEntities(
-                self.geo.wi.name, windingTags, regionType.powered, entityType.vol
+                self.geo.winding.name, windingTags, regionType.powered, entityType.vol
             )
 
-            insulatorTags = [dimTag[1] for dimTag in self.dimTags[self.geo.ii.name]]
+            insulatorTags = [dimTag[1] for dimTag in self.dimTags[self.geo.contactLayer.name]]
 
             terminalDimTags = (
-                self.dimTags[self.geo.ti.i.name] + self.dimTags[self.geo.ti.o.name]
+                self.dimTags[self.geo.terminals.inner.name] + self.dimTags[self.geo.terminals.outer.name]
             )
             terminalAndNotchSurfaces = gmsh.model.getBoundary(
                 terminalDimTags, combined=False, oriented=False
@@ -2185,7 +2189,7 @@ class Mesh(Base):
                     contactLayer.append(insulatorTag)
 
             self.regions.addEntities(
-                self.geo.ii.name, contactLayer, regionType.insulator, entityType.vol
+                self.geo.contactLayer.name, contactLayer, regionType.insulator, entityType.vol
             )
 
             self.regions.addEntities(
@@ -2200,9 +2204,9 @@ class Mesh(Base):
             # are created because of the TSA's pro file formulation.
 
             # find the smallest prime number that divides NofVolumes:
-            windingDimTags = self.dimTags[self.geo.wi.name + "1"]
+            windingDimTags = self.dimTags[self.geo.winding.name + "1"]
             windingTags = [dimTag[1] for dimTag in windingDimTags]
-            NofVolumes = self.geo.wi.NofVolPerTurn
+            NofVolumes = self.geo.winding.numberOfVolumesPerTurn
             smallest_prime_divisor = 2
             while NofVolumes % smallest_prime_divisor != 0:
                 smallest_prime_divisor += 1
@@ -2215,7 +2219,7 @@ class Mesh(Base):
             NofSets = 2 * NofStacks
 
             allInnerTerminalSurfaces = gmsh.model.getBoundary(
-                self.dimTags[self.geo.ti.i.name] + self.dimTags["innerTransitionNotch"],
+                self.dimTags[self.geo.terminals.inner.name] + self.dimTags["innerTransitionNotch"],
                 combined=False,
                 oriented=False,
             )
@@ -2240,8 +2244,8 @@ class Mesh(Base):
                 finalWindingSets.append([])
                 finalContactLayerSets.append([])
 
-            for i in range(self.geo.N):
-                windingDimTags = self.dimTags[self.geo.wi.name + str(i + 1)]
+            for i in range(self.geo.numberOfPancakes):
+                windingDimTags = self.dimTags[self.geo.winding.name + str(i + 1)]
                 windingTags = [dimTag[1] for dimTag in windingDimTags]
 
                 NofVolumes = len(windingDimTags)
@@ -2374,8 +2378,8 @@ class Mesh(Base):
 
             # Seperate transition layer:
             terminalAndNotchSurfaces = gmsh.model.getBoundary(
-                self.dimTags[self.geo.ti.i.name]
-                + self.dimTags[self.geo.ti.o.name]
+                self.dimTags[self.geo.terminals.inner.name]
+                + self.dimTags[self.geo.terminals.outer.name]
                 + self.dimTags["innerTransitionNotch"]
                 + self.dimTags["outerTransitionNotch"],
                 combined=False,
@@ -2409,7 +2413,7 @@ class Mesh(Base):
             for j in range(NofSets):
                 # Add winding volumes:
                 self.regions.addEntities(
-                    self.geo.wi.name + "-" + str(j + 1),
+                    self.geo.winding.name + "-" + str(j + 1),
                     finalWindingSets[j],
                     regionType.powered,
                     entityType.vol,
@@ -2417,7 +2421,7 @@ class Mesh(Base):
 
                 # Add insulator surfaces:
                 self.regions.addEntities(
-                    self.geo.ii.name + "-" + str(j + 1),
+                    self.geo.contactLayer.name + "-" + str(j + 1),
                     contactLayerSets[j],
                     regionType.insulator,
                     entityType.surf,
@@ -2425,14 +2429,35 @@ class Mesh(Base):
                 allContactLayerSurfacesForAllPancakes.extend(contactLayerSets[j])
 
                 # Add terminal and winding contact layer:
+                allContactLayerSurfacesForAllPancakes.extend(
+                    terminalWindingContactLayerSets[j]
+                )
+
+                # Add intersection of transition notch boundary and WindingAndTerminalContactLayer:
+                transitionNotchSurfaces = gmsh.model.getBoundary(
+                    self.dimTags["innerTransitionNotch"]
+                    + self.dimTags["outerTransitionNotch"],
+                    combined=False,
+                    oriented=False,
+                    recursive=False
+                )
+
+                terminalContactLayerMinusNotch = set(terminalWindingContactLayerSets[j]).difference([tag for (dim, tag) in transitionNotchSurfaces])
+                
                 self.regions.addEntities(
-                    "WindingAndTerminalContactLayer" + "-" + str(j + 1),
-                    terminalWindingContactLayerSets[j],
+                    "WindingAndTerminalContactLayerWithoutNotch" + "-" + str(j + 1),
+                    list(terminalContactLayerMinusNotch),
                     regionType.insulator,
                     entityType.surf,
                 )
-                allContactLayerSurfacesForAllPancakes.extend(
-                    terminalWindingContactLayerSets[j]
+
+                notchAndTerminalContactLayerIntersection = set([tag for (dim, tag) in transitionNotchSurfaces]).intersection(terminalWindingContactLayerSets[j])
+
+                self.regions.addEntities(
+                    "WindingAndTerminalContactLayerOnlyNotch" + "-" + str(j + 1),
+                    list(notchAndTerminalContactLayerIntersection),
+                    regionType.insulator,
+                    entityType.surf,
                 )
 
             allContactLayerSurfacesForAllPancakes = list(
@@ -2501,23 +2526,23 @@ class Mesh(Base):
         # TERMINAL REGIONS START =======================================================
         # ==============================================================================
 
-        innerTerminalTags = [dimTag[1] for dimTag in self.dimTags[self.geo.ti.i.name]]
+        innerTerminalTags = [dimTag[1] for dimTag in self.dimTags[self.geo.terminals.inner.name]]
         self.regions.addEntities(
-            self.geo.ti.i.name, innerTerminalTags, regionType.powered, entityType.vol_in
+            self.geo.terminals.inner.name, innerTerminalTags, regionType.powered, entityType.vol_in
         )
-        outerTerminalTags = [dimTag[1] for dimTag in self.dimTags[self.geo.ti.o.name]]
+        outerTerminalTags = [dimTag[1] for dimTag in self.dimTags[self.geo.terminals.outer.name]]
         self.regions.addEntities(
-            self.geo.ti.o.name,
+            self.geo.terminals.outer.name,
             outerTerminalTags,
             regionType.powered,
             entityType.vol_out,
         )
 
         # Top and bottom terminal surfaces:
-        firstTerminalDimTags = self.dimTags[self.geo.ti.firstName]
-        lastTerminalDimTags = self.dimTags[self.geo.ti.lastName]
+        firstTerminalDimTags = self.dimTags[self.geo.terminals.firstName]
+        lastTerminalDimTags = self.dimTags[self.geo.terminals.lastName]
 
-        if self.mesh.ti.structured:
+        if self.mesh.terminals.structured:
             topSurfaceDimTags = []
             for i in [1, 2, 3, 4]:
                 lastTerminalSurfaces = gmsh.model.getBoundary(
@@ -2531,7 +2556,7 @@ class Mesh(Base):
             topSurfaceDimTags = [lastTerminalSurfaces[-1]]
         topSurfaceTags = [dimTag[1] for dimTag in topSurfaceDimTags]
 
-        if self.mesh.ti.structured:
+        if self.mesh.terminals.structured:
             bottomSurfaceDimTags = []
             for i in [1, 2, 3, 4]:
                 firstTerminalSurfaces = gmsh.model.getBoundary(
@@ -2558,17 +2583,17 @@ class Mesh(Base):
             entityType.surf_in,
         )
 
-        # if self.geo.ii.tsa:
+        # if self.geo.contactLayer.tsa:
         #     outerTerminalSurfaces = gmsh.model.getBoundary(
-        #         self.dimTags[self.geo.ti.o.name], combined=True, oriented=False
+        #         self.dimTags[self.geo.terminals.o.name], combined=True, oriented=False
         #     )
         #     outerTerminalSurfaces = [dimTag[1] for dimTag in outerTerminalSurfaces]
         #     innerTerminalSurfaces = gmsh.model.getBoundary(
-        #         self.dimTags[self.geo.ti.i.name], combined=True, oriented=False
+        #         self.dimTags[self.geo.terminals.i.name], combined=True, oriented=False
         #     )
         #     innerTerminalSurfaces = [dimTag[1] for dimTag in innerTerminalSurfaces]
         #     windingSurfaces = gmsh.model.getBoundary(
-        #         self.dimTags[self.geo.wi.name] + self.dimTags[self.geo.ii.name],
+        #         self.dimTags[self.geo.winding.name] + self.dimTags[self.geo.contactLayer.name],
         #         combined=True,
         #         oriented=False,
         #     )
@@ -2596,15 +2621,15 @@ class Mesh(Base):
         # ==============================================================================
         # AIR AND AIR SHELL REGIONS STARTS =============================================
         # ==============================================================================
-        airTags = [dimTag[1] for dimTag in self.dimTags[self.geo.ai.name]]
+        airTags = [dimTag[1] for dimTag in self.dimTags[self.geo.air.name]]
         self.regions.addEntities(
-            self.geo.ai.name, airTags, regionType.air, entityType.vol
+            self.geo.air.name, airTags, regionType.air, entityType.vol
         )
 
         # Create a region with two points on air to be used in the pro file formulation:
         # To those points, Phi=0 boundary condition will be applied to set the gauge.
         outerAirSurfaces = gmsh.model.getBoundary(
-            self.dimTags[self.geo.ai.name + "-OuterTube"], combined=True, oriented=False
+            self.dimTags[self.geo.air.name + "-OuterTube"], combined=True, oriented=False
         )
         outerAirSurface = outerAirSurfaces[-1]
         outerAirCurves = gmsh.model.getBoundary(
@@ -2623,7 +2648,7 @@ class Mesh(Base):
         )
 
         innerAirSurfaces = gmsh.model.getBoundary(
-            self.dimTags[self.geo.ai.name + "-InnerCylinder"],
+            self.dimTags[self.geo.air.name + "-InnerCylinder"],
             combined=True,
             oriented=False,
         )
@@ -2643,36 +2668,36 @@ class Mesh(Base):
             entityType.point,
         )
 
-        if self.geo.ai.shellTransformation:
-            if self.geo.ai.type == "cylinder":
+        if self.geo.air.shellTransformation:
+            if self.geo.air.type == "cylinder":
                 airShellTags = [
-                    dimTag[1] for dimTag in self.dimTags[self.geo.ai.shellVolumeName]
+                    dimTag[1] for dimTag in self.dimTags[self.geo.air.shellVolumeName]
                 ]
                 self.regions.addEntities(
-                    self.geo.ai.shellVolumeName,
+                    self.geo.air.shellVolumeName,
                     airShellTags,
                     regionType.air_far_field,
                     entityType.vol,
                 )
-            elif self.geo.ai.type == "cuboid":
+            elif self.geo.air.type == "cuboid":
                 airShell1Tags = [
                     dimTag[1]
-                    for dimTag in self.dimTags[self.geo.ai.shellVolumeName + "-Part1"]
-                    + self.dimTags[self.geo.ai.shellVolumeName + "-Part3"]
+                    for dimTag in self.dimTags[self.geo.air.shellVolumeName + "-Part1"]
+                    + self.dimTags[self.geo.air.shellVolumeName + "-Part3"]
                 ]
                 airShell2Tags = [
                     dimTag[1]
-                    for dimTag in self.dimTags[self.geo.ai.shellVolumeName + "-Part2"]
-                    + self.dimTags[self.geo.ai.shellVolumeName + "-Part4"]
+                    for dimTag in self.dimTags[self.geo.air.shellVolumeName + "-Part2"]
+                    + self.dimTags[self.geo.air.shellVolumeName + "-Part4"]
                 ]
                 self.regions.addEntities(
-                    self.geo.ai.shellVolumeName + "-PartX",
+                    self.geo.air.shellVolumeName + "-PartX",
                     airShell1Tags,
                     regionType.air_far_field,
                     entityType.vol,
                 )
                 self.regions.addEntities(
-                    self.geo.ai.shellVolumeName + "-PartY",
+                    self.geo.air.shellVolumeName + "-PartY",
                     airShell2Tags,
                     regionType.air_far_field,
                     entityType.vol,
@@ -2684,10 +2709,10 @@ class Mesh(Base):
         # ==============================================================================
         # CUTS STARTS ==================================================================
         # ==============================================================================
-        if self.geo.ai.cutName in self.dimTags:
-            cutTags = [dimTag[1] for dimTag in self.dimTags[self.geo.ai.cutName]]
+        if self.geo.air.cutName in self.dimTags:
+            cutTags = [dimTag[1] for dimTag in self.dimTags[self.geo.air.cutName]]
             self.regions.addEntities(
-                self.geo.ai.cutName, cutTags, regionType.air, entityType.cochain
+                self.geo.air.cutName, cutTags, regionType.air, entityType.cochain
             )
 
         if "CutsForPerfectInsulation" in self.dimTags:
@@ -2710,10 +2735,10 @@ class Mesh(Base):
         # ==============================================================================
         # Pancake3D Boundary Surface:
         allPancakeVolumes = (
-            self.dimTags[self.geo.wi.name]
-            + self.dimTags[self.geo.ti.i.name]
-            + self.dimTags[self.geo.ti.o.name]
-            + self.dimTags[self.geo.ii.name]
+            self.dimTags[self.geo.winding.name]
+            + self.dimTags[self.geo.terminals.inner.name]
+            + self.dimTags[self.geo.terminals.outer.name]
+            + self.dimTags[self.geo.contactLayer.name]
             + self.dimTags["innerTransitionNotch"]
             + self.dimTags["outerTransitionNotch"]
         )
@@ -2733,12 +2758,70 @@ class Mesh(Base):
             entityType.surf,
         )
 
-        if not self.geo.ii.tsa:
+        if self.geo.contactLayer.thinShellApproximation:
+            # add non-winding boundary for convective cooling 
+            windingBoundaryDimTags = gmsh.model.getBoundary(
+                [(3, tag) for tag in itertools.chain(*finalWindingSets)],
+                combined=True,
+                oriented=False,
+            )
+
+            inner_terminal_and_transition_notch_all_boundaries = gmsh.model.getBoundary(
+                self.dimTags[self.geo.terminals.inner.name] + self.dimTags["innerTransitionNotch"],
+                combined=True,
+                oriented=False
+            )
+
+            inner_terminal_and_transition_notch_boundary_dim_tags = set(Pancake3DBoundaryDimTags).intersection(inner_terminal_and_transition_notch_all_boundaries)
+            inner_terminal_and_transition_notch_boundary_tags = [dimTag[1] for dimTag in inner_terminal_and_transition_notch_boundary_dim_tags]
+            self.regions.addEntities(
+                f"{self.geo.pancakeBoundaryName}-InnerTerminalAndTransitionNotch",
+                inner_terminal_and_transition_notch_boundary_tags,
+                regionType.powered,
+                entityType.surf_th,
+            )
+
+            outer_terminal_and_transition_notch_all_boundaries = gmsh.model.getBoundary(
+                self.dimTags[self.geo.terminals.outer.name] + self.dimTags["outerTransitionNotch"],
+                combined=True,
+                oriented=False
+            )
+
+            outer_terminal_and_transition_notch_boundary_dim_tags = set(Pancake3DBoundaryDimTags).intersection(outer_terminal_and_transition_notch_all_boundaries)
+            outer_terminal_and_transition_notch_boundary_tags = [dimTag[1] for dimTag in outer_terminal_and_transition_notch_boundary_dim_tags]
+            self.regions.addEntities(
+                f"{self.geo.pancakeBoundaryName}-outerTerminalAndTransitionNotch",
+                outer_terminal_and_transition_notch_boundary_tags,
+                regionType.powered,
+                entityType.surf_th,
+            )
+
+            # add pancake boundary for convective cooling following the winding numbering logic
+            # computes the intersection between pancake boundary and the boundary of each winding group
+            for j in range(NofSets):
+
+                windingBoundaryDimTags = gmsh.model.getBoundary(
+                    [(3, tag) for tag in finalWindingSets[j]],
+                    combined=True,
+                    oriented=False,
+                )
+
+                windingBoundaryDimTags = set(windingBoundaryDimTags).intersection(Pancake3DBoundaryDimTags)
+
+                windingBoundaryTags = [dimTag[1] for dimTag in windingBoundaryDimTags]
+                self.regions.addEntities(
+                    f"{self.geo.pancakeBoundaryName}-Winding{j+1}",
+                    windingBoundaryTags,
+                    regionType.powered,
+                    entityType.surf_th,
+                )
+
+        if not self.geo.contactLayer.thinShellApproximation:
             # Pancake3D Boundary Surface with only winding and terminals:
             allPancakeVolumes = (
-                self.dimTags[self.geo.wi.name]
-                + self.dimTags[self.geo.ti.i.name]
-                + self.dimTags[self.geo.ti.o.name]
+                self.dimTags[self.geo.winding.name]
+                + self.dimTags[self.geo.terminals.inner.name]
+                + self.dimTags[self.geo.terminals.outer.name]
                 + self.dimTags["innerTransitionNotch"]
                 + self.dimTags["outerTransitionNotch"]
                 + [(3, tag) for tag in contactLayerBetweenTerminalsAndWinding]