femagtools 1.7.5__py3-none-any.whl → 1.7.7__py3-none-any.whl

femagtools/fsl.py

@@ -42,7 +42,7 @@ class Builder:
             default_filters=['decode.utf8'])
 
         self.fsl_stator = False
-        self.fsl_magnet = False
+        self.fsl_rotor = False
 
     def create_wdg_def(self, model):
         name = 'winding'
@@ -216,7 +216,7 @@ class Builder:
                .format(model.magnet.get('mcvkey_shaft', 'dummy'))]
 
         if 'magnetFsl' in model.magnet:
-            self.fsl_magnet = True
+            self.fsl_rotor = True
             #  obsolete
             if 'parameter' in model.magnet['magnetFsl']:
                 return mcv + self.render_template(
@@ -242,10 +242,10 @@ class Builder:
         magmodel['mcvkey_magnet'] = model.get_mcvkey_magnet()
         if templ == 'dxf':
             return mcv + [
-                u'xmag = {}',
-                u'ymag = {}',
-                u'mag_orient = {}',
-                u'ndt(agndst)'] + model.magnet['dxf']['fsl']
+                'xmag = {}',
+                'ymag = {}',
+                'mag_orient = {}',
+                'ndt(agndst)'] + model.magnet['dxf']['fsl']
 
         return mcv + self.render_rotor(magmodel, templ)
 
@@ -267,12 +267,16 @@ class Builder:
                 rotmodel['winding_inside'] = not model.external_rotor
                 culosses = self.create_cu_losses(rotmodel, condMat)
 
-        rotmodel.update(model.rotor[templ])
         rotmodel['is_rotor'] = True  # just in case for the template
+        if templ == 'EESM':
+            if 'dxf' in rotmodel:
+                return mcv + ['ndt(agndst)'] + rotmodel['dxf']['fsl']
+            templ = 'rot_hsm'
+        rotmodel.update(model.rotor[templ])
         return mcv + culosses + self.render_rotor(rotmodel, templ)
 
     def create_rotor_winding(self, model):
-        if hasattr(model, 'rotor') and model.rotortype() == 'rot_hsm':
+        if hasattr(model, 'rotor') and model.rotortype() == 'EESM':
             return self.render_rotor(model.rotor, 'rotor_winding')
         return []
 
@@ -306,21 +310,22 @@ class Builder:
 
         if templ == 'dxf':
             # reuse dxfsl model
-            self.fsl_magnet = True
+            self.fsl_rotor = True
         if templ != 'dxffile':
             return
 
         from femagtools.dxfsl.converter import convert
         params = {}
-        params['split'] = model.magnet[templ].get('split', False)
-        params['show_plots'] = model.magnet[templ].get('plot', False)
+        rotor = model.magnet
+        params['split'] = rotor[templ].get('split', False)
+        params['show_plots'] = rotor[templ].get('plot', False)
         params['write_fsl'] = True
         params['airgap'] = -1.0
         pos = 'out' if model.external_rotor else 'in'
         params['part'] = ('rotor', pos)
         logger.info("Conv rotor from %s",
-                    model.magnet[templ]['name'])
-        conv = convert(model.magnet[templ]['name'], **params)
+                    rotor[templ]['name'])
+        conv = convert(rotor[templ]['name'], **params)
         model.set_value('poles', int(conv.get('num_poles')))
         self.set_diameter_parameter(model, conv)
         if model.get('da2'):
@@ -328,9 +333,9 @@ class Builder:
             ag = (model.get('bore_diam') - model.get('da2')/1e3)/2
             model.set_value('airgap', ag)
 
-        model.magnet['dxf'] = dict(fsl=conv['fsl'])
-        self.fsl_magnet = True
-        del model.magnet[templ]
+        rotor['dxf'] = dict(fsl=conv['fsl'])
+        self.fsl_rotor = True
+        del rotor[templ]
 
     def render_rotor(self, magmodel, templ):
         fslcode = self.__render(magmodel, templ, magnet=True)
