fiqus 2024.7.0__py3-none-any.whl → 2024.12.1__py3-none-any.whl

fiqus/data/DataMultipole.py

@@ -1,5 +1,5 @@
 from pydantic import BaseModel
-from typing import (Dict, List, Optional)
+from typing import Dict, List, Tuple, Optional
 
 
 class Coord(BaseModel):
@@ -13,13 +13,27 @@ class Area(BaseModel):
 
 
 class Region(BaseModel):
-    points: Dict[str | int, int] = {}
-    lines: Dict[str | int, int] = {}
-    areas: Dict[str | int, Area] = {}
+    points: Dict[str, int] = {}
+    lines: Dict[str, int] = {}
+    areas: Dict[str, Area] = {}
+
+
+# class CableInsulated(BaseModel):
+#     type: #Literal['Insulated']
+#     insulated: Region = Region()
+#
+#
+# class CableBare(BaseModel):
+#     type: #Literal['Bare']
+#     bare: Region = Region()
+#     insulation: Region = Region()
 
 
 class BlockData(BaseModel):
-    half_turns: Region = Region()
+    half_turns: Region = (
+        Region()
+    )  # Union[CableInsulated, CableBare] = {'type': 'Insulated'}
+    insulation: Region = Region()
     current_sign: Optional[int] = None
 
 
@@ -39,14 +53,10 @@ class Layer(BaseModel):
 
 class Pole(BaseModel):
     poles: Dict[int, Layer] = {}
+    type: Optional[str] = None
     bore_center: Coord = Coord()
 
 
-class Iron(BaseModel):
-    quadrants: Dict[int, Region] = {}
-    max_radius: float = 0.
-
-
 class Order(BaseModel):
     coil: Optional[int] = None
     pole: Optional[int] = None
@@ -55,28 +65,165 @@ class Order(BaseModel):
     block: Optional[int] = None
 
 
+class AnticlockwiseOrder(BaseModel):
+    pole: Optional[int] = None
+    winding: Optional[int] = None
+    block: Optional[int] = None
+
+
+class MidLayer(BaseModel):
+    half_turn_lists: Dict[str, List[int]] = {}
+    point_angles: Dict[str, float] = {}
+    mid_layers: Region = Region()
+
+
+class Iron(BaseModel):
+    quadrants: Dict[int, Region] = {}
+    max_radius: float = 0.0
+
+
+class LayerOrder(BaseModel):
+    layers: Dict[int, List[AnticlockwiseOrder]] = {}
+
+
+class CoilOrder(BaseModel):
+    coils: Dict[int, LayerOrder] = {}
+
+
 class Coil(BaseModel):
     coils: Dict[int, Pole] = {}
-    electrical_order: List[Order] = []
+    physical_order: List[Order] = []
+    anticlockwise_order: CoilOrder = CoilOrder()
+    concentric_coils: Dict[Tuple[float, float], List[int]] = {}
+    max_radius: float = 0.0
+
+
+class InsulationThickness(BaseModel):
+    mid_pole: Dict[str, float] = {}
+    mid_layer: Dict[str, float] = {}
+    mid_winding: Dict[str, float] = {}
+
+
+class ThinShell(BaseModel):
+    mid_layers_ht_to_ht: Dict[str, MidLayer] = {}
+    mid_layers_wdg_to_ht: Dict[str, Region] = {}
+    mid_layers_ht_to_wdg: Dict[str, Region] = {}
+    mid_layers_wdg_to_wdg: Dict[str, Region] = {}
+    mid_poles: Dict[str, Region] = {}
+    mid_windings: Dict[str, Region] = {}
+    mid_turn_blocks: Dict[str, Region] = {}
+    mid_wedge_turn: Dict[str, Region] = {}
+    mid_layers_aux: Dict[str, Region] = {}
+    ins_thickness: InsulationThickness = InsulationThickness()
+
+
+class WedgeRegion(BaseModel):
+    wedges: Dict[int, Region] = {}
+    block_prev: Dict[int, int] = {}
+    block_next: Dict[int, int] = {}
+
+
+class WedgeLayer(BaseModel):
+    layers: Dict[int, WedgeRegion] = {}
+
+
+class Wedge(BaseModel):
+    coils: Dict[int, WedgeLayer] = {}
+
+
+class InsulationRegion(BaseModel):
+    ins: Region = Region()
+    blocks: List[List[int]] = []
+    wedges: List[List[int]] = []
+
+
+class InsulationGroup(BaseModel):
+    group: Dict[int, InsulationRegion] = {}
+
+
+class Insulation(BaseModel):
+    coils: Dict[int, InsulationGroup] = {}
 
 
 class Geometry(BaseModel):
     coil: Coil = Coil()
     iron: Iron = Iron()
