femagtools 1.8.17__py3-none-any.whl → 1.8.19__py3-none-any.whl

femagtools/dxfsl/machine.py

@@ -580,10 +580,8 @@ class Machine(object):
         return self.geom.create_auxiliary_lines(self.startangle, self.endangle)
 
     def set_alfa_and_corners(self):
-        self.geom.start_corners = self.geom.get_corner_nodes(self.center,
-                                                             self.startangle)
-        self.geom.end_corners = self.geom.get_corner_nodes(self.center,
-                                                           self.endangle)
+        self.geom.set_start_corners(self.center, self.startangle)
+        self.geom.set_end_corners(self.center, self.endangle)
         self.geom.alfa = alpha_angle(self.startangle, self.endangle)
 
         if self.mirror_geom is not None:
@@ -639,6 +637,22 @@ class Machine(object):
         if self.radius <= 0.0:
             return False
 
+        if is_outer:
+            self.geom.set_subregion_parameters(self.startangle, self.endangle)
+            if self.part > 1:
+                self.geom.set_start_corners(self.center, self.startangle, rtol=1e-3, atol=1e-2)
+                self.geom.set_end_corners(self.center, self.endangle, rtol=1e-3, atol=1e-2)
+            else:
+                self.geom.set_virtual_start_end_corners()
+
+            self.geom.looking_for_corners()
+            create_areas = self.geom.close_outer_winding_areas()
+            if self.geom.adjust_outer_hull_for_symmetry():
+                create_areas = True
+
+            if create_areas:
+                self.geom.create_list_of_areas(delete=True)
+
         symmetry = Symmetry(geom=self.geom,
                             startangle=self.startangle,
                             endangle=self.endangle)
@@ -1270,6 +1284,30 @@ class Machine(object):
     def search_critical_elements(self, mindist):
         self.geom.search_critical_elements(mindist)
 
+    def create_arc_element(self,
+                           radius,
+                           startangle,
+                           endangle):
+        arc = Arc(Element(center=self.center,
+                          radius=radius,
+                          start_angle=startangle*180/np.pi,
+                          end_angle=endangle*180/np.pi),
+                  color='darkred',
+                  linestyle='dotted')
+
+        node1 = self.geom.find_the_node(arc.p1)
+        if node1 is None:
+            self.geom.split_with_point(arc.p1)
+            node1 = self.geom.find_the_node(arc.p1)
+        node2 = self.geom.find_the_node(arc.p2)
+        if node2 is None:
+            self.geom.split_with_point(arc.p2)
+            node2 = self.geom.find_the_node(arc.p2)
+        assert(node1 is not None)
+        assert(node2 is not None)
+        logger.debug("ARC Node1=%s, Node2=%s", node1, node2)
+        self.geom.add_element(arc, rtol=1e-3, atol=1e-3)
+
     def create_arc(self, radius,
                    color='red', linestyle='dotted',
                    attr=None):
@@ -1330,6 +1368,79 @@ class Machine(object):
                                 self.endangle)
         return self.geom.possible_magnet_in_the_middle(midangle)
 
