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

fiqus/mesh_generators/MeshMultipole.py

@@ -88,19 +88,16 @@ class Mesh:
         self.md = Util.read_data_from_yaml(f"{self.geom_files}_{run_type}.aux", dM.MultipoleData)
 
     def updateAuxiliaryFile(self, run_type):
-        Util.write_data_to_yaml(f'{self.model_file}_{run_type}.aux', self.md.dict())
-        # md2 = Util.read_data_from_yaml(f"{self.geom_files}.aux", dM.MultipoleData)
-        # md2.domains.physical_groups = self.md.domains.physical_groups
-        # Util.write_data_to_yaml(f"{self.geom_files}.aux", md2.dict())
+        Util.write_data_to_yaml(f'{self.model_file}_{run_type}.aux', self.md.model_dump())
 
     def saveMeshFile(self, run_type):
         gmsh.write(f'{self.model_file}_{run_type}.msh')
 
     def saveRegionFile(self, run_type):
-        Util.write_data_to_yaml(f'{self.model_file}_{run_type}.reg', self.rm.dict())
+        Util.write_data_to_yaml(f'{self.model_file}_{run_type}.reg', self.rm.model_dump())
 
     def saveRegionCoordinateFile(self, run_type):
-        Util.write_data_to_yaml(f'{self.model_file}_{run_type}.reco', self.rc.dict())
+        Util.write_data_to_yaml(f'{self.model_file}_{run_type}.reco', self.rc.model_dump())
 
     def getIronCurvesTags(self):
         for quadrant, qq in self.md.geometries.iron.quadrants.items():
@@ -206,7 +203,7 @@ class Mesh:
                             layer_nr].windings[block_order.winding]
                         cable = self.data.conductors[winding.conductor_name].cable
                         for line_key, line in winding.blocks[block_order.block].half_turns.lines.items():
-                            if mesh.dict().get('isothermal_conductors', False):
+                            if mesh.model_dump().get('isothermal_conductors', False):
                                 elements = 1
                             elif any([i in line_key for i in ['i', 'o']]):
                                 elements = max(1, round(cable.bare_cable_height_mean / mesh.conductors.transfinite.curve_target_size_height))
@@ -214,12 +211,12 @@ class Mesh:
                                 elements = max(1, round(cable.bare_cable_width / mesh.conductors.transfinite.curve_target_size_width))
                                 
                             self.mesh.setTransfiniteCurve(line, elements)
-                        if mesh.conductors.transfinite.enabled_for=='curves_and_surfaces' or mesh.dict().get('isothermal_conductors', False):
+                        if mesh.conductors.transfinite.enabled_for=='curves_and_surfaces' or mesh.model_dump().get('isothermal_conductors', False):
                             for _, area in winding.blocks[block_order.block].half_turns.areas.items():
                                 self.mesh.setTransfiniteSurface(area.surface)
                                 self.mesh.setRecombine(2, area.surface)
         
-        if 'insulation' in mesh.dict() and 'TSA' in mesh.dict()["insulation"]:
+        if 'insulation' in mesh.model_dump() and 'TSA' in mesh.model_dump()["insulation"]:
             # Apply transfinite curves to thin shell lines
             if geometry.use_TSA:
                 gts = self.md.geometries.thin_shells
@@ -273,7 +270,7 @@ class Mesh:
                             pnts = gmsh.model.getAdjacencies(1, wedge.lines['o'])[1]
                             outer_height = Func.points_distance(gmsh.model.getValue(0, pnts[0], []), gmsh.model.getValue(0, pnts[1], []))
                             for line_key, line in wedge.lines.items():
-                                if mesh.dict().get('isothermal_wedges', False):
+                                if mesh.model_dump().get('isothermal_wedges', False):
                                     elements = 1
                                 elif 'i' in line_key:
                                     elements = max(1, round(inner_height / mesh.wedges.transfinite.curve_target_size_height))
@@ -284,7 +281,7 @@ class Mesh:
                                     elements = max(1, round(width / mesh.wedges.transfinite.curve_target_size_width))
                                 if mesh.wedges.transfinite.enabled_for in ['curves', 'curves_and_surfaces']:
                                     self.mesh.setTransfiniteCurve(line, elements)
