femagtools 1.3.0__py3-none-any.whl → 1.3.2__py3-none-any.whl

femagtools/__init__.py

@@ -9,7 +9,7 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.3.0'
+__version__ = '1.3.2'
 __author__ = 'Ronald Tanner'
 __license__ = 'BSD'
 __copyright__ = 'Copyright 2016-2022 SEMAFOR Informatik & Energie AG'

femagtools/airgap.py

@@ -9,6 +9,7 @@
 """
 import numpy as np
 import logging
+from . import utils
 
 logger = logging.getLogger(__name__)
 
@@ -22,49 +23,22 @@ def fft(pos, b, pmod=0):
       b: (list of floats) flux density values
       pmod: number of poles in model (ignored if 0)
     """
-    model_angle = pos[-1] - pos[0]
-    ntiles = int(round(360/model_angle))
-
-    if pmod:
-        negative_periodic = pmod % 2
-    else:
-        negative_periodic = np.abs(b[0] - b[-1])/np.max(b) > 1
-
-    if negative_periodic:
-        bx = np.append(
-            np.concatenate(
-                [n*b[:-1]
-                 for n in [m % 2 or -1
-                           for m in range(1, ntiles+1)]]),
-            b[0])
-    else:
-        bx = np.append(
-            np.tile(b[:-1], ntiles),
-            b[0])
-
-    N = len(bx)
-    # compute DFT from induction
-    Y = np.fft.fft(bx)
-
-    # find the peak (amplitude of base harmonic)
-    i = np.argmax(np.abs(Y[:N//2]))
-    a = 2*np.abs(Y[i])/N
-    freq = np.fft.fftfreq(N, d=pos[1]-pos[0])
-    T0 = np.abs(1/freq[i])
+    r = utils.fft(pos, b, pmod)
+    Bamp = r['a']
+    alfa0 = r['alfa0']
+    T0 = r['T0']
     npoles = 2*int(np.ceil(360/T0))
     logger.info("flux density: %s poles B amp %f ",
-                npoles, a)
-
-    alfa0 = np.angle(Y[i])
-    return dict(Bamp=a, npoles=npoles,
+                npoles, r['a'])
+    return dict(Bamp=Bamp, npoles=npoles,
                 phi0=alfa0,
                 pos=pos.tolist(),
                 B=b.tolist(),
                 nue=np.arange(0, 9*npoles).tolist(),
-                B_nue=(2*np.abs(Y[:9*npoles])/N).tolist(),
-                B_fft=(a*np.cos(2*np.pi*pos/T0+alfa0)).tolist(),
-                Bi=bx.tolist(),
-                phi=np.linspace(pos[0], 360+pos[0], len(bx)).tolist())
+                B_nue=r['nue'],
+                B_fft=(Bamp*np.cos(2*np.pi*pos/T0+alfa0)).tolist(),
+                Bi=r['yi'],
+                phi=np.linspace(pos[0], 360+pos[0], len(r['yi'])).tolist())
 
 
 def read(filename, pmod=0):

femagtools/amela.py

@@ -11,12 +11,110 @@ import logging
 from pathlib import Path
 import femagtools.nc
 import numpy as np
-from numpy import pi
+from numpy import pi, sin, cos
 import subprocess
 
 #  set logging
 logger = logging.getLogger(__name__)
 
+def geometry_id(bndx, bndy):
+    '''identify the magnet geometry''' 
+    # caculate magnet area 
+    xy = 0
+    yx = 0
+    for i in range(len(bndy)):
+        if i < (len(bndy)-1):
+            xy += bndx[i]*bndy[i+1]
+            yx += bndy[i]*bndx[i+1]
+        else:
+            xy += bndx[i]*bndy[0]
+            yx += bndy[i]*bndx[0]
+    area = np.abs(yx-xy)*0.5
+
+    x0, y0 = np.mean(bndx), np.mean(bndy)
+    distances = [] 
+    for i in range(len(bndx)): 
+        for j in range(len(bndy)): 
+            dist = np.sqrt((bndx[i] - bndx[j])**2 + (bndy[i] - bndy[j])**2)
+            distances.append([dist, bndx[i], bndx[j], bndy[i], bndy[j]])
+    
+    distances.sort(reverse=True)
+    xe = [distances[0][2], distances[2][1], distances[0][1], distances[2][2]]
+    ye = [distances[0][4], distances[2][3], distances[0][3], distances[2][4]]
+
+    # dimension 
+    dim = np.zeros((3, 5))
+    x1, y1 = xe[0], ye[0]
+
+    for i in range(3): 
+        x2, y2 = xe[i+1], ye[i+1]
+        dim[i, 0] = np.sqrt((x2-x1)**2 + (y2-y1)**2)
+        dim[i, 1:3] = [x1, x2]
+        dim[i, 3:5] = [y1, y2]
+
+    dim = dim[np.lexsort((dim[:, 2], dim[:, 1], dim[:, 0]))]
+    dx12, dy12 = dim[1, 1] - dim[1, 2],  dim[1, 3] - dim[1, 4]
+    dx14, dy14 = dim[0, 1] - dim[0, 2],  dim[0, 3] - dim[0, 4]
+    
+    alp1 = np.arctan2(dy12, dx12)
+    alp2 = np.arctan2(dy14, dx14)
+
+    if alp1 < 0: alp1 += 2*np.pi
+    if alp2 < 0: alp2 += 2*np.pi
+    if alp2 < alp1: 
+        alp2 += np.pi
+        alpha = (alp1 + (alp2 - np.pi/2))/2
+    else: 
+        alpha = (alp1 + (alp2 - np.pi/2))/2 + np.pi
+    
+    wm = dim[1, 0]
+    hm = area/wm 
+
+    return dict(wm=wm, 
+                hm=hm, 
+                x0=x0, 
+                y0=y0,
+                area=area, 
+                alpha=alpha)
+
+def tf(b1, b2, alpha):
+    '''Tranformation Matrix'''
+    T = np.array([[cos(alpha), sin(alpha)], 
+                [-sin(alpha), cos(alpha)]]) 
+    if b1.ndim > 1: 
+        r = T.dot(((b1.ravel()), (b2.ravel())))
+        return [r[0, :].reshape(*b1.shape), 
+                r[1, :].reshape(*b1.shape)]
+    else: 
+        return T.dot(((b1), (b2)))
+
+def transform_coord(geometry, xcp, ycp): 
+    '''transform from global coord to local coord'''
+    # transformation 
+    elcp = tf(b1=np.array(xcp)-geometry['x0'], 
+              b2=np.array(ycp)-geometry['y0'], 
+              alpha=geometry['alpha'])
+    return dict(excpl=elcp[0, :]+geometry['wm']/2, 
+                eycpl=elcp[1, :]+geometry['hm']/2, 
+                excp=np.array(xcp), 
+                eycp=np.array(ycp))
+
+def transform_flux_denstiy(geometry, bx, by): 
+    '''transform the magnet flux density to local coordinate system'''
+    # transformation 
+    bxy = tf(b1=bx, 
+             b2=by, 
+             alpha=geometry['alpha'])
+
+    # remove DC component
+    bxf = np.mean(bxy[0].T - np.mean(bxy[0],axis=1).T,axis=1)
+    byf = np.mean(bxy[1].T - np.mean(bxy[1],axis=1).T,axis=1)               
+     
+    return dict(bxl=bxy[0],
+                byl=bxy[1],
+                bxf=bxf, 
+                byf=byf 
+                )
 
 class Amela():
     '''Run Amela Calculation
@@ -66,7 +164,7 @@ class Amela():
         if 'nseglen' in self.magn:
             self.cmd.append(f"--nseglen {self.magn['nseglen']}")
 
-    def get_magnet_data(self):
+    def get_magnet_data(self, ibeta=None):
         '''Extract magnet data from nc file
         Parameters
         ----------
@@ -92,7 +190,15 @@ class Amela():
         ycp = [[] for i in range(len(spel_key))]
         bndx = [[] for i in range(len(spel_key))]
         bndy = [[] for i in range(len(spel_key))]
-
+        # prepare data for ialh method
+        wm = []
+        hm = []
+        alpha = []
+        x0 = [] 
+        y0 = []
+        geometry = []
+        elcp = []
+        bl = []
         # conductivity and permeability of the magnets
         cond = 0
         mur = 0
@@ -124,15 +230,26 @@ class Amela():
                 bndkey[k].pop(-1)
                 bndx[k].pop(-1)
                 bndy[k].pop(-1)
+            geo = geometry_id(bndx=bndx[k], bndy=bndy[k])
+            geometry.append(geo)
+            # necessary?
+            hm.append(geo['hm'])
+            wm.append(geo['wm'])
+            x0.append(geo['x0'])
+            y0.append(geo['y0'])
+            alpha.append(geo['alpha'])
 
         # default load angle (input beta I vs Up)
-        num_cases = r.el_fe_induction_1.shape[3] - 1
-        if 'loadcase' in self.magn:
-            indx = self.magn['loadcase'] - 1
+        if ibeta is not None:
+            indx = ibeta
         else:
-            indx = num_cases
-        if indx == 3:
-            indx = num_cases  # avoid error
+            num_cases = r.el_fe_induction_1.shape[3] - 1
+            if 'loadcase' in self.magn:
+                indx = self.magn['loadcase'] - 1
+            else:
+                indx = num_cases
+            if indx == 3:
+                indx = num_cases  # avoid error
 
         # stationary case, no rotation
         poles = 0
@@ -159,6 +276,10 @@ class Amela():
                     by[i][0][index, :] = fd['bx']*np.sin(theta) + \
                         fd['by']*np.cos(theta)
 
+            elcp.append(transform_coord(geometry[i], xcp[i], ycp[i]))
+            bl.append(transform_flux_denstiy(geometry[i], bx[i][0], by[i][0]))
+
+
         if poles == 0:
             freq = self.magn.get('f', r.speed)
             time_vec = np.linspace(0, 1/freq, len(r.pos_el_fe_induction))
@@ -177,9 +298,10 @@ class Amela():
         pm_data = []
         for i in range(len(spel_key)):
             pm_data.append(dict(name='pm_data_se' + str(spel_key[i]),
-                                hm=self.magn.get('hm', 0),
-                                wm=self.magn.get('wm', 0),
+                                hm=self.magn.get('hm', hm[i]),
+                                wm=self.magn.get('wm', wm[i]),
                                 lm=self.magn.get('lm', r.arm_length*1e3),
+                                alpha=alpha[i],
                                 ls=r.arm_length*1e3,
                                 sigma=float(self.magn.get('sigma', cond)),
                                 mur=float(self.magn.get('mur', mur)),
@@ -190,7 +312,10 @@ class Amela():
                                 bndkeys=bndkey[i],
                                 bndx=[float(c) for c in bndx[i]],
                                 bndy=[float(c) for c in bndy[i]],
-                                area=spel_area[i]))
+                                bl=bl[i],
+                                elcp=elcp[i],
+                                area=spel_area[i], 
+                                spel_key=spel_key[i]))
             pm_data[i].update(pos)
 
         for k in range(len(pm_node_key)):
