femagtools 1.8.12__py3-none-any.whl → 1.8.14__py3-none-any.whl

femagtools/machine/pm.py

@@ -92,7 +92,8 @@ class PmRelMachine(object):
         self.io = (1, -1)
         self.fo = 50.0
         self.tcu1 = 20
-        self.tmag = 20
+        # for information purpose only
+        self.tmag = kwargs.get('tmag', 20)
         self.zeta1 = 0.2
         self.gam = 0.7
         self.kh = 2

femagtools/machine/sizing.py

@@ -546,9 +546,10 @@ def get_interior_magnet_dimensions(I1, N, kw, psi1, lfe, Da2, par):
             iron_shape=Da2/2))
 
 
-def get_im_rotor_dimensions(A, Da2, psi1, lfe, par, rtype='rotorKs2'):
+def get_im_rotor_dimensions(A, Da2, psi1, lfe, par, rtype='statorRotor3'):
     r = dict()
     r['Da2'] = Da2
+    r['rotorfilfact']=0.95
     if 'Q2' not in par:
         r['num_slots'] = _rotor_slots(par['Q1'], par['p'])[0]
     else:
@@ -568,13 +569,42 @@ def get_im_rotor_dimensions(A, Da2, psi1, lfe, par, rtype='rotorKs2'):
     taup = np.pi * Da2/(2*par['p'])
     hyr = psi1/2/lfe*par['By']
     r['Dy2'] = round(Da2 - 2*hr - 2*hyr, 4)
-    logger.info("Dy2 %f Da2 %f hys %f hr %f",
-                r['Dy2']*1e3, Da2*1e3, hyr*1e3, hr*1e3)
     slotwidth = 1e-3
     Q2 = r['num_slots']
     r1 = wr/2-slotwidth
     r2 = (Da2/2-hr-hs1)*np.tan(alfar)
-    if rtype == 'statorRotor3':
+
+    logger.info("Dy2 %f Da2 %f hys %f hr %f",
+                r['Dy2']*1e3, Da2*1e3, hyr*1e3, hr*1e3)
+
+    # End-ring calculation
+    Ir_total_estimated = A * np.pi * Da2 / (2 * par['p'])
+    Ibar_eff = Ir_total_estimated / r['num_slots']
+
+    if r['num_slots'] > 0:
+        sin_term = np.sin(np.pi / r['num_slots'])
+        if sin_term != 0:
+             Iring_max_eff = Ibar_eff / (2 * sin_term)
+        else:
+             Iring_max_eff = 0
+    else:
+        Iring_max_eff = 0
+    if 'Jring' not in par:
+        par['Jring'] = par.get('J', 4e6)
+
+    Jring = par['Jring']
+
+    if 'kfilling_ring' not in par:
+        par['kfilling_ring'] = 1.0
+
+    kfilling_ring = par['kfilling_ring']
+
+    if Jring * kfilling_ring > 0:
+        Aring = Iring_max_eff / (Jring * kfilling_ring)
+    else:
+        Aring = 0
+
+    """if rtype == 'statorRotor3':
         r['statorRotor3'] = dict(
             slot_width=slotwidth,
             tooth_width=round(wt, 4),
@@ -587,6 +617,18 @@ def get_im_rotor_dimensions(A, Da2, psi1, lfe, par, rtype='rotorKs2'):
             wedge_width1=0,
             wedge_width2=0,
             middle_line=0)
+        r['statorRotor3'] = dict(
+            slot_width=1e-3,
+            tooth_width=0,
+            slot_height=0.0157,
+            slot_top_sh=0,
+            slot_h1=0.5e-3,
+            slot_h2=2.2e-3,
+            slot_r1=2.2e-3,
+            slot_r2=1e-3,
+            wedge_width1=1e-3,
+            wedge_width2=0,
+            middle_line=0)
     elif rtype == 'rotorAsyn':
         r['rotorAsyn'] = dict(
             slot_bs2=0.1e-3,
@@ -610,8 +652,52 @@ def get_im_rotor_dimensions(A, Da2, psi1, lfe, par, rtype='rotorKs2'):
             slot_h2=0,
             slot_r1=1e-3,  # r1,
             slot_r2=1e-3,  # r2,
+            middle_line=0)"""
+        
+    all_rotor_types = {}
+
+    all_rotor_types['statorRotor3'] = dict(
+            slot_width=slotwidth,
+            tooth_width=round(wt, 4),
+            slot_height=round(hr+r2, 4),
+            slot_top_sh=1.0,
+            slot_h1=round(hs1, 4),
+            slot_h2=round(hs1+r1, 4),
+            slot_r1=round(r1, 4),
+            slot_r2=round(r2),
+            wedge_width1=0,
+            wedge_width2=0,
             middle_line=0)
 
