femagtools 1.8.1__py3-none-any.whl → 1.8.2__py3-none-any.whl

femagtools/dxfsl/shape.py

@@ -11,7 +11,7 @@ from __future__ import print_function
 import numpy as np
 import logging
 from .functions import less_equal, greater_equal
-from .functions import distance, line_m, line_n
+from .functions import distance, line_m, line_n, mirror_point
 from .functions import point, points_are_close, points_on_arc
 from .functions import alpha_line, alpha_angle, alpha_triangle
 from .functions import normalise_angle, min_angle, max_angle, get_angle_of_arc
@@ -54,6 +54,9 @@ class Shape(object):
     def classname(self):
         return "Shape"
 
+    def clone(self):
+        return None
+
     def set_my_color(self, color):
         self.my_color = color
 
@@ -314,6 +317,32 @@ class Shape(object):
     def is_near(self, n):
         return False
 
+    def mirror_shape(self, geom_center, axis_m, axis_n):
+        n2 = mirror_point(self.start(), geom_center, axis_m, axis_n)
+        n1 = mirror_point(self.end(), geom_center, axis_m, axis_n)
+
+        el = None
+        if isinstance(self, Line):
+            el = Line(Element(start=n1, end=n2))
+
+        elif isinstance(self, Arc):
+            c = mirror_point(self.center, geom_center, axis_m, axis_n)
+            alpha1 = alpha_line(c, n1)
+            alpha2 = alpha_line(c, n2)
+            el = Arc(Element(center=c,
+                             radius=self.radius,
+                             start_angle=alpha1*180/np.pi,
+                             end_angle=alpha2*180/np.pi))
+
+        elif isinstance(self, Circle):
+            c = mirror_point(self.center, geom_center, axis_m, axis_n)
+            el = Circle(Element(center=c,
+                                radius=self.radius))
+
+        if el:
+            el.copy_attributes(self)
+        return el
+
     def print_nodes(self):
         return " n1={}/n2={}".format(self.n1, self.n2)
 
@@ -354,6 +383,10 @@ class Circle(Shape):
     def classname(self):
         return "Circle"
 
+    def clone(self):
+        return Circle(Element(center=self.center,
+                              radius=self.radius))
+
     def render(self, renderer, color='blue', with_nodes=False):
         tmp_color = self.get_my_color()
         if not tmp_color:
@@ -742,6 +775,14 @@ class Arc(Circle):
     def classname(self):
         return "Arc"
 
+    def clone(self):
+        alpha_start = alpha_line(self.center, self.p1)
+        alpha_end = alpha_line(self.center, self.p2)
+        return Arc(Element(center=self.center,
+                           radius=self.radius,
+                           start_angle=alpha_start*180/np.pi,
+                           end_angle=alpha_end*180/np.pi))
+
     def render(self, renderer, color='blue', with_nodes=False):
         tmp_color = self.get_my_color()
         if not tmp_color:
@@ -1285,6 +1326,10 @@ class Line(Shape):
     def classname(self):
         return "Line"
 
+    def clone(self):
+        return Line(Element(start=self.p1,
+                            end=self.p2))
+
     def render(self, renderer, color='blue', with_nodes=False):
         tmp_color = self.get_my_color()
         if not tmp_color:

femagtools/dxfsl/svgparser.py

@@ -106,7 +106,7 @@ def svgshapes(svgfile):
     for p in svg.findall(".//{http://www.w3.org/2000/svg}path"):
         m = bcolor.search(p.get('style'))
         if m:
-            logger.info("subregion %d: %s", sr, m.groups()[0])
+            logger.debug("subregion %d: %s", sr, m.groups()[0])
         yield from get_shapes(p.get('d'))
         sr += 1
     for p in svg.findall(".//{http://www.w3.org/2000/svg}line"):

femagtools/dxfsl/symmetry.py

@@ -12,6 +12,7 @@ import logging
 import sys
 from femagtools.dxfsl.shape import Element, Line
 from femagtools.dxfsl.area import Area
+import femagtools.dxfsl.area as AREA
 from femagtools.dxfsl.functions import alpha_angle, positive_angle, is_same_angle
 from femagtools.dxfsl.functions import min_angle, max_angle, gcd, point
 from femagtools.dxfsl.functions import less_equal, less, points_are_close
@@ -100,24 +101,25 @@ class Symmetry(object):
         return positive_angle(alpha_angle(self.startangle,
                                           a.get_mid_angle(self.geom.center)))
 