-    wedges: Region = Region()
+    wedges: Wedge = Wedge()
     air: Region = Region()
     air_inf: Region = Region()
+    symmetric_boundaries: Region = Region()
+    thin_shells: ThinShell = ThinShell()
+    insulation: Insulation = Insulation()
+
+
+# Domain classes #
+class MidLayerLine(BaseModel):
+    inner: Dict[str, int] = {}
+    outer: Dict[str, int] = {}
 
 
 class GroupType(BaseModel):
     curves: Dict[str, int] = {}
     surfaces: Dict[str, int] = {}
-    volumes: Dict[str, int] = {}
+
+
+class PoweredGroup(BaseModel):
+    tag: Optional[int] = None
+    group: Optional[str] = None
+    lines: Dict[str, int] = {}
+    mid_layer_lines: MidLayerLine = MidLayerLine()
+    mid_pole_lines: Dict[str, int] = {}
+    mid_winding_lines: Dict[str, int] = {}
+    mid_turn_lines: Dict[str, int] = {}
+    aux_lines: Dict[str, int] = {}
+
+
+class WedgeGroup(BaseModel):
+    tag: Optional[int] = None
+    group: Optional[str] = None
+    lines: Dict[str, int] = {}
+    mid_layer_lines: MidLayerLine = MidLayerLine()
+    mid_turn_lines: Dict[str, int] = {}
+    aux_lines: Dict[str, int] = {}
+
+
+class PoweredBlock(BaseModel):
+    half_turns: Dict[int, PoweredGroup] = {}
+    current_sign: Optional[int] = None
+    conductor: Optional[str] = None
+
+
+class SymmetryGroup(BaseModel):
+    normal_free: Optional[int] = None
+    tangential_free: Optional[int] = None
+
+
+class PhysicalGroup(BaseModel):
+    blocks: Dict[int, PoweredBlock] = {}
+    wedges: Dict[int, WedgeGroup] = {}
+    insulations: GroupType = GroupType()
+    iron: GroupType = GroupType()
+    air_inf: Optional[int] = None
+    air_inf_bnd: Optional[int] = None
+    air: Optional[int] = None
+    symmetric_boundaries: SymmetryGroup = SymmetryGroup()
+    half_turns_points: Optional[int] = None
+
+
+class SymmetryBoundaries(BaseModel):
+    x: List[int] = []
+    y: List[int] = []
+
+
+class GroupEntities(BaseModel):
+    iron: Dict[str, List[int]] = {}
+    air: List[int] = []
+    symmetric_boundaries: SymmetryBoundaries = SymmetryBoundaries()
 
 
 class Domain(BaseModel):
-    groups_surfaces: Dict[str, List[int]] = {}
-    physical_groups: GroupType = GroupType()
+    groups_entities: GroupEntities = GroupEntities()
+    physical_groups: PhysicalGroup = PhysicalGroup()
 
 
 class MultipoleData(BaseModel):
@@ -84,6 +231,24 @@ class MultipoleData(BaseModel):
     domains: Domain = Domain()
 
 
+#######################################
+
+
+class NeighbourNode(BaseModel):
+    groups: Dict[str, List[float]] = {}
+
+
+class IsothermalNodes(BaseModel):
+    conductors: Dict[str, Dict[int, List[float]]] = {}
+    wedges: Dict[str, Dict[int, List[float]]] = {}
+    thin_shells: Dict[int, List[float]] = {}
+
+
+class MultipoleRegionCoordinate(BaseModel):
+    isothermal_nodes: IsothermalNodes = IsothermalNodes()
+    neighbouring_nodes: NeighbourNode = NeighbourNode()
+
+
 # if __name__ == "__main__":
 #     write = True
 #     read = False

fiqus/data/DataRoxieParser.py

@@ -1,11 +1,12 @@
 from pydantic import BaseModel
-from typing import (Dict, List, Optional)
+from typing import Dict, List, Optional
 
 
 class Coord(BaseModel):
     """
-        Class for coordinates
+    Class for coordinates
     """
+
     x: Optional[float] = None
     y: Optional[float] = None
     z: Optional[float] = None
@@ -13,31 +14,35 @@ class Coord(BaseModel):
 
 class Roll(BaseModel):
     """
-        Class for roll2 transformation
+    Class for roll2 transformation
     """