+    all_rotor_types['rotorAsyn'] = dict(
+        slot_bs2=0.1e-3,
+        slot_hs2=0.5e-3,
+        slot_b32=0.0,
+        slot_h32=0.0,
+        slot_b42=0.0,
+        slot_h42=0.0,
+        slot_b52=round(wr, 4),
+        slot_b62=3e-3,
+        slot_h52=2.5e-3,
+        slot_h62=round(hr, 4),
+        slot_h72=2e-3
+    )
+
+    all_rotor_types['rotorKs2'] = dict(
+        slot_angle=round(2 * alfar * 180 / np.pi, 2),
+        slot_height=round(hr + r1 + r2, 4),
+        slot_topwidth=round(wr, 4),
+        slot_width=slotwidth,
+        slot_h1=hs1,
+        slot_h2=0,
+        slot_r1=1e-3,  # r1,
+        slot_r2=1e-3,   # r2,
+        middle_line=0
+    )
+
+
+    r.update(all_rotor_types)
+    r['Aring'] = Aring
     return r
 
 
@@ -947,7 +1033,7 @@ def im(pnom: float, speed: float, p: int, **kwargs) -> dict:
         slots = []
     r = get_stator_dimensions(par, slots=slots)
     # rotor parameters
-    rtype = kwargs.get('rtype', 'rotorKs2')
+    rtype = kwargs.get('rtype', 'statorRotor3')
     r['rotor'] = get_im_rotor_dimensions(
         par['cos_phi']*r['A'], r['Da2'], r['psi1'], r['lfe'],
         par, rtype=rtype)

femagtools/machine/sm.py

@@ -7,7 +7,7 @@ import pathlib
 import numpy as np
 import scipy.optimize as so
 import scipy.interpolate as ip
-from .utils import skin_resistance, wdg_resistance, betai1, iqd, KTH, create_wdg
+from .utils import skin_resistance, wdg_resistance, betai1, iqd, KTH, create_wdg, loss_models
 from .. import parstudy, windings
 import femagtools.bch
 
