Coverage for fiqus/geom_generators/GeometryCCT.py: 96%

1import os 

2import copy 

3import math 

4import collections 

5import logging 

6 

7import json 

8import timeit 

9import numpy as np 

10import gmsh 

11 

12from fiqus.data import RegionsModelFiQuS as Reg_Mod_FiQ 

13from fiqus.data.DataWindingsCCT import WindingsInformation # for winding information 

14from fiqus.utils.Utils import FilesAndFolders as uff 

15from fiqus.utils.Utils import GmshUtils 

16 

17logger = logging.getLogger(__name__) 

18class Hexahedrons: 

19 

20 def __init__(self): 

21 """ 

22 Points generator for CCT windings to give hexahedron volumes for hexahedron meshing in Gmsh. 

23 """ 

24 self.vertices_to_surf = [[0, 4, 7, 3], [1, 5, 6, 2], [1, 5, 4, 0], [2, 6, 7, 3], [0, 1, 2, 3], [4, 5, 6, 7]] 

25 # Node ordering following Gmsh for hexahedron https://gmsh.info/doc/texinfo/gmsh.html#Legacy-formats --> node ordering 

26 # above _vertices_to_surf is only used for manipulation of the hexahedra points on the data model level. Gmsh uses points connections and line connections for creating surfaces 

27 

28 self.hexes = {} 

29 self._corner_points = {} 

30 self._sur_names = ['x-', 'x+', 'y-', 'y+', 'z-', 'z+'] 

31 self._op_sign = {'+': '-', '-': '+'} 

32 self._sign = {1: '+', -1: '-'} 

33 

34 def _add_corner_points(self, corner_num, x, y, z, ct): 

35 self._corner_points[corner_num] = {'x': x, 'y': y, 'z': z, 'ct': ct} # ct is channel turn 

36 

37 def _generate_hexes(self): 

38 for h in range(len(self._corner_points[0]['x'])): 

39 self.hexes[h] = {} 

40 for p_num, p_coor in self._corner_points.items(): 

41 self.hexes[h][p_num] = {} 

42 for coor in ['x', 'y', 'z']: 

43 self.hexes[h][p_num][coor] = p_coor[coor][h] 

44 self.hexes[h]['ct'] = p_coor['ct'][h] 

45 return p_coor['ct'][h] 

46 

47 def _add_elem_to_elem(self, start_elem, dir_str, dist): 

48 """ 

49 :param start_elem: idx of start element 

50 :param dir_str: direction of adding element, options are: 'x-', 'x+', 'y-', 'y+', 'z-', 'z+' 

51 :param dist: length of new element in the direction specified above [m] 

52 :return: index of created element 

53 """ 

54 op_dir = dir_str[0] + self._op_sign[dir_str[1]] 

55 new_elem = start_elem + math.copysign(1, start_elem) 

56 self.hexes[new_elem] = {} 

57 source_points = self.vertices_to_surf[self._sur_names.index(dir_str)] 

58 destination_points = self.vertices_to_surf[self._sur_names.index(op_dir)] 

59 for d_p, s_p in zip(destination_points + source_points, source_points + source_points): 

60 self.hexes[new_elem][d_p] = copy.deepcopy(self.hexes[start_elem][s_p]) 

61 for s_p in source_points: # modif_points: 

62 self.hexes[new_elem][s_p][dir_str[0]] = self.hexes[new_elem][s_p][dir_str[0]] + dist 

63 self.hexes[new_elem]['ct'] = self.hexes[start_elem]['ct'] 

64 return new_elem 

65 

66 def _reorder_and_renumber_hexes(self): 

67 self.hexes = collections.OrderedDict(sorted(self.hexes.items())) 

68 first_hex_num = list(self.hexes.keys())[0] 

69 temp_dict = {} 

70 for h_num, h_dict in self.hexes.items(): 

71 temp_dict[h_num - first_hex_num + 1] = h_dict 

72 self.hexes = temp_dict 

73 for h_num, h_dict in self.hexes.items(): 

74 turn = h_dict.pop('ct', None) 

75 self.hexes[h_num] = collections.OrderedDict(sorted(h_dict.items())) 

76 self.hexes[h_num]['ct'] = turn 

77 

78 

79class Winding(Hexahedrons): 

80 

