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

1from pydantic import BaseModel 

2from typing import Dict, List, Optional 

3 

4 

5class Coord(BaseModel): 

6 """ 

7 Class for coordinates 

8 """ 

9 

10 x: Optional[float] = None 

11 y: Optional[float] = None 

12 z: Optional[float] = None 

13 

14 

15class Roll(BaseModel): 

16 """ 

17 Class for roll2 transformation 

18 """ 

19 

20 coor: Coord = Coord() 

21 alph: Optional[float] = None 

22 

23 

24class HyperHole(BaseModel): 

25 """ 

26 Class for hyper holes 

27 """ 

28 

29 areas: List[str] = [] 

30 

31 

32class HyperArea(BaseModel): 

33 """ 

34 Class for hyper areas 

35 """ 

36 

37 material: Optional[str] = None 

38 lines: List[str] = [] 

39 

40 

41class HyperLine(BaseModel): 

42 """ 

43 Class for hyper lines: lines, arcs, elliptic arcs, circles 

44 """ 

45 

46 type: Optional[str] = None 

47 kp1: Optional[str] = None 

48 kp2: Optional[str] = None 

49 kp3: Optional[str] = None 

50 arg1: Optional[float] = None 

51 arg2: Optional[float] = None 

52 elements: Optional[int] = None 

53 

54 

55class CondPar(BaseModel): 

56 """ 

57 Class for conductor parameters 

58 """ 

59 

60 wInsulNarrow: Optional[float] = None 

61 wInsulWide: Optional[float] = None 

62 dFilament: Optional[float] = None 

63 dstrand: Optional[float] = None 

64 fracCu: Optional[float] = None 

65 fracSc: Optional[float] = None 

66 RRR: Optional[float] = None 

67 TupRRR: Optional[float] = None 

68 Top: Optional[float] = None 

69 Rc: Optional[float] = None 

70 Ra: Optional[float] = None 

71 fRhoEff: Optional[float] = None 

72 lTp: Optional[float] = None 

73 wBare: Optional[float] = None 

74 hInBare: Optional[float] = None 

75 hOutBare: Optional[float] = None 

76 noOfStrands: Optional[int] = None 

77 noOfStrandsPerLayer: Optional[int] = None 

78 noOfLayers: Optional[int] = None 

79 lTpStrand: Optional[float] = None 

80 wCore: Optional[float] = None 

81 hCore: Optional[float] = None 

82 thetaTpStrand: Optional[float] = None 

83 degradation: Optional[float] = None 

84 C1: Optional[float] = None 

85 C2: Optional[float] = None 

86 fracHe: Optional[float] = None 

87 fracFillInnerVoids: Optional[float] = None 

88 fracFillOuterVoids: Optional[float] = None 

89 

90 

91class Conductor(BaseModel): 

92 """ 

93 Class for conductor type 

94 """ 

95 

96 conductorType: Optional[int] = None 

97 cableGeom: Optional[str] = None 

98 strand: Optional[str] = None 

99 filament: Optional[str] = None 

100 insul: Optional[str] = None 

101 trans: Optional[str] = None 

102 quenchMat: Optional[str] = None 

103 T_0: Optional[float] = None 

104 comment: Optional[str] = None 

105 parameters: CondPar = CondPar() 

106 

107 

108class Cable(BaseModel): 

109 """ 

110 Class for cable parameters 

111 """ 

112 

113 height: Optional[float] = None 

114 width_i: Optional[float] = None 

115 width_o: Optional[float] = None 

116 ns: Optional[float] = None 

117 transp: Optional[float] = None 

118 degrd: Optional[float] = None 

119 comment: Optional[str] = None 

120 

121 

122class Quench(BaseModel): 

123 """ 

124 Class for quench parameters 

125 """ 

126 

127 SCHeatCapa: Optional[float] = None 

128 CuHeatCapa: Optional[float] = None 

129 CuThermCond: Optional[float] = None 

130 CuElecRes: Optional[float] = None 

131 InsHeatCapa: Optional[float] = None 

132 InsThermCond: Optional[float] = None 

133 FillHeatCapa: Optional[float] = None 

134 He: Optional[float] = None 

135 comment: Optional[str] = None 

136 

137 

138class Transient(BaseModel): 

139 """ 

140 Class for transient parameters 

141 """ 

142 

143 Rc: Optional[float] = None 

144 Ra: Optional[float] = None 

145 filTwistp: Optional[float] = None 

146 filR0: Optional[float] = None 

147 fil_dRdB: Optional[float] = None 

148 strandfillFac: Optional[float] = None 

149 comment: Optional[str] = None 

150 

151 

152class Strand(BaseModel): 

153 """ 

154 Class for strand parameters 

155 """ 

156 

157 diam: Optional[float] = None 

158 cu_sc: Optional[float] = None 

159 RRR: Optional[float] = None 

160 Tref: Optional[float] = None 

161 Bref: Optional[float] = None 

162 Jc_BrTr: Optional[float] = None 

163 dJc_dB: Optional[float] = None 

164 comment: Optional[str] = None 

165 

166 

167class Filament(BaseModel): 

168 """ 

169 Class for filament parameters 

170 """ 

171 

172 fildiao: Optional[float] = None 

173 fildiai: Optional[float] = None 

174 Jc_fit: Optional[str] = None 

175 fit: Optional[str] = None 

176 comment: Optional[str] = None 

177 

178 

179class Insulation(BaseModel): 

180 """ 

181 Class for insulation parameters 

182 """ 

183 

184 radial: Optional[float] = None 

185 azimut: Optional[float] = None 

186 comment: Optional[str] = None 

187 

188 

189class Block(BaseModel): 

190 """ 

191 Class for block list 

192 """ 

193 

194 type: Optional[int] = None 