+    def separate_tooth_and_yoke(self, midangle):
+        logger.debug("begin separate_tooth_and_yoke")
+        wdg_list = self.geom.get_areas_of_type((AREA.TYPE_WINDINGS,))
+        wdg_max_dist = 0.0
+        wdg = None
+        for w in wdg_list:
+            if w.max_dist > wdg_max_dist:
+                wdg_max_dist = w.max_dist
+                wdg = w
+
+        tooth_list = self.geom.get_areas_of_type((AREA.TYPE_TOOTH,))
+        tooth_max_dist = 0.0
+        for tooth in tooth_list:
+            tooth_max_dist = max(tooth_max_dist, tooth.max_dist)
+        tooth_height = tooth_max_dist - self.geom.min_radius
+        wdg_height = wdg_max_dist - self.geom.min_radius
+
+        logger.debug("HEIGHT TOOTH=%s, WINDINGS=%s", tooth_height,  wdg_height)
+
+        if greater_equal(tooth_height, wdg_height * 0.9) and \
+           less_equal(tooth_height, wdg_height * 1.1):
+            logger.debug("Tooths are ok")
+            return False  # tooth ok
+
+        iron_list = self.geom.get_areas_of_irons()
+        tooth_list = [iron for iron in iron_list
+                      if iron.close_to_ag and greater(iron.max_dist, wdg_max_dist, rtol=1e-2, atol=1e-2)]
+        logger.debug("max winding dist = %s", wdg_max_dist)
+        logger.debug("tooths = %s", len(tooth_list))
+        wdg_nodes = [(distance(self.center, n), n) for n in wdg.list_of_nodes()]
+        wdg_nodes.sort(reverse=True)
+
+        top_nodes = []
+        other_nodes = []
+        for d, n in wdg_nodes:
+            if np.isclose(d, wdg.max_dist, rtol=1e-2, atol=1e-1):
+                top_nodes.append((alpha_line(self.center, n), d, n))
+            else:
+                other_nodes.append((d, alpha_line(self.center, n), n))
+
+        a_right, d_right, n_right = (None, None, None)
+        a_left, d_left, n_left = (None, None, None)
+
+        if not top_nodes:
+            other_nodes.sort(reverse=True)
+            for d, a, n in other_nodes:
+                if a > midangle:
+                    if not a_left:
+                        a_left = a
+                        d_left = d
+                        n_left = n
+                else:
+                    if not a_right:
+                        a_right = a
+                        d_right = d
+                        n_right = n
+                if a_left and a_right:
+                    break
+            if not (a_left and a_right):
+                logger.debug("end separate_tooth_and_yoke: no arcs possible")
+                return False # bad luck
+        else:
+            top_nodes.sort()
+            a_right, d_right, n_right = top_nodes[0]
+            a_left, d_left, n_left = top_nodes[0-1]
+        node_right = self.geom.find_the_node(n_right)
+        node_left = self.geom.find_the_node(n_left)
+
+        self.create_arc_element(d_right, self.startangle, a_right)
+        self.create_arc_element(d_left, a_left, self.endangle)
+        logger.debug("end separate_tooth_and_yoke")
+        return True
+
     def create_mirror_lines_outside_windings(self):
         logger.debug("create_mirror_lines_outside_windings")
 
@@ -1337,6 +1448,9 @@ class Machine(object):
             logger.debug("end create_mirror_lines_outside_windings: not done")
             return
 