@@ -42,14 +42,15 @@ def parident(workdir, engine, machine,
 
         optional arguments:
         num_cur_steps: number of current steps (default 5)
-        num_beta_steps: number of current steps (default 13)
-        num_exc_steps: number of excitation current (default 7)
+        num_beta_steps: number of beta steps (default 13)
+        num_exc_steps: number of excitation current (default 6)
         speed: rotor speed in 1/s (default 160/p)
         i1_max: maximum current in A rms (default approx 3*i1nom)
         beta_min: minimal current angle (default -180°)
         beta_max: maximal current angle (default 0°)
         num_move_steps: number of move steps
         cmd: femag command (default None, platform executable)
+        feloss: jordan, steinmetz, modified steinmetz, bertotti
         """
     cmd = kwargs.get('cmd', None)
 
@@ -79,9 +80,14 @@ def parident(workdir, engine, machine,
     exc_logspace = True
     ifmin, ifmax = ifnom/4, 1.4*ifnom
     if exc_logspace:
-        excur = np.logspace(np.log(ifmin), np.log(ifmax),
+        """excur = np.logspace(np.log(ifmin), np.log(ifmax),
                             kwargs.get("num_exc_steps", 6),
-                            base=np.exp(1)).tolist()
+                            base=np.exp(1)).tolist()"""
+        # create a data grid always contains ifnom
+        excur = np.logspace(np.log(ifmin), np.log(ifnom),
+                            kwargs.get("num_exc_steps", 6) - 2,
+                            base=np.exp(1), endpoint=False).tolist()
+        excur.extend([ifnom, ifmax])
     else:
         excur = np.linspace(ifmin, ifmax,
                             kwargs.get("num_exc_steps", 6))
@@ -120,6 +126,9 @@ def parident(workdir, engine, machine,
         period_frac=kwargs.get('period_frac', 6),
         speed=kwargs.get('speed', 50))
 
+    if kwargs.get("feloss", 0): 
+        simulation["feloss"] = kwargs["feloss"]
+        machine["calc_fe_loss"] = loss_models[kwargs["feloss"].lower()]
     ###self.cleanup()  # remove previously created files in workdir
     results = parvar(parvardef, machine, simulation, engine)
     b = results['f'][-1]
@@ -440,10 +449,6 @@ class SynchronousMachine(object):
 
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
-            def sqrtculoss(iqde):
-                pcu = self.culoss(iqde)
-                return pcu
-
             res = so.minimize(
                 self.culoss, startvals, method='SLSQP',  # trust-constr
                 bounds=self.bounds,
@@ -469,10 +474,6 @@ class SynchronousMachine(object):
 
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
-            def sqrtculoss(iqde):
-                pcu = self.culoss(iqde)
-                #logger.info("iqde %s --> pcu %f", iqde, pcu)
-                return pcu
             res = so.minimize(
                 self.culoss, startvals, method='SLSQP',  # trust-constr
                 bounds=self.bounds,
@@ -513,42 +514,38 @@ class SynchronousMachine(object):
          with minimal losses at max voltage"""
         iqde = self.iqd_tmech(torque, w1/2/np.pi/self.p)
         if np.linalg.norm(
-                self.uqd(w1, *iqde)) <= u1max*np.sqrt(2):
+            self.uqd(w1, *iqde)) <= u1max*np.sqrt(2):
             if log:
                 log(iqde)
             return (*iqde, torque)
-        #beta, i1 = betai1(iqde[0], iqde[1])
-        #iex = iqde[2]
-
-        #beta = 0 if torque>0 else np.pi
-        io = iqde[0], 0, iqde[2] #*iqd(beta, i1), iex
+        beta, i1 = betai1(iqde[0], iqde[1])
+        iex = iqde[2]
+        def ubeta(b):
+            return np.sqrt(2)*u1max - np.linalg.norm(
+                         self.uqd(w1, *iqd(b, i1), iex))
+        beta = -np.pi/4 if torque>0 else -3*np.pi/4
+        io = *iqd(beta, i1), iex
 
         #    logger.debug("--- torque %g io %s", torque, io)
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            n = w1/2/np.pi/self.p
-            def sqrtculoss(iqde):
-                pcu = self.culoss(iqde)
-                #logger.info("iqde %s pcu %g", iqde, pcu)
-                return pcu
-
-            res = so.minimize(
-                self.culoss, io, method='SLSQP',  # trust-constr
-                bounds=self.bounds,
-                constraints=[
-                    {'type': 'eq',
-                     'fun': lambda iqd: torque - self.tmech_iqd(*iqd, n)},
-                    {'type': 'eq',
-                     'fun': lambda iqd: u1max*np.sqrt(2)
-                       - np.linalg.norm(self.uqd(w1, *iqd))}])
-            #if res['success']:
-            if log:
-                log(res.x)
+        n = w1/2/np.pi/self.p
+        res = so.minimize(
+            self.culoss, io, method='SLSQP',  # trust-constr
+            bounds=self.bounds,
+            constraints=[
+                {'type': 'eq',
+                 'fun': lambda iqd: self.tmech_iqd(*iqd, n) - torque},
+                {'type': 'eq',
+                 'fun': lambda iqd: np.linalg.norm(
+                     self.uqd(w1, *iqd)) - u1max*np.sqrt(2)}])
+
+        if log:
+            log(res.x)
+        if res["success"]:
             return *res.x, self.tmech_iqd(*res.x, n)
