femagtools 1.8.18__py3-none-any.whl → 1.8.20__py3-none-any.whl

femagtools/dxfsl/machine.py

@@ -646,7 +646,7 @@ class Machine(object):
                 self.geom.set_virtual_start_end_corners()
 
             self.geom.looking_for_corners()
-            create_areas = self.geom.analyse_airgap_line(is_inner)
+            create_areas = self.geom.close_outer_winding_areas()
             if self.geom.adjust_outer_hull_for_symmetry():
                 create_areas = True
 
@@ -1284,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):
@@ -1344,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")
 
@@ -1351,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,
@@ -1359,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)))
@@ -1491,3 +1590,9 @@ class Machine(object):
         self.geom.check_airgap_connecting_nodes(m_outer.geom,
                                                 self.startangle,
                                                 self.endangle)
+
+    def remove_tiny_air_areas(self):
+        if not self.geom.remove_tiny_air_areas():
+            return False
+        self.repair_hull()
+        return True

femagtools/dxfsl/shape.py

@@ -90,6 +90,13 @@ class Shape(object):
             self.n2 = n1
             self.n1 = n2
 
+    def has_same_nodes(self, e):
+        if points_are_close(e.n1, self.n1):
+            return points_are_close(e.n2, self.n2)
+        if points_are_close(e.n1, self.n2):
+            return points_are_close(e.n2, self.n1)
+        return False
+
     """an abstract geometry with 2 points"""
 
     def start(self):

femagtools/femag.py

@@ -424,7 +424,7 @@ class BaseFemag(object):
         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):
+    def readResult(self, simulation, bch=None, machine=None):
         if simulation:
             if simulation['calculationMode'] == "fieldcalc":
                 nc = self.read_nc()
@@ -656,7 +656,7 @@ class Femag(BaseFemag):
             pass
 
         if simulation:
-            return self.readResult(machine, simulation)
+            return self.readResult(machine=machine, simulation=simulation)
 
         return {'status': 'ok', 'message': self.modelname,
                 'model': self.model.props()}
@@ -1196,6 +1196,6 @@ class ZmqFemag(BaseFemag):
         if r['status'] == 'ok':
             bch = femagtools.bch.Reader()
             bch.read(content.decode('latin1'))
-            bch = self.readResult(simulation, bch)
+            bch = self.readResult(simulation=simulation, bch=bch)
             return bch
         raise FemagError(r['message'])

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,7 +51,7 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
             smpars = copy.deepcopy(eecpars)
             smpars['tcu1'] = temp[0]
             smpars['tcu2'] = temp[1]
-            # external inductances 
+            # external inductances
             opts["ls"] = eecpars.get('ls1', 0)*rwdg**2
             if 'ldq' in smpars:
                 machine = SynchronousMachineLdq(smpars, lfe=rlfe, wdg=rwdg, **opts)

femagtools/machine/effloss.py

@@ -372,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)
@@ -385,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:

femagtools/machine/pm.py

@@ -97,7 +97,7 @@ class PmRelMachine(object):
         self.zeta1 = 0.2
         self.gam = 0.7
         self.kh = 2
-        self.kpfe = 1 # iron loss factor
+        self.kpfe = 1 # common iron loss factor
         self.kpmag = 1 # magnet loss factor
         self.kfric_b = 1
         self.rotor_mass = 0
@@ -181,9 +181,10 @@ class PmRelMachine(object):
         if np.abs(torque) < 1e-2:
             return (0, 0)
         if np.isscalar(iqd0):
-            i0 = self.io
+            i0 = list(self.io)
             if torque<0:
                 i0[0] = -i0[0]
+                i0 = tuple(i0)
         else:
             i0 = iqd0
         if with_mtpa:
@@ -258,7 +259,13 @@ class PmRelMachine(object):
         and friction windage losses"""
         if n > 1e-3:
             f1 = self.p*n
-            plfe = self.kpfe * (self.iqd_plfe1(iq, id, f1) + self.iqd_plfe2(iq, id, f1))
+            plfe1 = self.kpfe * self.iqd_plfe1(iq, id, f1)
+            plfe2 = self.kpfe * self.iqd_plfe2(iq, id, f1)
+            if hasattr(self, 'kpfe_s'):
+                plfe1 = self.kpfe_s * self.iqd_plfe1(iq, id, f1)
+            if hasattr(self, 'kpfe_r'):
+                plfe2 = self.kpfe_r * self.iqd_plfe2(iq, id, f1)
+            plfe = plfe1 + plfe2
             pmag = self.kpmag * self.iqd_plmag(iq, id, f1)
             return (plfe + pmag + self.pfric(n))/(2*np.pi*n)
         return 0
@@ -927,10 +934,10 @@ class PmRelMachine(object):
         plfe1 = self.iqd_plfe1(iq, id, f1)
         plfe2 = self.iqd_plfe2(iq, id, f1)
         plmag = self.iqd_plmag(iq, id, f1)
-        plfe = plfe1 + plfe2 + plmag
+        plfe = plfe1 + plfe2
         plfric = self.pfric(n)
         plcu = self.betai1_plcu(i1, 2 * np.pi * f1)
-        pltotal = plfe + plcu + plfric
+        pltotal = plfe + plcu + plfric + plmag
         p1 = pmech + pltotal
         if np.abs(pmech) < 1e-12:
             eta = 0  # power to low for eta calculation
@@ -1153,11 +1160,15 @@ class PmRelMachine(object):
         f1 = np.array(r['n'])*self.p
         plfe1 = self.kpfe*self.iqd_plfe1(np.array(r['iq']), np.array(r['id']), f1)
         plfe2 = self.kpfe*self.iqd_plfe2(np.array(r['iq']), np.array(r['id']), f1)
+        if hasattr(self, 'kpfe_s'):
+            plfe1 = self.kpfe_s*self.iqd_plfe1(np.array(r['iq']), np.array(r['id']), f1)
+        if hasattr(self, 'kpfe_r'):
+            plfe2 = self.kpfe_r*self.iqd_plfe2(np.array(r['iq']), np.array(r['id']), f1)
         plmag = self.kpmag*self.iqd_plmag(np.array(r['iq']), np.array(r['id']), f1)
-        plfe = plfe1 + plfe2 + plmag
+        plfe = plfe1 + plfe2
         plcu = self.betai1_plcu(np.array(r['i1']), 2*np.pi*f1)
         plfw = self.pfric(2*np.pi*f1)
-        pltotal = plfe + plcu + plfw
+        pltotal = plfe + plcu + plfw + plmag
         r['pmech'] = pmech.tolist()
         r['plfe'] = plfe.tolist()
         r['plcu'] = plcu.tolist()

femagtools/machine/sm.py

@@ -22,7 +22,7 @@ eecdefaults = {
     'tcu2': 20,
     'rotor_mass': 0,
     'kfric_b': 1,
-    'kpfe': 1 # iron loss factor
+    'kpfe': 1 # common iron loss factor
 }
 
 logger = logging.getLogger('sm')
@@ -76,7 +76,13 @@ def parident(workdir, engine, machine,
             raise ValueError('i1_max missing')
         i1_max = kwargs['i1_max']
 
-    ifnom = machine['rotor']['ifnom']
+
+    if "magnetFsl" in machine["magnet"]:
+        rotorkey = "magnet"
+    else:
+        rotorkey = "rotor"
+
+    ifnom = machine[rotorkey]['ifnom']
     exc_logspace = True
     ifmin, ifmax = ifnom/4, 1.4*ifnom
     if exc_logspace:
@@ -197,7 +203,7 @@ def parident(workdir, engine, machine,
     if simulation['calculationMode'] == 'ld_lq_fast':
         dqpars = dict(m=3, p=b['machine']['p'],
                       r1=float(r1),
-                      r2=machine['rotor'].get('resistance', 1),
+                      r2=machine[rotorkey].get('resistance', 1),
                       rotor_mass=rotor_mass, kfric_b=1,
                       ldq=[dict(
                           ex_current=b['machine']['ex_current'],
@@ -214,7 +220,7 @@ def parident(workdir, engine, machine,
     else:
         dqpars = dict(m=3, p=b['machine']['p'],
                       r1=r1,
-                      r2=machine['rotor'].get('resistance', 1),
+                      r2=machine[rotorkey].get('resistance', 1),
                       rotor_mass=rotor_mass, kfric_b=1,
                       psidq=[dict(
                           ex_current=b['machine']['ex_current'],
@@ -387,8 +393,13 @@ class SynchronousMachine(object):
             and friction windage losses"""
         if n > 1e-3:
             f1 = self.p*n