+        midangle = middle_angle(self.startangle, self.endangle)
+        self.separate_tooth_and_yoke(midangle)
+
         radius = self.radius+10
         ag_list = self.geom.detect_airgaps(self.center,
                                            self.startangle, self.endangle,
@@ -1345,7 +1459,6 @@ class Machine(object):
         radius_list = [(ag[0], (ag[0] + ag[1]) / 2, ag[1]) for ag in ag_list]
         radius_list.sort(reverse=True)
 
-        midangle = middle_angle(self.startangle, self.endangle)
         line = Line(
             Element(start=self.center,
                     end=point(self.center, radius, midangle)))
@@ -1353,10 +1466,11 @@ class Machine(object):
         pts = self.geom.split_and_get_intersect_points(line, aktion=False)
         pts.sort()
 
+        arcs_created = False
         p_critical = self.geom.critical_touch_point(pts)
         if p_critical:
             d_critical = distance(self.center, p_critical)
-            logger.info("Critical Point: %s, len=%s", p_critical, d_critical)
+            logger.debug("Critical Point: %s, len=%s", p_critical, d_critical)
             sep_radius = self.get_iron_separator(radius_list)
             logger.debug("Iron Separator found: %s", sep_radius)
             if sep_radius > 0.0 and sep_radius < d_critical:
@@ -1367,8 +1481,15 @@ class Machine(object):
                     if r[1] < d_critical:
                         if self.create_arc(r[1]):
                             radius = r[1]
+                            arcs_created = True
                         break
 
+        if arcs_created:
+            self.geom.create_list_of_areas(delete=True)
+            self.geom.search_subregions(self.startangle,
+                                        self.endangle,
+                                        False)
+
         # install line
         line = Line(
             Element(start=self.center,
@@ -1376,11 +1497,9 @@ class Machine(object):
 
         pts = self.geom.split_and_get_intersect_points(line)
         pts.sort()
-
         if self.geom.create_lines_outside_windings(pts):
-            self.geom.area_list = []
             logger.debug("create subregions again")
-            self.geom.create_list_of_areas()
+            self.geom.create_list_of_areas(delete=True)
             self.geom.search_subregions(self.startangle,
                                         self.endangle,
                                         False)

femagtools/dxfsl/symmetry.py

@@ -48,6 +48,7 @@ class Symmetry(object):
         self.atol = atol
         self.full = False
         self.ag_radius = 0.0
+        self.height = geom.max_radius - geom.min_radius
         if np.isclose(self.startangle, self.endangle):
             self.alpha = 2.0*np.pi
             self.full = True
@@ -120,9 +121,6 @@ class Symmetry(object):
         areas.sort(reverse=True)
         return areas
 
-    def get_equal_areas(self, areas):
-        return
-
     def build_results(self, areas):
         logger.debug("begin of build_results with %s areas", len(areas))
         [logger.debug("#%s: alpha=%s, min=%s, max=%s",
@@ -286,13 +284,22 @@ class Symmetry(object):
         logger.debug("Geometry: Alpha=%s,  Center=%s", self.alpha, self.geom.center)
         mid_angle, a = area_list[0]
         result['height'] = a.height
+        result['min_dist'] = a.min_dist
+        result['max_dist'] = a.max_dist
         result['alpha'] = a.get_alpha(self.geom.center)
         if self.geom.is_inner:
             result['airgap'] = np.isclose(a.max_dist, self.ag_radius)
         else:
             result['airgap'] = np.isclose(a.min_dist, self.ag_radius)
+            upper_quarter = self.geom.min_radius + self.height * 0.75
+            upper_half = self.geom.min_radius + self.height * 0.5
+            if a.max_dist > upper_quarter:
+                if a.min_dist > upper_half:
+                    result['upper_quarter'] = True
         if len(area_list) == 1:  # one area
-            return self.check_one_area(mid_angle, a, result, rtol=rtol, atol=atol)
+            rslt = self.check_one_area(mid_angle, a, result, rtol=rtol, atol=atol)
+            logger.debug("end of check_delta")
+            return rslt
 
         self.delta_check_count += 1
         area_list.sort()
@@ -353,6 +360,7 @@ class Symmetry(object):
             logger.debug("end of check_delta: BAD DELTA %s, (expected %s)",
                          delta_angle, geom_alpha)
             result['slices'] = 0
+            logger.debug("end of check_delta: very bad")
             return result  # very bad
 
         deltas = self.create_deltas(delta_list, rtol=rtol, atol=atol)
@@ -927,13 +935,20 @@ class Symmetry(object):
                     logger.debug("Symmetry-Destroyer destroyed")
                     slices = None
 
+            if rslt.get('upper_quarter', False):
+                if size < max_size / 20:
+                    slices = None
+
+            if slices == 1:
+                if rslt.get('upper_quarter', False):
+                    slices = None
+
             if slices == 1:
                 # symmetry killer
                 if areas < max(2, max_areas / 6):
                     if size < max_size * 0.05:
                         slices = None  # ignore tiny areas
 
-
             parts_possible = self.calc_parts(parts_possible, slices)
 
         if unsure_sym:

femagtools/femag.py

@@ -79,6 +79,7 @@ def set_magnet_properties(model, simulation, magnets):
         magn_temp = simulation.magn_temp
     if 'material' not in model.magnet:
         return
+
     try:
         material = model.magnet['material']
         magnetMat = magnets.find(material)
@@ -95,19 +96,24 @@ def set_magnet_properties(model, simulation, magnets):
                 tempcoefmuer = (tempcoefbr-tempcoefhc)/(1+tempcoefhc*(magn_temp-20))
             if 'temcoefmuer' in magnetMat:
                 tempcoefmuer = magnetMat['temcoefmuer']
-            hcj = magnetMat.get('HcJ', 0)
-            if hcj:
-                model.hc_min = -hcj * (1+tempcoefhc*(magn_temp-20))
+            if not hasattr(model, 'hc_min'):
+                for k in 'Hk', 'HcJ':
+                    if k in magnetMat:
+                        hcmin = magnetMat.get(k)
+                        model.hc_min = hcmin * (1+tempcoefhc*(magn_temp-20))
+                        break
+            if hasattr(model, 'hc_min'):
+                logger.info("hc_min %f", model.hc_min)
             model.magnet['temp_prop']['relperm'] = \
                 (1+tempcoefmuer*(magn_temp-20))*relperm
             if tempcoefbr:
                 model.magnet['temp_prop']['temcoefbr'] = tempcoefbr
             if tempcoefhc:
                 model.magnet['temp_prop']['temcoefhc'] = tempcoefhc
-
     except AttributeError:
         pass
 
+
 class BaseFemag(object):
     def __init__(self, workdir, cmd, magnetizingCurves, magnets, condMat,
                  templatedirs=[]):
@@ -415,7 +421,8 @@ class BaseFemag(object):
         except FileNotFoundError:
             pass
 
-        return list(pathlib.Path(self.workdir).glob('*.PROT'))[0].stem
+        return sorted(pathlib.Path(self.workdir).glob('*.PROT'),
+                      key=lambda x: x.stat().st_mtime, reverse=True)[0].stem
 
     def readResult(self, machine, simulation, bch=None):
         if simulation:
@@ -460,14 +467,6 @@ class BaseFemag(object):
 
             if not bch:
                 bch = self.read_bch(self.modelname)
-            if simulation['calculationMode'] == 'pm_sym_fast' or \
-                simulation['calculationMode'] == 'torq_calc':
-                if simulation.get('shortCircuit', False):
-                    from .shortcircuit import shortcircuit
-                    set_magnet_properties(self.model, simulation, self.magnets)
-                    bch.scData = shortcircuit(self, machine, bch, simulation)
-                    #bch.torque += bchsc.torque
-                    #bch.demag += bchsc.demag
 
             if 'airgap_induc' in simulation:
                 try:
@@ -477,6 +476,19 @@ class BaseFemag(object):
                 bch.airgap = ag.read(os.path.join(self.workdir, 'bag.dat'),
                                      pmod=pmod)
 
+            if simulation['calculationMode'] == 'pm_sym_fast' or \
+                simulation['calculationMode'] == 'torq_calc':
+                if simulation.get('shortCircuit', False):
+                    from .shortcircuit import shortcircuit
+                    set_magnet_properties(self.model, simulation, self.magnets)
+                    bch.scData = shortcircuit(self,
+                                              {'name': self.model.name,
+                                               'poles': self.model.poles,
+                                               'hc_min': self.model.get('hc_min', 0)},
+                                               bch, simulation)
+                    #bch.torque += bchsc.torque
+                    #bch.demag += bchsc.demag
+
             if simulation.get('magnet_loss', False):
                 logger.info('Evaluating magnet losses...')
                 ops = range(len(bch.torque))
@@ -490,7 +502,7 @@ class BaseFemag(object):
 
                 if len(ops) != len(bch.losses):
                     magn_losses.insert(0, magn_losses[0])
-                
+
                 magn_losses = [float(i) for i in magn_losses]
                 try:
                     for i in range(len(bch.losses)):
@@ -600,10 +612,9 @@ class Femag(BaseFemag):
                 os.remove(f)
 
     def __call__(self, machine, simulation={},
-                 options=['-b'], fsl_args=[]):
+                 options=['-b'], fsl_args=[], fslfile='femag.fsl'):
         """setup fsl file, run calculation and return
         BCH, ASM, TS or LOS results if any."""
-        fslfile = 'femag.fsl'
         with open(os.path.join(self.workdir, fslfile), 'w') as f:
             f.write('\n'.join(self.create_fsl(machine,
                                               simulation)))

femagtools/isa7.py

@@ -1359,28 +1359,31 @@ class Isa7(object):
         # prep dictionary for the loss calculation
         pm_data = []
         for i, se in enumerate(mag_spels):
-            ecp = [e.center for e in se.elements]
-            geometry = se.get_rect_geom()
-
-            #= np.moveaxis(bxy, 1, 0)
-            pd = dict(name='pm_data_se' + str(se.key),
-                      hm=geometry['h'],
-                      wm=geometry['w'],
-                      lm=self.arm_length,
-                      alpha=geometry['alpha'],
-                      ls=self.arm_length,
-                      sigma=cond,
-                      mur=mur,
-                      loadcase=ibeta,
-                      numpoles=poles,
-                      elcp=transform_coord(geometry, ecp),
-                      area=se.area(),
-                      spel_key=se.key)
-            if ibeta != None:
-                pd.update({'bl': self.get_magnet_flux_density(se, icur, ibeta)})
-            pd.update(pos)
-
-            pm_data.append(pd)
+            try:
+                ecp = [e.center for e in se.elements]
+                geometry = se.get_rect_geom()
+
+                #= np.moveaxis(bxy, 1, 0)
+                pd = dict(name='pm_data_se' + str(se.key),
+                          hm=geometry['h'],
+                          wm=geometry['w'],
+                          lm=self.arm_length,
+                          alpha=geometry['alpha'],
+                          ls=self.arm_length,
+                          sigma=cond,
+                          mur=mur,
+                          loadcase=ibeta,
+                          numpoles=poles,
+                          elcp=transform_coord(geometry, ecp),
+                          area=se.area(),
+                          spel_key=se.key)
+                if ibeta != None:
+                    pd.update({'bl': self.get_magnet_flux_density(se, icur, ibeta)})
+                pd.update(pos)
+
+                pm_data.append(pd)
+            except IndexError as e:
+                logger.warning("se %d magnet geometry ignored: %s", i, e)
         return pm_data
 
     def get_magnet_flux_density(self, se, icur, ibeta) -> list:

femagtools/machine/__init__.py

@@ -32,7 +32,7 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
     PM, EESM or IM"""
     rlfe = lfe
     rwdg = wdg
-    opts = {k: eecpars[k] for k in ('zeta1', 'gam', 'kh', 'kpfe',
+    opts = {k: eecpars[k] for k in ('zeta1', 'gam', 'kh', 'kpfe', 'kpfe_s', 'kpfe_r',
                                     'kfric_b', 'kpmag') if k in eecpars}
     try:
         opts['rotor_mass'] = rlfe*eecpars['rotor_mass']
@@ -51,6 +51,8 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
             smpars = copy.deepcopy(eecpars)
             smpars['tcu1'] = temp[0]
             smpars['tcu2'] = temp[1]
+            # external inductances
+            opts["ls"] = eecpars.get('ls1', 0)*rwdg**2
             if 'ldq' in smpars:
                 machine = SynchronousMachineLdq(smpars, lfe=rlfe, wdg=rwdg, **opts)
             else:

femagtools/machine/effloss.py

@@ -252,6 +252,8 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
                 rb['n'] = None
                 rb['T'] = None
         if 'n' not in rb:
+            if kwargs.get('i1max', 0):
+                kwargs['i1max'] = -kwargs['i1max']
             rb = m.characteristics(-T, max(r['n']), u1, nsamples=nsamples,
                                    with_mtpv=with_mtpv, with_mtpa=with_mtpa,
                                    with_pmconst=with_pmconst, with_tmech=with_tmech,
@@ -267,13 +269,17 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
         if isinstance(m, (SynchronousMachineLdq, SynchronousMachinePsidq)):
             iq, id, iex = m.iqd_torque(T[-1])
             i1max = betai1(iq, id)[1]
+            if kwargs.get("i1max", 0):
+                i1max = kwargs["i1max"]
             w1type, tmax = m.w1_imax_umax(i1max, u1)
             pmax = tmax*w1type/m.p
         else:
             iq, id = m.iqd_torque(T[-1])
-            w1type, tmax = m.w1_imax_umax(betai1(iq, id)[1], u1)
+            i1max = betai1(iq, id)[1]
+            if kwargs.get("i1max", 0):
+                i1max = kwargs["i1max"]
+            w1type, tmax = m.w1_imax_umax(i1max, u1)
 
-        i1max = betai1(iq, id)[1]
         logger.info("%s %s", n, T)
         for nx in n:
             w1 = 2*np.pi*nx*m.p
@@ -366,6 +372,10 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
     if isinstance(m, PmRelMachine):
         plfe1 = m.kpfe*m.iqd_plfe1(*iqd, f1)
         plfe2 = m.kpfe*m.iqd_plfe2(iqd[0], iqd[1], f1)
+        if hasattr(m, 'kpfe_s'):
+            plfe1 = m.kpfe_s*m.iqd_plfe1(*iqd, f1)
+        if hasattr(m, 'kpfe_r'):
+            plfe2 = m.kpfe_r*m.iqd_plfe2(iqd[0], iqd[1], f1)
         plmag = m.kpmag*m.iqd_plmag(iqd[0], iqd[1], f1)
         plcu1 = m.iqd_plcu1(iqd[0], iqd[1], 2*np.pi*f1)
         plcu2 = m.iqd_plcu2(*iqd)
@@ -379,6 +389,10 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
     elif isinstance(m, SynchronousMachine):
         plfe1 = m.kpfe*m.iqd_plfe1(*iqd, f1)
         plfe2 = m.kpfe*m.iqd_plfe2(*iqd, f1)
+        if hasattr(m, 'kpfe_s'):
+            plfe1 = m.kpfe_s*m.iqd_plfe1(*iqd, f1)
+        if hasattr(m, 'kpfe_r'):
+            plfe2 = m.kpfe_r*m.iqd_plfe2(*iqd, f1)
         plmag = np.zeros_like(plfe2)
         plcu1 = m.iqd_plcu1(iqd[0], iqd[1], f1)
         try:
@@ -431,7 +445,7 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
             e = pm / p1
         else:
             e = p1 / pm
-        eta.append(e)
+        eta.append(float(e))
 
     return dict(
         iq=iqd[0].tolist(),
@@ -450,4 +464,4 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
         plfric=plfric.tolist(),
         losses=ploss.tolist(),
         plcu1_dc=plcu1_dc,
-        plcu1_ac=plcu1_ac)
+        plcu1_ac=plcu1_ac)