-    def find_symmetry(self):
-        arealist = self.geom.list_of_areas()
-        logger.debug("begin of Symmetry::find_symmetry: %s areas available", len(arealist))
-        if len(arealist) == 0:
-            logger.debug("end of find_symmetry: no areas")
-            return 0
+    def area_list_entry(self, a):
+        return (round(a.get_alpha(self.geom.center), 3),
+                round(a.min_dist, 1),
+                round(a.height, 1),
+                self.calc_mid_angle(a),
+                a)
 
-        logger.debug("startangle=%s, endangle=%s", self.startangle, self.endangle)
+    def build_area_list(self, types=()):
+        arealist = self.geom.list_of_areas()
+        if types:
+            arealist = [a for a in arealist if a.type in types]
 
         areas = []
         for a in arealist:
-            areas.append((round(a.get_alpha(self.geom.center), 3),
-                          round(a.min_dist, 1),
-                          round(a.height, 1),
-                          self.calc_mid_angle(a),
-                          a))
+            areas.append(self.area_list_entry(a))
         areas.sort(reverse=True)
+        return areas
 
+    def build_results(self, areas):
         a0_alpha, a0_min_dist, a0_height, a0_mid_angle, a0 = areas[0]
         equal_areas = [(a0_mid_angle, a0)]
         check_rslt = []
@@ -146,6 +148,86 @@ class Symmetry(object):
         rslt['area'] = a0
         rslt['areasize'] = areasize
         check_rslt.append((areasize, rslt))
+        return check_rslt
+
+    def get_winding_symmetry(self, inside=False):
+        if inside:
+            areas = [self.area_list_entry(a) for a in self.geom.list_of_areas()
+                     if not a.close_to_ag]
+        else:
+            areas = self.build_area_list((AREA.TYPE_WINDINGS,))
+
+        logger.debug("begin of Symmetry::get_winding_symmetry: %s areas available", len(areas))
+        if not areas:
+            logger.debug("end of Symmetry::get_winding_symmetry: no areas")
+            return 0
+
+        check_rslt = self.build_results(areas)
+        logger.debug("%s results available", len(check_rslt))
+        [logger.debug("Result: %s", rslt) for rslt in check_rslt]
+
+        parts, start_delta = self.get_symmetry_parts(check_rslt)
+        if parts <= 1:
+            return 0
+        self.create_cut_lines(parts, start_delta)
+
+        sym = self.geom_part * parts
+        delta = 2*np.pi/sym
+        self.set_symmetry_parameters(self.startangle, parts, delta)
+
+        logger.debug("end of Symmetry::get_winding_symmetry: parts=%s", parts)
+        return parts
+
+    def get_magnet_symmetry(self):
+        areas = self.build_area_list((AREA.TYPE_MAGNET_AIRGAP, AREA.TYPE_MAGNET_RECT,))
+        air = self.build_area_list((AREA.TYPE_AIR,))
+        mag_list = [a for a in self.geom.list_of_areas() if a.is_magnet()]
+        air_list = [a for a in self.geom.list_of_areas() if a.is_air()]
+        sz_list = [a.area_size() for a in self.geom.list_of_areas()]
+        max_sz = max(sz_list)
+        for a in air_list:
+            if a.area_size() < max_sz * 0.005:
+                continue
+            for m in mag_list:
+                if a.is_touching(m):
+                    areas.append(self.area_list_entry(a))
+                    break
+
+        logger.debug("begin of Symmetry::get_magnet_symmetry: %s areas available", len(areas))
+        if not areas:
+            logger.debug("end of Symmetry::get_magnet_symmetry: no areas")
+            return 0
+
+        check_rslt = self.build_results(areas)
+        logger.debug("%s results available", len(check_rslt))
+        [logger.debug("Result: %s", rslt) for rslt in check_rslt]
+        for sz, rslt in check_rslt:
+            if not rslt.get('startdelta', 0.0) == 0.0:
+                return 0  # not proper
+            if rslt.get('halfslice', None):
+                return 0  # not proper
+
+        parts, start_delta = self.get_symmetry_parts(check_rslt)
+        if parts <= 1:
+            return 0
+        self.create_cut_lines(parts, start_delta)
+
+        sym = self.geom_part * parts
+        delta = 2*np.pi/sym
+        self.set_symmetry_parameters(self.startangle, parts, delta)
+
+        logger.debug("end of Symmetry::get_magnet_symmetry: parts=%s", parts)
+        return parts
+
+    def find_symmetry(self):
+        areas = self.build_area_list()
+
+        logger.debug("begin of Symmetry::find_symmetry: %s areas available", len(areas))
+        if not areas:
+            logger.debug("end of Symmetry::find_symmetry: no areas")
+            return 0
+
+        check_rslt = self.build_results(areas)
 
         parts, start_delta = self.get_symmetry_parts(check_rslt)
         if parts < 2:
