fiqus 2025.1.1__py3-none-any.whl → 2025.10.0__py3-none-any.whl

fiqus/data/RegionsModelFiQuS.py

@@ -1,5 +1,5 @@
 from pydantic import BaseModel
-from typing import List, Dict, Union, Optional
+from typing import List, Dict, Union, Optional, Literal
 
 
 class Region(BaseModel):
@@ -12,86 +12,61 @@ class Regions(BaseModel):
     numbers: Optional[List[int]] = None
 
 
-class TwoParBoundaryRegions(BaseModel):
+class Regions2(BaseModel):
     names: Optional[List[List[str]]] = None
     numbers: Optional[List[List[int]]] = None
+
+
+class TwoParBoundaryRegions(Regions2):
     values: Optional[List[List[Union[float, str]]]] = None
 
 
-class OneParBoundaryRegions(BaseModel):
-    names: Optional[List[List[str]]] = None
-    numbers: Optional[List[List[int]]] = None
-    value: Optional[List[float]] = None
+class TwoParBoundaryRegions2(Regions):
+    values: Optional[List[Union[float, str]]] = None
 
 
-class PoweredRegions(BaseModel):
-    names: Optional[List[str]] = None
-    numbers: Optional[List[int]] = None
-    currents: Optional[List[float]] = None
+class OneParBoundaryRegions(Regions2):
+    value: Optional[List[float]] = None
+
+class InducedRegions(Regions):
     sigmas: Optional[List[float]] = None
     mu_rs: Optional[List[float]] = None
 
 
-class InducedRegions(BaseModel):
-    names: Optional[List[str]] = None
-    numbers: Optional[List[int]] = None
-    sigmas: Optional[List[float]] = None
-    mu_rs: Optional[List[float]] = None
+class PoweredRegions(InducedRegions):
+    currents: Optional[List[float]] = None
 
 
-class InsulatorRegions(BaseModel):
-    names: Optional[List[str]] = None
-    numbers: Optional[List[int]] = None
-    sigmas: Optional[List[float]] = None
-    mu_rs: Optional[List[float]] = None
+class InsulatorRegions(InducedRegions):
+    pass # duplicate class
 
 
-class IronRegions(BaseModel):
-    names: Optional[List[str]] = None
-    numbers: Optional[List[int]] = None
-    sigmas: Optional[List[float]] = None
-    mu_rs: Optional[List[float]] = None
+class IronRegions(InducedRegions):
+    pass # duplicate class
 
 
-class AirRegion(BaseModel):
-    name: Optional[str] = None
-    number: Optional[int] = None
+class AirRegion(Region):
     sigma: Optional[float] = None
     mu_r: Optional[float] = None
 
 
-class AirFarFieldRegions(BaseModel):
-    names: Optional[List[str]] = None
-    numbers: Optional[List[int]] = None
+class AirFarFieldRegions(Regions):
     radius_in: Optional[float] = None
     radius_out: Optional[float] = None
 
 
-class NonPermeableSourceRegion(BaseModel):
-    name: Optional[str] = None
-    number: Optional[int] = None
-    sigma: Optional[float] = None
-    mu_r: Optional[float] = None
+class NonPermeableSourceRegion(AirRegion):
+    pass # duplicate class
 
 
-class SourceFreeRegion(BaseModel):
-    name: Optional[str] = None
-    number: Optional[int] = None
-    sigma: Optional[float] = None
-    mu_r: Optional[float] = None
+class SourceFreeRegion(AirRegion):
+    pass # duplicate class
 
 
-class Powered(BaseModel):
-    vol: PoweredRegions = PoweredRegions()  # volume region
-    vol_in: Region = Region()  # input terminal volume region
-    vol_out: Region = Region()  # input terminal volume region
-    conductors: Dict[str, List[str]] = {}  # conductor types
+class Iron(BaseModel):
+    vol: IronRegions = IronRegions()  # volume region
     surf: Regions = Regions()  # surface region
-    surf_th: Regions = Regions()  # surface region
-    surf_in: Regions = Regions()  # input terminal surface region
-    surf_out: Regions = Regions()  # output terminal surface region
-    cochain: Regions = Regions()  # winding cochain (cut)
-    curve: Regions = Regions()  # powered volumes lines
+    curves: Dict[str, List[str]] = {}  # curves region
 
 
 class Induced(BaseModel):
@@ -101,16 +76,17 @@ class Induced(BaseModel):
     surf_out: Regions = Regions()  # output terminal surface region
     cochain: Regions = Regions()  # winding cochain (cut)
 
-
 class Insulator(BaseModel):
     vol: InsulatorRegions = InsulatorRegions()  # volume region
     surf: Regions = Regions()  # surface region
     curve: Regions = Regions()  # curve region
 
-
-class Iron(BaseModel):
-    vol: IronRegions = IronRegions()  # volume region
-    surf: Regions = Regions()  # surface region
+class Powered(Induced, Insulator):
+    vol: PoweredRegions = PoweredRegions()  # volume region
+    vol_in: Region = Region()  # input terminal volume region
+    vol_out: Region = Region()  # output terminal volume region
+    conductors: Dict[str, List[str]] = {}  # conductor types
+    surf_insul: Regions = Regions()  # turn-to-turn insulation surfaces
 
 
 class Air(BaseModel):
@@ -135,26 +111,27 @@ class SourceFree(BaseModel):
     vol: SourceFreeRegion = SourceFreeRegion()  # volume region
     surf: Region = Region()  # surface region
 
