fiqus 2025.2.0__py3-none-any.whl → 2025.11.0__py3-none-any.whl

fiqus/post_processors/PostProcessMultipole.py

@@ -65,7 +65,7 @@ class PostProcess:
         self.postproc_settings = pd.DataFrame({
             'variables': settings.variables,
             'volumes': settings.volumes})
-        if 'compare_to_ROXIE' in settings.dict():
+        if 'compare_to_ROXIE' in settings.model_dump():
             self.physical_quantity = 'magnetic_flux_density'
         else:
             self.physical_quantity = 'temperature'
@@ -83,8 +83,8 @@ class PostProcess:
             # self.ax.set_xlim(0, 0.09)  # todo
             # self.ax.set_ylim(0, 0.09)
 
-            if not settings.dict().get('take_average_conductor_temperature', False):
-                if settings.dict().get('compare_to_ROXIE', False):
+            if not settings.model_dump().get('take_average_conductor_temperature', False):
+                if settings.model_dump().get('compare_to_ROXIE', False):
                     fig2 = plt.figure(2)
                     self.ax2 = fig2.add_subplot(projection='3d')
                     self.ax2.set_xlabel('x [m]')
@@ -99,9 +99,9 @@ class PostProcess:
                 self.ax3 = fig3.add_subplot(projection='3d')
                 self.ax3.set_xlabel('x [m]')
                 self.ax3.set_ylabel('y [m]')
-                self.ax3.set_zlabel('norm(B) [T]' if 'compare_to_ROXIE' in settings.dict() else '')
+                self.ax3.set_zlabel('norm(B) [T]' if 'compare_to_ROXIE' in settings.model_dump() else '')
 
-        if 'compare_to_ROXIE' in settings.dict() and 'b' in settings.variables:
+        if 'compare_to_ROXIE' in settings.model_dump() and 'b' in settings.variables:
             b_index = settings.variables.index('b')
             file_to_open = os.path.join(self.solution_folder, f"b_{settings.volumes[b_index]}.pos")
         elif 'T' in settings.variables:
@@ -178,9 +178,9 @@ class PostProcess:
 
     def postProcess(self, postproc):
         df_ref = pd.DataFrame()
-        model_file_extension = 'EM' if 'compare_to_ROXIE' in postproc.dict() else 'TH'
+        model_file_extension = 'EM' if 'compare_to_ROXIE' in postproc.model_dump() else 'TH'
 
-        if postproc.dict().get('compare_to_ROXIE', False):
+        if postproc.model_dump().get('compare_to_ROXIE', False):
             # flag_self_field = False
             # path_map2d = Path(postproc.compare_to_ROXIE, "MQXA_All_" +
             #                   f"{'WithIron_' if self.data.magnet.geometry.with_iron_yoke else 'NoIron_'}" +
@@ -196,13 +196,13 @@ class PostProcess:
                     conductorPositionsList = RoxieParsers.parseCond2d(path_cond2d)
 
         # Collect strands coordinates
-        strands_x = df_ref['X-POS/MM'] / 1e3 if postproc.dict().get('compare_to_ROXIE', False) else self.strands['x']
-        strands_y = df_ref['Y-POS/MM'] / 1e3 if postproc.dict().get('compare_to_ROXIE', False) else self.strands['y']
+        strands_x = df_ref['X-POS/MM'] / 1e3 if postproc.model_dump().get('compare_to_ROXIE', False) else self.strands['x']
+        strands_y = df_ref['Y-POS/MM'] / 1e3 if postproc.model_dump().get('compare_to_ROXIE', False) else self.strands['y']
 
         # Probe physical quantity values from view and region areas
         physical_quantity_values = {'x': [], 'y': []}
         cond_areas, current_signs = [], []
