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

1from pydantic import BaseModel 

2from typing import List, Dict, Union, Optional, Literal 

3 

4 

5class Region(BaseModel): 

6 name: Optional[str] = None 

7 number: Optional[int] = None 

8 

9 

10class Regions(BaseModel): 

11 names: Optional[List[str]] = None 

12 numbers: Optional[List[int]] = None 

13 

14 

15class Regions2(BaseModel): 

16 names: Optional[List[List[str]]] = None 

17 numbers: Optional[List[List[int]]] = None 

18 

19 

20class TwoParBoundaryRegions(Regions2): 

21 values: Optional[List[List[Union[float, str]]]] = None 

22 

23 

24class TwoParBoundaryRegions2(Regions): 

25 values: Optional[List[Union[float, str]]] = None 

26 

27 

28class OneParBoundaryRegions(Regions2): 

29 value: Optional[List[float]] = None 

30 

31class InducedRegions(Regions): 

32 sigmas: Optional[List[float]] = None 

33 mu_rs: Optional[List[float]] = None 

34 

35 

36class PoweredRegions(InducedRegions): 

37 currents: Optional[List[float]] = None 

38 

39 

40class InsulatorRegions(InducedRegions): 

41 pass # duplicate class 

42 

43 

44class IronRegions(InducedRegions): 

45 pass # duplicate class 

46 

47 

48class AirRegion(Region): 

49 sigma: Optional[float] = None 

50 mu_r: Optional[float] = None 

51 

52 

53class AirFarFieldRegions(Regions): 

54 radius_in: Optional[float] = None 

55 radius_out: Optional[float] = None 

56 

57 

58class NonPermeableSourceRegion(AirRegion): 

59 pass # duplicate class 

60 

61 

62class SourceFreeRegion(AirRegion): 

63 pass # duplicate class 

64 

65 

66class Iron(BaseModel): 

67 vol: IronRegions = IronRegions() # volume region 

68 surf: Regions = Regions() # surface region 

69 curves: Dict[str, List[str]] = {} # curves region 

70 

71 

72class Induced(BaseModel): 

73 vol: InducedRegions = InducedRegions() # volume region 

74 surf_th: Regions = Regions() # surface region 

75 surf_in: Regions = Regions() # input terminal surface region 

76 surf_out: Regions = Regions() # output terminal surface region 

77 cochain: Regions = Regions() # winding cochain (cut) 

78 

79class Insulator(BaseModel): 

80 vol: InsulatorRegions = InsulatorRegions() # volume region 

81 surf: Regions = Regions() # surface region 

82 curve: Regions = Regions() # curve region 

83 

84class Powered(Induced, Insulator): 

85 vol: PoweredRegions = PoweredRegions() # volume region 

86 vol_in: Region = Region() # input terminal volume region 

87 vol_out: Region = Region() # output terminal volume region 

88 conductors: Dict[str, List[str]] = {} # conductor types 

89 surf_insul: Regions = Regions() # turn-to-turn insulation surfaces 

90 

91 

92class Air(BaseModel): 

93 vol: AirRegion = AirRegion() # volume region 

94 surf: Region = Region() # surface region 

95 line: Region = Region() # line region 

96 point: Regions = Regions() # point region 

97 cochain: Regions = Regions() # air cochain (cut) 

98 

99 

100class AirFarField(BaseModel): 

101 vol: AirFarFieldRegions = AirFarFieldRegions() # volume region 

102 surf: Region = Region() # surface region 

103 

104 

105class NonPermeableSource(BaseModel): 

106 vol: NonPermeableSourceRegion = NonPermeableSourceRegion() # volume region 

107 surf: Region = Region() # surface region 

108 

109 

110class SourceFree(BaseModel): 

111 vol: SourceFreeRegion = SourceFreeRegion() # volume region 

112 surf: Region = Region() # surface region 

113 

114class RobinCondition_collar(BaseModel): 

115 bc: TwoParBoundaryRegions2 = TwoParBoundaryRegions2() 

116 

117class RobinCondition_grouped(BaseModel): 