@@ -215,6 +340,14 @@ class Amela():
         else:
             return [pm_data[0]]
 
+    def get_magnet_data_all(self, num_op): 
+        '''get all magnet data for all loadcases'''
+        pm_data = []
+        for i in num_op:
+            pmd = self.get_magnet_data(ibeta=i)
+            pm_data.append(pmd)
+        return pm_data
+
     def export_json(self, pm_data):
         '''Export magnet data to json files
         Parameters
@@ -230,6 +363,9 @@ class Amela():
         for i in pm_data:
             filename = (pm_dir / i['name']).with_suffix('.json')
             self.jsonfile.append(str(filename))  # for the future use
+            # pop out non necessary data
+            i.pop('bl')
+            i.pop('elcp')
             with filename.open('w') as f:
                 json.dump(i, f)
             logger.info('Exporting %s ...', i['name'])
@@ -279,4 +415,3 @@ class Amela():
         with log_file.open('w') as output:
             subprocess.run(cmd, stdout=output)
         return self.read_loss(r)
-        

femagtools/bch.py

@@ -170,6 +170,7 @@ class Reader:
         self.dqPar = {}
         self.ldq = {}
         self.losses = []
+        self.magnet_loss_th = []
         self.demag = []
         self.weights = []
         self.weight = {}
@@ -1497,11 +1498,12 @@ class Reader:
             if l.find('Fe-Losses-Rotor') > -1:
                 rec = self.__findNums(content[i+3])
                 if len(rec) == 2:
-                    if content[i+1].find('Iron') > -1 and content[i+1].find('StJo') > 0:
+                    if (content[i+1].find('Iron') > -1 and content[i+1].find('StJo') > 0 or
+                        content[i+1].split() == ['RoZa', 'RoJo']):
                         self.external_rotor = True
                         # TODO: there might be better places to check this
-                        losses['stajo'] = floatnan(rec[0])
-                        losses['staza'] = floatnan(rec[1])
+                        losses['staza'] = floatnan(rec[0])
+                        losses['stajo'] = floatnan(rec[1])
                         losses['total'] += losses['staza']+losses['stajo']
                     else:
                         losses['rotfe'] = floatnan(rec[1])
@@ -1509,6 +1511,20 @@ class Reader:
                 i += 4
                 continue
 
+            if l.find('Fe-Losses-Stator') > -1:
+                rec = self.__findNums(content[i+3])
+                if len(rec) == 2:
+                    if content[i+1].split() == ['StJo', 'StZa']:
+                        losses['stajo'] = floatnan(rec[0])
+                        losses['staza'] = floatnan(rec[1])
+                        losses['total'] += losses['staza']+losses['stajo']
+
+                    if content[i+1].split() == ['rotf', '----']:
+                        losses['rotfe'] = sum([floatnan(x) for x in rec])
+                        losses['total'] += losses['rotfe']
+                i += 4
+                continue
+
             if l.find('Magnet-Losses') > -1:
                 rec = self.__findNums(content[i+1])
                 if len(rec) == 1:

femagtools/dxfsl/area.py

@@ -39,6 +39,8 @@ class Area(object):
         self.min_air_angle = 0.0
         self.max_air_angle = 0.0
         self.close_to_ag = False
+        self.close_to_ag_startcorner = False
+        self.close_to_ag_endcorner = False
         self.close_to_startangle = False
         self.close_to_endangle = False
         self.mag_rectangle = False
@@ -128,6 +130,18 @@ class Area(object):
         except Exception as e:
             return
 
+    def has_fsl(self):
+        try:
+            return self.fsl
+        except AttributeError:
+            return True
+
+    def list_of_equal_edges(self, a):
+        for e1 in self.area:
+            for e2 in a.area:
+                if e1.n1 == e2.n1 and e1.n2 == e2.n2:
+                    yield e1
+
     def virtual_nodes(self, render=False):
         if len(self.area) < 2:
             return
@@ -1044,6 +1058,12 @@ class Area(object):
                         return True
         return False
 
+    def is_touching_areas(self, areas):
+        for a in areas:
+            if self.is_touching(a):
+                return True
+        return False
+
     def mark_stator_subregions(self,
                                is_inner,
                                stator_size,
@@ -1143,18 +1163,37 @@ class Area(object):
                 logger.debug("***** air (part of a circle)\n")
                 return self.type
 
+        def bad_winding_position():
+            if is_inner:
+                radius_third = airgap_radius - (airgap_radius - opposite_radius) * 0.33
+                if self.max_dist < radius_third:
+                    return True
+            else:  # outer
+                radius_third = airgap_radius + (opposite_radius - airgap_radius) * 0.33
+                if self.min_dist > radius_third:
+                    return True
+            return False
+
         if self.min_angle > 0.001:
             if self.max_angle < alpha - 0.001:
-                self.type = 2  # windings
-                logger.debug("***** windings #1\n")
+                if bad_winding_position():
+                    self.type = 12  # windings or air
+                    logger.debug("***** windings or air #1\n")
+                else:
+                    self.type = 2  # windings
+                    logger.debug("***** windings #1\n")
                 return self.type
             if mirrored:
-                self.type = 2  # windings
-                logger.debug("***** windings #2\n")
+                if bad_winding_position():
+                    self.type = 12  # windings or air
+                    logger.debug("***** windings or air #2\n")
+                else:
+                    self.type = 2  # windings
+                    logger.debug("***** windings #2\n")
                 return self.type
 
             self.type = 0  # air
-            logger.debug("***** air #2")
+            logger.debug("***** air #3")
 
         if self.close_to_startangle or self.close_to_endangle:
             f = self.surface / stator_size
@@ -1167,7 +1206,7 @@ class Area(object):
                 logger.debug("***** air or iron close to border\n")
             return self.type
 
-        logger.debug("***** air #3\n")
+        logger.debug("***** air #4\n")
         return 0
 
     def mark_rotor_subregions(self, is_inner, mirrored, alpha,
@@ -1319,6 +1358,15 @@ class Area(object):
         logger.debug(">>> air remains")
         return self.type
 
+    def mark_airgap_corners(self, start_cp, end_cp):
+        for n in self.list_of_nodes():
+            if self.close_to_startangle:
+                if points_are_close(n, start_cp):
+                    self.close_to_ag_startcorner = True
+            if self.close_to_endangle:
+                if points_are_close(n, end_cp):
+                    self.close_to_ag_endcorner = True
+
     def area_size(self):
         nodes = [n for n in self.list_of_nodes()]
         return area_size(nodes)
@@ -1455,14 +1503,19 @@ class Area(object):
 
     def __str__(self):
         return "Area {}\n".format(self.id) + \
-            "distance: from {} to {}\n".\
+            "distance...............: from {} to {}\n".\
             format(round(self.min_dist, 4), round(self.max_dist, 4)) + \
-            "height..: {}\n".format(self.height) + \
-            "alpha...: {}\n".format(self.alpha) + \
-            "angle...: from {} to {}\n".\
+            "height.................: {}\n".format(self.height) + \
+            "alpha..................: {}\n".format(self.alpha) + \
+            "angle..................: from {} to {}\n".\
             format(round(self.min_angle, 6), round(self.max_angle, 6)) + \
-            "delta...: {}\n".format(self.delta) + \
-            "number..: {}\n".format(self.count) + \
-            "equal...: {}\n".format(len(self.equal_areas)) + \
-            "symmetry: {}\n".format(self.symmetry) + \
-            "sym_type: {}".format(self.sym_type)
+            "delta..................: {}\n".format(self.delta) + \
+            "number.................: {}\n".format(self.count) + \
+            "equal areas............: {}\n".format(len(self.equal_areas)) + \
+            "symmetry...............: {}\n".format(self.symmetry) + \
+            "symmetry type..........: {}\n".format(self.sym_type) + \
+            "close to airgap........: {}\n".format(self.close_to_ag) + \
+            "close to startangle....: {}\n".format(self.close_to_startangle) + \
+            "close to endangle......: {}\n".format(self.close_to_endangle) + \
+            "close to ag startcorner: {}\n".format(self.close_to_ag_startcorner) + \
+            "close to ag endcorner..: {}\n".format(self.close_to_ag_endcorner)

femagtools/dxfsl/converter.py

@@ -240,6 +240,7 @@ def convert(dxfile,
                                         cols=2,  # columns
                                         num=3)   # start num
         machine_inner.set_inner()
+        machine_inner.check_and_correct_geom("Inner")
 
         machine_outer = machine.copy(0.0, 2*np.pi, True, False)
         machine_outer = symmetry_search(machine_outer,
@@ -251,6 +252,7 @@ def convert(dxfile,
                                         rows=3,  # rows
                                         cols=2,  # columns
                                         num=4)   # start num
+        machine_outer.check_and_correct_geom("Outer")
 
         machine_inner.sync_with_counterpart(machine_outer)
 
@@ -273,22 +275,25 @@ def convert(dxfile,
 
         machine_inner.delete_tiny_elements(mindist)
         machine_outer.delete_tiny_elements(mindist)
+        machine_inner.geom.create_corner_areas()
         logger.info("END of work: %s", basename)
 
         if show_plots:
             p.render_elements(machine_inner.geom, Shape,
                               draw_inside=True, title=inner_name,
                               rows=3, cols=2, num=5, show=False,
-                              # with_nodes=True,
-                              # neighbors=True,
+                              with_corners=False,
+                              with_nodes=False,
+                              neighbors=False,
                               write_id=write_id,
                               fill_areas=True)
 
             p.render_elements(machine_outer.geom, Shape,
                               draw_inside=True, title=outer_name,
                               rows=3, cols=2, num=6, show=False,
-                              # with_nodes=True,
-                              # neighbors=True,
+                              with_corners=False,
+                              with_nodes=False,
+                              neighbors=False,
                               write_id=write_id,
                               fill_areas=True)
             if write_png:
@@ -394,6 +399,7 @@ def convert(dxfile,
                     machine = machine.undo_mirror()
                     machine.geom.set_stator()
                     machine.geom.search_stator_subregions(part[1])
+                    machine.geom.looking_for_corners()
                     machine.create_mirror_lines_outside_windings()
 
                 params = create_femag_parameters_stator(machine,
@@ -401,20 +407,23 @@ def convert(dxfile,
             else:
                 machine.geom.set_rotor()
                 machine.geom.search_rotor_subregions(part[1])
+                machine.geom.looking_for_corners()
                 params = create_femag_parameters_rotor(machine,
                                                        part[1])
         else:
             machine.geom.search_subregions()
 
         machine.delete_tiny_elements(mindist)
+        machine.geom.create_corner_areas()
         logger.info("END of work: %s", basename)
 
         if show_plots:
             p.render_elements(machine.geom, Shape,
                               draw_inside=True, title=name,
                               rows=3, cols=2, num=5, show=False,
-                              # with_nodes=True,
-                              # neighbors=True,
+                              with_corners=False,
+                              with_nodes=False,
+                              neighbors=False,
                               write_id=write_id,
                               fill_areas=True)
             if write_png:

femagtools/dxfsl/fslrenderer.py

@@ -110,14 +110,19 @@ class FslRenderer(object):
         # if self.nodedist > 0:
         #     l = la.norm(np.asarray(p1)-p2)
         #     num = int(l/self.nodedist + 1)
-        if e is not None and e.has_attribute('auxline'):
-            self.content.append(
-                u"nc_line({}, {}, {}, {}, {}) -- auxiliary".format(
-                    p1[0], p1[1], p2[0], p2[1], num))
-        else:
-            self.content.append(
-                u"nc_line({}, {}, {}, {}, {})".format(
-                    p1[0], p1[1], p2[0], p2[1], num))
+        if e is not None:
+            if e.has_attribute('no_fsl'):
+                logger.info("line with attr nofsl")
+                return
+            if e.has_attribute('auxline'):
+                self.content.append(
+                    u"nc_line({}, {}, {}, {}, {}) -- auxiliary".format(
+                        p1[0], p1[1], p2[0], p2[1], num))
+                return
+
+        self.content.append(
+            u"nc_line({}, {}, {}, {}, {})".format(
+                p1[0], p1[1], p2[0], p2[1], num))
 
     def sorted_elements(self, geom, inner=False):
         if inner:

femagtools/dxfsl/functions.py

@@ -288,7 +288,7 @@ def is_same_angle(angle1, angle2, atol=0.001):
             np.isclose(np.sin(angle1), np.sin(angle2), atol=atol))
 
 
-def part_of_circle(startangle, endangle, dec_place=3):
+def part_of_circle(startangle, endangle, dec_place=2):
     """ returns the number of segments included in the circle
       if an integer number, 0 otherwise
     """