-        if postproc.dict().get('take_average_conductor_temperature', False):
+        if postproc.model_dump().get('take_average_conductor_temperature', False):
             half_turns = {name[:-3]: str(values.vol.numbers[i])
                           for group, values in self.rm.powered.items() for i, name in enumerate(values.vol.names)}
             self.avg_temperatures = pd.concat([pd.read_csv(os.path.join(self.solution_folder, 'T_avg', 'T_avg_0.txt'),
@@ -217,7 +217,7 @@ class PostProcess:
             self.avg_temperatures.to_csv(os.path.join(self.solution_folder, 'half_turn_temperatures_over_time.csv'), index=False)
         else:
             print(f"Info    : {self.data.general.magnet_name} - I n t e r p o l a t i n g . . .")
-            print(f"Info    : Interpolating {'magnetic flux density' if 'compare_to_ROXIE' in postproc.dict() else 'temperature'} ...")
+            print(f"Info    : Interpolating {'magnetic flux density' if 'compare_to_ROXIE' in postproc.model_dump() else 'temperature'} ...")
 
             # view = gmsh.view.getTags()[0] if len(postproc.variables) == 1 else self.postproc_settings[
             #     (self.postproc_settings['variables'] == self.supported_variables[self.physical_quantity]) &
@@ -235,7 +235,7 @@ class PostProcess:
 
                 # Probe
                 probe_data = gmsh.view.probe(view, strands_x[i], strands_y[i], 0)[0]
-                if 'compare_to_ROXIE' in postproc.dict():
+                if 'compare_to_ROXIE' in postproc.model_dump():
                     physical_quantity_values['x'].append(probe_data[0])
                     physical_quantity_values['y'].append(probe_data[1])
                 else:
@@ -243,7 +243,7 @@ class PostProcess:
                     physical_quantity_values['y'].append(0)
 
                 # Plot conductor and block identifiers
-                if postproc.dict().get('compare_to_ROXIE', False) and postproc.plot_all != 'false':
+                if postproc.model_dump().get('compare_to_ROXIE', False) and postproc.plot_all != 'false':
                     if is_new_conductor:
                         self.ax.text(df_ref['X-POS/MM'][i] / 1e3, df_ref['Y-POS/MM'][i] / 1e3, str(self.strands['ht'][i]),
                                      style='italic', bbox={'facecolor': 'blue', 'pad': 3})
@@ -283,7 +283,7 @@ class PostProcess:
                     f"{physical_quantity_values['y'][i]:.4f}",      # pq_y
                     f"{cond_areas[i] / strands_nr * 1e6:.4f}",      # area
                     f"{current_signs[i] * self.data.power_supply.I_initial / strands_nr:.2f}",                  # curr
-                    f"{df_ref['FILL FAC.'][i] if postproc.dict().get('compare_to_ROXIE', False) else 0:.4f}"))    # fill_fac
+                    f"{df_ref['FILL FAC.'][i] if postproc.model_dump().get('compare_to_ROXIE', False) else 0:.4f}"))    # fill_fac
 
             # Save map2d file
             with open(f"{self.model_file}_{model_file_extension}.map2d", 'w') as file:
@@ -291,19 +291,19 @@ class PostProcess:
                 file.writelines(content)
             print(f"Info    : Map2D file saved.")
             print(f"WARNING : [Map2D] All strand surface areas are equal within a conductor. Refer to the ROXIE map2d file for actual values")
-            if not postproc.dict().get('compare_to_ROXIE', True):
+            if not postproc.model_dump().get('compare_to_ROXIE', True):
                 print(f"WARNING : [Map2D] No data is available for Filling Factor. Refer to the ROXIE map2d file for correct values")
 
         # Compute errors
         pq = np.linalg.norm(np.column_stack((np.array(physical_quantity_values['x']), np.array(physical_quantity_values['y']))), axis=1)
-        if postproc.dict().get('compare_to_ROXIE', False):
+        if postproc.model_dump().get('compare_to_ROXIE', False):
             BB_err = pq - BB_roxie
             self.postprocess_parameters['overall_error'] = np.mean(abs(BB_err))
             self.postprocess_parameters['minimum_diff'] = np.min(BB_err)
             self.postprocess_parameters['maximum_diff'] = np.max(BB_err)
 
         if postproc.plot_all != 'false':