118 bc: TwoParBoundaryRegions = TwoParBoundaryRegions() 

119 groups: Dict[str, List[int]] = {} 

120 

121class NeumannCondition_grouped(BaseModel): 

122 bc: OneParBoundaryRegions = OneParBoundaryRegions() 

123 groups: Dict[str, List[int]] = {} 

124 

125class DirichletCondition_grouped(BaseModel): 

126 bc: OneParBoundaryRegions = OneParBoundaryRegions() 

127 groups: Dict[str, List[int]] = {} 

128 

129 

130class ThermalBoundaryConditions(BaseModel): 

131 temperature: DirichletCondition_grouped = DirichletCondition_grouped() 

132 heat_flux: NeumannCondition_grouped = NeumannCondition_grouped() 

133 cooling: RobinCondition_grouped = RobinCondition_grouped() 

134 collar: RobinCondition_collar = RobinCondition_collar() 

135 

136 

137class SymmetryBoundaryConditions(BaseModel): 

138 normal_free: Region = Region() 

139 tangential_free: Region = Region() 

140 

141 

142class BoundaryConditions(BaseModel): 

143 thermal: ThermalBoundaryConditions = ThermalBoundaryConditions() 

144 symmetry: SymmetryBoundaryConditions = SymmetryBoundaryConditions() 

145 

146 

147class InsulationType(BaseModel): 

148 layers_number: List[int] = [] 

149 thin_shells: List[List[int]] = [] 

150 layers_material: List[List[str]] = [] 

151 thicknesses: List[List[float]] = [] 

152 correction_factors: List[float] = [] # same correction factor per group. Can be used to scale the thin shell length 

153 label: List[List[Union[int, None]]] = ( 

154 [] 

155 ) # useful to indicate which quench heater a SS element refers to 

156 

157 

158class ThinShell(BaseModel): 

159 groups: Dict[str, List[int]] = {} # -> Checkboard convention of the hts 

160 mid_turns_layers_poles: Optional[List[int]] = None # indices of midlayers between HT, layers and poles 

161 ts_collar_groups: Dict[str, List[int]] = {} # groups of mid collar thin shells -> Checkboard convention 

162 ts_pole_groups: Dict[str, List[int]] = {} # groups of mid collar thin shells -> Checkboard convention 

163 

164 second_group_is_next: Dict[str, List[int]] = {} 

165 normals_directed: Dict[str, List[int]] = {} 

166 bdry_curves: Dict[Literal["collar", "poles", "outer_collar"], List[int]] = {} # save the boundary curves of a specific region, used in TSA 

167 

168 # insulation types, only mid layers 

169 insulation_types: InsulationType = InsulationType() # todo: merge all types into one @emma, consider dict ? 

170 quench_heaters: InsulationType = InsulationType() 

171 collar: InsulationType = InsulationType() 

172 poles: InsulationType = InsulationType() 

173 

174class PostProc(BaseModel): 

175 vol: Regions = Regions() # postprocessing volumes general 

176 surf: Regions = Regions() # postprocessing volumes general 

177 line: Regions = Regions() # postprocessing volumes general 

178 point: Regions = Regions() # postprocessing volumes general 

179 

180 

181class RegionsModel(BaseModel): 

182 powered: Dict[str, Powered] = {} #coils 

183 induced: Dict[str, Induced] = {} #wedges 

184 insulator: Insulator = Insulator() 

185 iron_yoke: Iron = Iron() # iron yoke 

186 collar: Iron = Iron() # collar is a type of iron region 

187 ref_mesh: Iron = Iron() # reference mesh 

188 poles: Iron = Iron() # poles 

189 

190 air: Air = Air() 

191 air_far_field: AirFarField = AirFarField() 

192 thin_shells: ThinShell = ThinShell() # Includes collar thin shells 

193 projection_points: Region = Region() 

194 boundaries: BoundaryConditions = BoundaryConditions() 

195 postproc_th: PostProc = PostProc() 

196 postproc_em: PostProc = PostProc() 

197