81 def __init__(self, cctdm, layer, post_proc=False): 

82 

83 super(Winding, self).__init__() 

84 self.cctdm = cctdm 

85 self.layer = layer 

86 self.post_proc = post_proc 

87 self.z_corr = 0 

88 self._populate_corners() 

89 self.z_corr = self._center_z_and_offset() 

90 self._generate_hexes() 

91 

92 def _populate_corners(self): 

93 r""" 

94 Generates hexahedron with 8 corners numbered 0-7. The size of hexahedron is taken from groove size of cct as specified in yaml. The length is from number of elements per turn. 

95 y (v) 

96 3----------2 

97 |\ ^ |\ 

98 | \ | | \ 

99 | \ | | \ 

100 | 7------+---6 

101 | | +-- |-- | -> x (u) 

102 0---+---\--1 | 

103 \ | \ \ | 

104 \ | \ \ | 

105 \| z(w)\| 

106 4----------5 

107 

108 :return: none 

109 """ 

110 self._sign_of_rot = math.copysign(1, self.cctdm.geometry.windings.alphas[self.layer]) 

111 if self._sign_of_rot > 0: 

112 corner_seq = { 

113 0: {'w_s': -1, 'h_s': -1, 'far': False}, # 'blcf' 

114 1: {'w_s': -1, 'h_s': 1, 'far': False}, # 'brcf' 

115 2: {'w_s': 1, 'h_s': 1, 'far': False}, # 'trcf' 

116 3: {'w_s': 1, 'h_s': -1, 'far': False}, # 'tlcf' 

117 4: {'w_s': -1, 'h_s': -1, 'far': True}, # bottom left corner close #'blcc' 

118 5: {'w_s': -1, 'h_s': 1, 'far': True}, # bottom right corner close #'brcc' 

119 6: {'w_s': 1, 'h_s': 1, 'far': True}, # top right corner close #'trcc' 

120 7: {'w_s': 1, 'h_s': -1, 'far': True}, # top right corner close #'tlcc' 

121 } 

122 else: 

123 corner_seq = { 

124 0: {'w_s': 1, 'h_s': 1, 'far': False}, # 'trcf' 

125 1: {'w_s': 1, 'h_s': -1, 'far': False}, # 'brcf' 

126 2: {'w_s': -1, 'h_s': -1, 'far': False}, # 'blcf' 

127 3: {'w_s': -1, 'h_s': 1, 'far': False}, # 'tlcf' 

128 4: {'w_s': 1, 'h_s': 1, 'far': True}, # top right corner close #'trcc' 

129 5: {'w_s': 1, 'h_s': -1, 'far': True}, # bottom right corner close #'brcc' 

130 6: {'w_s': -1, 'h_s': -1, 'far': True}, # bottom left corner close #'blcc' 

131 7: {'w_s': -1, 'h_s': 1, 'far': True}, # top left corner close #'tlcc' 

132 } 

133 for corner_num, corner_dict in corner_seq.items(): 

134 self._add_corner_points(corner_num, *self.calc_turns_corner_coords(corner_dict['w_s'], corner_dict['h_s'], far=corner_dict['far'])) 

135 

136 def calc_turns_corner_coords(self, w_s=1, h_s=1, far=False): 

137 """ 

138 Based on https://doi.org/10.1016/j.cryogenics.2020.103041 

139 :param h_s: wire height sign 

140 :param w_s: wire width sign 

141 :param far: for far surface set to True, for close surface set to False. This refers to walls of hexagon. 

142 :return: 

143 """ 

144 r_wm = self.cctdm.geometry.windings.r_wms[self.layer] # radius of winding layer, in the middle of the conductor groove [m] 

145 w_i = self.cctdm.geometry.windings.lps[self.layer] # layer pitch [m] 

146 n_turns = self.cctdm.geometry.windings.n_turnss[self.layer] # number of turns [-] 

147 nept = self.cctdm.geometry.windings.ndpts[self.layer] - 1 # number of elements per turn [-] 

148 alpha = self.cctdm.geometry.windings.alphas[self.layer] * np.pi / 180 # inclination of the winding [deg] 

149 theta_0 = 0 # offset start at theta_0, i.e. angular position of the beginning of the 1st turn[deg] 

150 z_0 = 0 # offset start at z_0, i.e. axial position of the beginning of the 1st turn [m] 

