femagtools 1.5.7__py3-none-any.whl → 1.6.1__py3-none-any.whl

femagtools/dxfsl/machine.py

@@ -5,7 +5,7 @@
 from __future__ import print_function
 import numpy as np
 import logging
-from .shape import Element, Circle, Arc, Line, Shape
+from .shape import Element, Circle, Arc, Line
 from .corner import Corner
 from .functions import point, points_are_close, distance
 from .functions import alpha_angle, normalise_angle, middle_angle, third_angle
@@ -14,6 +14,7 @@ from .functions import within_interval, part_of_circle
 from .functions import less, less_equal, greater, greater_equal
 logger = logging.getLogger('femagtools.geom')
 
+
 #############################
 #          Machine          #
 #############################
@@ -170,7 +171,8 @@ class Machine(object):
 
     def copy(self, startangle, endangle,
              airgap=False, inside=True, split=False,
-             delete_appendices=False):
+             delete_appendices=False,
+             concatenate_tiny_el=False):
         if airgap and self.airgap_radius > 0.0:
             if inside:
                 if self.airgap2_radius > 0.0:
@@ -181,7 +183,8 @@ class Machine(object):
                                              startangle, endangle,
                                              0.0, new_radius,
                                              split=split,
-                                             delete_appendices=delete_appendices)
+                                             delete_appendices=delete_appendices,
+                                             concatenate_tiny_el=concatenate_tiny_el)
             else:
                 new_radius = self.radius
                 gap_radius = max(self.airgap_radius, self.airgap2_radius)
@@ -189,7 +192,8 @@ class Machine(object):
                                              startangle, endangle,
                                              gap_radius, self.radius+9999,
                                              split=split,
-                                             delete_appendices=delete_appendices)
+                                             delete_appendices=delete_appendices,
+                                            concatenate_tiny_el=concatenate_tiny_el)
 
             circ = Circle(Element(center=self.center,
                                   radius=self.airgap_radius))
@@ -200,7 +204,8 @@ class Machine(object):
                                          startangle, endangle, 0.0,
                                          self.radius+9999,
                                          split=split,
-                                         delete_appendices=delete_appendices)
+                                         delete_appendices=delete_appendices,
+                                         concatenate_tiny_el=concatenate_tiny_el)
 
         if not np.isclose(normalise_angle(startangle),
                           normalise_angle(endangle), 0.0):
@@ -231,6 +236,7 @@ class Machine(object):
         return clone.get_machine()
 
     def copy_mirror(self, startangle, midangle, endangle):