@@ -351,23 +356,25 @@ class Builder:
             if 'thcond' in model.stator:
                 fslcmds += [
                     '-- thermal properties in airgap',
-                    'ag_cond = 0.063',
-                    'thcap = 1007',
-                    'beta = math.pi*m.npols_gen/m.num_poles + m.zeroangl/180*math.pi',
-                    'xai, yai = pr2c((da1+da2)/4, beta)',
-                    'def_mat_therm(xai,yai,"cyan",1.19,ag_cond,thcap,1)',
-                    'xai, yai = pr2c((da1+da2)/4-ag/4, beta)',
-                    'def_mat_therm(xai,yai,"cyan",1.19,ag_cond,thcap,1)',
-                    'xai, yai = pr2c((da1+da2)/4+ag/4, beta)',
-                    'def_mat_therm(xai,yai,"cyan",1.19,ag_cond,thcap,1)',
+                    'if m.zeroangl ~= nil then',
+                    '   ag_cond = 0.063',
+                    '   thcap = 1007',
+                    '   beta = math.pi*m.npols_gen/m.num_poles + m.zeroangl/180*math.pi',
+                    '   xai, yai = pr2c((da1+da2)/4, beta)',
+                    '   def_mat_therm(xai,yai,"cyan",1.19,ag_cond,thcap,1)',
+                    '   xai, yai = pr2c((da1+da2)/4-ag/4, beta)',
+                    '   def_mat_therm(xai,yai,"cyan",1.19,ag_cond,thcap,1)',
+                    '   xai, yai = pr2c((da1+da2)/4+ag/4, beta)',
+                    '   def_mat_therm(xai,yai,"cyan",1.19,ag_cond,thcap,1)',
                     '',
-                    'state_of_problem("therm_static") -- thermic boundary conditions',
-                    'x1,y1 = pd2c(dy2/2,m.zeroangl)',
-                    'x2,y2 = pd2c(dy1/2,m.zeroangl)',
-                    'beta = 360*m.npols_gen/m.num_poles',
-                    'x3,y3 = pd2c(dy1/2,beta+m.zeroangl)',
-                    'x4,y4 = pd2c(dy2/2,beta+m.zeroangl)',
-                    'def_bcond_tp(x1,y1,x2,y2,x3,y3,x4,y4, 4)',
+                    '   state_of_problem("therm_static") -- thermic boundary conditions',
+                    '   x1,y1 = pd2c(dy2/2,m.zeroangl)',
+                    '   x2,y2 = pd2c(dy1/2,m.zeroangl)',
+                    '   beta = 360*m.npols_gen/m.num_poles',
+                    '   x3,y3 = pd2c(dy1/2,beta+m.zeroangl)',
+                    '   x4,y4 = pd2c(dy2/2,beta+m.zeroangl)',
+                    '   def_bcond_tp(x1,y1,x2,y2,x3,y3,x4,y4, 4)',
+                    'end',
                     'state_of_problem("mag_static")']
             return fslcmds
         return []
@@ -409,10 +416,10 @@ class Builder:
                 cond = condMat.find(windings['material'])
             if not cond:
                 raise FslBuilderError(
-                    'conductor material {} not found'.format(
-                        windings['material']))
+                    'conductor material {} not found in {}'.format(
+                        windings['material'], condMat))
             windings['cuconduct'] = cond['elconduct']
-            for k in ('thcond', 'thcap'):
+            for k in ('thcond', 'thcap', 'spmaweight'):
                 if k in cond:
                     windings[k] = cond[k]
 
@@ -433,7 +440,14 @@ class Builder:
         return []
 
     def create_gen_winding(self, model):
-        genwdg = self.__render(model, 'gen_winding')
+        try:
+            if model.winding['wire']['name'] == 'hairpin_winding':
+                model.winding['wire'].update(
+                    {"num_layers": model.winding["num_layers"]})
+                genwdg = self.__render(model.winding,
+                                       'gen_' + model.winding['wire'].get('name'))
+        except KeyError:  # not hairpin_winding
+            genwdg = self.__render(model, 'gen_winding')
         k = list({'leak_dist_wind',
                   'leak_evol_wind',
                   'leak_tooth_wind'}.intersection(model.winding))
@@ -480,6 +494,9 @@ class Builder:
         params['airgap'] = model.dxffile.get('airgap', 0.0)
         params['nodedist'] = model.dxffile.get('nodedist', 1)
         params['full_model'] = model.dxffile.get('full_model', False)
+        params['EESM'] = model.dxffile.get('type', 'PMSM') == 'EESM'
+        if params['EESM']:
+            model.rotor['EESM'] = {}
         conv = convert(dxfname, **params)
 
         model.set_value('poles', conv.get('num_poles'))