151 hh = 0.5 * h_s * self.cctdm.geometry.windings.wwhs[self.layer] # half of h (groove height) 

152 hw = 0.5 * w_s * self.cctdm.geometry.windings.wwws[self.layer] # half of w (groove width) 

153 tot_angle = 2 * np.pi * (n_turns + 1 / nept) 

154 tot_points = int(nept * n_turns) + 1 

155 if alpha > 0: 

156 theta = np.linspace(0, tot_angle, tot_points, endpoint=False) 

157 else: 

158 theta = np.linspace(0 + np.pi, tot_angle + np.pi, tot_points, endpoint=False) # this rotates terminals for opposite inclination to be on the opposite side 

159 if far: 

160 theta = theta[1:] # give all points but the first one, so the far surface can be created 

161 else: 

162 theta = theta[:-1] # give all the points but the last one so a near surface can be created 

163 if theta.size < 2: 

164 raise ValueError(f'Combination of number of division points per turn (ndpts) and number of turns (n_turnss) must result in at least 2 Hexahedrons, but inputs result in only {theta.size}!') 

165 C = r_wm * np.arctan(alpha) * np.cos(theta - theta_0) + w_i / (2 * np.pi) 

166 D = np.sqrt(r_wm ** 2 + np.square(C)) 

167 # -- x, y, z points coordinates 

168 xs = (r_wm + hh) * np.cos(theta) - np.sin(theta) * hw * C / D 

169 ys = (r_wm + hh) * np.sin(theta) + np.cos(theta) * hw * C / D 

170 zs = r_wm * np.sin(theta - theta_0) / np.tan(alpha) + w_i * (theta - theta_0) / (2 * np.pi) + z_0 - hw * r_wm / D # original formula 

171 if alpha > 0: 

172 channel_turn = np.ceil((theta - 2 * np.pi / (nept + 1)) / (2 * np.pi)) 

173 # channel_turn[0] = channel_turn[1] # make the hex at theta 0 to belong to the first turn. 

174 else: 

175 channel_turn = np.ceil((theta - np.pi - 2 * np.pi / (nept + 1)) / (2 * np.pi)) 

176 channel_turn[0] = channel_turn[1] # make the hex at theta 0 to belong to the first turn. 

177 return xs.tolist(), ys.tolist(), zs.tolist(), list(map(int, channel_turn)) 

178 

179 def _center_z_and_offset(self, offset=0): 

180 z_mins = [] 

181 z_maxs = [] 

182 for c_val in self._corner_points.values(): 

183 z_mins.append(np.min(c_val['z'])) 

184 z_maxs.append(np.max(c_val['z'])) 

185 z_min_wind = np.min(np.array(z_mins)) 

186 z_max_wind = np.max(np.array(z_maxs)) 

187 z_centre = (z_min_wind + z_max_wind) / 2 

188 if not self.post_proc: 

189 for c_key, c_val in self._corner_points.items(): 

190 self._corner_points[c_key]['z'] = (c_val['z'] - z_centre + offset).tolist() 

191 z_mins = [] 

192 z_maxs = [] 

193 for c_val in self._corner_points.values(): 

194 z_mins.append(np.min(c_val['z'])) 

195 z_maxs.append(np.max(c_val['z'])) 

196 self.z_min_winding_layer = np.min(np.array(z_mins)) 

197 self.z_max_winding_layer = np.max(np.array(z_maxs)) 

198 return z_centre + offset 

199 

200 

201class FQPL(Hexahedrons): 

202 def __init__(self, cctdm, layer): 

203 """ 

204 FQPL hex generator 

205 :param cctdm: cct data model object parsed from yaml input file 

206 :param layer: loop number, integer 

207 """ 

208 super(FQPL, self).__init__() 

209 self.cctdm = cctdm 

210 self.layer = layer 

211 self._calc_z_unit_len() 

212 self._populate_corners() 

213 self._generate_hexes() 

214 self._generate_fqpl() 

215 self._rotate_fqpl() 

216 self._reorder_and_renumber_hexes() 

217 self._clean_attr() 

218 

219 def _calc_z_unit_len(self): 

220 if self.cctdm.geometry.fqpls.z_starts[self.layer] == 'z_min': 