+        logger.debug("begin of copy_mirror")
         geom1 = self.geom.copy_shape(self.radius,
                                      startangle,
                                      midangle,
@@ -254,6 +260,7 @@ class Machine(object):
         machine.mirror_geom = geom2
         machine.mirror_startangle = midangle
         machine.mirror_endangle = endangle
+        logger.debug("end of copy_mirror")
         return machine
 
     def has_mirrored_windings(self):
@@ -279,16 +286,16 @@ class Machine(object):
             self.endangle += angle
 
     def airgap(self, correct_airgap=0.0, correct_airgap2=0.0, atol=0.1):
-        logger.debug('locking for airgap')
+        logger.debug('begin airgap (locking for airgap)')
         self.airgap_radius = 0.0
         self.airgap2_radius = 0.0
 
         if np.isclose(self.radius, 0.0):
-            logger.debug('no radius')
+            logger.debug('end airgap: no radius')
             return False
 
         if correct_airgap < 0:
-            logger.debug('no airgap')
+            logger.debug('end airgap: no airgap (%s)', correct_airgap)
             return False  # no airgap
 
         self.airgaps = []
@@ -354,33 +361,39 @@ class Machine(object):
             logger.error("No airgap with radius {} found"
                          .format(correct_airgap))
             self.show_airgap_candidates(airgap_candidates, False)
+            logger.debug("end airgap: bad")
             return True  # bad exit
 
         if correct_airgap2 > 0.0 and self.airgap2_radius == 0.0:
             logger.error("No airgap2 with radius {} found"
                          .format(correct_airgap2))
             self.show_airgap_candidates(airgap_candidates, False)
+            logger.debug("end airgap: bad")
             return True  # bad exit
 
         if len(self.airgaps) == 0:
-            logger.debug('No airgap found')
+            logger.debug('end airgap: No airgap found')
             return False  # no airgaps found
 
         if self.airgap_radius > 0.0:
+            logger.debug("end airgap: radius=%s", self.airgap_radius)
             return False  # correct airgap set
 
         gaps = [c for b, c, d in airgap_candidates if b == 0]
 
         if len(gaps) == 1:  # one candidate without border intersection
             self.airgap_radius = gaps[0].radius
+            logger.debug("end airgap: radius=%s", self.airgap_radius)
             return False  # ok
 
         if len(airgap_candidates) == 1:  # one candidate found
             self.airgap_radius = airgap_candidates[0][1].radius
+            logger.debug("end airgap: radius=%s", self.airgap_radius)
             return False  # ok
 
         self.airgap_radius = self.show_airgap_candidates(airgap_candidates,
                                                          True)
+        logger.debug("end airgap: radius=%s", self.airgap_radius)
         return False  # ok
 
     def show_airgap_candidates(self, airgap_candidates, get_one):
@@ -451,7 +464,7 @@ class Machine(object):
                 self.geom.delete_circle((0.0, 0.0), first_dist)
 
     def repair_hull(self):
-        logger.debug('repair_hull')
+        logger.debug('begin repair_hull(%s, %s)', self.startangle, self.endangle)
         if self.is_full() and not self.has_airgap():
             self.delete_center_circle()
 
@@ -468,18 +481,31 @@ class Machine(object):
         logger.debug('end of repair_hull')
 
     def repair_hull_geom(self, geom, startangle, endangle):
-        logger.debug('repair_hull_geom')
+        logger.debug('begin repair_hull_geom (%s, %s)', startangle, endangle)
 
+        rtol = 1e-4
+        atol = 1e-4
         c_corner = Corner(self.center, self.center)
-        start_corners = geom.get_corner_list(self.center, startangle)
-        end_corners = geom.get_corner_list(self.center, endangle)
+        start_c_added, start_corners = geom.get_corner_list(self.center, startangle,
+                                                            rtol=rtol, atol=atol)
+        end_c_added, end_corners = geom.get_corner_list(self.center, endangle,
+                                                        rtol=rtol, atol=atol)
+        if start_c_added or end_c_added:
+            rtol = 1e-3
+            atol = 1e-3
+            start_c_added, start_corners = geom.get_corner_list(self.center, startangle,
+                                                                rtol=rtol, atol=atol)
+            end_c_added, end_corners = geom.get_corner_list(self.center, endangle,
+                                                            rtol=rtol, atol=atol)
 
         geom.repair_hull_line(self.center,
                               startangle, start_corners,
-                              c_corner in end_corners)
+                              c_corner in end_corners,
+                              rtol=rtol, atol=atol)
         geom.repair_hull_line(self.center,
                               endangle, end_corners,
-                              c_corner in start_corners)
+                              c_corner in start_corners,
+                              rtol=rtol, atol=atol)
         logger.debug('end of repair_hull_geom')
 
     def create_stator_auxiliary_lines(self):
@@ -657,7 +683,8 @@ class Machine(object):
             return None
 
         machine_slice = self.copy(self.geom.symmetry_startangle(),
-                                  self.geom.symmetry_endangle())
+                                  self.geom.symmetry_endangle(),
+                                  concatenate_tiny_el=True)
         machine_slice.clear_cut_lines()
         machine_slice.repair_hull()
         machine_slice.rotate_to(0.0)

femagtools/dxfsl/plotrenderer.py

@@ -287,7 +287,7 @@ class PlotRenderer(object):
 
         self.ax.axis('scaled')
         self.ax.set_aspect('equal')
-        
+
         self.ax.set_xlim(x_min, x_max)
         self.ax.set_ylim(y_min, y_max)
 
@@ -360,7 +360,7 @@ class PlotRenderer(object):
         area.render(self, 'red', with_nodes=True)
 
         self.ax.axis('scaled')
-        self.ax.set_aspect('equal')       
+        self.ax.set_aspect('equal')
         pl.show()
 
     def draw_slot(self, id, slot, ax):

femagtools/dxfsl/shape.py