@@ -156,18 +238,7 @@ class Symmetry(object):
             self.startangle = self.startangle - self.delta_angle_corr
             self.endangle = self.endangle - self.delta_angle_corr
 
-        self.geom.clear_cut_lines()
-        for alpha in self.symmetry_lines(parts,
-                                         self.startangle,
-                                         start_delta,
-                                         self.endangle):
-            plus = self.geom.max_radius / 10
-            min_radius = max(10, self.geom.min_radius - plus)
-            p1 = point(self.geom.center, min_radius, alpha)
-            p2 = point(self.geom.center, self.geom.max_radius + plus, alpha)
-            line = Line(Element(start=p1, end=p2))
-            line.init_attributes(color='green')
-            self.geom.add_cut_line(line)
+        self.create_cut_lines(parts, start_delta)
 
         logger.debug("end of Symmetry::find_symmetry: -> %s", parts)
         return parts
@@ -375,9 +446,6 @@ class Symmetry(object):
 
                     dlist = []
                     x = 0
-                    # logger.info("inx: %s", inx)
-                    # [logger.info("%s deltas: %s", n, d) for n, d in deltas]
-                    # [logger.info("area: %s", m) for m, a in area_list]
 
                     for i in inx:
                         for n in range(x, i):
@@ -833,6 +901,20 @@ class Symmetry(object):
         logger.debug("return %s parts", parts)
         return parts
 