221 self.near = self.cctdm.geometry.air.z_min 

222 self.z_unit_len = (self.cctdm.geometry.fqpls.z_ends[self.layer] - self.near - self.cctdm.geometry.fqpls.fwws[self.layer]) / self.cctdm.geometry.fqpls.fndpls[self.layer] 

223 

224 elif self.cctdm.geometry.fqpls.z_starts[self.layer] == 'z_max': 

225 self.near = self.cctdm.geometry.air.z_max 

226 self.z_unit_len = (self.near - self.cctdm.geometry.fqpls.z_ends[self.layer] - self.cctdm.geometry.fqpls.fwws[self.layer]) / self.cctdm.geometry.fqpls.fndpls[self.layer] 

227 else: 

228 raise ValueError(f'fqpl.z_starts parameter must be a string equal to z_min or z_max, but {self.cctdm.geometry.fqpls.z_starts[self.layer]} was given!') 

229 

230 self.extrusion_sign = math.copysign(1, self.cctdm.geometry.fqpls.z_ends[self.layer] - self.near) 

231 

232 def _calc_first_corner_coords(self, w_s, h_s, far, offset): 

233 x = [self.cctdm.geometry.fqpls.r_ins[self.layer] + self.cctdm.geometry.fqpls.fwhs[self.layer] * h_s] # not rotated coordinate 

234 y = [self.cctdm.geometry.fqpls.fwws[self.layer] * w_s] # not rotated coordinate 

235 if far: 

236 z = [self.near - self.z_unit_len + offset] 

237 else: 

238 z = [self.near + offset] 

239 return x, y, z, [1] 

240 

241 def _populate_corners(self): 

242 r""" 

243 Generates hexahedron with 8 corners numbered 0-7. The size of hexahedron is taken from groove size of cct as specified in yaml. The length is from number of elements per turn. 

244 y (v) 

245 3----------2 

246 |\ ^ |\ 

247 | \ | | \ 

248 | \ | | \ 

249 | 7------+---6 

250 | | +-- |-- | -> x (u) 

251 0---+---\--1 | 

252 \ | \ \ | 

253 \ | \ \ | 

254 \| z(w)\| 

255 4----------5 

256 

257 :return: none 

258 """ 

259 if self.extrusion_sign > 0: 

260 offset = self.z_unit_len 

261 corner_seq = { 

262 0: {'w_s': -0.5, 'h_s': 0, 'far': True}, # 'blcf' 

263 1: {'w_s': -0.5, 'h_s': 1, 'far': True}, # 'tlcf' 

264 2: {'w_s': 0.5, 'h_s': 1, 'far': True}, # 'trcf' 

265 3: {'w_s': 0.5, 'h_s': 0, 'far': True}, # 'brcf' 

266 4: {'w_s': -0.5, 'h_s': 0, 'far': False}, # bottom left corner close #'blcc' 

267 5: {'w_s': -0.5, 'h_s': 1, 'far': False}, # top left corner close #'tlcc' 

268 6: {'w_s': 0.5, 'h_s': 1, 'far': False}, # top right corner close #'trcc' 

269 7: {'w_s': 0.5, 'h_s': 0, 'far': False}, # bottom right corner close #'brcc' 

270 } 

271 else: 

272 offset = 0 

273 corner_seq = { 

274 0: {'w_s': -0.5, 'h_s': 0, 'far': False}, # 'blcf' 

275 1: {'w_s': -0.5, 'h_s': 1, 'far': False}, # 'tlcf' 

276 2: {'w_s': 0.5, 'h_s': 1, 'far': False}, # 'trcf' 

277 3: {'w_s': 0.5, 'h_s': 0, 'far': False}, # 'brcf' 

278 4: {'w_s': -0.5, 'h_s': 0, 'far': True}, # bottom left corner close #'blcc' 

279 5: {'w_s': -0.5, 'h_s': 1, 'far': True}, # top left corner close #'tlcc' 

280 6: {'w_s': 0.5, 'h_s': 1, 'far': True}, # top right corner close #'trcc' 

281 7: {'w_s': 0.5, 'h_s': 0, 'far': True}, # bottom right corner close #'brcc' 

282 } 

283 for corner_num, corner_dict in corner_seq.items(): 

