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

1from pydantic import BaseModel 

2from typing import List, Dict, Union, Optional 

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 TwoParBoundaryRegions(BaseModel): 

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

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

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

19 

20 

21class OneParBoundaryRegions(BaseModel): 

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

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

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

25 

26 

27class PoweredRegions(BaseModel): 

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

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

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

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

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

33 

34 

35class InducedRegions(BaseModel): 

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

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

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

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

40 

41 

42class InsulatorRegions(BaseModel): 

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

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

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

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

47 

48 

49class IronRegions(BaseModel): 

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

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

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

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

54 

55 

56class AirRegion(BaseModel): 

57 name: Optional[str] = None 

58 number: Optional[int] = None 

59 sigma: Optional[float] = None 

60 mu_r: Optional[float] = None 

61 

62 

63class AirFarFieldRegions(BaseModel): 

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

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

66 radius_in: Optional[float] = None 

67 radius_out: Optional[float] = None 

68 

69 

70class NonPermeableSourceRegion(BaseModel): 

71 name: Optional[str] = None 

72 number: Optional[int] = None 

73 sigma: Optional[float] = None 

74 mu_r: Optional[float] = None 

75 

76 

77class SourceFreeRegion(BaseModel): 

78 name: Optional[str] = None 

79 number: Optional[int] = None 

80 sigma: Optional[float] = None 

81 mu_r: Optional[float] = None 

82 

83 

84class Powered(BaseModel): 

85 vol: PoweredRegions = PoweredRegions() # volume region 

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

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

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

89 surf: Regions = Regions() # surface region 

90 surf_th: Regions = Regions() # surface region 

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

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

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

94 curve: Regions = Regions() # powered volumes lines 

95 

96 

97class Induced(BaseModel): 

98 vol: InducedRegions = InducedRegions() # volume region 

99 surf_th: Regions = Regions() # surface region 

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

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

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

103 

104 

105class Insulator(BaseModel): 

106 vol: InsulatorRegions = InsulatorRegions() # volume region 

107 surf: Regions = Regions() # surface region 

108 curve: Regions = Regions() # curve region 

109 

110 

111class Iron(BaseModel): 

112 vol: IronRegions = IronRegions() # volume region 

113 surf: Regions = Regions() # surface region 

114 

115 

116class Air(BaseModel): 

117 vol: AirRegion = AirRegion() # volume region 

118 surf: Region = Region() # surface region 

119 line: Region = Region() # line region 

120 point: Regions = Regions() # point region 

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

122 

123 

124class AirFarField(BaseModel): 

125 vol: AirFarFieldRegions = AirFarFieldRegions() # volume region 

126 surf: Region = Region() # surface region 

127 

128 

129class NonPermeableSource(BaseModel): 

130 vol: NonPermeableSourceRegion = NonPermeableSourceRegion() # volume region 

131 surf: Region = Region() # surface region 

132 

133 

134class SourceFree(BaseModel): 

135 vol: SourceFreeRegion = SourceFreeRegion() # volume region 

136 surf: Region = Region() # surface region 

137 

138 

139class RobinCondition(BaseModel): 

140 bc: TwoParBoundaryRegions = TwoParBoundaryRegions() 

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

142 

143 

144class NeumannCondition(BaseModel): 

145 bc: OneParBoundaryRegions = OneParBoundaryRegions() 

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

147 

148 

149class DirichletCondition(BaseModel): 

150 bc: OneParBoundaryRegions = OneParBoundaryRegions() 

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

152 

153 

154class ThermalBoundaryConditions(BaseModel): 

155 temperature: DirichletCondition = DirichletCondition() 

156 heat_flux: NeumannCondition = NeumannCondition() 

157 cooling: RobinCondition = RobinCondition() 

158 

159 

160class SymmetryBoundaryConditions(BaseModel): 

161 normal_free: Region = Region() 

162 tangential_free: Region = Region() 

163 

164 

165class BoundaryConditions(BaseModel): 

166 thermal: ThermalBoundaryConditions = ThermalBoundaryConditions() 

167 symmetry: SymmetryBoundaryConditions = SymmetryBoundaryConditions() 

168 

169 

170class InsulationType(BaseModel): 

171 layers_number: List[int] = [] 

172 thin_shells: List[List[int]] = [] 

173 layers_material: List[List[str]] = [] 

174 thicknesses: List[List[float]] = [] 

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

176 [] 

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

178 

179 

180class ThinShell(BaseModel): 

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

182 mid_turns_layers_poles: Optional[List[int]] = None 

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

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

185 insulation_types: InsulationType = InsulationType() 

186 quench_heaters: InsulationType = InsulationType() 

187 

188 

189class PostProc(BaseModel): 

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

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

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

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

194 

195 

196class RegionsModel(BaseModel): 

197 powered: Dict[str, Powered] = {} 

198 induced: Dict[str, Induced] = {} 

199 insulator: Insulator = Insulator() 

200 iron: Iron = Iron() 

201 air: Air = Air() 

202 air_far_field: AirFarField = AirFarField() 

203 thin_shells: ThinShell = ThinShell() 

204 projection_points: Region = Region() 

205 boundaries: BoundaryConditions = BoundaryConditions() 

206 postproc_th: PostProc = PostProc() 

207 postproc_em: PostProc = PostProc() 

208 

209 

210# if __name__ == "__main__": 

211# write = True 

212# read = False 

213# 

214# def read_regions(regions_file_name): 

215# with open(regions_file_name, 'r') as stream: 

216# yaml_str = ruamel.yaml.safe_load(stream) 

217# return RegionsModel(**yaml_str) 

218# 

219# def flist(x): 

220# retval = ruamel.yaml.comments.CommentedSeq(x) 

221# retval.fa.set_flow_style() # fa -> format attribute 

222# return retval 

223# 

224# if write: 

225# model = RegionsModel() 

226# model.powered.vol = [1, 2] 

227# data_dict = model.dict() 

228# yaml = ruamel.yaml.YAML() 

229# yaml.default_flow_style = False 

230# yaml.emitter.alt_null = 'Null' 

231# 

232# def my_represent_none(self, data): 

233# return self.represent_scalar('tag:yaml.org,2002:null', 'null') 

234# 

235# yaml.representer.add_representer(type(None), my_represent_none) 

236# with open('cct_regions_empty.yaml', 'w') as yaml_file: 

237# yaml.dump(model.dict(), yaml_file) 

238# if read: 

239# regions_file_name = 'cct1_regions_manual.yaml' 

240# regions = read_regions(regions_file_name)