Coverage for fiqus/data/DataMultipole.py: 100%

1from pydantic import BaseModel 

2from typing import Dict, List, Tuple, Optional 

3 

4 

5class Coord(BaseModel): 

6 x: Optional[float] = None 

7 y: Optional[float] = None 

8 

9 

10class Area(BaseModel): 

11 loop: Optional[int] = None 

12 surface: Optional[int] = None 

13 

14 

15class Region(BaseModel): 

16 points: Dict[str, int] = {} 

17 lines: Dict[str, int] = {} 

18 areas: Dict[str, Area] = {} 

19 

20# class CableInsulated(BaseModel): 

21# type: #Literal['Insulated'] 

22# insulated: Region = Region() 

23# 

24# 

25# class CableBare(BaseModel): 

26# type: #Literal['Bare'] 

27# bare: Region = Region() 

28# insulation: Region = Region() 

29 

30 

31class BlockData(BaseModel): 

32 half_turns: Region = ( 

33 Region() 

34 ) # Union[CableInsulated, CableBare] = {'type': 'Insulated'} 

35 insulation: Region = Region() 

36 current_sign: Optional[int] = None 

37 

38 

39class Block(BaseModel): 

40 blocks: Dict[int, BlockData] = {} 

41 conductor_name: Optional[str] = None 

42 conductors_number: Optional[int] = None 

43 

44 

45class Winding(BaseModel): 

46 windings: Dict[int, Block] = {} 

47 

48 

49class Layer(BaseModel): 

50 layers: Dict[int, Winding] = {} 

51 

52 

53class Pole(BaseModel): 

54 poles: Dict[int, Layer] = {} 

55 type: Optional[str] = None 

56 bore_center: Coord = Coord() 

57 

58 

59class Order(BaseModel): 

60 coil: Optional[int] = None 

61 pole: Optional[int] = None 

62 layer: Optional[int] = None 

63 winding: Optional[int] = None 

64 block: Optional[int] = None 

65 

66 

67class AnticlockwiseOrder(BaseModel): 

68 pole: Optional[int] = None 

69 winding: Optional[int] = None 

70 block: Optional[int] = None 

71 

72 

73class MidLayer(BaseModel): 

74 half_turn_lists: Dict[str, List[int]] = {} 

75 point_angles: Dict[str, float] = {} 

76 mid_layers: Region = Region() 

77 

78class BaseIron(BaseModel): 

79 quadrants: Dict[int, Region] = {} 

80 

81class Iron(BaseIron): 

82 max_radius: float = 0.0 

83 

84class Collar(BaseIron): 

85 inner_boundary_tags: Dict[int, List[int]] = {} # separated per quadrant 

86 cooling_tags: List[int] = [] # all tags 

87 outer_boundary_tags: Dict[int, List[int]] = {} # separated per quadrant 

88 

89class LayerOrder(BaseModel): 

90 layers: Dict[int, List[AnticlockwiseOrder]] = {} 

91 

92 

93class CoilOrder(BaseModel): 

94 coils: Dict[int, LayerOrder] = {} 

95 

96 

97class Coil(BaseModel): 

98 coils: Dict[int, Pole] = {} 

99 physical_order: List[Order] = [] 

100 anticlockwise_order: CoilOrder = CoilOrder() 

101 concentric_coils: Dict[Tuple[float, float], List[int]] = {} 

102 max_radius: float = 0.0 

103 

104 

105class InsulationThickness(BaseModel): 

106 mid_pole: Dict[str, float] = {} 

107 mid_layer: Dict[str, float] = {} 

108 mid_winding: Dict[str, float] = {} 

109 collar: Dict[str, float] = {} 

110 poles: Dict[str, float] = {} 

111 

112class ThinShell(BaseModel): 

113 mid_layers_ht_to_ht: Dict[str, MidLayer] = {} 

114 mid_layers_wdg_to_ht: Dict[str, Region] = {} 

115 mid_layers_ht_to_wdg: Dict[str, Region] = {} 

116 mid_layers_wdg_to_wdg: Dict[str, Region] = {} 

117 mid_poles: Dict[str, Region] = {} 

118 mid_windings: Dict[str, Region] = {} 

119 mid_turn_blocks: Dict[str, Region] = {} 

120 mid_wedge_turn: Dict[str, Region] = {} 

121 mid_layers_aux: Dict[str, Region] = {} 

122 collar_layers: Dict[str, Region] = {} 

123 pole_layers: Dict[str, Region] = {} 

124 ins_thickness: InsulationThickness = InsulationThickness() 

125 

126 

127class WedgeRegion(BaseModel): 

128 wedges: Dict[int, Region] = {} 

129 block_prev: Dict[int, int] = {} 

130 block_next: Dict[int, int] = {} 

131 

132 

133class WedgeLayer(BaseModel): 

134 layers: Dict[int, WedgeRegion] = {} 

135 

136 

137class Wedge(BaseModel): 

138 coils: Dict[int, WedgeLayer] = {} 

139 

140 

141class InsulationRegion(BaseModel): 

142 ins: Region = Region() 