284 self._add_corner_points(corner_num, *self._calc_first_corner_coords(corner_dict['w_s'], corner_dict['h_s'], corner_dict['far'], offset)) 

285 

286 def _get_ref_point(self, elem_number, surf_n_dir_str, coord, dist): 

287 """ 

288 Gets center point for a surface 'pointing' in the direction surf_n_dir_str of hex with elem_number. It then moves that point into along coordinate coord and by distance dist 

289 :param elem_number: hex number to take the surface from 

290 :param surf_n_dir_str: 'direction of surface' (kind of normal), options are: 'x-', 'x+', 'y-', 'y+', 'z-', 'z+' 

291 :param coord: direction to more the point in, options are: 'x', 'y', 'z' 

292 :param dist: distance to move the point, this is positive or negative float 

293 :return: 

294 """ 

295 source_points = self.vertices_to_surf[self._sur_names.index(surf_n_dir_str)] # get the indexes 4 points for the surface points in direction surf_n_dir_str 

296 points_coor = [self.hexes[elem_number][point] for point in source_points] # get the points, they contain coordinates 

297 xs = [] 

298 ys = [] 

299 zs = [] 

300 for point in points_coor: # get coordinates into list for each axis 

301 for cor_list, coor in zip([xs, ys, zs], ['x', 'y', 'z']): 

302 cor_list.append(point[coor]) 

303 p = {'x': np.mean(xs), 'y': np.mean(ys), 'z': np.mean(zs)} # get averages of each axis coordinate, giving the center of the surface 

304 p[coord] = p[coord] + dist 

305 return p 

306 

307 def _add_elem_with_rot(self, elem_number, surf_n_dir_str, add_ax, angle, ref_p_coor): 

308 """ 

309 :param elem_number: idx of start element 

310 :param surf_n_dir_str: direction of adding element, options are: 'x-', 'x+', 'y-', 'y+', 'z-', 'z+' 

311 :param ref_p_coor: length of new element in the direction specified above [m] 

312 :return: index of created element 

313 """ 

314 mod_coor = [surf_n_dir_str[0], add_ax] 

315 # mod_coor.remove(surf_n_dir_str[0]) # get the other two coordinates that arenet the direction of the surface to take 

316 

317 angle_rad = np.deg2rad(angle) 

318 op_dir = surf_n_dir_str[0] + self._op_sign[surf_n_dir_str[1]] 

319 new_elem = elem_number + math.copysign(1, elem_number) 

320 self.hexes[new_elem] = {} 

321 source_points = self.vertices_to_surf[self._sur_names.index(surf_n_dir_str)] 

322 destination_points = self.vertices_to_surf[self._sur_names.index(op_dir)] 

323 for d_p, s_p in zip(destination_points + source_points, source_points + source_points): 

324 self.hexes[new_elem][d_p] = copy.deepcopy(self.hexes[elem_number][s_p]) 

325 for s_p in source_points: # modif_points: 

326 v1 = self.hexes[new_elem][s_p][mod_coor[0]] 

327 v2 = self.hexes[new_elem][s_p][mod_coor[1]] 

328 v1_ofset = ref_p_coor[mod_coor[0]] 

329 v2_ofset = ref_p_coor[mod_coor[1]] 

330 v1 = v1 - v1_ofset 

331 v2 = v2 - v2_ofset 

332 v1_new = np.cos(angle_rad) * v1 - np.sin(angle_rad) * v2 

333 v2_new = np.sin(angle_rad) * v1 + np.cos(angle_rad) * v2 

334 v1 = v1_new + v1_ofset 

335 v2 = v2_new + v2_ofset 

336 self.hexes[new_elem][s_p][mod_coor[0]] = v1 

337 self.hexes[new_elem][s_p][mod_coor[1]] = v2 

338 self.hexes[new_elem]['ct'] = self.hexes[elem_number]['ct'] 

339 return new_elem 

340 

341 def _generate_fqpl(self): 

342 new_elem = self._add_elem_to_elem(0, 'z+', self.extrusion_sign * self.z_unit_len) 

343 for _ in range(self.cctdm.geometry.fqpls.fndpls[self.layer] - 2): 

344 new_elem = self._add_elem_to_elem(new_elem, 'z+', self.extrusion_sign * self.z_unit_len) 

345 coord = 'x' 