+    def create_cut_lines(self, parts, start_delta):
+        self.geom.clear_cut_lines()
+        for alpha in self.symmetry_lines(parts,
+                                         self.startangle,
+                                         start_delta,
+                                         self.endangle):
+            plus = self.geom.max_radius / 10
+            min_radius = max(10, self.geom.min_radius - plus)
+            p1 = point(self.geom.center, min_radius, alpha)
+            p2 = point(self.geom.center, self.geom.max_radius + plus, alpha)
+            line = Line(Element(start=p1, end=p2))
+            line.init_attributes(color='green')
+            self.geom.add_cut_line(line)
+
     def symmetry_lines(self, parts, startangle, start_delta, endangle):
         logger.debug("begin symmetry_lines from %s to %s with start %s",
                      startangle,
@@ -858,14 +940,17 @@ class Symmetry(object):
             yield start
 
         # Damit man anschliessend ohne Umstände schneiden kann.
-        self.geom.sym_startangle = sym_startangle
-        self.geom.sym_endangle = sym_startangle + delta
+        self.set_symmetry_parameters(sym_startangle, parts, delta)
+        logger.debug("end symmetry_lines")
+
+    def set_symmetry_parameters(self, startangle, parts, delta):
+        self.geom.sym_startangle = startangle
+        self.geom.sym_endangle = startangle + delta
         self.geom.sym_slices = parts
         self.geom.sym_slice_angle = delta
         self.geom.sym_area = Area([], (0,0), 0.0)
         self.geom.sym_area.sym_startangle = self.geom.sym_startangle
         self.geom.sym_area.sym_endangle = self.geom.sym_endangle
-        logger.debug("end symmetry_lines")
 
     def check_symmetry_of_mirror(self, mirror_geom, mirrorangle):
         logger.debug("begin of Symmetry::check_symmetry_of_mirror")

femagtools/fsl.py

@@ -158,13 +158,13 @@ class Builder:
         if templ == 'statorFsl':
             #  obsolete
             th_props = [' ']
-            try: 
+            try:
                 th_props = [f'stator_density = {model.stator["density"]}',
                             f'stator_thcond = {model.stator["thcond"]}',
                             f'stator_thcap = {model.stator["thcap"]}',
                             ]
-            except: 
-                pass 
+            except:
+                pass
             if 'parameter' in model.stator['statorFsl']:
                 return self.render_template(
                     model.stator['statorFsl']['content_template'],
@@ -226,20 +226,20 @@ class Builder:
             self.fsl_rotor = True
             #  obsolete
             th_props = [' ']
-            try: 
+            try:
                 logger.info(model.magnet)
                 th_props = [f'rotor_density = {model["magnet"]["density"]}',
                             f'rotor_thcond = {model["magnet"]["thcond"]}',
                             f'rotor_thcap = {model["magnet"]["thcap"]}'
                             ]
-            except: 
-                pass 
+            except:
+                pass
             if 'parameter' in model.magnet['magnetFsl']:
                 return mcv + self.render_template(
                     model.magnet['magnetFsl']['content_template'],
                     model.magnet['magnetFsl']['parameter']) + th_props
             elif model.magnet['magnetFsl'].get('content'):
-                return mcv + model.magnet['magnetFsl']['content'].split('\n') 
+                return mcv + model.magnet['magnetFsl']['content'].split('\n')
             if isinstance(model.magnet['magnetFsl']
                           ['content_template'], str):
                 with open(model.magnet['magnetFsl']
@@ -248,7 +248,7 @@ class Builder:
             else:
                 templ = model.magnet['magnetFsl']['content_template']
             return mcv + self.render_template(
-                '\n'.join(templ), 
+                '\n'.join(templ),
                 model.magnet['magnetFsl'])
 
         templ = model.magnettype()
@@ -364,8 +364,8 @@ class Builder:
         """return connect_model if rotating machine and incomplete model
         (Note: femag bug with connect model)"
         """
-        if (model.get('move_action') == 0 and (
-                model.connect_full or
+        if (model.connect_full or (
+                model.get('move_action', 0) == 0 and
                 model.stator['num_slots'] > model.stator['num_slots_gen'])):
             fslcmds = ['pre_models("connect_models")\n']
             if 'thcond' in model.stator:

femagtools/machine/__init__.py

@@ -68,8 +68,9 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
         psid = rwdg*rlfe*dqp['psid']
         psiq = rwdg*rlfe*dqp['psiq']
         losses = __scale_losses(dqp['losses'], rlfe)
-        losses['ef'] = dqpars[-1]['losses']['ef']
-        losses['eh'] = dqpars[-1]['losses']['ef']
+        losses['ef'] = dqpars[-1]['losses'].get('ef', [2.0, 2.0])
+        losses['hf'] = dqpars[-1]['losses'].get('hf', [1.0, 1.0])
+        # TODO handle bertotti excess loss factor
 
         if 'psidq' in eecpars:
             machine = PmRelMachinePsidq(
@@ -140,7 +141,7 @@ def create(bch, r1, ls, lfe=1, wdg=1):
             try:
                 losses = __scale_losses(bch.psidq['losses'], rlfe)
                 losses['ef'] = bch.lossPar.get('ef', [2.0, 2.0])
-                losses['eh'] = bch.lossPar.get('eh', [1.0, 1.0])
+                losses['hf'] = bch.lossPar.get('hf', [1.0, 1.0])
             except KeyError:
                 losses = {}
             if 'ex_current' in bch.machine:
@@ -162,7 +163,7 @@ def create(bch, r1, ls, lfe=1, wdg=1):
             try:
                 losses = __scale_losses(bch.ldq['losses'], rlfe)
                 losses['ef'] = bch.lossPar.get('ef', [2.0, 2.0])
-                losses['eh'] = bch.lossPar.get('eh', [1.0, 1.0])
+                losses['hf'] = bch.lossPar.get('hf', [1.0, 1.0])
             except KeyError:
                 losses = {}
             if 'ex_current' in bch.machine:

femagtools/machine/afpm.py

@@ -25,6 +25,25 @@ AFM_TYPES = (
     "S2R1_all"   # 2 stator, 1 rotor, all simulated
 )
 
+def num_agnodes(Q, p, pw, ag):
+    """return total number of nodes in airgap per pole
+     Args:
+      Q: (int) number of slots
+      p: (int) number of pole pairs
+      pw: (float) pole width
+      ag: (float) airgap height
+    """
+    num_nodes = np.arange(12, 120, 6)
+    i = np.argmin(np.abs(pw/num_nodes - ag/2))
+    if p*num_nodes[i-1] % Q:
+        lcm = np.lcm(Q, 2*p)//p
+        nmin, nmax = num_nodes[0]//lcm, num_nodes[-1]//lcm
+        num_nodes = np.array(
+            [i*lcm for i in range(nmin, nmax) if i*lcm % 6 == 0])
+        i = np.argmin(np.abs(pw/num_nodes - ag/2))
+        # nodedist 0.5, 2, 4, 6
+    return num_nodes[i-1]
+
 def _integrate(radius, pos, val):
     interp = RegularGridInterpolator((radius, pos), val)
     def func(x, y):
@@ -141,10 +160,8 @@ def parident(workdir, engine, temp, machine,
 
     if "num_agnodes" not in machine:
         for pw in pole_width:
-            machine['num_agnodes'] = 6*round(pw/machine['airgap']/4)
-
-            #if machine['num_agnodes'] < nper:
-            #    machine['num_agnodes'] = 8*round(pw/machine['airgap']/4)
+            machine['num_agnodes'] = num_agnodes(Q1, p//2, pw,
+                                                 machine['airgap'])
 
     nlparvardef = {
         "decision_vars": [
@@ -189,7 +206,8 @@ def parident(workdir, engine, temp, machine,
 
             nlresults = pstudy(nlparvardef, machine, nlcalc, engine)
             if nlresults['status'].count('C') != len(nlresults['status']):
-                raise ValueError('Noload simulation failed %s', nlresults['status'])
+                raise ValueError(
+                    f"Noload simulation failed {nlresults['status']}")
         else:
             nlresults = {"x": [], "f": []}
             i = 0
@@ -210,7 +228,7 @@ def parident(workdir, engine, temp, machine,
                 nlresults['f'].append({k: v for k, v in r.items()})
                 i = i + 1
         nlresults.update(process(lfe, pole_width, machine, nlresults['f']))
-
+        weights = nlresults['weights']
         current_angles = nlresults['f'][0]['current_angles']
         results = []
         i = 0
@@ -325,7 +343,7 @@ def parident(workdir, engine, temp, machine,
                                       (-1, num_beta_steps)),
                            axis=1).T.tolist()})
         ldq.append({'temperature': magtemp,
-                    'i1':i1, 'beta':beta,
+                    'i1': i1, 'beta': beta,
                     'psid': psid.tolist(), 'psiq': psiq.tolist(),
                     'ld': ld, 'lq': lq,
                     'torque': torque.tolist(),
@@ -334,7 +352,8 @@ def parident(workdir, engine, temp, machine,
         #iq, id = femagtools.machine.utils.iqd(*np.meshgrid(beta, i1))
 
     return {'m': machine[wdgk]['num_phases'],
-            'p': machine['poles']//2,
+            'p': machine['poles']//2, 'weights': weights,
+            'rotor_mass': sum(weights[1]), "kfric_b": 1,
             'ls1': 0, 'r1': r1, 'ldq': ldq}
 
 
@@ -442,8 +461,17 @@ def process(lfe, pole_width, machine, bch):
                         mmod.outer_diam, mmod.inner_diam)
     i1 = np.mean([np.max(c) for c in currents])/np.sqrt(2)
     plcu = mmod.winding['num_phases']*i1**2*r1
+    weights = np.array([[0, 0, 0], [0, 0, 0]])
+    try:
+        for b in bch:
+            weights = weights + b['weights']
+        weights *= scale_factor
+    except KeyError as exc:
+        #logger.warning("missing key %s", exc)
+        pass
 
     return {
+        'weights': weights.tolist(),
         'pos': pos.tolist(), 'r1': r1,
         'torque': torque,
         'emf': emf,
@@ -603,14 +631,12 @@ class AFPM:
                     for pw in pole_width]
 
         if "num_agnodes" not in machine:
+            Q1 = machine['stator']['num_slots']
+            p = machine['poles']
             for pw in pole_width:
-                machine['num_agnodes'] = 6*round(pw/machine['airgap']/4)
-                #Q = machine['stator']['num_slots']
-                #p = machine['poles']
-                #nper = np.lcm(Q, p)
-                #if machine['num_agnodes'] < nper:
-                #    machine['num_agnodes'] = 8*round(pw/machine['airgap']/4)
-
+                machine['num_agnodes'] = num_agnodes(Q1, p//2, pw,
+                                                     machine['airgap'])
+            logger.info("Num agnodes/pole %d", machine['num_agnodes'])
         parvardef = {
             "decision_vars": [
                 {"values": pole_width,