+
     coor: Coord = Coord()
     alph: Optional[float] = None
 
 
 class HyperHole(BaseModel):
     """
-        Class for hyper holes
+    Class for hyper holes
     """
+
     areas: List[str] = []
 
 
 class HyperArea(BaseModel):
     """
-        Class for hyper areas
+    Class for hyper areas
     """
+
     material: Optional[str] = None
     lines: List[str] = []
 
 
 class HyperLine(BaseModel):
     """
-        Class for hyper lines: lines, arcs, elliptic arcs, circles
+    Class for hyper lines: lines, arcs, elliptic arcs, circles
     """
+
     type: Optional[str] = None
     kp1: Optional[str] = None
     kp2: Optional[str] = None
@@ -49,8 +54,9 @@ class HyperLine(BaseModel):
 
 class CondPar(BaseModel):
     """
-        Class for conductor parameters
+    Class for conductor parameters
     """
+
     wInsulNarrow: Optional[float] = None
     wInsulWide: Optional[float] = None
     dFilament: Optional[float] = None
@@ -84,8 +90,9 @@ class CondPar(BaseModel):
 
 class Conductor(BaseModel):
     """
-        Class for conductor type
+    Class for conductor type
     """
+
     conductorType: Optional[int] = None
     cableGeom: Optional[str] = None
     strand: Optional[str] = None
@@ -100,8 +107,9 @@ class Conductor(BaseModel):
 
 class Cable(BaseModel):
     """
-        Class for cable parameters
+    Class for cable parameters
     """
+
     height: Optional[float] = None
     width_i: Optional[float] = None
     width_o: Optional[float] = None
@@ -113,8 +121,9 @@ class Cable(BaseModel):
 
 class Quench(BaseModel):
     """
-        Class for quench parameters
+    Class for quench parameters
     """
+
     SCHeatCapa: Optional[float] = None
     CuHeatCapa: Optional[float] = None
     CuThermCond: Optional[float] = None
@@ -128,8 +137,9 @@ class Quench(BaseModel):
 
 class Transient(BaseModel):
     """
-        Class for transient parameters
+    Class for transient parameters
     """
+
     Rc: Optional[float] = None
     Ra: Optional[float] = None
     filTwistp: Optional[float] = None
@@ -141,8 +151,9 @@ class Transient(BaseModel):
 
 class Strand(BaseModel):
     """
-        Class for strand parameters
+    Class for strand parameters
     """
+
     diam: Optional[float] = None
     cu_sc: Optional[float] = None
     RRR: Optional[float] = None
@@ -155,8 +166,9 @@ class Strand(BaseModel):
 
 class Filament(BaseModel):
     """
-        Class for filament parameters
+    Class for filament parameters
     """
+
     fildiao: Optional[float] = None
     fildiai: Optional[float] = None
     Jc_fit: Optional[str] = None
@@ -166,8 +178,9 @@ class Filament(BaseModel):
 
 class Insulation(BaseModel):
     """
-        Class for insulation parameters
+    Class for insulation parameters
     """
+
     radial: Optional[float] = None
     azimut: Optional[float] = None
     comment: Optional[str] = None
@@ -175,8 +188,9 @@ class Insulation(BaseModel):
 
 class Block(BaseModel):
     """
-        Class for block list
+    Class for block list
     """
+
     type: Optional[int] = None
     nco: Optional[int] = None
     radius: Optional[float] = None
@@ -198,8 +212,9 @@ class Block(BaseModel):
 
 class Group(BaseModel):
     """
-        Class for group list
+    Class for group list
     """
+
     symm: Optional[int] = None
     typexy: Optional[int] = None
     blocks: List[int] = []  # map
@@ -207,8 +222,9 @@ class Group(BaseModel):
 
 class Trans(BaseModel):
     """
-        Class for transformation list
+    Class for transformation list
     """
+
     x: Optional[float] = None
     y: Optional[float] = None
     alph: Optional[float] = None
@@ -220,8 +236,9 @@ class Trans(BaseModel):
 
 class Iron(BaseModel):
     """
-        Class for the iron yoke data
+    Class for the iron yoke data
     """
+
     key_points: Dict[str, Coord] = {}
     hyper_lines: Dict[str, HyperLine] = {}
     hyper_areas: Dict[str, HyperArea] = {}
@@ -230,8 +247,9 @@ class Iron(BaseModel):
 
 class Cadata(BaseModel):
     """
-        Class for the conductor data
+    Class for the conductor data
     """