@@ -492,6 +509,7 @@ class Builder:
         if not hasattr(model, 'stator'):
             setattr(model, 'stator', {})
         model.stator['num_slots'] = conv.get('tot_num_slot')
+        model.stator['slot_area'] = conv.get('slot_area')
         if model.get('num_agnodes', 0) == 0:
             model.set_value('agndst', conv['agndst']*1e-3)
             logger.info("num poles %d num slots %d outer diameter %.4f m agndst %.4f mm",
@@ -509,11 +527,17 @@ class Builder:
         if 'fsl_stator' in conv:
             self.fsl_stator = True
             model.stator['dxf'] = dict(fsl=conv['fsl_stator'])
-        if not hasattr(model, 'magnet'):
-            setattr(model, 'magnet', {})
-        if 'fsl_magnet' in conv:
-            self.fsl_magnet = True
-            model.magnet['dxf'] = dict(fsl=conv['fsl_magnet'])
+        if not (hasattr(model, 'magnet') or hasattr(model, 'rotor')):
+            if params['EESM']:
+                setattr(model, 'rotor', {})
+            else:
+                setattr(model, 'magnet', {})
+        if 'fsl_rotor' in conv:
+            self.fsl_rotor = True
+            if hasattr(model, 'magnet'):
+                model.magnet['dxf'] = dict(fsl=conv['fsl_rotor'])
+            if hasattr(model, 'rotor'):
+                model.rotor['dxf'] = dict(fsl=conv['fsl_rotor'])
 
     def create_model(self, model, magnets=[], condMat=[], ignore_material=False):
         magnetMat = {}
@@ -563,10 +587,9 @@ class Builder:
                         'remanenc', 1.2)
                     model['magnet']['relperm'] = magnetMat.get('relperm', 1.05)
                     model['magnet']['rlen'] = magnetMat.get('rlen', 1.0)
-                    for k in ('thcond', 'thcap'):
+                    for k in ('spmaweight', 'thcond', 'thcap'):
                         if k in magnetMat:
-                            model['magnet'][k] = magnetMat[k]
-
+                            model['magnet'][k+'_magnet'] = magnetMat[k]
                 rotor = (self.create_magnet(model) +
                          self.create_magnet_model(model))
                 if magnetMat:
@@ -714,11 +737,10 @@ class Builder:
         return self.__render(model, 'colorgrad')
 
     def mesh_airgap(self, model):
-        if ((self.fsl_stator and self.fsl_magnet) or
+        if ((self.fsl_stator and self.fsl_rotor) or
                 model.get('num_agnodes', 0)):
             return self.__render(model, 'mesh-airgap')
-        else:
-            return []
+        return []
 
     def create(self, model, sim, magnets=None, condMat=[]):
         "create model and analysis function"
@@ -769,6 +791,9 @@ class Builder:
         return (fslmodel + self.create_analysis(sim) +
                 ['save_model("close")'])
 
+    def create_detailed_wire(self, params, templ):
+        return self.__render(params, templ)
+
     def __render(self, model, templ, stator=False, magnet=False):
         if templ.split('.')[-1] in ('fsl', 'mako'):
             try:
@@ -788,7 +813,7 @@ class Builder:
             if stator:
                 self.fsl_stator = True
             if magnet:
-                self.fsl_magnet = True
+                self.fsl_rotor = True
 
         return template.render_unicode(model=model).split('\n')
 

femagtools/isa7.py

@@ -528,7 +528,7 @@ class Isa7(object):
 
     color = {1: [1.0, 0.0, 0.0],  # RED
              2: [0.0, 1.0, 0.0],  # GREEN
-             3: [1.0, 1.0, 0.0],  # DARKYELLOW
+             3: [1.0, 0.8, 0.0],  # DARKYELLOW
              4: [0.0, 0.5019607843137255, 1.0], # BLUE
              5: [0.9803921568627451, 0.0, 1.0], # MAGENTA
              6: [0.0, 1.0, 0.8235294117647058], # CYAN
@@ -749,7 +749,7 @@ class Isa7(object):
                                      for e in self.elements])
 
         for a in ('FC_RADIUS', 'pole_pairs', 'poles_sim',
-                  'delta_node_angle', 'speed',
+                  'layers', 'coil_span', 'delta_node_angle', 'speed',
                   'MAGN_TEMPERATURE', 'BR_TEMP_COEF',
                   'MA_SPEZ_WEIGHT', 'CU_SPEZ_WEIGHT'):
             v = getattr(reader, a, '')