-                            if mesh.wedges.transfinite.enabled_for=='curves_and_surfaces' or mesh.dict().get('isothermal_wedges', False):
+                            if mesh.wedges.transfinite.enabled_for=='curves_and_surfaces' or mesh.model_dump().get('isothermal_wedges', False):
                                 self.mesh.setTransfiniteSurface(list(wedge.areas.values())[0].surface)
                                 self.mesh.setRecombine(2, list(wedge.areas.values())[0].surface)
 
@@ -292,7 +289,7 @@ class Mesh:
         """
             Creates physical groups by grouping the mirrored entities according to the Roxie domains
         """
-        offset: int = 1 if 'symmetry' in geometry.dict() else int(1e6)
+        offset: int = 1 if 'symmetry' in geometry.model_dump() else int(1e6)
         pg_tag = offset
 
         # Create physical groups of iron yoke regions and block insulation
@@ -305,7 +302,7 @@ class Mesh:
             pg_tag += 1
 
         # Create the physical group of air infinite
-        if 'symmetry' in geometry.dict():
+        if 'symmetry' in geometry.model_dump():
             gmsh.model.setPhysicalName(0, gmsh.model.addPhysicalGroup(
                 0, [pnt for pnt_name, pnt in self.md.geometries.air.points.items() if 'bore_field' in pnt_name], pg_tag), 'bore_centers')
             pg_tag += 1
@@ -353,13 +350,13 @@ class Mesh:
                         pg_tag += 1
                         # Assign thin-shell group
                         # the check for reversed block coil is not tested well
-                        if geometry.dict().get('correct_block_coil_tsa_checkered_scheme', False) and self.md.geometries.coil.coils[coil_nr].type == 'reversed-block-coil':
+                        if geometry.model_dump().get('correct_block_coil_tsa_checkered_scheme', False) and self.md.geometries.coil.coils[coil_nr].type == 'reversed-block-coil':
                             azimuthal = 'a1' if list(wnd.blocks.keys()).index(block_nr) % 2 == 0 else 'a2'
                         else:
                             azimuthal = 'a1' if lyr_list_group.index('cl' + str(coil_nr) + 'ly' + str(layer_nr)) % 2 == 0 else 'a2'
                         radial = 'r1' if ht_list_group.index(ht_key) % 2 == 0 else 'r2'
                         ht_pg.group = radial + '_' + azimuthal
-                    if geometry.dict().get('use_TSA', False):
+                    if geometry.model_dump().get('use_TSA', False):
                         # Create 1D physical groups of thin shells
                         for ht_line_key, ht_line in block.half_turns.lines.items():
                             ht_nr = ht_line_key[:-1]
@@ -373,7 +370,7 @@ class Mesh:
                             blk_pg.half_turns[int(ht_nr)].lines[ht_line_key[-1]] = line_pg
 
         # Create points region for projection