-        #logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
-        #               res['message'], w1, torque, u1max, io)
-        #raise ValueError(res['message'])
-        #return [float('nan')]*4
+
+        logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
+                       res['message'], w1, torque, u1max, io)
+        raise ValueError(res['message'])
 
     def iqd_torque_umax(self, torque, w1, u1max,
                         disp=False, maxiter=500, log=0, **kwargs):
@@ -559,33 +556,31 @@ class SynchronousMachine(object):
                 if log:
                     log(iqde)
                 return (*iqde, torque)
-        io = iqde[0], 0, iqde[2]
-        #    logger.debug("--- torque %g io %s", torque, io)
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            def sqrtculoss(iqde):
-                pcu = self.culoss(iqde)
-                #logger.info("iqde %s pcu %g", iqde, pcu)
-                return pcu
-
-            res = so.minimize(
-                self.culoss, io, method='SLSQP',  # trust-constr
-                bounds=self.bounds,
-                #options={'disp': disp, 'maxiter': maxiter},
-                #            jac=gradient_respecting_bounds(self.bounds, self.culoss),
-                constraints=[
-                    {'type': 'eq',
-                     'fun': lambda iqd: self.torque_iqd(*iqd) - torque},
-                    {'type': 'eq',
-                     'fun': lambda iqd: u1max*np.sqrt(2) - np.linalg.norm(
-                         self.uqd(w1, *iqd))}])
-            #if res['success']:
-            if log:
-                log(res.x)
+        beta, i1 = betai1(iqde[0], iqde[1])
+        iex = iqde[2]
+        def ubeta(b):
+            return np.sqrt(2)*u1max - np.linalg.norm(
+                         self.uqd(w1, *iqd(b, i1), iex))
+        beta = -np.pi/4 if torque>0 else -3*np.pi/4
+        io = *iqd(beta, i1), iex
+        res = so.minimize(
+            self.culoss, io, method='SLSQP',  # trust-constr
+            bounds=self.bounds,
+            #options={'disp': disp, 'maxiter': maxiter},
+            #            jac=gradient_respecting_bounds(self.bounds, self.culoss),
+            constraints=[
+                {'type': 'eq',
+                 'fun': lambda iqd: self.torque_iqd(*iqd) - torque},
+                {'type': 'eq',
+                 'fun': lambda iqd: u1max*np.sqrt(2) - np.linalg.norm(
+                     self.uqd(w1, *iqd))}])
+        if log:
+            log(res.x)
+        if res['success']:
             return *res.x, self.torque_iqd(*res.x)
-            #logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
-            #               res['message'], w1, torque, u1max, io)
-            #raise ValueError(res['message'])
+        logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
+                       res['message'], w1, torque, u1max, io)
+        raise ValueError(res['message'])
 
     def w1_imax_umax(self, i1max, u1max):
         """return frequency w1 and shaft torque at voltage u1max and current i1max
@@ -669,10 +664,12 @@ class SynchronousMachine(object):
 
         wmtab = []
         dw = 0
+        wmMax = 2*np.pi*n
+        '''
         wmMax = 5*wmType
         if n > 0:
             wmMax = min(wmMax, 2*np.pi*n)
-
+        '''
         if wmType > wmMax:
             wmrange = sorted([0, wmMax])
             wmtab = np.linspace(0, wmMax, nsamples).tolist()
@@ -793,6 +790,7 @@ class SynchronousMachinePsidq(SynchronousMachine):
         self.psiqf = ip.RegularGridInterpolator(
             (exc, iqx, idx), psiq,
             method='cubic', bounds_error=False, fill_value=None)
+        # excitation currents bounds should respect ifnom
         self.bounds = [(min(iq), max(iq)),
                        (min(id), 0),
                        (iexc[0], iexc[-1])]
@@ -909,6 +907,7 @@ class SynchronousMachineLdq(SynchronousMachine):
             method='cubic'
             , bounds_error=False, fill_value=None)
         i1max = np.sqrt(2)*(max(i1))
+        # excitation currents bounds should respect ifnom
         self.bounds = [(np.cos(min(beta))*i1max, i1max),
                        (-i1max, 0),
                        (iexc[0], iexc[-1])]

femagtools/machine/utils.py

@@ -8,9 +8,16 @@ import numpy.linalg as la
 import scipy.interpolate as ip
 import logging
 from .. import parstudy, windings
+from ..model import MachineModel
 
 logger = logging.getLogger(__name__)
 
+loss_models = {
+    "modified steinmetz": 10,
+    "bertotti": 11,
+    "jordan": 1,
+    "steinmetz": 1
+}
 
 def K(d):
     """space phasor transformation matrix
