Coverage for fiqus/mains/MainMultipole.py: 83%

1import os 

2import gmsh 

3import time 

4 

5from fiqus.utils.Utils import GmshUtils 

6from fiqus.utils.Utils import FilesAndFolders as Util 

7from fiqus.data import DataFiQuS as dF 

8from fiqus.geom_generators.GeometryMultipole import Geometry 

9from fiqus.mesh_generators.MeshMultipole import Mesh 

10from fiqus.getdp_runners.RunGetdpMultipole import RunGetdpMultipole 

11from fiqus.getdp_runners.RunGetdpMultipole import AssignNaming 

12from fiqus.post_processors.PostProcessMultipole import PostProcess 

13from fiqus.plotters.PlotPythonMultipole import PlotPythonMultipole 

14 

15 

16class MainMultipole: 

17 def __init__(self, fdm: dF.FDM = None, sdm: dF.FiQuSSettings = None, rgd_path: str = None, 

18 verbose: bool = None): 

19 """ 

20 Main class for working with simulations for multipole type magnets 

21 :param fdm: FiQuS data model 

22 :param rgd_path: ROXIE geometry data path 

23 :param sdm: settings data model 

24 :param verbose: if True, more info is printed in the console 

25 """ 

26 self.fdm = fdm 

27 self.sett = sdm 

28 self.rgd = rgd_path 

29 self.verbose = verbose 

30 

31 self.settings = None 

32 self.geom_folder = None 

33 self.mesh_folder = None 

34 self.solution_folder = None 

35 self.model_file = None 

36 

37 def generate_geometry(self, gui: bool = False): 

38 geom = Util.read_data_from_yaml(self.rgd, dF.FiQuSGeometry) 

39 gg = Geometry(data=self.fdm, geom=geom, sett=self.sett, geom_folder=self.geom_folder, verbose=self.verbose) 

40 self.model_file = gg.model_file 

41 gg.saveStrandPositions() 

42 if self.fdm.magnet.geometry.with_iron_yoke: 

43 gg.constructIronGeometry() 

44 gg.constructWedgeGeometry() 

45 gg.constructCoilGeometry() 

46 gg.buildDomains() 

47 gg.saveBoundaryRepresentationFile() 

48 gg.loadBoundaryRepresentationFile() 

49 gg.updateTags() 

50 gg.saveAuxiliaryFile() 

51 gg.ending_step(gui) 

52 

53 def load_geometry(self, gui: bool = False): 

54 gu = GmshUtils(self.geom_folder, self.verbose) 

55 gu.initialize() 

56 self.model_file = f"{os.path.join(self.geom_folder, self.fdm.general.magnet_name)}.brep" 

57 gmsh.option.setString('Geometry.OCCTargetUnit', 'M') # set units to meters 

58 gmsh.open(self.model_file) 

59 if gui: 

60 gu.launch_interactive_GUI() 

61 

62 def pre_process(self, gui: bool = False): 

63 pass 

64 

65 def mesh(self, gui: bool = False): 

66 mm = Mesh(data=self.fdm, sett=self.sett, mesh_folder=self.mesh_folder, verbose=self.verbose) 

67 self.model_file = mm.model_file 

68 mm.loadAuxiliaryFile() 

69 mm.getIronCurvesTags() 

70 mm.defineMesh() 

71 mm.fragment() 

72 mm.createPhysicalGroups() 

73 mm.updateAuxiliaryFile() 

74 mm.assignRegionsTags() 

75 mm.saveRegionFile() 

76 mm.setMeshOptions() 

77 mm.generateMesh() 

78 mm.checkMeshQuality() 

79 mm.saveMeshFile() 

80 mm.ending_step(gui) 

81 return mm.mesh_parameters 

82 

83 def load_mesh(self, gui: bool = False): 

84 gu = GmshUtils(self.geom_folder, self.verbose) 

85 gu.initialize() 

86 self.model_file = f"{os.path.join(self.mesh_folder, self.fdm.general.magnet_name)}.msh" 

87 gmsh.open(self.model_file) 

88 if gui: 

89 gu.launch_interactive_GUI() 

90 

91 def solve_and_postprocess_getdp(self, gui: bool = False): 

92 an = AssignNaming(data=self.fdm) 

93 rg = RunGetdpMultipole(data=an, sett=self.sett, solution_folder=self.solution_folder, settings=self.settings, 

94 verbose=self.verbose) 

95 self.model_file = rg.model_file 

96 rg.loadRegionFile() 

97 rg.assemblePro() 

98 start_time = time.time() 

99 rg.solve_and_postprocess() 

100 rg.ending_step(gui) 

101 return time.time() - start_time 

102 

103 def post_process_getdp(self, gui: bool = False): 

104 an = AssignNaming(data=self.fdm) 

105 rg = RunGetdpMultipole(data=an, sett=self.sett, solution_folder=self.solution_folder, settings=self.settings, 

106 verbose=self.verbose) 

107 self.model_file = rg.model_file 

108 rg.loadRegionFile() 

109 rg.assemblePro() 

110 rg.postprocess() 

111 rg.ending_step(gui) 

112 

113 def post_process_python(self, gui: bool = False): 

114 if self.fdm.run.type == 'post_process_python_only': 

115 an = AssignNaming(data=self.fdm) 

116 data = an.data 

117 else: 

118 data = self.fdm 

119 pp = PostProcess(data=data, sett=self.sett, solution_folder=self.solution_folder, verbose=self.verbose) 

120 self.model_file = pp.model_file 

121 pp.loadStrandPositions() 

122 if self.fdm.magnet.postproc.plot_all: 

123 pp.loadHalfTurnCornerPositions() 

124 pp.postProcess() 

125 pp.ending_step(gui) 

126 return pp.postprocess_parameters 

127 

128 def plot_python(self): 

129 os.chdir(self.solution_folder) 

130 p = PlotPythonMultipole(self.fdm) 

131 p.dummy_plot_func()