-        if 'use_TSA' in geometry.dict():
+        if 'use_TSA' in geometry.model_dump():
             self.md.domains.physical_groups.half_turns_points = gmsh.model.addPhysicalGroup(
                 0, [gmsh.model.getAdjacencies(1, gmsh.model.getAdjacencies(2, ht.surface)[1][0])[1][0]
                     for coil_nr, coil in self.md.geometries.coil.anticlockwise_order.coils.items()
@@ -383,7 +380,7 @@ class Mesh:
             gmsh.model.setPhysicalName(0, self.md.domains.physical_groups.half_turns_points, 'points')
 
         # Create physical groups of insulations
-        if not geometry.dict().get('use_TSA', True):
+        if not geometry.model_dump().get('use_TSA', True):
             for coil_nr, coil in self.md.geometries.insulation.coils.items():
                 for group_nr, group in coil.group.items():
                     # Areas
@@ -427,7 +424,7 @@ class Mesh:
                     else:
                         prev_group = prev_block_hts[list(prev_block_hts.keys())[0]].group
                         wedge_pg.group = ('r1' if prev_group[1] == '2' else 'r2') + prev_group[prev_group.index('_'):]
-                    if geometry.dict().get('use_TSA', False):
+                    if geometry.model_dump().get('use_TSA', False):
                         # Create 1D physical groups of thin shells
                         for line_key, line in wedge.lines.items():
                             wedge_pg.lines[line_key] = gmsh.model.addPhysicalGroup(1, [line], pg_tag)
@@ -437,7 +434,7 @@ class Mesh:
                             pg_tag += 1
 
         # Create physical groups of thin shells
-        if geometry.dict().get('use_TSA', False):
+        if geometry.model_dump().get('use_TSA', False):
             gts = self.md.geometries.thin_shells
             # Create physical groups of block mid-layer lines
             block_coil_flag = False
@@ -520,7 +517,7 @@ class Mesh:
                             pg.blocks[int(el_name1)].half_turns[int(ht1)].__dict__[ts_group_name + '_lines'][line_name] = line_pg
 
         # Create physical groups of symmetric boundaries
-        if geometry.dict().get('symmetry', 'none') != 'none':
+        if geometry.model_dump().get('symmetry', 'none') != 'none':
             line_tags_normal_free, line_tags_tangent_free = [], []
             if geometry.symmetry == 'xy':
                 if len(self.md.geometries.coil.coils[1].poles) == 2:
@@ -561,8 +558,8 @@ class Mesh:
                 self.qh_data[qh.ids[ht_index]][thin_shell] = {'conductor': blk_pg.conductor, 'ht_side': qh_side}
 
         def _store_ts_tags(pg_el, geom_ts_name='', geom_ts_name2=None, ts_grp='', lines='', lines_side=None):
-            geom_ts = self.md.geometries.thin_shells.dict()[geom_ts_name]
-            for ln_name, ln_tag in (pg_el.dict()[lines][lines_side] if lines_side else pg_el.dict()[lines]).items():
+            geom_ts = self.md.geometries.thin_shells.model_dump()[geom_ts_name]
+            for ln_name, ln_tag in (pg_el.model_dump()[lines][lines_side] if lines_side else pg_el.model_dump()[lines]).items():
                 for ts_name in ts_groups[ts_grp]:
                     if ts_name in geom_ts:
                         if ln_name in (geom_ts[ts_name][geom_ts_name2]['lines'] if geom_ts_name2 else geom_ts[ts_name]['lines']):
@@ -726,7 +723,7 @@ class Mesh:
         qh = self.data.quench_protection.quench_heaters
 
         # Air and air far field
-        if 'bore_field' in mesh.dict():
+        if 'bore_field' in mesh.model_dump():
             self.rm.air_far_field.vol.radius_out = float(abs(max(gmsh.model.getValue(0, gmsh.model.getAdjacencies(
                     1, self.md.geometries.air_inf.lines['outer'])[1][0], []), key=abs)))
             self.rm.air_far_field.vol.radius_in = float(abs(max(gmsh.model.getValue(0, gmsh.model.getAdjacencies(
@@ -737,13 +734,13 @@ class Mesh:
             self.rm.air_far_field.vol.numbers = [pg.air_inf]
             self.rm.air_far_field.surf.name = "Surface_Inf"
             self.rm.air_far_field.surf.number = pg.air_inf_bnd
-            if geometry.dict().get('symmetry', 'none') != 'none':
+            if geometry.model_dump().get('symmetry', 'none') != 'none':
                 self.rm.boundaries.symmetry.normal_free.name = 'normal_free_bnd'
                 self.rm.boundaries.symmetry.normal_free.number = pg.symmetric_boundaries.normal_free
                 self.rm.boundaries.symmetry.tangential_free.name = 'tangent_free_bnd'
                 self.rm.boundaries.symmetry.tangential_free.number = pg.symmetric_boundaries.tangential_free
 
-        if 'use_TSA' in geometry.dict():
+        if 'use_TSA' in geometry.model_dump():
             self.rm.projection_points.name = 'projection_points'
             self.rm.projection_points.number = self.md.domains.physical_groups.half_turns_points
 
@@ -757,10 +754,10 @@ class Mesh:
                 self.rm.induced[group] = rM.Induced()
                 self.rm.induced[group].vol.names = []
                 self.rm.induced[group].vol.numbers = []
-            if 'bore_field' in mesh.dict():
+            if 'bore_field' in mesh.model_dump():
                 initial_current = self.data.power_supply.I_initial
                 self.rm.powered[group].vol.currents = []
-            if geometry.dict().get('use_TSA', False):
+            if geometry.model_dump().get('use_TSA', False):
                 self.rm.powered[group].surf_in.names = []
                 self.rm.powered[group].surf_in.numbers = []
                 self.rm.powered[group].surf_out.names = []
@@ -771,9 +768,9 @@ class Mesh:
                     self.rm.induced[group].surf_out.names = []
                     self.rm.induced[group].surf_out.numbers = []
         if geometry.with_iron_yoke:
-            self.rm.iron.vol.names = []
-            self.rm.iron.vol.numbers = []
-        if geometry.dict().get('use_TSA', False):
+            self.rm.iron_yoke.vol.names = []
+            self.rm.iron_yoke.vol.numbers = []
+        if geometry.model_dump().get('use_TSA', False):
             unique_thin_shells = []
             self.rm.thin_shells.second_group_is_next['azimuthally'] = []
             self.rm.thin_shells.second_group_is_next['radially'] = []
@@ -785,7 +782,7 @@ class Mesh:
             self.rm.insulator.surf.names = []
             self.rm.insulator.surf.numbers = []
 
-        if geometry.dict().get('use_TSA', False):
+        if geometry.model_dump().get('use_TSA', False):
             # Categorize insulation types
             min_h = mesh.insulation.global_size
             # min_h = 1
@@ -821,7 +818,7 @@ class Mesh:
                             self.rm.thin_shells.insulation_types.layers_material[-1].extend([side_ins_type[nr]] * tsa_layers)
 
             # Mid-pole, mid-winding, and mid-layer insulation layers
-            ins_th_dict = self.md.geometries.thin_shells.ins_thickness.dict()
+            ins_th_dict = self.md.geometries.thin_shells.ins_thickness.model_dump()
             for ins_type, ins in self.ins_type.items():
                 for ins_name, tags in ins.items():
                     # Get conductors insulation
@@ -930,13 +927,13 @@ class Mesh:
         for blk_nr, blk in pg.blocks.items():
             ht_list = list(blk.half_turns.keys())
             for ht_nr, ht in blk.half_turns.items():
-                ht_name = f"ht{ht_nr}_{'EM' if 'bore_field' in mesh.dict() else 'TH'}"
+                ht_name = f"ht{ht_nr}_{'EM' if 'bore_field' in mesh.model_dump() else 'TH'}"
                 self.rm.powered[ht.group].conductors[blk.conductor].append(ht_name)
                 self.rm.powered[ht.group].vol.names.append(ht_name)
                 self.rm.powered[ht.group].vol.numbers.append(ht.tag)
-                if 'bore_field' in mesh.dict():
+                if 'bore_field' in mesh.model_dump():
                     self.rm.powered[ht.group].vol.currents.append(initial_current * (1 if blk.current_sign > 0 else -1))
-                if geometry.dict().get('use_TSA', False):
+                if geometry.model_dump().get('use_TSA', False):
                     for line in ['l', 'i', 'o', 'h']:
                         # Bare edges
                         self.rm.powered[ht.group].surf_in.names.append(ht_name + line)
@@ -991,17 +988,17 @@ class Mesh:
                         # conductor edges precede a2
                         self.rm.thin_shells.second_group_is_next['radially'].append(ht.lines['o'])
 
-        if geometry.dict().get('use_TSA', False):
+        if geometry.model_dump().get('use_TSA', False):
             for group in ['r1_a1', 'r2_a1', 'r1_a2', 'r2_a2']:
                 unique_thin_shells.extend(self.rm.powered[group].surf_out.numbers)
 
         # Wedges
         if geometry.with_wedges:
             for wdg_nr, wdg in pg.wedges.items():
-                wdg_name = f"w{wdg_nr}_{'EM' if 'bore_field' in mesh.dict() else 'TH'}"
+                wdg_name = f"w{wdg_nr}_{'EM' if 'bore_field' in mesh.model_dump() else 'TH'}"
                 self.rm.induced[wdg.group].vol.names.append(wdg_name)
                 self.rm.induced[wdg.group].vol.numbers.append(wdg.tag)
-                if geometry.dict().get('use_TSA', False):
+                if geometry.model_dump().get('use_TSA', False):
                     # Bare edges
                     for line in ['l', 'i', 'o', 'h']:
                         self.rm.induced[wdg.group].surf_in.names.append(wdg_name + line)
@@ -1031,30 +1028,30 @@ class Mesh:
                                 self.rm.thin_shells.second_group_is_next['radially'].append(line_tag)
                     elif not wdg.mid_layer_lines.outer:
                         self.rm.thin_shells.second_group_is_next['radially'].append(wdg.lines['o'])
-            if geometry.dict().get('use_TSA', False):
+            if geometry.model_dump().get('use_TSA', False):
                 for group in ['r1_a1', 'r2_a1', 'r1_a2', 'r2_a2']:
                     unique_thin_shells.extend(self.rm.induced[group].surf_out.numbers)
 
         # Unique mid layers
-        if geometry.dict().get('use_TSA', False):
+        if geometry.model_dump().get('use_TSA', False):
             self.rm.thin_shells.mid_turns_layers_poles = list(set(unique_thin_shells))
 
         # Insulation
         for group_name, surface in pg.insulations.surfaces.items():
             self.rm.insulator.vol.names.append('ins' + group_name)
             self.rm.insulator.vol.numbers.append(surface)
-        if 'insulation' in mesh.dict() and 'TSA' in mesh.dict()["insulation"]:
+        if 'insulation' in mesh.model_dump() and 'TSA' in mesh.model_dump()["insulation"]:
             for group_name, curve in pg.insulations.curves.items():
                 self.rm.insulator.surf.names.append('ins' + group_name)
                 self.rm.insulator.surf.numbers.append(curve)
 
         # Iron
         for group_name, surface in pg.iron.surfaces.items():
-            self.rm.iron.vol.names.append(group_name)
-            self.rm.iron.vol.numbers.append(surface)
+            self.rm.iron_yoke.vol.names.append(group_name)
+            self.rm.iron_yoke.vol.numbers.append(surface)
 
         # Boundary conditions
-        if 'insulation' in mesh.dict() and 'TSA' in mesh.dict()["insulation"]:
+        if 'insulation' in mesh.model_dump() and 'TSA' in mesh.model_dump()["insulation"]:
             # Initialize lists
             for bc_data, bc_rm in zip(self.data.magnet.solve.thermal.overwrite_boundary_conditions, self.rm.boundaries.thermal):  # b.c. type
                 bc_rm[1].bc.names = []
@@ -1091,7 +1088,7 @@ class Mesh:
             bc_rm = {'Robin': self.rm.boundaries.thermal.cooling, 'Neumann': self.rm.boundaries.thermal.heat_flux}
             bnd_list_names = {'Robin': [], 'Neumann': []}
             bnd_list_numbers = {'Robin': [], 'Neumann': []}
-            if geometry.dict().get('use_TSA', False):
+            if geometry.model_dump().get('use_TSA', False):
                 # Half turn boundaries
                 for coil_nr, coil in self.md.geometries.coil.anticlockwise_order.coils.items():
                     for lyr_nr, orders in coil.layers.items():
@@ -1147,7 +1144,7 @@ class Mesh:
                 for _, bc in bc_data[1].items():  # all boundary conditions of one b.c. type (e.g., Dirichlet with different temperatures)
                     bnd_list_names = []
                     bnd_list_numbers = []
-                    if geometry.dict().get('use_TSA', False):
+                    if geometry.model_dump().get('use_TSA', False):
                         for bnd in bc.boundaries:  # all boundaries of one boundary condition
                             if bnd[0] == 'w':
                                 if not geometry.with_wedges:

fiqus/parsers/ParserDAT.py

@@ -1,16 +1,16 @@
-import pandas as pd
-
-
-class ParserDAT:
-
-    def __init__(self, dat_file_path):
-        """
-        Read dat file and returns its content as object attribute .pqv (postprocessed quantity value) that is a float
-        :param dat_file_path: Full path to .pos file, including file name and extension.
-        :return: nothing, keeps attribute pqv (postprocessed quantity value)
-        """
-        pqn = 'pqn'  # postprocessed quantity name
-        delimiter = ' '
-        columns = ['NaN', pqn]
-        df = pd.read_csv(dat_file_path, delimiter=delimiter, header=None, engine='python', names=columns, skipinitialspace=True)
-        self.pqv = float(df[pqn][0])
+import pandas as pd
+
+
+class ParserDAT:
+
+    def __init__(self, dat_file_path):
+        """
+        Read dat file and returns its content as object attribute .pqv (postprocessed quantity value) that is a float
+        :param dat_file_path: Full path to .pos file, including file name and extension.
+        :return: nothing, keeps attribute pqv (postprocessed quantity value)
+        """
+        pqn = 'pqn'  # postprocessed quantity name
+        delimiter = ' '
+        columns = ['NaN', pqn]
+        df = pd.read_csv(dat_file_path, delimiter=delimiter, header=None, engine='python', names=columns, skipinitialspace=True)
+        self.pqv = float(df[pqn][0])