346 ref_point = self._get_ref_point(new_elem, 'z+', coord, self.cctdm.geometry.fqpls.r_bs[self.layer]) # centre of rotation pint. 

347 n_seg = 10 

348 angle = 180 / n_seg 

349 for _ in range(n_seg): 

350 new_elem = self._add_elem_with_rot(new_elem, 'z+', coord, self.extrusion_sign * angle, ref_point) 

351 for _ in range(self.cctdm.geometry.fqpls.fndpls[self.layer]): 

352 new_elem = self._add_elem_to_elem(new_elem, 'z+', -self.extrusion_sign * self.z_unit_len) 

353 

354 def _rotate_fqpl(self): 

355 for h_num, h_dict in self.hexes.items(): 

356 channel_turn = h_dict.pop('ct', None) 

357 for p_num, p_dict in h_dict.items(): 

358 xx = p_dict['x'] 

359 yy = p_dict['y'] 

360 x = xx * np.cos(np.deg2rad(self.cctdm.geometry.fqpls.thetas[self.layer])) - yy * np.sin(np.deg2rad(self.cctdm.geometry.fqpls.thetas[self.layer])) # rotated coordinate 

361 y = xx * np.sin(np.deg2rad(self.cctdm.geometry.fqpls.thetas[self.layer])) + yy * np.cos(np.deg2rad(self.cctdm.geometry.fqpls.thetas[self.layer])) # rotated coordinate 

362 self.hexes[h_num][p_num]['x'] = x 

363 self.hexes[h_num][p_num]['y'] = y 

364 self.hexes[h_num]['ct'] = channel_turn 

365 

366 def _clean_attr(self): 

367 del self.cctdm 

368 del self.layer 

369 del self.near 

370 del self.z_unit_len 

371 

372 

373class Generate_BREPs: 

374 def __init__(self, fdm, verbose=True): 

375 """ 

376 Class to generate (build) Windings and Formers (WF) of a canted cosine theta (CCT) magnet and save them to brep files 

377 :param fdm: fiqus data model 

378 :param verbose: If True more information is printed in python console. 

379 """ 

380 self.cctdm = fdm.magnet 

381 self.model_folder = os.path.join(os.getcwd()) 

382 self.magnet_name = fdm.general.magnet_name 

383 

384 self.verbose = verbose 

385 self.cctwi = WindingsInformation() 

386 self.cctwi.magnet_name = self.magnet_name 

387 self.transl_dict = {'vol': '', 'surf': '_bd', 'surf_in': '_in', 'surf_out': '_out', 'cochain': '_cut'} 

388 self.gu = GmshUtils(self.model_folder, self.verbose) 

389 self.gu.initialize() 

390 self.formers = [] 

391 self.air = [] 

392 gmsh.option.setString('Geometry.OCCTargetUnit', 'M') 

393 

394 def generate_windings_or_fqpls(self, type_str): 

395 """ 

396 Generates windings brep files, as many as number of entries in the yaml file for windings. 

397 :param type_str: What to generate, options are: 'windings' or 'fqpls' 

398 :return: None, saves brep to disk 

399 """ 

400 if self.verbose: 

401 print(f'Generating {type_str} started') 

402 start_time = timeit.default_timer() 

403 

404 def generate_geom(worf_in, names_in): 

405 worf_tags_dict_in = {} 

406 for worf_num, worf_in in enumerate(worf_in): 

407 worf_tags_dict_in[worf_num] = self.generate_hex_geom(worf_in) 

408 gmsh.model.occ.synchronize() 

409 gmsh.write(os.path.join(self.model_folder, f'{names_in[worf_num]}.brep')) 

410 gmsh.clear() 

411 return worf_tags_dict_in 

412 

413 if self.cctdm.geometry.windings.names and type_str == 'windings': 

414 worf = [Winding(self.cctdm, i) for i, _ in enumerate(self.cctdm.geometry.windings.names)] # worf = winding or fqpl 

415 names = [name for name in self.cctdm.geometry.windings.names] 

416 for w in worf: 

417 if self.cctdm.geometry.air.z_min > w.z_min_winding_layer or w.z_max_winding_layer > self.cctdm.geometry.air.z_max: 

418 raise ValueError(f'{self.cctdm.geometry.air.name} region dimensions are too s mall to fit the windings turns. Please extend z_min and/or z_max') 