@@ -9,7 +9,6 @@
 """
 from __future__ import print_function
 import numpy as np
-import sys
 import logging
 from .functions import less_equal, greater_equal
 from .functions import distance, line_m, line_n
@@ -18,7 +17,7 @@ from .functions import alpha_line, alpha_angle, alpha_triangle
 from .functions import normalise_angle, min_angle, max_angle, get_angle_of_arc
 from .functions import lines_intersect_point, nodes_are_equal
 from .functions import is_angle_inside, intersect_point
-from .functions import middle_angle
+from .functions import middle_angle, middle_point_of_line
 
 logger = logging.getLogger('femagtools.geom')
 
@@ -50,7 +49,10 @@ class Shape(object):
         if hasattr(s, 'my_attrs'):
             self.my_attrs = []
             for a in s.my_attrs:
-               self.my_attrs.append(a)
+                self.my_attrs.append(a)
+
+    def classname(self):
+        return "Shape"
 
     def get_my_color(self):
         if hasattr(self, 'my_color'):
@@ -209,8 +211,8 @@ class Shape(object):
         d1 = distance(n, self.n1)
         d2 = distance(n, self.n2)
         if d1 == d2:
-            logger.info("distances of %s and %s are equal (%s / %s)",
-                        self.n1, self.n2, d1, d2)
+            logger.warning("distances of %s and %s are equal (%s / %s)",
+                           self.n1, self.n2, d1, d2)
             raise ValueError('both nodes are equal in element')
 
         if d1 < d2:
@@ -307,6 +309,9 @@ class Circle(Shape):
         self.n1 = None
         self.n2 = None
 
+    def classname(self):
+        return "Circle"
+
     def render(self, renderer, color='blue', with_nodes=False):
         tmp_color = self.get_my_color()
         if not tmp_color:
@@ -544,6 +549,19 @@ class Circle(Shape):
         assert(len(points) == 0)
         return []
 
+    def cut_into_halves(self):
+        """ return two arcs
+        """
+        a1 = Arc(Element(center=self.center,
+                         radius=self.radius,
+                         start_angle=0.0,
+                         end_angle=180.0))
+        a2 = Arc(Element(center=self.center,
+                         radius=self.radius,
+                         start_angle=180.0,
+                         end_angle=0.0))
+        return a1, a2
+
     def get_angle_of_arc(self):
         return np.pi*2.0
 
@@ -608,6 +626,9 @@ class Arc(Circle):
         else:
             self.rtheta = None
 
+    def classname(self):
+        return "Arc"
+
     def render(self, renderer, color='blue', with_nodes=False):
         tmp_color = self.get_my_color()
         if not tmp_color:
@@ -715,8 +736,9 @@ class Arc(Circle):
                 points.append(e.p2)
 
         elif e.is_point_inside(self.p2, rtol, atol):
-            if not points_are_close(self.p1, e.p1):
+            if not points_are_close(self.p1, e.p1, rtol=rtol, atol=atol):
                 logger.error("FATAL ERROR in overlapping_shape() of Arc")
+
                 raise ValueError('FATAL ERROR in overlapping_shape() of Arc')
             points.append(e.p1)
             points.append(self.p2)
@@ -808,6 +830,20 @@ class Arc(Circle):
         assert(len(points_inside) == 0)
         return []
 
+    def cut_into_halves(self):
+        """ return two arcs
+        """
+        midangle = middle_angle(self.startangle, self.endangle)
+        a1 = Arc(Element(center=self.center,
+                         radius=self.radius,
+                         start_angle=self.startangle*180/np.pi,
+                         end_angle=midangle*180/np.pi))
+        a2 = Arc(Element(center=self.center,
+                         radius=self.radius,
+                         start_angle=midangle*180/np.pi,
+                         end_angle=self.endangle*180/np.pi))
+        return a1, a2
+
     def concatenate_arc(self, n1, n2, el):
         if not points_are_close(self.center, el.center):
             return None
@@ -817,9 +853,11 @@ class Arc(Circle):
         if np.isclose(self.startangle, el.endangle):
             start_angle = el.startangle
             end_angle = self.endangle
-        else:
+        elif np.isclose(el.startangle, self.endangle):
             start_angle = self.startangle
             end_angle = el.endangle
+        else:
+            return None
 
         logger.debug("concatenate_arc: start=%s, end=%s",
                      start_angle,
@@ -833,30 +871,30 @@ class Arc(Circle):
     def is_point_inside(self, p, rtol=1e-03, atol=1e-03, include_end=False):
         """ returns true if p is on arc
         """
-        logger.debug("is_point_inside: p=%s", p)
+        # logger.debug("is_point_inside: p=%s", p)
         d = distance(p, self.center)
         if not np.isclose(d, self.radius, rtol=rtol, atol=atol):
-            logger.debug(" <== RADIUS %s, DISTANCE %s",
-                         self.radius, d)
+            # logger.debug(" <== RADIUS %s, DISTANCE %s",
+            #              self.radius, d)
             return False
         if points_are_close(p, self.p1, rtol=rtol, atol=atol):
-            logger.debug(" <== CLOSE TO P1 %s: rtol=%s, atol=%s",
-                         self.p1, rtol, atol)
+            # logger.debug(" <== CLOSE TO P1 %s: rtol=%s, atol=%s",
+            #              self.p1, rtol, atol)
             return include_end
         elif points_are_close(p, self.p2, rtol=rtol, atol=atol):
-            logger.debug(" <== CLOSE TO P2 %s: rtol=%s, atol=%s",
-                         self.p2, rtol, atol)
+            # logger.debug(" <== CLOSE TO P2 %s: rtol=%s, atol=%s",
+            #              self.p2, rtol, atol)
             return include_end
         elif points_are_close(self.p1, self.p2, rtol=rtol, atol=atol):
-            logger.debug(" <== P1 AND P2 CLOSE TOGETHER")
+            # logger.debug(" <== P1 AND P2 CLOSE TOGETHER")
             return False
 
         alpha_p1 = alpha_line(self.center, self.p1)
         alpha_p2 = alpha_line(self.center, self.p2)
         alpha_p = alpha_line(self.center, p)
         alpha_inside = is_angle_inside(alpha_p1, alpha_p2, alpha_p)
-        logger.debug("is_point_inside: %s (%s, %s ,%s)",
-                     alpha_inside, alpha_p1, alpha_p2, alpha_p)
+        # logger.debug("is_point_inside: %s (%s, %s ,%s)",
+        #              alpha_inside, alpha_p1, alpha_p2, alpha_p)
         return alpha_inside
 
     def is_angle_inside(self, alpha, rtol=1e-03, atol=1e-03,
@@ -889,7 +927,7 @@ class Arc(Circle):
         self.startangle = np.arctan2(p1[1], p1[0])
         self.endangle = np.arctan2(p2[1], p2[0])
         if self.rtheta is not None:
-            self.rtheta = self.rtheta + alpha
+            self.rtheta = self.rtheta + dest_alpha
         return self
 
     def minmax(self):
@@ -1054,6 +1092,9 @@ class Line(Shape):
         self.n1 = None
         self.n2 = None
 
+    def classname(self):
+        return "Line"
+
     def render(self, renderer, color='blue', with_nodes=False):
         tmp_color = self.get_my_color()
         if not tmp_color:
@@ -1186,9 +1227,29 @@ class Line(Shape):
             return split_lines
         return []
 
+    def cut_into_halves(self):
+        """ return two lines
+        """
+        pm = middle_point_of_line(self.p1, self.p2)
+        l1 = Line(Element(start=self.p1, end=pm))
+        l2 = Line(Element(start=pm, end=self.p2))
+        return l1, l2
+
     def concatenate_line(self, n1, n2, el):
-        if np.isclose(self.m(999999.0), el.m(999999.0)):
+        if not np.isclose(self.m(999999.0), el.m(999999.0)):
+            return None
+
+        if n1 and n2:
             return Line(Element(start=n1, end=n2))
+
+        if points_are_close(self.p1, el.p1):
+            return Line(Element(start=self.p2, end=el.p2))
+        if points_are_close(self.p1, el.p2):
+            return Line(Element(start=self.p2, end=el.p1))
+        if points_are_close(self.p2, el.p1):
+            return Line(Element(start=self.p1, end=el.p2))
+        if points_are_close(self.p2, el.p2):
+            return Line(Element(start=self.p1, end=el.p1))
         return None
 
     def is_point_inside(self, point,
@@ -1293,6 +1354,9 @@ class Point(Shape):
     def __init__(self, p):
         self.p1 = p
 
+    def classname(self):
+        return "Point"
+
     def render(self, renderer):
         renderer.point(self.p1)
 
@@ -1301,6 +1365,7 @@ class Point(Shape):
         self.p1 = (n[0], n[1])
         return self
 
+
 def is_Circle(e):
     return isinstance(e, Circle) and not isinstance(e, Arc)
 

femagtools/femag.py

@@ -90,7 +90,7 @@ def get_shortCircuit_parameters(bch, nload):
             fc_radius=bch.machine['fc_radius'],
             lfe=bch.armatureLength/1e3,
             pocfilename=bch.machine['pocfile'],
-            num_par_wdgs=bch.machine['num_par_wdgs'],
+            num_par_wdgs=bch.machine.get('num_par_wdgs', 0),
             calculationMode='shortcircuit')
     except (KeyError, AttributeError, IndexError):
         raise FemagError("missing pm/Rel-Sim results")
@@ -222,6 +222,12 @@ class BaseFemag(object):
             pass
         builder = femagtools.fsl.Builder(self.templatedirs)
         if simulation:
+            if 'num_par_wdgs' not in simulation:
+                try:
+                    num_par_wdgs = self.model.winding['num_par_wdgs']
+                    simulation['num_par_wdgs'] = num_par_wdgs
+                except:
+                    pass
             set_magnet_properties(self.model, simulation, self.magnets)
             return builder.create(self.model, simulation,
                                   self.magnets, self.condMat)
@@ -351,6 +357,16 @@ class BaseFemag(object):
 
     def readResult(self, simulation, bch=None):
         if simulation:
+            if simulation['calculationMode'] == "fieldcalc":
+                nc = self.read_nc()
+                pmod = nc.poles_sim
+                r = {'airgap': ag.read(
+                    os.path.join(self.workdir, 'bag.dat'), pmod=pmod)}
+                if 'plots' in simulation:
+                    if 'field_lines' in simulation['plots']:
+                        r['field_lines'] = os.path.join(
+                            self.workdir, 'field.svg')
+                return r
             if simulation['calculationMode'] == "pm_sym_loss":
                 return self.read_los(self.modelname)
 
@@ -365,7 +381,8 @@ class BaseFemag(object):
 
             if simulation['calculationMode'] == 'therm-dynamic':
                 temp = [[float(n) for n in l.split()]
-                        for l in (pathlib.Path(self.workdir) / 'temperature.dat').read_text().split('\n') if l]
+                        for l in (pathlib.Path(self.workdir) /
+                                  'temperature.dat').read_text().split('\n') if l]
                 ttemp = list(zip(*temp))
                 return {'t': ttemp[0], 'temperature': ttemp[1]}
 
@@ -383,9 +400,10 @@ class BaseFemag(object):
                     set_magnet_properties(self.model, simulation, self.magnets)
                     fslcmds = (builder.open_model(self.model) +
                                builder.create_shortcircuit(simulation))
+                    fslfile = 'shortcicuit.fsl'
                     with open(os.path.join(self.workdir, fslfile), 'w') as f:
                         f.write('\n'.join(fslcmds))
-                    self.run(fslfile, options)
+                    self.run(fslfile) #, options?
                     bchfile = self.get_bch_file(self.modelname)
                     if bchfile:
                         bchsc = femagtools.bch.Reader()

femagtools/fsl.py

@@ -484,7 +484,11 @@ class Builder:
         if not hasattr(model, 'stator'):
             setattr(model, 'stator', {})
         model.stator['num_slots'] = conv.get('tot_num_slot')
-        model.stator['num_slots_gen'] = conv.get('num_sl_gen')
+        if model.stator.get('num_slots_gen', 0):
+            if model.stator['num_slots'] % model.stator['num_slots_gen'] > 0:
+                model.stator['num_slots_gen'] = conv.get('num_sl_gen')
+        else:
+            model.stator['num_slots_gen'] = conv.get('num_sl_gen')
         if 'fsl_stator' in conv:
             self.fsl_stator = True
             model.stator['dxf'] = dict(fsl=conv['fsl_stator'])
@@ -633,15 +637,23 @@ class Builder:
 
     def create_analysis(self, sim):
         pfefunc = sim.get('loss_funct', '')
+        custom_fefunc = ['']
         if pfefunc:
             sim['loss_funct'] = 1 # 3?
+            if pfefunc == 'bertotti' or 'modified_steinmetz':
+                custom_fefunc = self.__render(sim['PVFE_FSL'], pfefunc)
+            else:
+                custom_fefunc = pfefunc.split('\n')
+
         airgap_induc = (self.create_airgap_induc()
                         if sim.get('airgap_induc', 0) else [])
-        felosses = pfefunc.split('\n') + self.create_fe_losses(sim)
+        felosses = custom_fefunc + self.create_fe_losses(sim)
         fslcalc = (self.__render(sim, sim.get('calculationMode')) +
                    airgap_induc)
+        '''
         if pfefunc:
             sim['loss_funct'] = pfefunc
+        '''
 
         if sim.get('calculationMode') in ('cogg_calc',
                                           'ld_lq_fast',

femagtools/machine/__init__.py

@@ -14,13 +14,14 @@ import logging
 logger = logging.getLogger(__name__)
 
 
-def __scale_losses(losses, lfe):
+def __scale_losses(losses, rlfe):
     if losses:
-        l = {k: lfe*np.array(losses[k]) for k in (
+        l = {k: rlfe*np.array(losses[k]) for k in (
             'styoke_hyst', 'styoke_eddy',
             'stteeth_hyst', 'stteeth_eddy',
+            'styoke_excess', 'stteeth_excess', 'rotor_excess',
             'rotor_hyst', 'rotor_eddy',
-            'magnet')}
+            'magnet') if k in losses}
         l['speed'] = losses['speed']
         return l
     return {}
@@ -66,18 +67,15 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
 
         psid = rwdg*rlfe*dqp['psid']
         psiq = rwdg*rlfe*dqp['psiq']
-        try:
-            losses = __scale_losses(dqp['losses'], rlfe)
-            losses['ef'] = dqpars[-1]['losses']['ef']
-            losses['eh'] = dqpars[-1]['losses']['ef']
-        except KeyError as e:
-            logger.warning(e)
-            losses = {}
+        losses = __scale_losses(dqp['losses'], rlfe)
+        losses['ef'] = dqpars[-1]['losses']['ef']
+        losses['eh'] = dqpars[-1]['losses']['ef']
+
         if 'psidq' in eecpars:
             machine = PmRelMachinePsidq(
                 eecpars['m'], eecpars['p'],
-                r1=eecpars['r1']*rlfe*rwdg**2,
-                ls=eecpars['ls1']*rwdg**2,
+                r1=eecpars.get('r1', 0)*rlfe*rwdg**2,
+                ls=eecpars.get('ls1', 0)*rwdg**2,
                 psid=psid,
                 psiq=psiq,
                 losses=losses,
@@ -90,8 +88,8 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
             i1 = np.array(dqp['i1'])/rwdg
             machine = PmRelMachineLdq(
                 eecpars['m'], eecpars['p'],
-                r1=eecpars['r1']*rlfe*rwdg**2,
-                ls=eecpars['ls1']*rwdg**2,
+                r1=eecpars.get('r1', 0)*rlfe*rwdg**2,
+                ls=eecpars.get('ls1', 0)*rwdg**2,
                 psid=psid,
                 psiq=psiq,
                 losses=losses,
@@ -103,7 +101,7 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
 
     # must be an induction machine (TODO: check scaling)
     pars = copy.deepcopy(eecpars)
-    pars['r1'] = rlfe*rwdg**2*pars['r1']
+    pars['r1'] = rlfe*rwdg**2*pars.get('r1', 0)
     pars['lsigma1'] = rlfe*pars['lsigma1']
     pars['lsigma2'] = rlfe*pars['lsigma2']
     pars['psiref'] = rwdg*rlfe*pars['psiref']
@@ -119,24 +117,6 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
     return InductionMachine(pars)
 
 
-def __scale_losses(losses, rlfe):
-    if losses:
-        l = {k: rlfe*np.array(losses[k]) for k in (
-            'styoke_hyst', 'styoke_eddy',
-            'stteeth_hyst', 'stteeth_eddy',
-            'rotor_hyst', 'rotor_eddy',
-            'magnet')}
-        if 'styoke_exc' in losses:
-            l.update({k: rlfe*np.array(losses[k]) 
-                        for k in (
-                            'styoke_exc',
-                            'stteeth_exc', 
-                            'rotor_exc')})
-        l['speed'] = losses['speed']
-        return l
-    return {}
-
-
 def create(bch, r1, ls, lfe=1, wdg=1):
     """create PmRelMachine from BCH