195 nco: Optional[int] = None 

196 radius: Optional[float] = None 

197 phi: Optional[float] = None 

198 alpha: Optional[float] = None 

199 current: Optional[float] = None 

200 condname: Optional[str] = None 

201 n1: Optional[int] = None 

202 n2: Optional[int] = None 

203 imag: Optional[int] = None 

204 turn: Optional[float] = None 

205 coil: Optional[int] = None 

206 pole: Optional[int] = None 

207 layer: Optional[int] = None 

208 winding: Optional[int] = None 

209 shift2: Coord = Coord() 

210 roll2: Roll = Roll() 

211 

212 

213class Group(BaseModel): 

214 """ 

215 Class for group list 

216 """ 

217 

218 symm: Optional[int] = None 

219 typexy: Optional[int] = None 

220 blocks: List[int] = [] # map 

221 

222 

223class Trans(BaseModel): 

224 """ 

225 Class for transformation list 

226 """ 

227 

228 x: Optional[float] = None 

229 y: Optional[float] = None 

230 alph: Optional[float] = None 

231 bet: Optional[float] = None 

232 string: Optional[str] = None 

233 act: Optional[int] = None 

234 bcs: List[int] = [] # map 

235 

236 

237class Iron(BaseModel): 

238 """ 

239 Class for the iron yoke data 

240 """ 

241 

242 key_points: Dict[str, Coord] = {} 

243 hyper_lines: Dict[str, HyperLine] = {} 

244 hyper_areas: Dict[str, HyperArea] = {} 

245 hyper_holes: Dict[int, HyperHole] = {} 

246 

247 

248class Cadata(BaseModel): 

249 """ 

250 Class for the conductor data 

251 """ 

252 

253 insul: Dict[str, Insulation] = {} 

254 filament: Dict[str, Filament] = {} 

255 strand: Dict[str, Strand] = {} 

256 transient: Dict[str, Transient] = {} 

257 quench: Dict[str, Quench] = {} 

258 cable: Dict[str, Cable] = {} 

259 conductor: Dict[str, Conductor] = {} 

260 

261 

262class Coil(BaseModel): 

263 """ 

264 Class for the coil data 

265 """ 

266 

267 blocks: Dict[str, Block] = {} 

268 groups: Dict[str, Group] = {} 

269 transs: Dict[str, Trans] = {} 

270 

271 

272class StrandGroup(BaseModel): 

273 """ 

274 Class for strand group 

275 """ 

276 

277 strand_positions: Dict[int, Coord] = {} 

278 

279 

280class Corner(BaseModel): 

281 """ 

282 Class for corner positions 

283 """ 

284 

285 iH: Coord = Coord() # inner left 

286 iL: Coord = Coord() # inner right 

287 oH: Coord = Coord() # outer left 

288 oL: Coord = Coord() # outer right 

289 

290 

291class HalfTurnCorner(BaseModel): 

292 """ 

293 Class for corner type 

294 """ 

295 

296 insulated: Corner = Corner() 

297 bare: Corner = Corner() 

298 

299 

300class HalfTurn(BaseModel): 

301 """ 

302 Class for half-turn data 

303 """ 

304 

305 corners: HalfTurnCorner = HalfTurnCorner() 

306 strand_groups: Dict[int, StrandGroup] = {} 

307 

308 

309class Order(BaseModel): 

310 """ 

311 Class for electrical order (block location) 

312 """ 

313 

314 coil: Optional[int] = None 

315 pole: Optional[int] = None 

316 layer: Optional[int] = None 

317 winding: Optional[int] = None 

318 block: Optional[int] = None 

319 

320 

321class CenterShift(BaseModel): 

322 """ 

323 Class for bore center shift 

324 """ 

325 

326 inner: Coord = Coord() 

327 outer: Coord = Coord() 

328 

329 

330class Wedge(BaseModel): 

331 """ 

332 Class for wedge positions 

333 """ 

334 

335 corners: Corner = Corner() 

336 corners_ins: Corner = Corner() 

337 corrected_center: CenterShift = CenterShift() 

338 corrected_center_ins: CenterShift = CenterShift() 

339 order_l: Order = Order() 

340 order_h: Order = Order() 

341 

342 

343class BlockData(BaseModel): 

344 """ 

345 Class for block data 

346 """ 

347 

348 block_corners: Corner = Corner() 

349 block_corners_ins: Corner = Corner() 

350 current_sign: Optional[int] = None 

351 half_turns: Dict[int, HalfTurn] = {} 

352 

353 

354class WindingData(BaseModel): 

355 """ 

356 Class for winding data 

357 """ 

358 

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

360 conductor_name: Optional[str] = None 

361 conductors_number: Optional[int] = None 

362 

363 

364class Winding(BaseModel): 

365 """ 

366 Class for windings 

367 """ 

368 

369 windings: Dict[int, WindingData] = {} 

370 

371 

372class Layer(BaseModel): 

373 """ 

374 Class for winding layers 

375 """ 

376 

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

378 

379 

380class Pole(BaseModel): 

381 """ 

382 Class for poles 

383 """ 

384 

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

386 type: Optional[str] = None 

387 bore_center: Coord = Coord() 

388 

389 

390class CoilData(BaseModel): 

391 """ 

392 Class for coils 

393 """ 

394 

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

396 physical_order: List[Order] = [] 

397 

398 

399class RoxieRawData(BaseModel): 

400 """ 

401 Class for the raw data 

402 """ 

403 

404 cadata: Cadata = Cadata() 

405 coil: Coil = Coil() 

406 

407 

408class RoxieData(BaseModel): 

409 """ 

410 Class for the roxie parser 

411 """ 

412 

413 iron: Iron = Iron() 

414 coil: CoilData = CoilData() 

415 wedges: Dict[int, Wedge] = {}