-            if postproc.dict().get('take_average_conductor_temperature', False):
+            if postproc.model_dump().get('take_average_conductor_temperature', False):
                 min_value = self.avg_temperatures.iloc[:, 1:].min().min()
                 max_value = self.avg_temperatures.iloc[:, 1:].max().max()
                 ht_polygons = [patches.Polygon(np.array([(self.crns['iHr'][i][0], self.crns['iHr'][i][1]),
@@ -324,12 +324,12 @@ class PostProcess:
                         plt.pause(0.05)
 
             else:
-                self.plotHalfTurnGeometry(postproc.dict().get('compare_to_ROXIE', False))
+                self.plotHalfTurnGeometry(postproc.model_dump().get('compare_to_ROXIE', False))
                 map2d_strands = self.ax.scatter(strands_x, strands_y, edgecolor='black', facecolor='black', s=10)
 
                 scatter3D_pos = self.ax3.scatter3D(strands_x, strands_y, pq, c=pq, cmap='Greens', vmin=0, vmax=10)
 
-                if postproc.dict().get('compare_to_ROXIE', False):
+                if postproc.model_dump().get('compare_to_ROXIE', False):
                     if os.path.isfile(path_cond2d):
                         conductors_corners = [condPos.xyCorner for condPos in conductorPositionsList]
                         for corners in conductors_corners:

fiqus/pre_processors/PreProcessCCT.py

@@ -1,175 +1,175 @@
-import math
-import os
-import timeit
-import json
-import gmsh
-import numpy as np
-from fiqus.utils.Utils import FilesAndFolders as uff
-from fiqus.utils.Utils import GmshUtils
-from fiqus.data.DataWindingsCCT import WindingsInformation         # for volume information
-
-
-class Pre_Process:
-    def __init__(self, fdm, verbose=True):
-        """
-        Class to preparing brep files by adding terminals.
-        :param fdm: FiQuS data model
-        :param verbose: If True more information is printed in python console.
-        """
-        self.cctdm = fdm.magnet
-        self.model_folder = os.path.join(os.getcwd())
-        self.magnet_name = fdm.general.magnet_name
-        winding_info_file = os.path.join(self.model_folder, f'{self.magnet_name}.wi')
-        self.cctwi = uff.read_data_from_yaml(winding_info_file, WindingsInformation)
-        self.verbose = verbose
-        self.gu = GmshUtils(self.model_folder, self.verbose)
-        self.gu.initialize()
-
-    def calculate_normals(self, gui=False):
-        """
-        Calculates normals for the cct channel directions, i.e. along winding direction, along radial direction of the former (height) and along axial direction (width). Normals are saved to a .json
-        file and used later for post-processing of magnetic field into components along channel length, height and width. Note that this function does not give the correct 'sign of normals', i.e.
-        normals facing inwards or outwards of the surface are not properly distinguished. The normals along the length are not reliable and only along the height and width are used for calculations and
-        the field along the length is taken as a remaining field.
-        This function needs full geom_generators .brep file and volume information files (.vi) for each individual powered volume.
-        :param gui: if True, the gmsh graphical user interface is shown at the end and normals are displayed as a view
-        :return: Nothing, a file for each powered geom_generators brep is
-        """
-        if self.verbose:
-            print('Calculating Normals Started')
-            start_time = timeit.default_timer()
-        gmsh.open(os.path.join(self.model_folder, f'{self.magnet_name}.brep'))
-
-        def _calc_normals_dir(tags_for_normals_in, surfs_idx, surfs_scale):
-            v_to_suf = [[0, 1, 2, 3], [0, 1, 5, 4], [4, 5, 6, 7], [3, 7, 6, 2], [0, 3, 7, 4], [1, 5, 6, 2]]
-            norm_e_x = []   # normal along x of volume
-            norm_e_y = []
-            norm_e_z = []
-            norm_dict = {}
-            normals_view = []  # this remains an empty list if view is False
-            coor_e_x = []   # coordinate x of the center of volume
-            coor_e_y = []
-            coor_e_z = []
-            for vol_tag in tags_for_normals_in:
-                all_surf_tags = gmsh.model.getAdjacencies(3, vol_tag)[1]
-                surf_tags = [all_surf_tags[index] for index in surfs_idx]
-                norm = []
-                node_coord = []
-                vol_line_tags = []
-                for surf_tag in all_surf_tags:
-                    line_tags_new = gmsh.model.getAdjacencies(2, surf_tag)[1]
-                    for line_tag in line_tags_new:
-                        if line_tag not in vol_line_tags:
-                            vol_line_tags.append(line_tag)
-                point_tags = []
-                for line_tag in vol_line_tags:
-                    point_tags_new = gmsh.model.getAdjacencies(1, line_tag)[1]
-                    for point_tag in point_tags_new:
-                        if point_tag not in point_tags:
-                            point_tags.append(int(point_tag))
-                for surf_i, surf_tag, scale in zip(surfs_idx, surf_tags, surfs_scale):
-                    p_idx = v_to_suf[surf_i]
-                    s_node_coord = []
-                    for p_i in p_idx:
-                        xmin, ymin, zmin, xmax, ymax, zmax = gmsh.model.occ.getBoundingBox(0, point_tags[p_i])
-                        s_node_coord.append((xmin + xmax) / 2)
-                        s_node_coord.append((ymin + ymax) / 2)
-                        s_node_coord.append((zmin + zmax) / 2)
-                    parametricCoord = gmsh.model.getParametrization(2, surf_tag, s_node_coord)
-                    s_norm = gmsh.model.getNormal(surf_tag, parametricCoord)
-                    norm.extend(scale*s_norm)
-                    node_coord.extend(s_node_coord)
-                coor_s_x = []   # coordinates surface x
-                coor_s_y = []
-                coor_s_z = []
-                norm_s_x = []   # normals surface x
-                norm_s_y = []
-                norm_s_z = []
-
-                for i in range(0, len(node_coord), 3):
-                    coor_s_x.append(node_coord[i])
-                    coor_s_y.append(node_coord[i+1])
-                    coor_s_z.append(node_coord[i+2])
-                    norm_s_x.append(norm[i])
-                    norm_s_y.append(norm[i+1])
-                    norm_s_z.append(norm[i+2])
-
-                coor_e_x.append(np.mean(coor_s_x))
-                coor_e_y.append(np.mean(coor_s_y))
-                coor_e_z.append(np.mean(coor_s_z))
-                # norm_e_x.append(np.mean(norm_s_x))
-                # norm_e_y.append(np.mean(norm_s_y))
-                # norm_e_z.append(np.mean(norm_s_z))
-
-                # norm_e_x.append(np.sqrt(np.sum(np.square(norm_s_x)))/(2*np.sqrt(2)))
-                # norm_e_y.append(np.sqrt(np.sum(np.square(norm_s_y)))/(2*np.sqrt(2)))
-                # norm_e_z.append(np.sqrt(np.sum(np.square(norm_s_z)))/(2*np.sqrt(2)))
-                v_x = np.sum(norm_s_x)
-                v_y = np.sum(norm_s_y)
-                v_z = np.sum(norm_s_z)
-                ampl = math.sqrt(v_x**2 + v_y**2 + v_z**2)
-
-                norm_e_x.append(v_x/ampl)
-                norm_e_y.append(v_y/ampl)
-                norm_e_z.append(v_z/ampl)
-
-            for i in range(len(coor_e_x)):
-                normals_view.append(coor_e_x[i])
-                normals_view.append(coor_e_y[i])
-                normals_view.append(coor_e_z[i])
-                normals_view.append(norm_e_x[i])
-                normals_view.append(norm_e_y[i])
-                normals_view.append(norm_e_z[i])
-            norm_dict['x'] = coor_e_x
-            norm_dict['y'] = coor_e_y
-            norm_dict['z'] = coor_e_z
-            norm_dict['n_x'] = norm_e_x
-            norm_dict['n_y'] = norm_e_y
-            norm_dict['n_z'] = norm_e_z
-            return norm_dict, normals_view
-        """
-        This is helper function called in a loop below.
-        """
-        max_tag = 0
-        for f_name in self.cctwi.w_names+self.cctwi.f_names:
-            vol_tags = json.load(open(os.path.join(self.model_folder, f'{f_name}.vi')))
-            export_tags = vol_tags['export']
-            tags_for_normals = [e + max_tag for e in export_tags]
-            max_tag = np.max(vol_tags['all']) + max_tag
-            surfs_idx_l = [0, 2]    # along length of the former groove
-            if f_name in self.cctwi.w_names:
-                surfs_scale_l = [1, 1]
-            elif f_name in self.cctwi.f_names:
-                surfs_scale_l = [1, -1]     # change direction for fqpl
-            norm_l, norm_view_l = _calc_normals_dir(tags_for_normals, surfs_idx_l, surfs_scale_l)
-            surfs_idx_h = [1, 3]         # along height of the former groove
-            surfs_scale_h = [1, -1]
-            norm_h, norm_view_h = _calc_normals_dir(tags_for_normals, surfs_idx_h, surfs_scale_h)
-            surfs_idx_w = [4, 5]        # along width of the former groove
-            surfs_scale_w = [1, -1]
-            norm_w, norm_view_w = _calc_normals_dir(tags_for_normals, surfs_idx_w, surfs_scale_w)
-            normals_dict = {'normals_l': norm_l, 'normals_h': norm_h, 'normals_w': norm_w}
-            json.dump(normals_dict, open(f"{os.path.join(self.model_folder, f_name)}.normals", 'w'))
-            if gui:
-                normals_all = [norm_view_l, norm_view_h, norm_view_w]
-                self.__add_normals_view(f_name, normals_all)
-        if self.verbose:
-            print(f'Calculating Normals Took {timeit.default_timer() - start_time:.2f} s')
-        if gui:
-            self.gu.launch_interactive_GUI()
-
-    @staticmethod
-    def __add_normals_view(name, normals_all, norm_list=[0, 1, 2]):
-        """
-        THis adds new view in gmsh.
-        :param name: name of view
-        :param normals_all: dictionary with normals
-        :param norm_list: which normals to plot. Default is: [0, 1, 2] corresponds to [n_l, n_h, n_w]. If this array is shorter the corresponding normals are skipped in views.
-        :return:
-        """
-        norm_names_all = [f"{name}_n_l", f"{name}_n_h", f"{name}_n_w"]
-        norm_names = [norm_names_all[index] for index in norm_list]
-        normals = [normals_all[index] for index in norm_list]
-        for view_name, view_data in zip(norm_names, normals):
-            gmsh.view.addListData(gmsh.view.add(view_name), "VP", len(view_data) // 6, view_data)
-        gmsh.model.occ.synchronize()
+import math
+import os
+import timeit
+import json
+import gmsh
+import numpy as np
+from fiqus.utils.Utils import FilesAndFolders as uff
+from fiqus.utils.Utils import GmshUtils
+from fiqus.data.DataWindingsCCT import WindingsInformation         # for volume information
+
+
+class Pre_Process:
+    def __init__(self, fdm, verbose=True):
+        """
+        Class to preparing brep files by adding terminals.
+        :param fdm: FiQuS data model
+        :param verbose: If True more information is printed in python console.
+        """
+        self.cctdm = fdm.magnet
+        self.model_folder = os.path.join(os.getcwd())
+        self.magnet_name = fdm.general.magnet_name
+        winding_info_file = os.path.join(self.model_folder, f'{self.magnet_name}.wi')
+        self.cctwi = uff.read_data_from_yaml(winding_info_file, WindingsInformation)
+        self.verbose = verbose
+        self.gu = GmshUtils(self.model_folder, self.verbose)
+        self.gu.initialize()
+
+    def calculate_normals(self, gui=False):
+        """
+        Calculates normals for the cct channel directions, i.e. along winding direction, along radial direction of the former (height) and along axial direction (width). Normals are saved to a .json
+        file and used later for post-processing of magnetic field into components along channel length, height and width. Note that this function does not give the correct 'sign of normals', i.e.
+        normals facing inwards or outwards of the surface are not properly distinguished. The normals along the length are not reliable and only along the height and width are used for calculations and
+        the field along the length is taken as a remaining field.
+        This function needs full geom_generators .brep file and volume information files (.vi) for each individual powered volume.
+        :param gui: if True, the gmsh graphical user interface is shown at the end and normals are displayed as a view
+        :return: Nothing, a file for each powered geom_generators brep is
+        """
+        if self.verbose:
+            print('Calculating Normals Started')
+            start_time = timeit.default_timer()
+        gmsh.open(os.path.join(self.model_folder, f'{self.magnet_name}.brep'))
+
+        def _calc_normals_dir(tags_for_normals_in, surfs_idx, surfs_scale):
+            v_to_suf = [[0, 1, 2, 3], [0, 1, 5, 4], [4, 5, 6, 7], [3, 7, 6, 2], [0, 3, 7, 4], [1, 5, 6, 2]]
+            norm_e_x = []   # normal along x of volume
+            norm_e_y = []
+            norm_e_z = []
+            norm_dict = {}
+            normals_view = []  # this remains an empty list if view is False
+            coor_e_x = []   # coordinate x of the center of volume
+            coor_e_y = []
+            coor_e_z = []
+            for vol_tag in tags_for_normals_in:
+                all_surf_tags = gmsh.model.getAdjacencies(3, vol_tag)[1]
+                surf_tags = [all_surf_tags[index] for index in surfs_idx]
+                norm = []
+                node_coord = []
+                vol_line_tags = []
+                for surf_tag in all_surf_tags:
+                    line_tags_new = gmsh.model.getAdjacencies(2, surf_tag)[1]
+                    for line_tag in line_tags_new:
+                        if line_tag not in vol_line_tags:
+                            vol_line_tags.append(line_tag)
+                point_tags = []
+                for line_tag in vol_line_tags:
+                    point_tags_new = gmsh.model.getAdjacencies(1, line_tag)[1]
+                    for point_tag in point_tags_new:
+                        if point_tag not in point_tags:
+                            point_tags.append(int(point_tag))
+                for surf_i, surf_tag, scale in zip(surfs_idx, surf_tags, surfs_scale):
+                    p_idx = v_to_suf[surf_i]
+                    s_node_coord = []
+                    for p_i in p_idx:
+                        xmin, ymin, zmin, xmax, ymax, zmax = gmsh.model.occ.getBoundingBox(0, point_tags[p_i])
+                        s_node_coord.append((xmin + xmax) / 2)
+                        s_node_coord.append((ymin + ymax) / 2)
+                        s_node_coord.append((zmin + zmax) / 2)
+                    parametricCoord = gmsh.model.getParametrization(2, surf_tag, s_node_coord)
+                    s_norm = gmsh.model.getNormal(surf_tag, parametricCoord)
+                    norm.extend(scale*s_norm)
+                    node_coord.extend(s_node_coord)
+                coor_s_x = []   # coordinates surface x
+                coor_s_y = []
+                coor_s_z = []
+                norm_s_x = []   # normals surface x
+                norm_s_y = []
+                norm_s_z = []
+
+                for i in range(0, len(node_coord), 3):
+                    coor_s_x.append(node_coord[i])
+                    coor_s_y.append(node_coord[i+1])
+                    coor_s_z.append(node_coord[i+2])
+                    norm_s_x.append(norm[i])
+                    norm_s_y.append(norm[i+1])
+                    norm_s_z.append(norm[i+2])
+
+                coor_e_x.append(np.mean(coor_s_x))
+                coor_e_y.append(np.mean(coor_s_y))
+                coor_e_z.append(np.mean(coor_s_z))
+                # norm_e_x.append(np.mean(norm_s_x))
+                # norm_e_y.append(np.mean(norm_s_y))
+                # norm_e_z.append(np.mean(norm_s_z))
+
+                # norm_e_x.append(np.sqrt(np.sum(np.square(norm_s_x)))/(2*np.sqrt(2)))
+                # norm_e_y.append(np.sqrt(np.sum(np.square(norm_s_y)))/(2*np.sqrt(2)))
+                # norm_e_z.append(np.sqrt(np.sum(np.square(norm_s_z)))/(2*np.sqrt(2)))
+                v_x = np.sum(norm_s_x)
+                v_y = np.sum(norm_s_y)
+                v_z = np.sum(norm_s_z)
+                ampl = math.sqrt(v_x**2 + v_y**2 + v_z**2)
+
+                norm_e_x.append(v_x/ampl)
+                norm_e_y.append(v_y/ampl)
+                norm_e_z.append(v_z/ampl)
+
+            for i in range(len(coor_e_x)):
+                normals_view.append(coor_e_x[i])
+                normals_view.append(coor_e_y[i])
+                normals_view.append(coor_e_z[i])
+                normals_view.append(norm_e_x[i])
+                normals_view.append(norm_e_y[i])
+                normals_view.append(norm_e_z[i])
+            norm_dict['x'] = coor_e_x
+            norm_dict['y'] = coor_e_y
+            norm_dict['z'] = coor_e_z
+            norm_dict['n_x'] = norm_e_x
+            norm_dict['n_y'] = norm_e_y
+            norm_dict['n_z'] = norm_e_z
+            return norm_dict, normals_view
+        """
+        This is helper function called in a loop below.
+        """
+        max_tag = 0
+        for f_name in self.cctwi.w_names+self.cctwi.f_names:
+            vol_tags = json.load(open(os.path.join(self.model_folder, f'{f_name}.vi')))
+            export_tags = vol_tags['export']
+            tags_for_normals = [e + max_tag for e in export_tags]
+            max_tag = np.max(vol_tags['all']) + max_tag
+            surfs_idx_l = [0, 2]    # along length of the former groove
+            if f_name in self.cctwi.w_names:
+                surfs_scale_l = [1, 1]
+            elif f_name in self.cctwi.f_names:
+                surfs_scale_l = [1, -1]     # change direction for fqpl
+            norm_l, norm_view_l = _calc_normals_dir(tags_for_normals, surfs_idx_l, surfs_scale_l)
+            surfs_idx_h = [1, 3]         # along height of the former groove
+            surfs_scale_h = [1, -1]
+            norm_h, norm_view_h = _calc_normals_dir(tags_for_normals, surfs_idx_h, surfs_scale_h)
+            surfs_idx_w = [4, 5]        # along width of the former groove
+            surfs_scale_w = [1, -1]
+            norm_w, norm_view_w = _calc_normals_dir(tags_for_normals, surfs_idx_w, surfs_scale_w)
+            normals_dict = {'normals_l': norm_l, 'normals_h': norm_h, 'normals_w': norm_w}
+            json.dump(normals_dict, open(f"{os.path.join(self.model_folder, f_name)}.normals", 'w'))
+            if gui:
+                normals_all = [norm_view_l, norm_view_h, norm_view_w]
+                self.__add_normals_view(f_name, normals_all)
+        if self.verbose:
+            print(f'Calculating Normals Took {timeit.default_timer() - start_time:.2f} s')
+        if gui:
+            self.gu.launch_interactive_GUI()
+
+    @staticmethod
+    def __add_normals_view(name, normals_all, norm_list=[0, 1, 2]):
+        """
+        THis adds new view in gmsh.
+        :param name: name of view
+        :param normals_all: dictionary with normals
+        :param norm_list: which normals to plot. Default is: [0, 1, 2] corresponds to [n_l, n_h, n_w]. If this array is shorter the corresponding normals are skipped in views.
+        :return:
+        """
+        norm_names_all = [f"{name}_n_l", f"{name}_n_h", f"{name}_n_w"]
+        norm_names = [norm_names_all[index] for index in norm_list]
+        normals = [normals_all[index] for index in norm_list]
+        for view_name, view_data in zip(norm_names, normals):
+            gmsh.view.addListData(gmsh.view.add(view_name), "VP", len(view_data) // 6, view_data)
+        gmsh.model.occ.synchronize()