femagtools/machine/effloss.py

@@ -323,6 +323,8 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
         plcu1 = m.iqd_plcu1(iqd[0], iqd[1], 2*np.pi*f1)
         plcu2 = m.iqd_plcu2(*iqd)
         tfric = m.tfric
+        logger.info("Iex %f %f",
+                    np.min(iqd[2]), np.max(iqd[2]))
     else:
         plfe1 = np.array(r['plfe1'])
         plfe2 = np.zeros(ntmesh.shape[1])

femagtools/machine/pm.py

@@ -5,7 +5,7 @@ import logging
 import warnings
 import numpy as np
 import numpy.linalg as la
-from .utils import iqd, betai1, skin_resistance, dqparident, KTH, K
+from .utils import iqd, betai1, skin_resistance, dqparident, KTH, K, T
 import scipy.optimize as so
 import scipy.interpolate as ip
 import scipy.integrate as ig
@@ -14,6 +14,38 @@ from functools import partial
 logger = logging.getLogger(__name__)
 
 
+def find_peaks_and_valleys(t, iabc, tshort):
+    """ return peaks and valleys of phase current with maximum amplitude
+    """
+    iph = iabc[np.argmax([np.max(np.abs(iph))
+                          for iph in iabc])]
+    ts = t[t>tshort]
+    Z = iph[t>tshort]
+    peaks = (np.diff(np.sign(np.diff(Z))) < 0).nonzero()[0] + 1
+    if len(peaks>0):
+        p = {'ip': Z[peaks].tolist(), 'tp': ts[peaks].tolist()}
+    else:
+        p = {'ip': [], 'tp': []}
+    valleys = (np.diff(np.sign(np.diff(Z))) > 0).nonzero()[0] + 1
+    if len(valleys>0):
+        v = {'iv': Z[valleys].tolist(), 'tv': ts[valleys].tolist()}
+    else:
+        v = {'iv': [], 'tv': []}
+    try:
+        cs = ip.CubicSpline(ts[peaks], Z[peaks])
+        p.update({'i': cs(ts).tolist(), 't': ts.tolist()})
+    except ValueError as e:
+        logger.warning("no peaks in current: %d",
+                       len(peaks))
+    try:
+        cs = ip.CubicSpline(ts[valleys], Z[valleys])
+        v.update({'i': cs(ts).tolist(), 't': ts.tolist()})
+    except ValueError as e:
+        logger.warning("no valleys in current: %d",
+                       len(valleys))
+    return p, v
+
+
 def parident(workdir, engine, temp, machine,
              magnetizingCurves, magnetMat, condMat,
              **kwargs):
@@ -109,6 +141,14 @@ class PmRelMachine(object):
     def rstat(self, w):
         """stator resistance
         """
+        if isinstance(self.zeta1, list):
+            logger.info("setup ac loss parameters...")
+            # polyfit from ac loss calculation
+            freq = w/2/np.pi
+            kr = self.zeta1[0]*freq**3 + self.zeta1[1]*freq**2 + \
+                self.zeta1[2]*freq + self.zeta1[3]
+            kr[kr<1] = 1.
+            return self.r1*(1 - self.kth1*(self.tcu1 - 20))*kr  # ref 20°C
         if self.skin_resistance is not None:
             return self.skin_resistance(self.r1, w, self.tcu1, kth=self.kth1)
 