419 else: 

420 pass 

421 worf_tags_dict = generate_geom(worf, names) 

422 

423 if self.cctdm.geometry.fqpls.names and type_str == 'fqpls': 

424 worf = [FQPL(self.cctdm, i) for i, _ in enumerate(self.cctdm.geometry.fqpls.names)] # worf = winding or fqpl 

425 names = [name for name in self.cctdm.geometry.fqpls.names] 

426 worf_tags_dict = generate_geom(worf, names) 

427 

428 w_z_maxs = [] 

429 w_z_mins = [] 

430 if type_str == 'windings': 

431 for winding in worf: 

432 w_z_maxs.append(winding.z_max_winding_layer) 

433 w_z_mins.append(winding.z_min_winding_layer) 

434 self.cctwi.windings_avg_length = float(np.mean(w_z_maxs) - np.mean(w_z_mins)) 

435 self.cctwi.windings.names = names 

436 self.cctwi.windings.t_in.vol_st = [] 

437 self.cctwi.windings.t_in.surf_st = [] 

438 self.cctwi.windings.t_out.vol_st = [] 

439 self.cctwi.windings.t_out.surf_st = [] 

440 self.cctwi.windings.t_in.vol_et = [] 

441 self.cctwi.windings.t_in.surf_et = [] 

442 self.cctwi.windings.t_out.vol_et = [] 

443 self.cctwi.windings.t_out.surf_et = [] 

444 self.cctwi.windings.t_in.lc_et = [] 

445 self.cctwi.windings.t_out.lc_et = [] 

446 self.cctwi.windings.t_in.ndpterms = self.cctdm.geometry.windings.ndpt_ins 

447 self.cctwi.windings.t_out.ndpterms = self.cctdm.geometry.windings.ndpt_outs 

448 self.cctwi.windings.t_in.z_air = self.cctdm.geometry.air.z_min 

449 self.cctwi.windings.t_out.z_air = self.cctdm.geometry.air.z_max 

450 for winding_num, winding_dict in worf_tags_dict.items(): 

451 first_vol = list(winding_dict.keys())[0] 

452 last_vol = list(winding_dict.keys())[-1] 

453 self.cctwi.windings.t_in.vol_st.append(winding_dict[first_vol]['v_t']) 

454 self.cctwi.windings.t_in.surf_st.append(winding_dict[first_vol]['sf_ts'][0]) 

455 self.cctwi.windings.t_out.vol_st.append(winding_dict[last_vol]['v_t']) 

456 self.cctwi.windings.t_out.surf_st.append(winding_dict[last_vol]['sf_ts'][2]) 

457 self.cctwi.windings.t_in.vol_et.append(winding_dict[first_vol]['v_t']) 

458 self.cctwi.windings.t_in.surf_et.append(winding_dict[first_vol]['sf_ts'][0]) 

459 self.cctwi.windings.t_out.vol_et.append(winding_dict[last_vol]['v_t']) 

460 self.cctwi.windings.t_out.surf_et.append(winding_dict[last_vol]['sf_ts'][2]) 

461 

462 lc_st_neg_alpha = [[1, 0], [0, 3], [3, 2], [2, 1], [6, 4], [4, 5], [5, 7], [7, 6], [1, 6], [0, 4], [3, 5], [2, 7]] 

463 lc_st_pos_alpha = [[3, 1], [1, 0], [0, 2], [2, 3], [7, 4], [4, 5], [5, 6], [6, 7], [3, 7], [1, 4], [0, 5], [2, 6]] 

464 lc_et_neg_alpha = [[5, 7], [7, 6], [6, 4], [4, 5], [1, 3], [3, 2], [2, 0], [0, 1], [5, 1], [7, 3], [6, 2], [4, 0]] 

465 lc_et_pos_alpha = [[5, 7], [7, 6], [6, 4], [4, 5], [1, 3], [3, 2], [2, 0], [0, 1], [5, 1], [7, 3], [6, 2], [4, 0]] 

466 # [[1, 2], [2, 3], [3, 4], [4, 1], [5, 6], [6, 7], [7, 8], [8, 5], [1, 5], [2, 6], [3, 7], [4, 8]] 