+
     insul: Dict[str, Insulation] = {}
     filament: Dict[str, Filament] = {}
     strand: Dict[str, Strand] = {}
@@ -243,8 +261,9 @@ class Cadata(BaseModel):
 
 class Coil(BaseModel):
     """
-        Class for the coil data
+    Class for the coil data
     """
+
     blocks: Dict[str, Block] = {}
     groups: Dict[str, Group] = {}
     transs: Dict[str, Trans] = {}
@@ -252,67 +271,91 @@ class Coil(BaseModel):
 
 class StrandGroup(BaseModel):
     """
-        Class for strand group
+    Class for strand group
     """
+
     strand_positions: Dict[int, Coord] = {}
 
 
 class Corner(BaseModel):
     """
-        Class for corner positions
+    Class for corner positions
     """
-    iL: Coord = Coord()  # inner left
-    iR: Coord = Coord()  # inner right
-    oL: Coord = Coord()  # outer left
-    oR: Coord = Coord()  # outer right
+
+    iH: Coord = Coord()  # inner left
+    iL: Coord = Coord()  # inner right
+    oH: Coord = Coord()  # outer left
+    oL: Coord = Coord()  # outer right
 
 
 class HalfTurnCorner(BaseModel):
     """
-        Class for corner type
+    Class for corner type
     """
+
     insulated: Corner = Corner()
     bare: Corner = Corner()
 
 
 class HalfTurn(BaseModel):
     """
-        Class for half-turn data
+    Class for half-turn data
     """
+
     corners: HalfTurnCorner = HalfTurnCorner()
     strand_groups: Dict[int, StrandGroup] = {}
 
 
+class Order(BaseModel):
+    """
+    Class for electrical order (block location)
+    """
+
+    coil: Optional[int] = None
+    pole: Optional[int] = None
+    layer: Optional[int] = None
+    winding: Optional[int] = None
+    block: Optional[int] = None
+
+
 class CenterShift(BaseModel):
     """
-        Class for bore center shift
+    Class for bore center shift
     """
+
     inner: Coord = Coord()
     outer: Coord = Coord()
 
 
 class Wedge(BaseModel):
     """
-        Class for wedge positions
+    Class for wedge positions
     """
+
     corners: Corner = Corner()
+    corners_ins: Corner = Corner()
     corrected_center: CenterShift = CenterShift()
-    coil: Optional[int] = None
+    corrected_center_ins: CenterShift = CenterShift()
+    order_l: Order = Order()
+    order_h: Order = Order()
 
 
 class BlockData(BaseModel):
     """
-        Class for block data
+    Class for block data
     """
+
     block_corners: Corner = Corner()
+    block_corners_ins: Corner = Corner()
     current_sign: Optional[int] = None
     half_turns: Dict[int, HalfTurn] = {}
 
 
 class WindingData(BaseModel):
     """
-        Class for winding data
+    Class for winding data
     """
+
     blocks: Dict[int, BlockData] = {}
     conductor_name: Optional[str] = None
     conductors_number: Optional[int] = None
@@ -320,57 +363,53 @@ class WindingData(BaseModel):
 
 class Winding(BaseModel):
     """
-        Class for windings
+    Class for windings
     """
+
     windings: Dict[int, WindingData] = {}
 
 
 class Layer(BaseModel):
     """
-        Class for winding layers
+    Class for winding layers
     """
+
     layers: Dict[int, Winding] = {}
 
 
 class Pole(BaseModel):
     """
-        Class for poles
+    Class for poles
     """
+
     poles: Dict[int, Layer] = {}
+    type: Optional[str] = None
     bore_center: Coord = Coord()
 
 
-class Order(BaseModel):
-    """
-        Class for electrical order (block location)
-    """
-    coil: Optional[int] = None
-    pole: Optional[int] = None
-    layer: Optional[int] = None
-    winding: Optional[int] = None
-    block: Optional[int] = None
-
-
 class CoilData(BaseModel):
     """
-        Class for coils
+    Class for coils
     """
+
     coils: Dict[int, Pole] = {}
-    electrical_order: List[Order] = []
+    physical_order: List[Order] = []
 
 
 class RoxieRawData(BaseModel):
     """
-        Class for the raw data
+    Class for the raw data
     """
+
     cadata: Cadata = Cadata()
     coil: Coil = Coil()
 
 
 class RoxieData(BaseModel):
     """
-        Class for the roxie parser
+    Class for the roxie parser
     """
+
     iron: Iron = Iron()
     coil: CoilData = CoilData()
     wedges: Dict[int, Wedge] = {}