-            plfe = self.kpfe * (self.iqd_plfe1(iq, id, iex, f1)
-                                + self.iqd_plfe2(iq, id, iex, f1))
+            plfe1 = self.kpfe * self.iqd_plfe1(iq, id, iex, f1)
+            plfe2 = self.kpfe * self.iqd_plfe2(iq, id, iex, f1)
+            if hasattr(self, 'kpfe_s'):
+                plfe1 = self.kpfe_s * self.iqd_plfe1(iq, id, iex, f1)
+            if hasattr(self, 'kpfe_r'):
+                plfe2 = self.kpfe_r * self.iqd_plfe2(iq, id, iex, f1)
+            plfe = plfe1 + plfe2
             return (plfe + self.pfric(n))/(2*np.pi*n)
         return 0
 

femagtools/mcv.py

@@ -1173,7 +1173,10 @@ class MagnetizingCurve(object):
         mcv = self.find_by_name(name)
         if not mcv:
             bname = name
-            filename = ''.join((name, ext))
+            filename = name if pathlib.Path(name).suffix.upper() == ext \
+                else ''.join((name, ext))
+            if name == 'dummy':
+                return filename
             # check fillfac and readmcv
             if not fillfac or fillfac == 1.0:
                 try:

femagtools/model.py

@@ -477,8 +477,14 @@ class MachineModel(Model):
         model = {k: getattr(self, k) for k in keys if hasattr(self, k)}
         if hasattr(self, 'stator'):
             model['stator'] = {k: self.stator[k]
-                               for k in ('num_slots', 'num_slots_gen', 'slot_area')
+                               for k in ('num_slots',
+                                         'num_slots_gen',
+                                         'slot_area')
                                if k in self.stator}
+
+        for k in model:
+            if isinstance(model[k], np.float64):
+                model[k] = float(model[k])
         return model
 
 class FeaModel(Model):

femagtools/shortcircuit.py

@@ -108,11 +108,11 @@ def shortcircuit(femag, machine, bch, simulation, engine=0):
             bchsc.scData['demag'] = bchsc.demag
             if simulation.get('sim_demagn', 0):
                 dd = {'displ': [d['displ']
-                               for d in bchsc.demag if 'displ' in d],
-                     'H_max': [d['H_max']
-                               for d in bchsc.demag if 'H_max' in d],
-                     'H_av': [d['H_av']
-                              for d in bchsc.demag if 'H_av' in d]}
+                                for d in bchsc.demag if 'displ' in d],
+                      'H_max': [d['H_max']
+                                for d in bchsc.demag if 'H_max' in d],
+                      'H_av': [d['H_av']
+                               for d in bchsc.demag if 'H_av' in d]}
                 x1 = bchsc.demag[0]['current_1']
                 x2 = bchsc.demag[0]['current_2']
                 def func(phi):
@@ -121,6 +121,7 @@ def shortcircuit(femag, machine, bch, simulation, engine=0):
                 i1max = x1/np.cos(phi)
 
                 phirot = dd['displ'][0]/180*np.pi
+                logger.info("i1max %g phi %g phirot %g", i1max, phi, phirot)
                 bchsc.scData['demag'] = demag(
                     femag, machine, simulation,
                     i1max, phirot, phi, engine)
@@ -319,7 +320,7 @@ def shortcircuit_2phase(femag, machine, simulation, engine=0):
     # rotor position at maximum current:
     trot = min(iav[0], iap[0])
     phirot = wm*trot + phi0