467 # [[2, 1], [1, 4], [4, 3], [3, 2], [6, 5], [5, 8], [8, 7], [7, 6], [2, 6], [1, 5], [4, 8], [3, 7]] 

468 

469 lc_et_pos_corr = [[1, 0], [0, 3], [3, 2], [2, 1], [5, 4], [4, 7], [7, 6], [6, 5], [1, 5], [0, 4], [3, 7], [2, 6]] 

470 

471 self.cctwi.windings.t_in.lc_st = [] 

472 self.cctwi.windings.t_out.lc_st = [] 

473 for alpha in self.cctdm.geometry.windings.alphas: 

474 if alpha > 0: 

475 self.cctwi.windings.t_in.lc_st.append(lc_st_pos_alpha) 

476 self.cctwi.windings.t_out.lc_st.append(lc_st_pos_alpha) 

477 self.cctwi.windings.t_in.lc_et.append(lc_et_pos_corr) 

478 self.cctwi.windings.t_out.lc_et.append(lc_et_pos_alpha) 

479 else: 

480 self.cctwi.windings.t_in.lc_st.append(lc_st_neg_alpha) 

481 self.cctwi.windings.t_out.lc_st.append(lc_st_neg_alpha) 

482 self.cctwi.windings.t_in.lc_et.append(lc_et_neg_alpha) 

483 self.cctwi.windings.t_out.lc_et.append(lc_et_pos_corr) 

484 

485 if self.verbose: 

486 print(f'Generating {type_str} took {timeit.default_timer() - start_time:.2f} s') 

487 

488 def save_volume_info(self): 

489 if self.cctdm.geometry.fqpls.names: 

490 fqpls = self.cctdm.geometry.fqpls.names 

491 else: 

492 fqpls = [] 

493 

494 self.cctwi.w_names = self.cctdm.geometry.windings.names 

495 self.cctwi.f_names = fqpls 

496 self.cctwi.formers = self.cctdm.geometry.formers.names 

497 self.cctwi.air = self.cctdm.geometry.air.name 

498 

499 volume_info_file = os.path.join(self.model_folder, f'{self.cctwi.magnet_name}.wi') 

500 uff.write_data_to_yaml(volume_info_file, self.cctwi.dict()) 

501 

502 def generate_formers(self): 

503 if self.cctdm.geometry.formers.r_ins: 

504 if self.verbose: 

505 print('Generating Formers Started') 

506 start_time = timeit.default_timer() 

507 

508 for f_i, _ in enumerate(self.cctdm.geometry.formers.r_ins): 

509 z = self.cctdm.geometry.formers.z_mins[f_i] 

510 dz = self.cctdm.geometry.formers.z_maxs[f_i] - self.cctdm.geometry.formers.z_mins[f_i] 

511 cylin_out = (3, gmsh.model.occ.addCylinder(0, 0, z, 0, 0, dz, self.cctdm.geometry.formers.r_outs[f_i], angle=2 * math.pi)) # add cylinder to align to existing bodies in the pro file 

512 cylin_in = (3, gmsh.model.occ.addCylinder(0, 0, z, 0, 0, dz, self.cctdm.geometry.formers.r_ins[f_i], angle=2 * math.pi)) # add another cylinder to subtract from the first one to make a tube 

513 cylinder = gmsh.model.occ.cut([cylin_out], [cylin_in], removeObject=True) # subtract cylinders to make a tube 

514 self.formers.append(cylinder[0][0]) # keep just the tag and append 

515 gmsh.model.occ.synchronize() 

516 gmsh.write(os.path.join(self.model_folder, f'{self.cctdm.geometry.formers.names[f_i]}.brep')) 

517 gmsh.clear() 

518 if self.verbose: 

519 print(f'Generating formers took {timeit.default_timer() - start_time:.2f} s') 

520 

521 def generate_air(self): 

522 if self.cctdm.geometry.air.ar: 

523 if self.verbose: 

524 print('Generating air started') 

525 start_time = timeit.default_timer() 

526 if self.cctdm.geometry.air.sh_type == 'cylinder': 

527 self.air = [(3, gmsh.model.occ.addCylinder(0, 0, self.cctdm.geometry.air.z_min, 0, 0, self.cctdm.geometry.air.z_max - self.cctdm.geometry.air.z_min, self.cctdm.geometry.air.ar, angle=2 * math.pi))]