@@ -369,6 +376,7 @@ def dqparident(workdir, engine, temp, machine,
     period_frac: (int) fraction of rotating angle (default 6)
     dqtype: (str) type of identification: 'ldq' (default), 'psidq'
     cmd: femag executable
+    feloss: jordan, steinmetz, modified steinmetz, bertotti
     """
     import pathlib
 
@@ -390,21 +398,25 @@ def dqparident(workdir, engine, temp, machine,
     else:
         fcu = 0.42
 
-    try: # calc basic dimensions if not fsl or dxf model
-        from ..model import MachineModel
+    try:
         wdg = create_wdg(machine)
-        Q1 = wdg.Q
-        model = MachineModel(machine)
-        Jmax = 30e6  # max current density in A/m2
-        Acu = fcu*model.slot_area()  # approx. copper area of one slot
-        i1_max = round(g*Acu/wdg.l/N*Jmax/10)*10
     except KeyError:
-        if kwargs.get('i1_max', 0) == 0:
-            raise ValueError('i1_max missing')
+        pass
+    model = MachineModel(machine)
+    if kwargs.get('i1_max', 0):
         i1_max = kwargs['i1_max']
+    else:
+        try: # calc basic dimensions if not fsl or dxf model
+            Jmax = 30e6  # max current density in A/m2
+            Acu = fcu*model.slot_area()  # approx. copper area of one slot
+            i1_max = round(g*Acu/wdg.l/N*Jmax/10)*10
+        except KeyError:
+            raise ValueError('i1_max missing')
 
     # winding resistance
     try:
+        da1 = machine['bore_diam']
+        hs = model.slot_height()
         if 'wire_gauge' in machine[wdgk]:
             aw = machine[wdgk]['wire_gauge']
         elif 'dia_wire' in machine[wdgk]:
@@ -412,10 +424,10 @@ def dqparident(workdir, engine, temp, machine,
         elif ('wire_width' in machine[wdgk]) and ('wire_height' in machine[wdgk]):
             aw = machine[wdgk]['wire_width']*machine[wdgk]['wire_height']
         else:  # wire diameter from slot area
-            da1 = machine['bore_diam']
+            Q1 = wdg.Q
             aw = 0.75 * fcu * np.pi*da1*hs/Q1/wdg.l/N
-        r1 = wdg_resistance(wdg, N, g, aw, da1, hs, lfe)
-    except (NameError, KeyError):
+        r1 = float(wdg_resistance(wdg, N, g, aw, da1, hs, lfe))
+    except (NameError, KeyError) as ex:
         r1 = 0  # cannot calc winding resistance
 
     n = len(temp)
@@ -483,6 +495,10 @@ def dqparident(workdir, engine, temp, machine,
             speed=kwargs.get('speed', defspeed),
             period_frac=period_frac)
 
+    if kwargs.get("feloss", 0):
+        simulation["feloss"] = kwargs["feloss"]
+        machine["calc_fe_loss"] = loss_models[kwargs["feloss"].lower()]
+
     # TODO: cleanup()  # remove previously created files in workdir
     # start calculation
     results = parvar(parvardef, machine, simulation, engine)
@@ -490,7 +506,6 @@ def dqparident(workdir, engine, temp, machine,
     if 'poles' not in machine:  # dxf model?
         machine['poles'] = 2*results['f'][0]['machine']['p']
         da1 = 2*results['f'][0]['machine']['fc_radius']
-        wdg = create_wdg(machine)
     if 'bore_diam' in machine:
         da1 = machine['bore_diam']
     ls1 = 0
@@ -506,6 +521,14 @@ def dqparident(workdir, engine, temp, machine,
     except KeyError:
         rotor_mass = 0  # need femag classic > rel-9.3.x-48-gca42bbd0
 
+    if rotor_mass == 0:
+        try:
+            nc = parvar.femag.read_nc()
+            rotor_mass = float(sum(nc.get_mass()[1].values()))
+            logger.info("rotor mass from nc-file: %.1f kg", rotor_mass)
+        except StopIteration:
+            logger.warning("Could not read nc-file. Setting rotor_mass = 0!")
+
     dq = []
     if dqtype == 'ldq':
         for i in range(0, len(results['f']), 2):
@@ -585,7 +608,7 @@ def dqparident(workdir, engine, temp, machine,
             # diameter of wires
             aw = fcu*asl/Q1/nlayers/N
             hs = asl/(np.pi*da1/3)
-            dqpars['r1'] = wdg_resistance(wdg, N, g, aw, da1, hs, lfe)
+            dqpars['r1'] = float(wdg_resistance(wdg, N, g, aw, da1, hs, lfe))
 
     if 'current_angles' in results['f'][0]:
         dqpars['current_angles'] = results['f'][0]['current_angles']

femagtools/multiproc.py

@@ -235,6 +235,12 @@ class Engine:
         self.pool = None # garbage collector deletes threads
         return status
 
+    def read_nc(self):
+        """return a generator object of nc list"""
+        for t in self.job.tasks:
+            yield t.read_nc()
+        return None
+
     def stopThreads(self):
         """ stop all running treads
         """

femagtools/parstudy.py

@@ -140,7 +140,8 @@ class ParameterStudy(object):
 
     def __call__(self, opt, machine, simulation,
                  engine, bchMapper=None,
-                 extra_files=[], num_samples=0):
+                 extra_files=[], num_samples=0,
+                 data_model_created=False):
         """calculate objective vars for all decision vars
         Args:
           opt: variation parameter dict (decision_vars, objective_vars)
@@ -150,6 +151,8 @@ class ParameterStudy(object):
           bchMapper: bch result transformation function
           extra_files: list of additional input file names to be copied
           num_samples: number of samples (ingored with Grid sampling)
+          data_model_created: model and complete data structur
+                              was already created before calling this function
         """
 
         self.stop = False  # make sure the calculation will start. thomas.maier/OSWALD
@@ -174,7 +177,8 @@ class ParameterStudy(object):
             workdir = pathlib.Path(self.femag.workdir)
         for d in workdir.glob('[0-9]*'):
             if re.search(r'^\d+$', d.name):
-                shutil.rmtree(d)
+                if not data_model_created:
+                    shutil.rmtree(d)
 
         extra_result_files = []
         if simulation.get('airgap_induc', False):
@@ -198,8 +202,7 @@ class ParameterStudy(object):
 
         prob = femagtools.moproblem.FemagMoProblem(decision_vars,
                                                    objective_vars)
-
-        if immutable_model:
+        if not data_model_created and immutable_model:
             modelfiles = self.setup_model(builder, model, recsin=fea.recsin,
                                           feloss=simulation.get('feloss', ''))
             logger.info("Files %s", modelfiles+extra_files)
@@ -282,7 +285,7 @@ class ParameterStudy(object):
                 task = job.add_task(self.result_func)
                 for fn in extra_files:
                     task.add_file(fn)
-                if immutable_model:
+                if not data_model_created and immutable_model:
                     prob.prepare(x, [fea, self.femag.magnets])
                     for m in modelfiles:
                         task.add_file(m)
@@ -297,18 +300,21 @@ class ParameterStudy(object):
                 else:
                     prob.prepare(x, [model, fea, self.femag.magnets])
                     logger.info("prepare %s", x)
-                    for mc in self.femag.copy_magnetizing_curves(
-                            model,
-                            dir=task.directory,
-                            recsin=fea.recsin,
-                            feloss=feloss):
-                        task.add_file(mc)
-                    set_magnet_properties(model, fea, self.femag.magnets)
+                    if not data_model_created:
+                        for mc in self.femag.copy_magnetizing_curves(
+                                model,
+                                dir=task.directory,
+                                recsin=fea.recsin,
+                                feloss=feloss):
+                            task.add_file(mc)
+                        set_magnet_properties(model, fea, self.femag.magnets)
                     task.add_file(
                         'femag.fsl',
-                        builder.create_model(model, self.femag.magnets) +
+                        (builder.create_model(model, self.femag.magnets) if not data_model_created else []) +
                         builder.create_analysis(fea) +
-                        ['save_model("close")'])
+                        ['save_model("close")'],
+                        append=data_model_created  # model already created, append fsl
+                    )
 
                 if hasattr(fea, 'poc'):
                     task.add_file(fea.pocfilename,

femagtools/plot/bch.py

@@ -559,7 +559,7 @@ def demagnetization(demag, ax=0):
     #        arrowprops=dict(facecolor='green', edgecolor='green', shrink=0.05))
     ax.set_ylim([rrmin, 1.01])
     ax.set_ylabel('Rel. Remanence')
-    ax.set_xlabel(f'Phase Current / {unit}')
+    ax.set_xlabel(f'Phase Current / {unit} (peak)')
     ax.grid()
 
 

femagtools/shortcircuit.py

@@ -112,12 +112,17 @@ def shortcircuit(femag, machine, bch, simulation, engine=0):
                                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]}
-                i1max = bchsc.scData['iks']
-                if dd['displ']:
-                    phi = dd['displ'][0]/180*np.pi
+                x1 = bchsc.demag[0]['current_1']
+                x2 = bchsc.demag[0]['current_2']
+                def func(phi):
+                    return x2*np.cos(phi) - x1*np.cos(phi-2*np.pi/3)
+                phi=so.fsolve(func, 0)[0]
+                i1max = x1/np.cos(phi)
+
+                phirot = dd['displ'][0]/180*np.pi
                 bchsc.scData['demag'] = demag(
                     femag, machine, simulation,
-                    i1max, phi, engine)
+                    i1max, phirot, phi, engine)
                 bchsc.scData['demag'].update(dd)
             scdata = bchsc.scData
             #for w in bch.flux:
@@ -310,7 +315,7 @@ def shortcircuit_2phase(femag, machine, simulation, engine=0):
 
     # rotor position at maximum current:
     trot = min(iav[0], iap[0])
-    phi = wm*trot + phi0
+    phirot = wm*trot + phi0
     logger.info("phi %.1f")
 
     scData = {
@@ -330,10 +335,10 @@ def shortcircuit_2phase(femag, machine, simulation, engine=0):
     if simulation.get('sim_demagn', 0):
         i1max = iap[1] if iap[1] > abs(iav[1]) else iav[1]
         scData['demag'] = demag(femag, machine, simulation,
-                                i1max, phi, engine)
+                                i1max, phirot, 0, engine)
     return scData
 
-def demag(femag, machine, simulation, i1max, phi, engine=0):
+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))
@@ -345,7 +350,8 @@ def demag(femag, machine, simulation, i1max, phi, engine=0):
     i1tab = b*(a+np.log(xtab))
 
     if simulation.get('sc_type', 3) == 3:
-        curvec = [[-a/2, a, -a/2] for a in i1tab]
+        curvec = [[a*np.cos(phi), a*np.cos(phi-2*np.pi/3),
+                   a*np.cos(phi+2*np.pi/3)] for a in i1tab]
     else:
         if i1max > 0:
             curvec = [[a, -a, 0] for a in i1tab]
@@ -353,7 +359,7 @@ def demag(femag, machine, simulation, i1max, phi, engine=0):
             curvec = [[-a, a, 0] for a in i1tab]
     simulation.update({
         'calculationMode': 'psi-torq-rem',
-        'phi': phi,
+        'phi': phirot,
         'magntemp': simulation['Tmag'],
         'curvec': curvec})
     _ = femag(machine, simulation)

femagtools/templates/FE-losses.mako

@@ -15,6 +15,3 @@ m.poison          =      ${model.get('poison', 0.3)}
 m.dampfact        =      ${model.get('dampfact', 0.0)}
 m.thcond          =      ${model.get('thcond', 30.0)}
 m.thcap           =      ${model.get('thcap', 480.0)}
-
- pre_models("FE-Losses-1")
- pre_models("FE-Losses-2")