143 blocks: List[List[int]] = [] 

144 wedges: List[List[int]] = [] 

145 

146 

147class InsulationGroup(BaseModel): 

148 group: Dict[int, InsulationRegion] = {} 

149 

150 

151class Insulation(BaseModel): 

152 coils: Dict[int, InsulationGroup] = {} 

153 

154 

155class Geometry(BaseModel): 

156 coil: Coil = Coil() 

157 wedges: Wedge = Wedge() 

158 air: Region = Region() 

159 air_inf: Region = Region() 

160 symmetric_boundaries: Region = Region() 

161 thin_shells: ThinShell = ThinShell() 

162 insulation: Insulation = Insulation() 

163 iron_yoke: Iron = Iron() 

164 collar: Collar = Collar() 

165 poles: BaseIron = BaseIron() 

166 

167 

168# Domain classes # 

169class MidLayerLine(BaseModel): 

170 inner: Dict[str, int] = {} 

171 outer: Dict[str, int] = {} 

172 

173 

174class GroupType(BaseModel): 

175 curves: Dict[str, int] = {} 

176 surfaces: Dict[str, int] = {} 

177 

178 

179class PoweredGroup(BaseModel): 

180 tag: Optional[int] = None 

181 group: Optional[str] = None 

182 lines: Dict[str, int] = {} 

183 mid_layer_lines: MidLayerLine = MidLayerLine() 

184 mid_pole_lines: Dict[str, int] = {} 

185 mid_winding_lines: Dict[str, int] = {} 

186 mid_turn_lines: Dict[str, int] = {} 

187 aux_lines: Dict[str, int] = {} 

188 single_node: Optional[int] = None 

189 

190 

191class WedgeGroup(BaseModel): 

192 tag: Optional[int] = None 

193 group: Optional[str] = None 

194 lines: Dict[str, int] = {} 

195 mid_layer_lines: MidLayerLine = MidLayerLine() 

196 mid_turn_lines: Dict[str, int] = {} 

197 aux_lines: Dict[str, int] = {} 

198 

199 

200class PoweredBlock(BaseModel): 

201 half_turns: Dict[int, PoweredGroup] = {} 

202 current_sign: Optional[int] = None 

203 conductor: Optional[str] = None 

204 

205 

206class SymmetryGroup(BaseModel): 

207 normal_free: Optional[int] = None 

208 tangential_free: Optional[int] = None 

209 

210 

211class PhysicalGroup(BaseModel): 

212 blocks: Dict[int, PoweredBlock] = {} 

213 wedges: Dict[int, WedgeGroup] = {} 

214 insulations: GroupType = GroupType() 

215 iron_yoke: GroupType = GroupType() 

216 collar: GroupType = GroupType() 

217 poles: GroupType = GroupType() 

218 ref_mesh: GroupType = GroupType() # used for the reference mesh 

219 

220 # more PG can be added here 

221 air_inf: Optional[int] = None 

222 air_inf_bnd: Optional[int] = None 

223 air: Optional[int] = None 

224 symmetric_boundaries: SymmetryGroup = SymmetryGroup() 

225 half_turns_points: Optional[int] = None 

226 inner_col: Optional[int] = None 

227 outer_col: Optional[int] = None 

228 collar_cooling: Optional[int] = None 

229 

230class SymmetryBoundaries(BaseModel): 

231 x: List[int] = [] 

232 y: List[int] = [] 

233 

234 

235class GroupEntities(BaseModel): 

236 air: List[int] = [] 

237 iron_yoke: Dict[str, List[int]] = {} 

238 collar: Dict[str, List[int]] = {} # first str determines the material 

239 ref_mesh: Dict[str, List[int]] = {} # used for the reference mesh 

240 poles: Dict[str, List[int]] = {} 

241 # more entities can be added here 

242 symmetric_boundaries: SymmetryBoundaries = SymmetryBoundaries() 

243 

244class Domain(BaseModel): 

245 groups_entities: GroupEntities = GroupEntities() 

246 physical_groups: PhysicalGroup = PhysicalGroup() 

247 

248class MultipoleData(BaseModel): 

249 geometries: Geometry = Geometry() 

250 domains: Domain = Domain() 

251 

252 

253####################################### 

254 

255 

256class NeighbourNode(BaseModel): 

257 groups: Dict[str, List[float]] = {} 

258 

259 

260class IsothermalNodes(BaseModel): 

261 conductors: Dict[str, Dict[int, List[float]]] = {} 

262 wedges: Dict[str, Dict[int, List[float]]] = {} 

263 thin_shells: Dict[int, List[float]] = {} 

264 

265 

266class MultipoleRegionCoordinate(BaseModel): 

267 isothermal_nodes: IsothermalNodes = IsothermalNodes() 

268 neighbouring_nodes: NeighbourNode = NeighbourNode() 

269 

270 # this class stores the same information as the crns file 

271 # but at the mesh level (see https://gitlab.cern.ch/steam/steam-fiqus-dev/-/issues/95) 

272 coordinates_per_half_turn: Dict[str, List[List[float]]] = {} 

273 

274