-    logger.info("phi %.1f")
+    logger.debug("phirot %.1f", phirot)
 
     scData = {
         'ia': ia.tolist(),
@@ -345,7 +346,7 @@ def demag(femag, machine, simulation, i1max, phirot, phi, engine=0):
     """demag simulation using psi-torq-rem-rot"""
     logger.info("Demagnetization processing")
     i1min = simulation.get('i1min', abs(i1max/3))
-    num_steps = 7
+    num_steps = simulation.get('num_demag_cur_steps', 7)
     b = (i1min-abs(i1max))/np.log(i1min/abs(i1max))
     a = abs(i1max)/b
     xtab = np.linspace(i1min/abs(i1max),

femagtools/templates/psi-torq-rem.mako

@@ -82,14 +82,14 @@ rotate({
     mode   = "save"         -- save initial model state
 })
 
+rotate({angle=phi, mode="absolute"})
+
 file_psi = io.open("psi-torq-rem.dat","w")
 for i=1, #curvec do
-  print(string.format(" current: %d/%d %g, %g, %g\n",
-        i, #curvec, curvec[i][1], curvec[i][2], curvec[i][3]))
-
-    rotate({angle=phi, mode="absolute"})
     psi, tq, rr = calc_flux_torq_rem(curvec[i])
 
+    print(string.format(" current: %d/%d %g, %g, %g torque %g rr %g\n",
+        i, #curvec, curvec[i][1], curvec[i][2], curvec[i][3], tq, rr))
     file_psi:write(string.format("%g ", phi))
     for k=1, 3 do
       file_psi:write(string.format("%g ", curvec[i][k]))

femagtools/templates/statorKS1.mako

@@ -0,0 +1,43 @@
+
+m.yoke_diam   = dy1
+m.inside_diam = da1
+
+m.wdg_location = -1 -- for gen_windings
+
+m.slot_angle = ${model['slot_angle']*1e3}
+m.slot_height = ${model['slot_height']*1e3}
+m.slot_h1     = ${model['slot_h1']*1e3}
+m.slot_h2     = ${model['slot_h2']*1e3}
+m.slot_bk     = ${model['slot_bk']*1e3}
+m.slot_width  = ${model['slot_width']*1e3}
+m.slot_r1     = ${model['slot_r1']*1e3}
+m.slot_r2     = ${model['slot_r2']*1e3}
+m.middle_line = ${model.get('middle_line',0)}
+m.tooth_width = ${model.get('tooth_width',0)*1e3}
+m.slot_topwidth = ${model.get('slot_topwidth',0)*1e3}
+
+m.zeroangl    = ${model.get('zeroangle',0)}
+m.rlength     = ${model.get('rlength',1)*100}
+
+% if model.get('ac_loss', False):
+  m.ac_loss = ${model.get('ac_loss', 6)}
+% endif
+m.mcvkey_yoke = mcvkey_yoke
+
+pre_models("STATOR_KS1")
+
+if mcvkey_teeth ~= nil then
+  if m.inside_diam > m.yoke_diam then
+     r = (m.inside_diam - m.slot_height)/2
+  else
+     r = (m.inside_diam + m.slot_height)/2
+  end
+  x0, y0 = pr2c(r, 2*math.pi/m.tot_num_slot + m.zeroangl/180*math.pi)
+   def_mat_fm_nlin(x0, y0, "blue", mcvkey_teeth, m.rlength)
+end
+
+%if model.get('thcond', 0) and model.get('thcap', 0):
+stator_thcond = ${model.get('thcond', 24)}
+stator_thcap = ${model.get('thcap', 480)}
+stator_density = ${model.get('density', 7700)}
+%endif

{femagtools-1.8.18.dist-info → femagtools-1.8.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: femagtools
-Version: 1.8.18
+Version: 1.8.20
 Summary: Python API for FEMAG
 Author-email: Ronald Tanner <tar@semafor.ch>, Dapu Zhang <dzhang@gtisoft.com>, Beat Holm <hob@semafor.ch>, Günther Amsler <amg@semafor.ch>, Nicolas Mauchle <mau@semafor.ch>
 License: Copyright (c) 2016-2023, Semafor Informatik & Energie AG, Basel