+class RobinCondition_collar(BaseModel):
+    bc: TwoParBoundaryRegions2 = TwoParBoundaryRegions2()
 
-class RobinCondition(BaseModel):
+class RobinCondition_grouped(BaseModel):
     bc: TwoParBoundaryRegions = TwoParBoundaryRegions()
     groups: Dict[str, List[int]] = {}
 
-
-class NeumannCondition(BaseModel):
+class NeumannCondition_grouped(BaseModel):
     bc: OneParBoundaryRegions = OneParBoundaryRegions()
     groups: Dict[str, List[int]] = {}
 
-
-class DirichletCondition(BaseModel):
+class DirichletCondition_grouped(BaseModel):
     bc: OneParBoundaryRegions = OneParBoundaryRegions()
     groups: Dict[str, List[int]] = {}
 
 
 class ThermalBoundaryConditions(BaseModel):
-    temperature: DirichletCondition = DirichletCondition()
-    heat_flux: NeumannCondition = NeumannCondition()
-    cooling: RobinCondition = RobinCondition()
+    temperature: DirichletCondition_grouped = DirichletCondition_grouped()
+    heat_flux: NeumannCondition_grouped = NeumannCondition_grouped()
+    cooling: RobinCondition_grouped = RobinCondition_grouped()
+    collar: RobinCondition_collar = RobinCondition_collar()
 
 
 class SymmetryBoundaryConditions(BaseModel):
@@ -172,19 +149,27 @@ class InsulationType(BaseModel):
     thin_shells: List[List[int]] = []
     layers_material: List[List[str]] = []
     thicknesses: List[List[float]] = []
+    correction_factors: List[float] = [] # same correction factor per group. Can be used to scale the thin shell length
     label: List[List[Union[int, None]]] = (
         []
     )  # useful to indicate which quench heater a SS element refers to
 
 
 class ThinShell(BaseModel):
-    groups: Dict[str, List[int]] = {}
-    mid_turns_layers_poles: Optional[List[int]] = None
+    groups: Dict[str, List[int]] = {} # -> Checkboard convention of the hts
+    mid_turns_layers_poles: Optional[List[int]] = None # indices of midlayers between HT, layers and poles
+    ts_collar_groups: Dict[str, List[int]] = {} # groups of mid collar thin shells -> Checkboard convention
+    ts_pole_groups: Dict[str, List[int]] = {} # groups of mid collar thin shells -> Checkboard convention
+
     second_group_is_next: Dict[str, List[int]] = {}
     normals_directed: Dict[str, List[int]] = {}
-    insulation_types: InsulationType = InsulationType()
-    quench_heaters: InsulationType = InsulationType()
+    bdry_curves: Dict[Literal["collar", "poles", "outer_collar"], List[int]] = {} # save the boundary curves of a specific region, used in TSA
 
+    # insulation types, only mid layers
+    insulation_types: InsulationType = InsulationType() # todo: merge all types into one @emma, consider dict ?
+    quench_heaters: InsulationType = InsulationType()
+    collar: InsulationType = InsulationType()
+    poles: InsulationType = InsulationType()
 
 class PostProc(BaseModel):
     vol: Regions = Regions()  # postprocessing volumes general
@@ -194,47 +179,19 @@ class PostProc(BaseModel):
 
 
 class RegionsModel(BaseModel):
-    powered: Dict[str, Powered] = {}
-    induced: Dict[str, Induced] = {}
+    powered: Dict[str, Powered] = {} #coils
+    induced: Dict[str, Induced] = {} #wedges
     insulator: Insulator = Insulator()
-    iron: Iron = Iron()
+    iron_yoke: Iron = Iron() # iron yoke
+    collar: Iron = Iron() # collar is a type of iron region
+    ref_mesh: Iron = Iron()  # reference mesh
+    poles: Iron = Iron()  # poles
+
     air: Air = Air()
     air_far_field: AirFarField = AirFarField()
-    thin_shells: ThinShell = ThinShell()
+    thin_shells: ThinShell = ThinShell() # Includes collar thin shells
     projection_points: Region = Region()
     boundaries: BoundaryConditions = BoundaryConditions()
     postproc_th: PostProc = PostProc()
     postproc_em: PostProc = PostProc()
 
-
-# if __name__ == "__main__":
-#     write = True
-#     read = False
-#
-#     def read_regions(regions_file_name):
-#         with open(regions_file_name, 'r') as stream:
-#             yaml_str = ruamel.yaml.safe_load(stream)
-#         return RegionsModel(**yaml_str)
-#
-#     def flist(x):
-#         retval = ruamel.yaml.comments.CommentedSeq(x)
-#         retval.fa.set_flow_style()  # fa -> format attribute
-#         return retval
-#
-#     if write:
-#         model = RegionsModel()
-#         model.powered.vol = [1, 2]
-#         data_dict = model.dict()
-#         yaml = ruamel.yaml.YAML()
-#         yaml.default_flow_style = False
-#         yaml.emitter.alt_null = 'Null'
-#
-#         def my_represent_none(self, data):
-#             return self.represent_scalar('tag:yaml.org,2002:null', 'null')
-#
-#         yaml.representer.add_representer(type(None), my_represent_none)
-#         with open('cct_regions_empty.yaml', 'w') as yaml_file:
-#             yaml.dump(model.dict(), yaml_file)
-#     if read:
-#         regions_file_name = 'cct1_regions_manual.yaml'
-#         regions = read_regions(regions_file_name)