fiqus 2024.7.0__py3-none-any.whl → 2024.12.1__py3-none-any.whl

fiqus/post_processors/PostProcessPancake3D.py

@@ -11,7 +11,6 @@ import matplotlib
 import matplotlib.pyplot as plt
 
 from fiqus.mains.MainPancake3D import Base
-import fiqus.data.DataFiQuSPancake3D as dm
 from fiqus.utils.Utils import GmshUtils
 from fiqus.parsers.ParserGetDPTimeTable import ParserGetDPTimeTable
 from fiqus.parsers.ParserGetDPOnSection import ParserGetDPOnSection
@@ -217,22 +216,18 @@ class Postprocess(Base):
             filePath = os.path.join(
                 self.solution_folder, timeSeriesPlot.fileName + "-TimeTableFormat.csv"
             )
-            # check if this is Pancake3DPositionInCoordinates or not:
-            if isinstance(
-                timeSeriesPlot, dm.Pancake3DPostprocessTimeSeriesPlotPositionRequired
-            ):
-                if isinstance(
-                    timeSeriesPlot.position, dm.Pancake3DPositionInCoordinates
-                ):
+
+            if hasattr(timeSeriesPlot, 'position'):
+                if hasattr(timeSeriesPlot.position, 'turnNumber'):
                     title = (
-                        f"{timeSeriesPlot.quantityProperName} at"
-                        f" ({timeSeriesPlot.position.x}, {timeSeriesPlot.position.y},"
-                        f" {timeSeriesPlot.position.z})"
+                        f"{timeSeriesPlot.quantityProperName} at turn"
+                        f" {timeSeriesPlot.position.turnNumber}"
                     )
                 else:
                     title = (
-                        f"{timeSeriesPlot.quantityProperName} at turn"
-                        f" {timeSeriesPlot.position.turnNumber}"
+                        f"{timeSeriesPlot.quantityProperName} at"
+                        f" ({timeSeriesPlot.position.x}, {timeSeriesPlot.position.y},"
+                        f" {timeSeriesPlot.position.z})"
                     )
             else:
                 title = f"{timeSeriesPlot.quantityProperName}"

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()

fiqus/pro_assemblers/ProAssembler.py

@@ -1,6 +1,7 @@
 from fiqus.pro_templates import combined
 from jinja2 import Environment, FileSystemLoader
 import numpy as np
+import os
 
 
 class ASS_PRO:
@@ -16,26 +17,33 @@ class ASS_PRO:
         else:
             self.naming_conv = naming_conv
 
-    def assemble_combined_pro(self, template, rm, dm, rc=None, mf=None, ps=None, ed=None, mp=None, BH_curves_path: str = ''):
+    def assemble_combined_pro(self, template, dm, rm=None, mf=None, ps=None, ed=None, mp=None, rm_EM=None, rm_TH=None, rc=None,
+                              BH_curves_path: str = '', external_templates_paths: list = None):
         """
         Generates model .pro file from .pro template and regions model (rm)
+        :param external_templates_paths: list of paths to external templates directories
         :param BH_curves_path: path of the BH curves pro file
         :param template: .pro template file name
         :param rm: regions model data structure (yaml loaded to regions data model)
+        :param rm_EM: regions model data structure for electromagnetics (yaml loaded to regions data model)
+        :param rm_TH: regions model data structure for thermal (yaml loaded to regions data model)
         :param rc: regions coordinates data structure
         :param dm: data model structure
         :param mf: full path to mesh file to be used in solution
         :param ps: previous solution folder (this is used by CWS for co-simulation run)
         :param ed: excitation dictionary with lists (e.g. times and currents) to be used in a pro file (e.g. transient simulation)
-        :param mp: material properties data structure (for CAC with Geometry YAML)
+        :param mp: material properties data structure
         :return: None. Generates .pro file and saves it on disk in the model folder under model_name.pro
         """
-        loader = FileSystemLoader(combined.__path__)
+        external_templates_paths = external_templates_paths if external_templates_paths else []
+        loader = FileSystemLoader([os.path.dirname(combined.__file__)] + external_templates_paths)
         env = Environment(loader=loader, variable_start_string='<<', variable_end_string='>>',
-                          trim_blocks=True, lstrip_blocks=True)
-        env.globals.update(set=set, str=str, int=int, float=float, zip=zip, enumerate=enumerate, list=list, len=len, isinstance=isinstance, arange=np.arange, Pi=np.pi)  # this is to pass python zip function to the template, as normally it is not available. It should work for passing any python function that is not available in .pro template.
+                          trim_blocks=True, lstrip_blocks=True, extensions=['jinja2.ext.do'])
+        env.globals.update(set=set, str=str, int=int, float=float, zip=zip, enumerate=enumerate, list=list,
+                           len=len, isinstance=isinstance, arange=np.arange, Pi=np.pi)  # this is to pass python zip function to the template, as normally it is not available. It should work for passing any python function that is not available in .pro template.
         pro_template = env.get_template(template)
-        output_from_parsed_template = pro_template.render(BHcurves=BH_curves_path, rm=rm, rc=rc, dm=dm, mf=mf, nc=self.naming_conv, ps=ps, ed=ed, mp=mp)
+        output_from_parsed_template = pro_template.render(BHcurves=BH_curves_path, dm=dm, rm=rm, mf=mf, nc=self.naming_conv,
+                                                          ps=ps, ed=ed, mp=mp, rm_EM=rm_EM, rm_TH=rm_TH, rc=rc)
         with open(f"{self.file_base_path}.pro", "w") as tf:
             tf.write(output_from_parsed_template)