@@ -915,7 +955,7 @@ class PmRelMachine(object):
         i1max: max. phase current (RMS)
         """
         r = dict(id=[], iq=[], uq=[], ud=[], u1=[], i1=[], T=[],
-                 beta=[], gamma=[], phi=[], cosphi=[], pmech=[], n=[])
+                 beta=[], gamma=[], phi=[], cosphi=[], pmech=[], n=[], type_op=[])
 
         if kwargs.get('i1max', 0):
             w1type, T = self.w1_imax_umax(kwargs['i1max'], u1max)
@@ -1000,6 +1040,7 @@ class PmRelMachine(object):
                 r['n'].append(nx)
                 r['T'].append(Tf)
 
+            r['type_op'] = list(betai1(iq, id))
             Pmax = 2*np.pi*n1*Tf
             for ns, nu, iv in zip(nstab[1:], speedrange[2:], interv):
                 # find id, iq, torque in fieldweakening range
@@ -1487,14 +1528,62 @@ class PmRelMachinePsidq(PmRelMachine):
     def betai1_plmag(self, beta, i1, f1):
         return self.iqd_plmag(*iqd(beta, i1), f1)
 
+    def ldlqpsim(self):
+        def ext_array(id, iq, a):
+            """extend array a if current is 0 at edge
+            id: list of n id values
+            iq: list of m iq values
+            a: nxm array to extend"""
+            if id[0] == 0:
+                y = np.array(a)[:, 1].reshape((-1, 1))
+                m = np.hstack((y, a))
+            elif id[-1] == 0:
+                y = np.array(a)[:, -2].reshape((-1, 1))
+                m = np.hstack((a, y))
+            else:
+                m = np.array(a)
+
+            if iq[0] == 0:
+                return np.concatenate(([m[1]], m))
+            elif iq[-1] == 0:
+                return np.concatenate((m, [m[-2]]))
+
+            return m
+
+        idn = np.append(self.id, -self.id[-2])
+        iqz = np.where(self.iq == 0.)[0][0]
+        if iqz in {0, len(self.iq)-1}:
+            iqn = np.insert(self.iq, 0, -self.iq[1])
+        elif iqz == len(self.iq)-1:
+            iqn = np.append(self.iq, -self.iq[iqz-1])
+        else:
+            iqn = np.array(self.iq)
+        psid2 = ext_array(self.id, self.iq, self.psid)
+        psiq2 = ext_array(self.id, self.iq, self.psiq)
+
+        # create n x m matrix of currents
+        id = np.ones(psid2.shape) * idn
+        iq = (np.ones(psid2.shape).T * iqn).T
+
+        # calculate ec model parameters
+        psim = (np.ones(psid2.shape).T * psid2[id == 0.]).T
+        nz = np.any(id != 0., axis=0)
+        ld = ((psid2-psim)[:, nz])/id[:, nz]
+        nz = np.any(iq != 0., axis=1)
+        lq = (psiq2[nz, :])/iq[nz, :]
+
+        # create interpolation functions
+        return (ip.RectBivariateSpline(iq[:, 0], id[0][id[0] != 0], ld),
+                ip.RectBivariateSpline(iq[:, 0][iq[:, 0] != 0], id[0], lq),
+                ip.RectBivariateSpline(iq[:, 0], id[0], psim))
+
 
     ### EXPERIMENTAL
 
     def transient(self, u1, tload, speed,
                   fault_type=3, # 'LLL', 'LL', 'LG',
-                  tend=0.1, nsamples=200):
-
-        tshort = 0
+                  tshort=0, tend=0.1, nsamples=200):
+        ns = round(tshort/tend*nsamples), round((tend-tshort)/tend*nsamples)
         w1 = 2*np.pi*self.p*speed
         i0 = self.iqd_torque(tload)
         res = so.minimize(
@@ -1507,49 +1596,116 @@ class PmRelMachinePsidq(PmRelMachine):
                  - la.norm(self.uqd(w1, *iqd))}))
         iqx, idx = res.x
         uq0, ud0 = self.uqd(w1, iqx, idx)
+        psid = ip.RectBivariateSpline(self.iq, self.id, self.psid, kx=3, ky=3)
+        psiq = ip.RectBivariateSpline(self.iq, self.id, self.psiq, kx=3, ky=3)
         logger.info("transient: Torque %f Nm, Speed %f rpm, Curr %f A",
                     tload, speed*60, betai1(iqx, idx)[1])
+        #_ld, _lq, _psim = self.ldlqpsim()
+        #Ld = _ld(iqx, idx)[0, 0]
+        #Lq = _lq(iqx, idx)[0, 0]
+        #psim = _psim(iqx, idx)[0, 0]
+        #logger.info("idx %f iqx %f, Ld %f, Lq %f, psim %f",
+        #            idx, iqx, Ld, Lq, psim)
         if fault_type == 3:  # 3 phase short circuit
-            USC = lambda t: np.zeros(2)
+            Y0 = iqx, idx
+            def U(t):
+                return (uq0, ud0) if t < tshort else (0, 0)
+            def didt(t, iqd):
+                uq, ud = U(t)
+                ldd = psid(*iqd, dx=0, dy=1)[0,0]
+                lqq = psiq(*iqd, dx=1, dy=0)[0,0]
+                ldq = psid(*iqd, dx=1, dy=0)[0,0]
+                lqd = psiq(*iqd, dx=0, dy=1)[0,0]
+                psi = psid(*iqd)[0,0], psiq(*iqd)[0,0]
+                return [
+                    (-ldd*psi[0]*w1 + ldd*(uq-self.r1*iqd[0])
+                     - lqd*psi[1]*w1 - lqd*(ud-self.r1*iqd[1]))/(ldd*lqq - ldq*lqd),
+                    (ldq*psi[0]*w1 - ldq*(uq-self.r1*iqd[0])
+                     + lqq*psi[1]*w1 + lqq*(ud-self.r1*iqd[1]))/(ldd*lqq - ldq*lqd)]
+            #def didtl(t, iqd):
+            #    lqd = lq(*iqd)[0,0], ld(*iqd)[0,0]
+            #    return [
+            #        (uq-r1*iqd[0] -w1 * ld*iqd[1] - w1*psim(*iqd)[0,0])/lq,
+            #        (ud-r1*iqd[1] +w1 * lq*iqd[0])/ld]
         else: # 2 phase short circuit
-            #ustat = np.array([K(w1*x).dot((uq, ud)) for x in t])
-            USC = lambda t: np.array([
-                uq0/2*(1+np.cos(2*w1*t)),
-                uq0/2*np.sin(2*w1*t)])
-        U = lambda t: (uq0, ud0) if t < tshort else USC(t)
-
-        psid = ip.RectBivariateSpline(self.iq, self.id, self.psid, kx=3, ky=3)
-        psiq = ip.RectBivariateSpline(self.iq, self.id, self.psiq, kx=3, ky=3)
-        #ld = ip.RectBivariateSpline(iq, id, dqpars['psidq'][0]['ld'], kx=3, ky=3)
-        #lq = ip.RectBivariateSpline(iq, id, dqpars['psidq'][0]['lq'], kx=3, ky=3)
-        #psim = ip.RectBivariateSpline(iq, id, dqpars['psidq'][0]['psim'], kx=3, ky=3)
-        #def didtl(t, iqd):
-        #    lqd = lq(*iqd)[0,0], ld(*iqd)[0,0]
-        #    return [
-        #        (uq-r1*iqd[0] -w1 * lqd[1]*iqd[1] - w1*psim(*iqd)[0,0])/lqd[0],
-        #        (ud-r1*iqd[1] +w1*lqd[0]*iqd[0])/lqd[1]]
-
-        def didt(t, iqd):
-            uq, ud = U(t)
-            ldd = psid(*iqd, dx=0, dy=1)[0,0]
-            lqq = psiq(*iqd, dx=1, dy=0)[0,0]
-            ldq = psid(*iqd, dx=1, dy=0)[0,0]
-            lqd = psiq(*iqd, dx=0, dy=1)[0,0]
-            psi = psid(*iqd)[0,0], psiq(*iqd)[0,0]
-            return [
-                (-ldd*psi[0]*w1 + ldd*(uq-self.r1*iqd[0])
-                 - lqd*psi[1]*w1 - lqd*(ud-self.r1*iqd[1]))/(ldd*lqq - ldq*lqd),
-                (ldq*psi[0]*w1 - ldq*(uq-self.r1*iqd[0])
-                 + lqq*psi[1]*w1 + lqq*(ud-self.r1*iqd[1]))/(ldd*lqq - ldq*lqd)]
-
-        t = np.linspace(0, tend, nsamples)
-        Y0 = iqx, idx
+            _ld, _lq, _psim = self.ldlqpsim()
+            Ld = _ld(iqx, idx)[0, 0]
+            Lq = _lq(iqx, idx)[0, 0]
+            psim = _psim(iqx, idx)[0, 0]
+            Y0 = (0,)
+            def didt(t, i):
+                gamma = w1*t
+                iqd = [2/3*i*(-np.sin(gamma) + np.sin(gamma+2*np.pi/3)),
+                       2/3*i*(np.cos(gamma) + np.cos(gamma+2*np.pi/3))]
+                ldd = psid(*iqd, dx=0, dy=1)[0,0]
+                lqq = psiq(*iqd, dx=1, dy=0)[0,0]
+                ldq = psid(*iqd, dx=1, dy=0)[0,0]
+                lqd = psiq(*iqd, dx=0, dy=1)[0,0]
+                psi = psid(*iqd)[0, 0], psiq(*iqd)[0, 0]
+                A = ((ldd-lqq)*np.cos(2*gamma + np.pi/3)
+                     - (ldq+lqd)*np.sin(2*gamma + np.pi/3) + lqq + ldd)
+                B = 2/3*w1*((ldd-lqq)*np.sin(2*gamma + np.pi/3)
+                            + (ldq+lqd)*np.cos(2*gamma + np.pi/3)
+                            + ldq - lqd) + 2*self.r1
+                C = np.sqrt(3)*w1*(psi[0]*np.sin(gamma + np.pi/6)
+                                   + psi[1]*np.cos(gamma + np.pi/6))
+                return -(B*i + C)/A
+
+            #def didt2(t, i):
+            #    gamma = w1*t
+                # idy, iqy = T(gamma).dot([i[0], -i[0], 0])
+                # ua - ub = 0; ia = -ib; ic = 0
+            #    B = np.sqrt(3)*psim*np.cos(gamma + np.pi/6)
+            #    A = 2*Ld*np.cos(gamma + np.pi/6)**2 + 2*Lq*np.sin(gamma + np.pi/6)**2
+            #    dAdt = 4*w1*np.cos(gamma+np.pi/6)*np.sin(gamma+np.pi/6)*(Ld - Lq)
+            #    dBdt = np.sqrt(3)*w1*psim*np.sin(gamma+np.pi/6)
+
+            #    return -(i*dAdt + dBdt + 2*self.r1*i)/A
+
+        t = np.linspace(tshort, tend, ns[1])
         sol = ig.solve_ivp(didt, (t[0], t[-1]), Y0, dense_output=True)
         y = sol.sol(t).T
 
+        t = np.linspace(0, tend, nsamples)
+        if fault_type == 3:  # 3 phase short circuit
+            if ns[0] > 0:
+                iqd = np.vstack(
+                    (np.ones((ns[0], 2)) * (iqx, idx), y))
+            else:
+                iqd = y
+            iabc = np.array([K(w1*x[0]).dot((x[1][1], x[1][0]))
+                             for x in zip(t, iqd)]).T
+            peaks, valleys = find_peaks_and_valleys(t, iabc, tshort)
+
+            #iqx, idx = iqd[-1, 0], iqd[-1, 1],
+            #Ld = _ld(iqx, idx)[0, 0]
+            #Lq = _lq(iqx, idx)[0, 0]
+            #psim = _psim(iqx, idx)[0, 0]
+            #logger.info("idx %f iqx %f, Ld %f, Lq %f, psim %f",
+            #            idx, iqx, Ld, Lq, psim)
+            return {
+                't': t.tolist(),
+                'iq': iqd[:,0], 'id': iqd[:,1],
+                'istat': iabc.tolist(),
+                'peaks': peaks,
+                'valleys': valleys,
+                'torque': [self.torque_iqd(*x) for x in iqd]}
+        if ns[0] > 0:
+            iabc = np.hstack(
+                (np.array(
+                    [K(w1*t).dot((idx, iqx))
+                     for t in np.linspace(0, tshort, ns[0])]).T,
+                 [y[:, 0], (-y)[:, 0], np.zeros(ns[1])]))
+        else:
+            iabc = np.array(
+                 [y[:, 0], (-y)[:, 0], np.zeros(len(t))])
+        peaks, valleys = find_peaks_and_valleys(t, iabc, tshort)
+        idq = np.array([T(w1*x[0]).dot(x[1])
+                        for x in zip(t, iabc.T)]).T
         return {
             't': t.tolist(),
-            'iq': y[:,0], 'id': y[:,1],
-            'istat': np.array([K(w1*x[0]).dot((x[1][1], x[1][0]))
-                               for x in zip(t, y)]).T.tolist(),
-            'torque': [self.torque_iqd(*iqd) for iqd in y]}
+            'iq': idq[1], 'id': idq[0],
+            'istat': iabc.tolist(),
+            'peaks': peaks,
+            'valleys': valleys,
+            'torque': self.torque_iqd(idq[1], idq[0])}