def __init__(self, system, config): TGBase.__init__(self, system, config) self.F1 = Lag( u='ue * (omega - wref)', T=self.T1, K=self.K1, ) self.F2 = LeadLag( u=self.F1_y, T1=self.T2, T2=self.T3, K=1.0, ) self.HL = GainLimiter( u='ue * (paux + pref0 - F2_y)', K=1.0, R=1.0, lower=self.PMIN, upper=self.PMAX, ) self.F3 = Lag( u=self.HL_y, T=self.T4, K=1.0, ) self.F4 = Lag( u=self.F3_y, T=self.T5, K=self.K2, ) self.F5 = Lag( u=self.F4_y, T=self.T6, K=self.K3, ) self.pout.e_str = 'ue * ((1-K2)*F3_y + (1-K3)*F4_y + F5_y) - pout'
def __init__(self, system, config): Model.__init__(self, system, config) self.flags.tds = True self.group = 'DG' self.config.add(OrderedDict((('plim', 0), ))) self.config.add_extra('_help', plim='enable input power limit check bound by [0, pmx]', ) self.config.add_extra('_tex', plim='P_{lim}', ) self.config.add_extra('_alt', plim=(0, 1), ) self.SWPQ = Switcher(u=self.pqflag, options=(0, 1), tex_name='SW_{PQ}', cache=True) self.buss = DataSelect(self.igreg, self.bus, info='selected bus (bus or igreg)', ) self.busfreq = DeviceFinder(self.busf, link=self.buss, idx_name='bus') # --- initial values from power flow --- # a : bus voltage angle # v : bus voltage magnitude # p0s : active power from connected static PV generator # q0s : reactive power from connected static PV generator # pref0 : initial active power set point for the PVD1 device # qref0 : initial reactive power set point for the PVD1 device self.a = ExtAlgeb(model='Bus', src='a', indexer=self.buss, tex_name=r'\theta', info='bus (or igreg) phase angle', unit='rad.', e_str='-Ipout_y * v * u', ename='P', tex_ename='P', ) self.v = ExtAlgeb(model='Bus', src='v', indexer=self.buss, tex_name='V', info='bus (or igreg) terminal voltage', unit='p.u.', e_str='-Iqout_y * v * u', ename='Q', tex_ename='Q', ) self.p0s = ExtService(model='StaticGen', src='p', indexer=self.gen, tex_name='P_{0s}', info='Initial P from static gen', ) self.q0s = ExtService(model='StaticGen', src='q', indexer=self.gen, tex_name='Q_{0s}', info='Initial Q from static gen', ) # --- calculate the initial P and Q for this distributed device --- self.pref0 = ConstService(v_str='gammap * p0s', tex_name='P_{ref0}', info='Initial P for the PVD1 device', ) self.qref0 = ConstService(v_str='gammaq * q0s', tex_name='Q_{ref0}', info='Initial Q for the PVD1 device', ) # frequency measurement variable `f` self.f = ExtAlgeb(model='FreqMeasurement', src='f', indexer=self.busfreq, export=False, info='Bus frequency', unit='p.u.', ) self.fHz = Algeb(info='frequency in Hz', v_str='fn * f', e_str='fn * f - fHz', unit='Hz', tex_name='f_{Hz}', ) # --- frequency branch --- self.FL1 = Limiter(u=self.fHz, lower=self.ft0, upper=self.ft1, info='Under frequency comparer', no_warn=True, ) self.FL2 = Limiter(u=self.fHz, lower=self.ft2, upper=self.ft3, info='Over frequency comparer', no_warn=True, ) self.Kft01 = ConstService(v_str='1/(ft1 - ft0)', tex_name='K_{ft01}') self.Ffl = Algeb(info='Coeff. for under frequency', v_str='FL1_zi * Kft01 * (fHz - ft0) + FL1_zu', e_str='FL1_zi * Kft01 * (fHz - ft0) + FL1_zu - Ffl', tex_name='F_{fl}', discrete=self.FL1, ) self.Kft23 = ConstService(v_str='1/(ft3 - ft2)', tex_name='K_{ft23}') self.Ffh = Algeb(info='Coeff. for over frequency', v_str='FL2_zl + FL2_zi * (1 + Kft23 * (ft2 - fHz))', e_str='FL2_zl + FL2_zi * (1 + Kft23 * (ft2 - fHz)) - Ffh', tex_name='F_{fh}', discrete=self.FL2, ) self.Fdev = Algeb(info='Frequency deviation', v_str='fn - fHz', e_str='fn - fHz - Fdev', unit='Hz', tex_name='f_{dev}', ) self.DB = DeadBand1(u=self.Fdev, center=0.0, lower=self.fdbd, upper=0.0, gain=self.ddn, info='frequency deviation deadband with gain', ) # outputs `Pdrp` self.DB.db.no_warn = True # --- Voltage flags --- self.VL1 = Limiter(u=self.v, lower=self.vt0, upper=self.vt1, info='Under voltage comparer', no_warn=True, ) self.VL2 = Limiter(u=self.v, lower=self.vt2, upper=self.vt3, info='Over voltage comparer', no_warn=True, ) self.Kvt01 = ConstService(v_str='1/(vt1 - vt0)', tex_name='K_{vt01}') self.Fvl = Algeb(info='Coeff. for under voltage', v_str='VL1_zi * Kvt01 * (v - vt0) + VL1_zu', e_str='VL1_zi * Kvt01 * (v - vt0) + VL1_zu - Fvl', tex_name='F_{vl}', discrete=self.VL1, ) self.Kvt23 = ConstService(v_str='1/(vt3 - vt2)', tex_name='K_{vt23}') self.Fvh = Algeb(info='Coeff. for over voltage', v_str='VL2_zl + VL2_zi * (1 + Kvt23 * (vt2 - v))', e_str='VL2_zl + VL2_zi * (1 + Kvt23 * (vt2 - v)) - Fvh', tex_name='F_{vh}', discrete=self.VL2, ) # --- sensed voltage with lower limit of 0.01 --- self.VLo = Limiter(u=self.v, lower=0.01, upper=999, no_upper=True, info='Voltage lower limit (0.01) flag', ) self.vp = Algeb(tex_name='V_p', info='Sensed positive voltage', v_str='v * VLo_zi + 0.01 * VLo_zl', e_str='v * VLo_zi + 0.01 * VLo_zl - vp', ) self.Pext0 = ConstService(info='External additional signal added to Pext', tex_name='P_{ext0}', v_str='0', ) self.Pext = Algeb(tex_name='P_{ext}', info='External power signal (for AGC)', v_str='u * Pext0', e_str='u * Pext0 - Pext' ) self.Pref = Algeb(tex_name='P_{ref}', info='Reference power signal (for scheduling setpoint)', v_str='u * pref0', e_str='u * pref0 - Pref' ) self.Psum = Algeb(tex_name='P_{tot}', info='Sum of P signals', v_str='u * (Pext + Pref + DB_y)', e_str='u * (Pext + Pref + DB_y) - Psum', ) # `DB_y` is `Pdrp` (f droop) self.PHL = Limiter(u=self.Psum, lower=0.0, upper=self.pmx, enable=self.config.plim, info='limiter for Psum in [0, pmx]', ) self.Vcomp = VarService(v_str='abs(v*exp(1j*a) + (1j * xc) * (Ipout_y + 1j * Iqout_y))', info='Voltage before Xc compensation', tex_name='V_{comp}' ) self.Vqu = ConstService(v_str='v1 - (qref0 - qmn) / dqdv', info='Upper voltage bound => qmx', tex_name='V_{qu}', ) self.Vql = ConstService(v_str='v0 + (qmx - qref0) / dqdv', info='Lower voltage bound => qmn', tex_name='V_{ql}', ) self.VQ1 = Limiter(u=self.Vcomp, lower=self.Vql, upper=self.v0, info='Under voltage comparer for Q droop', no_warn=True, ) self.VQ2 = Limiter(u=self.Vcomp, lower=self.v1, upper=self.Vqu, info='Over voltage comparer for Q droop', no_warn=True, ) Qdrp = 'u * VQ1_zl * qmx + VQ2_zu * qmn + ' \ 'u * VQ1_zi * (qmx + dqdv *(Vqu - Vcomp)) + ' \ 'u * VQ2_zi * (dqdv * (v1 - Vcomp)) ' self.Qdrp = Algeb(tex_name='Q_{drp}', info='External power signal (for AGC)', v_str=Qdrp, e_str=f'{Qdrp} - Qdrp', discrete=(self.VQ1, self.VQ2), ) self.Qref = Algeb(tex_name=r'Q_{ref}', info='Reference power signal (for scheduling setpoint)', v_str='u * qref0', e_str='u * qref0 - Qref' ) self.Qsum = Algeb(tex_name=r'Q_{tot}', info='Sum of Q signals', v_str=f'u * (qref0 + {Qdrp})', e_str='u * (Qref + Qdrp) - Qsum', discrete=(self.VQ1, self.VQ2), ) self.Ipul = Algeb(info='Ipcmd before Ip hard limit', v_str='(Psum * PHL_zi + pmx * PHL_zu) / vp', e_str='(Psum * PHL_zi + pmx * PHL_zu) / vp - Ipul', tex_name='I_{p,ul}', ) self.Iqul = Algeb(info='Iqcmd before Iq hard limit', v_str='Qsum / vp', e_str='Qsum / vp - Iqul', tex_name='I_{q,ul}', ) # --- Ipmax, Iqmax and Iqmin --- Ipmaxsq = "(Piecewise((0, Le(ialim**2 - Iqcmd_y**2, 0)), ((ialim**2 - Iqcmd_y ** 2), True)))" Ipmaxsq0 = "(Piecewise((0, Le(ialim**2 - (u*qref0/v)**2, 0)), ((ialim**2 - (u*qref0/v) ** 2), True)))" self.Ipmaxsq = VarService(v_str=Ipmaxsq, tex_name='I_{pmax}^2') self.Ipmaxsq0 = ConstService(v_str=Ipmaxsq0, tex_name='I_{pmax0}^2') self.Ipmax = Algeb(v_str='(SWPQ_s1 * ialim + SWPQ_s0 * sqrt(Ipmaxsq0))', e_str='(SWPQ_s1 * ialim + SWPQ_s0 * sqrt(Ipmaxsq)) - Ipmax', tex_name='I_{pmax}', ) Iqmaxsq = "(Piecewise((0, Le(ialim**2 - Ipcmd_y**2, 0)), ((ialim**2 - Ipcmd_y ** 2), True)))" Iqmaxsq0 = "(Piecewise((0, Le(ialim**2 - (u*pref0/v)**2, 0)), ((ialim**2 - (u*pref0/v) ** 2), True)))" self.Iqmaxsq = VarService(v_str=Iqmaxsq, tex_name='I_{qmax}^2') self.Iqmaxsq0 = ConstService(v_str=Iqmaxsq0, tex_name='I_{qmax0}^2') self.Iqmax = Algeb(v_str='SWPQ_s0 * ialim + SWPQ_s1 * sqrt(Iqmaxsq0)', e_str='SWPQ_s0 * ialim + SWPQ_s1 * sqrt(Iqmaxsq) - Iqmax', tex_name='I_{qmax}', ) # TODO: set option whether to use degrading gain # --- `Ipcmd` and `Iqcmd` --- self.Ipcmd = GainLimiter(u=self.Ipul, K=1, R='Fvl * Fvh * Ffl * Ffh * recflag + 1 * (1 - recflag)', lower=0, upper=self.Ipmax, info='Ip with limiter and coeff.', tex_name='I^{pcmd}', ) self.Iqcmd = GainLimiter(u=self.Iqul, K=1, R='Fvl * Fvh * Ffl * Ffh * recflag + 1 * (1 - recflag)', lower=self.Iqmax, sign_lower=-1, upper=self.Iqmax, info='Iq with limiter and coeff.', tex_name='I^{qcmd}', ) self.Ipout = Lag(u=self.Ipcmd_y, T=self.tip, K=1.0, info='Output Ip filter', ) self.Iqout = Lag(u=self.Iqcmd_y, T=self.tiq, K=1.0, info='Output Iq filter', )
def __init__(self, system, config): Model.__init__(self, system, config) self.flags.tds = True self.group = 'RenExciter' self.config.add(OrderedDict((('kqs', 2), ('kvs', 2), ('tpfilt', 0.02), ))) self.config.add_extra('_help', kqs='Q PI controller tracking gain', kvs='Voltage PI controller tracking gain', tpfilt='Time const. for Pref filter', ) self.config.add_extra('_tex', kqs='K_{qs}', kvs='K_{vs}', tpfilt='T_{pfilt}', ) # --- Sanitize inputs --- self.Imaxr = Replace(self.Imax, flt=lambda x: np.less_equal(x, 0), new_val=1e8, tex_name='I_{maxr}') # --- Flag switchers --- self.SWPF = Switcher(u=self.PFFLAG, options=(0, 1), tex_name='SW_{PF}', cache=True) self.SWV = Switcher(u=self.VFLAG, options=(0, 1), tex_name='SW_{V}', cache=True) self.SWQ = Switcher(u=self.QFLAG, options=(0, 1), tex_name='SW_{V}', cache=True) self.SWP = Switcher(u=self.PFLAG, options=(0, 1), tex_name='SW_{P}', cache=True) self.SWPQ = Switcher(u=self.PQFLAG, options=(0, 1), tex_name='SW_{PQ}', cache=True) # --- External parameters --- self.bus = ExtParam(model='RenGen', src='bus', indexer=self.reg, export=False, info='Retrieved bus idx', vtype=str, default=None, ) self.buss = DataSelect(self.busr, self.bus, info='selected bus (bus or busr)') self.gen = ExtParam(model='RenGen', src='gen', indexer=self.reg, export=False, info='Retrieved StaticGen idx', vtype=str, default=None, ) self.Sn = ExtParam(model='RenGen', src='Sn', indexer=self.reg, tex_name='S_n', export=False, ) # --- External variables --- self.a = ExtAlgeb(model='Bus', src='a', indexer=self.bus, tex_name=r'\theta', info='Bus voltage angle', ) self.v = ExtAlgeb(model='Bus', src='v', indexer=self.bus, tex_name=r'V', info='Bus voltage magnitude', ) # check whether to use `bus` or `buss` self.Pe = ExtAlgeb(model='RenGen', src='Pe', indexer=self.reg, export=False, info='Retrieved Pe of RenGen') self.Qe = ExtAlgeb(model='RenGen', src='Qe', indexer=self.reg, export=False, info='Retrieved Qe of RenGen') self.Ipcmd = ExtAlgeb(model='RenGen', src='Ipcmd', indexer=self.reg, export=False, info='Retrieved Ipcmd of RenGen', e_str='-Ipcmd0 + IpHL_y', ) self.Iqcmd = ExtAlgeb(model='RenGen', src='Iqcmd', indexer=self.reg, export=False, info='Retrieved Iqcmd of RenGen', e_str='-Iqcmd0 - IqHL_y', ) self.p0 = ExtService(model='RenGen', src='p0', indexer=self.reg, tex_name='P_0', ) self.q0 = ExtService(model='RenGen', src='q0', indexer=self.reg, tex_name='Q_0', ) # Initial current commands self.Ipcmd0 = ConstService('p0 / v', info='initial Ipcmd') self.Iqcmd0 = ConstService('-q0 / v', info='initial Iqcmd') # --- Initial power factor angle --- # NOTE: if `p0` = 0, `pfaref0` = pi/2, `tan(pfaref0)` = inf self.pfaref0 = ConstService(v_str='atan2(q0, p0)', tex_name=r'\Phi_{ref0}', info='Initial power factor angle', ) # flag devices with `p0`=0, which causes `tan(PF) = +inf` self.zp0 = ConstService(v_str='Eq(p0, 0)', vtype=float, tex_name='z_{p0}', ) # --- Discrete components --- self.Vcmp = Limiter(u=self.v, lower=self.Vdip, upper=self.Vup, tex_name='V_{cmp}', info='Voltage dip comparator', equal=False, ) self.Volt_dip = VarService(v_str='1 - Vcmp_zi', info='Voltage dip flag; 1-dip, 0-normal', tex_name='z_{Vdip}', ) # --- Equations begin --- self.s0 = Lag(u=self.v, T=self.Trv, K=1, info='Voltage filter', ) self.VLower = Limiter(u=self.v, lower=0.01, upper=999, no_upper=True, info='Limiter for lower voltage cap', ) self.vp = Algeb(tex_name='V_p', info='Sensed lower-capped voltage', v_str='v * VLower_zi + 0.01 * VLower_zl', e_str='v * VLower_zi + 0.01 * VLower_zl - vp', ) self.pfaref = Algeb(tex_name=r'\Phi_{ref}', info='power factor angle ref', unit='rad', v_str='pfaref0', e_str='pfaref0 - pfaref', ) self.S1 = Lag(u='Pe', T=self.Tp, K=1, tex_name='S_1', info='Pe filter', ) # ignore `Qcpf` if `pfaref` is pi/2 by multiplying (1-zp0) self.Qcpf = Algeb(tex_name='Q_{cpf}', info='Q calculated from P and power factor', v_str='q0', e_str='(1-zp0) * (S1_y * tan(pfaref) - Qcpf)', diag_eps=True, unit='p.u.', ) self.Qref = Algeb(tex_name='Q_{ref}', info='external Q ref', v_str='q0', e_str='q0 - Qref', unit='p.u.', ) self.PFsel = Algeb(v_str='SWPF_s0*Qref + SWPF_s1*Qcpf', e_str='SWPF_s0*Qref + SWPF_s1*Qcpf - PFsel', info='Output of PFFLAG selector', ) self.PFlim = Limiter(u=self.PFsel, lower=self.QMin, upper=self.QMax) self.Qerr = Algeb(tex_name='Q_{err}', info='Reactive power error', v_str='(PFsel*PFlim_zi + QMin*PFlim_zl + QMax*PFlim_zu) - Qe', e_str='(PFsel*PFlim_zi + QMin*PFlim_zl + QMax*PFlim_zu) - Qe - Qerr', ) self.PIQ = PITrackAWFreeze(u=self.Qerr, kp=self.Kqp, ki=self.Kqi, ks=self.config.kqs, lower=self.VMIN, upper=self.VMAX, freeze=self.Volt_dip, ) # If `VFLAG=0`, set the input as `Vref1` (see the NREL report) self.Vsel = GainLimiter(u='SWV_s0 * Vref1 + SWV_s1 * PIQ_y', K=1, R=1, lower=self.VMIN, upper=self.VMAX, info='Selection output of VFLAG', ) # --- Placeholders for `Iqmin` and `Iqmax` --- self.s4 = LagFreeze(u='PFsel / vp', T=self.Tiq, K=1, freeze=self.Volt_dip, tex_name='s_4', info='Filter for calculated voltage with freeze', ) # --- Upper portion - Iqinj calculation --- self.Verr = Algeb(info='Voltage error (Vref0)', v_str='Vref0 - s0_y', e_str='Vref0 - s0_y - Verr', tex_name='V_{err}', ) self.dbV = DeadBand1(u=self.Verr, lower=self.dbd1, upper=self.dbd2, center=0.0, enable='DB_{V}', info='Deadband for voltage error (ref0)' ) self.pThld = ConstService(v_str='Indicator(Thld > 0)', tex_name='p_{Thld}') self.nThld = ConstService(v_str='Indicator(Thld < 0)', tex_name='n_{Thld}') self.Thld_abs = ConstService(v_str='abs(Thld)', tex_name='|Thld|') self.fThld = ExtendedEvent(self.Volt_dip, t_ext=self.Thld_abs, ) # Gain after dbB Iqv = "(dbV_y * Kqv)" Iqinj = f'{Iqv} * Volt_dip + ' \ f'(1 - Volt_dip) * fThld * ({Iqv} * nThld + Iqfrz * pThld)' # state transition, output of Iqinj self.Iqinj = Algeb(v_str=Iqinj, e_str=Iqinj + ' - Iqinj', tex_name='I_{qinj}', info='Additional Iq signal during under- or over-voltage', ) # --- Lower portion - active power --- self.wg = Algeb(tex_name=r'\omega_g', info='Drive train generator speed', v_str='1.0', e_str='1.0 - wg', ) self.Pref = Algeb(tex_name='P_{ref}', info='external P ref', v_str='p0 / wg', e_str='p0 / wg - Pref', unit='p.u.', ) self.pfilt = LagRate(u=self.Pref, T=self.config.tpfilt, K=1, rate_lower=self.dPmin, rate_upper=self.dPmax, info='Active power filter with rate limits', tex_name='P_{filt}', ) self.Psel = Algeb(tex_name='P_{sel}', info='Output selection of PFLAG', v_str='SWP_s1*wg*pfilt_y + SWP_s0*pfilt_y', e_str='SWP_s1*wg*pfilt_y + SWP_s0*pfilt_y - Psel', ) # `s5_y` is `Pord` self.s5 = LagAWFreeze(u=self.Psel, T=self.Tpord, K=1, lower=self.PMIN, upper=self.PMAX, freeze=self.Volt_dip, tex_name='s5', ) self.Pord = AliasState(self.s5_y) # --- Current limit logic --- self.kVq12 = ConstService(v_str='(Iq2 - Iq1) / (Vq2 - Vq1)', tex_name='k_{Vq12}', ) self.kVq23 = ConstService(v_str='(Iq3 - Iq2) / (Vq3 - Vq2)', tex_name='k_{Vq23}', ) self.kVq34 = ConstService(v_str='(Iq4 - Iq3) / (Vq4 - Vq3)', tex_name='k_{Vq34}', ) self.zVDL1 = ConstService(v_str='(Vq1 <= Vq2) & (Vq2 <= Vq3) & (Vq3 <= Vq4) & ' '(Iq1 <= Iq2) & (Iq2 <= Iq3) & (Iq3 <= Iq4)', tex_name='z_{VDL1}', info='True if VDL1 is in service', ) self.VDL1 = Piecewise(u=self.s0_y, points=('Vq1', 'Vq2', 'Vq3', 'Vq4'), funs=('Iq1', f'({self.s0_y.name} - Vq1) * kVq12 + Iq1', f'({self.s0_y.name} - Vq2) * kVq23 + Iq2', f'({self.s0_y.name} - Vq3) * kVq34 + Iq3', 'Iq4'), tex_name='V_{DL1}', info='Piecewise linear characteristics of Vq-Iq', ) self.kVp12 = ConstService(v_str='(Ip2 - Ip1) / (Vp2 - Vp1)', tex_name='k_{Vp12}', ) self.kVp23 = ConstService(v_str='(Ip3 - Ip2) / (Vp3 - Vp2)', tex_name='k_{Vp23}', ) self.kVp34 = ConstService(v_str='(Ip4 - Ip3) / (Vp4 - Vp3)', tex_name='k_{Vp34}', ) self.zVDL2 = ConstService(v_str='(Vp1 <= Vp2) & (Vp2 <= Vp3) & (Vp3 <= Vp4) & ' '(Ip1 <= Ip2) & (Ip2 <= Ip3) & (Ip3 <= Ip4)', tex_name='z_{VDL2}', info='True if VDL2 is in service', ) self.VDL2 = Piecewise(u=self.s0_y, points=('Vp1', 'Vp2', 'Vp3', 'Vp4'), funs=('Ip1', f'({self.s0_y.name} - Vp1) * kVp12 + Ip1', f'({self.s0_y.name} - Vp2) * kVp23 + Ip2', f'({self.s0_y.name} - Vp3) * kVp34 + Ip3', 'Ip4'), tex_name='V_{DL2}', info='Piecewise linear characteristics of Vp-Ip', ) self.fThld2 = ExtendedEvent(self.Volt_dip, t_ext=self.Thld2, extend_only=True, ) self.VDL1c = VarService(v_str='Lt(VDL1_y, Imaxr)') self.VDL2c = VarService(v_str='Lt(VDL2_y, Imaxr)') # `Iqmax` not considering mode or `Thld2` Iqmax1 = '(zVDL1*(VDL1c*VDL1_y + (1-VDL1c)*Imaxr) + 1e8*(1-zVDL1))' # `Ipmax` not considering mode or `Thld2` Ipmax1 = '(zVDL2*(VDL2c*VDL2_y + (1-VDL2c)*Imaxr) + 1e8*(1-zVDL2))' Ipmax2sq0 = '(Imax**2 - Iqcmd0**2)' Ipmax2sq = '(Imax**2 - IqHL_y**2)' # `Ipmax20`-squared (non-negative) self.Ipmax2sq0 = ConstService(v_str=f'Piecewise((0, Le({Ipmax2sq0}, 0.0)), ({Ipmax2sq0}, True), \ evaluate=False)', tex_name='I_{pmax20,nn}^2', ) self.Ipmax2sq = VarService(v_str=f'Piecewise((0, Le({Ipmax2sq}, 0.0)), ({Ipmax2sq}, True), \ evaluate=False)', tex_name='I_{pmax2}^2', ) Ipmax = f'((1-fThld2) * (SWPQ_s0*sqrt(Ipmax2sq) + SWPQ_s1*{Ipmax1}))' Ipmax0 = f'((1-fThld2) * (SWPQ_s0*sqrt(Ipmax2sq0) + SWPQ_s1*{Ipmax1}))' self.Ipmax = Algeb(v_str=f'{Ipmax0}', e_str=f'{Ipmax} + (fThld2 * Ipmaxh) - Ipmax', tex_name='I_{pmax}', diag_eps=True, info='Upper limit on Ipcmd', ) self.Ipmaxh = VarHold(self.Ipmax, hold=self.fThld2) Iqmax2sq = '(Imax**2 - IpHL_y**2)' Iqmax2sq0 = '(Imax**2 - Ipcmd0**2)' # initialization equation by using `Ipcmd0` self.Iqmax2sq0 = ConstService(v_str=f'Piecewise((0, Le({Iqmax2sq0}, 0.0)), ({Iqmax2sq0}, True), \ evaluate=False)', tex_name='I_{qmax,nn}^2', ) self.Iqmax2sq = VarService(v_str=f'Piecewise((0, Le({Iqmax2sq}, 0.0)), ({Iqmax2sq}, True), \ evaluate=False)', tex_name='I_{qmax2}^2') self.Iqmax = Algeb(v_str=f'(SWPQ_s0*{Iqmax1} + SWPQ_s1*sqrt(Iqmax2sq0))', e_str=f'(SWPQ_s0*{Iqmax1} + SWPQ_s1*sqrt(Iqmax2sq)) - Iqmax', tex_name='I_{qmax}', info='Upper limit on Iqcmd', ) self.Iqmin = ApplyFunc(self.Iqmax, lambda x: -x, cache=False, tex_name='I_{qmin}', info='Lower limit on Iqcmd', ) self.Ipmin = ConstService(v_str='0.0', tex_name='I_{pmin}', info='Lower limit on Ipcmd', ) self.PIV = PITrackAWFreeze(u='Vsel_y - s0_y * SWV_s0', x0='-SWQ_s1 * Iqcmd0', kp=self.Kvp, ki=self.Kvi, ks=self.config.kvs, lower=self.Iqmin, upper=self.Iqmax, freeze=self.Volt_dip, ) self.Qsel = Algeb(info='Selection output of QFLAG', v_str='SWQ_s1 * PIV_y + SWQ_s0 * s4_y', e_str='SWQ_s1 * PIV_y + SWQ_s0 * s4_y - Qsel', tex_name='Q_{sel}', ) # `IpHL_y` is `Ipcmd` self.IpHL = GainLimiter(u='s5_y / vp', K=1, R=1, lower=self.Ipmin, upper=self.Ipmax, ) # `IqHL_y` is `Iqcmd` self.IqHL = GainLimiter(u='Qsel + Iqinj', K=1, R=1, lower=self.Iqmin, upper=self.Iqmax)
def __init__(self, system, config): ExcBase.__init__(self, system, config) self.KPC = ConstService(v_str='KP * exp(1j * radians(THETAP))', tex_name='K_{PC}', info='KP polar THETAP', vtype=np.complex) # vd, vq, Id, Iq from SynGen self.vd = ExtAlgeb( src='vd', model='SynGen', indexer=self.syn, tex_name=r'V_d', info='d-axis machine voltage', ) self.vq = ExtAlgeb( src='vq', model='SynGen', indexer=self.syn, tex_name=r'V_q', info='q-axis machine voltage', ) self.Id = ExtAlgeb( src='Id', model='SynGen', indexer=self.syn, tex_name=r'I_d', info='d-axis machine current', ) self.Iq = ExtAlgeb( src='Iq', model='SynGen', indexer=self.syn, tex_name=r'I_q', info='q-axis machine current', ) # control block begin self.LG = Lag( self.v, T=self.TR, K=1, info='Voltage transducer', ) self.UEL = Algeb(info='Interface var for under exc. limiter', tex_name='U_{EL}', v_str='0', e_str='0 - UEL') self.VE = VarService( tex_name='V_E', info='VE', v_str='Abs(KPC*(vd + 1j*vq) + 1j*(KI + KPC*XL)*(Id + 1j*Iq))', ) self.IN = Algeb( tex_name='I_N', info='Input to FEX', v_str='KC * XadIfd / VE', e_str='KC * XadIfd / VE - IN', ) self.FEX = Piecewise( u=self.IN, points=(0, 0.433, 0.75, 1), funs=('1', '1 - 0.577*IN', 'sqrt(0.75 - IN ** 2)', '1.732*(1 - IN)', 0), info='Piecewise function FEX', ) self.VBMIN = dummify(-9999) self.VGMIN = dummify(-9999) self.VB = GainLimiter( u='VE*FEX_y', K=1, upper=self.VBMAX, lower=self.VBMIN, no_lower=True, info='VB with limiter', ) self.VG = GainLimiter( u=self.vout, K=self.KG, upper=self.VGMAX, lower=self.VGMIN, no_lower=True, info='Feedback gain with HL', ) self.vrs = Algeb( tex_name='V_{RS}', info='VR subtract feedback VG', v_str='vf0 / VB_y / KM', e_str='LAW1_y - VG_y - vrs', ) self.vref = Algeb( info='Reference voltage input', tex_name='V_{ref}', unit='p.u.', v_str='(vrs + VG_y) / KA + v', e_str='vref0 - vref', ) self.vref0 = PostInitService( info='Initial reference voltage input', tex_name='V_{ref0}', v_str='vref', ) # input excitation voltages; PSS outputs summed at vi self.vi = Algeb( info='Total input voltages', tex_name='V_i', unit='p.u.', e_str='-LG_y + vref - vi', v_str='-v + vref', ) self.vil = Algeb(info='Input voltage after limit', tex_name='V_{il}', v_str='HLI_zi*vi + HLI_zl*VIMIN + HLI_zu*VIMAX', e_str='HLI_zi*vi + HLI_zl*VIMIN + HLI_zu*VIMAX - vil') self.HG = HVGate( u1=self.UEL, u2=self.vil, info='HVGate for under excitation', ) self.LL = LeadLag( u=self.HG_y, T1=self.TC, T2=self.TB, info='Regulator', zero_out=True, ) # LL_y == VA self.LAW1 = LagAntiWindup( u=self.LL_y, T=self.TA, K=self.KA, lower=self.VRMIN, upper=self.VRMAX, info='Lag AW on VR', ) # LAW1_y == VR self.HLI = HardLimiter( u=self.vi, lower=self.VIMIN, upper=self.VIMAX, info='Input limiter', ) self.LAW2 = LagAntiWindup( u=self.vrs, T=self.TM, K=self.KM, lower=self.VMMIN, upper=self.VMMAX, info='Lag AW on VM', ) # LAW2_y == VM self.vout.e_str = 'VB_y * LAW2_y - vout'
def __init__(self, system, config): PSSBase.__init__(self, system, config) # ALL THE FOLLOWING IS FOR INPUT 2 # retrieve indices of bus and bus freq self.buss2 = DataSelect(self.busr2, self.bus, info='selected bus (bus or busr)') self.busfreq2 = DeviceFinder(self.busf2, link=self.buss2, idx_name='bus') # from Bus self.v2 = ExtAlgeb( model='Bus', src='v', indexer=self.buss2, tex_name=r'V', info='Bus (or busr2, if given) terminal voltage', ) # from BusFreq 2 self.f2 = ExtAlgeb(model='FreqMeasurement', src='f', indexer=self.busfreq2, export=False, info='Bus frequency 2') # Config self.config.add(OrderedDict([('freq_model', 'BusFreq')])) self.config.add_extra( '_help', {'freq_model': 'default freq. measurement model'}) self.config.add_extra('_alt', {'freq_model': ('BusFreq', )}) self.busf.model = self.config.freq_model self.busf2.model = self.config.freq_model # input signal switch self.dv = Derivative(self.v) self.dv2 = Derivative(self.v2) self.SnSb = ExtService( model='SynGen', src='M', indexer=self.syn, attr='pu_coeff', info='Machine base to sys base factor for power', tex_name='(Sb/Sn)') self.SW = Switcher( u=self.MODE, options=[0, 1, 2, 3, 4, 5, 6, np.nan], ) self.SW2 = Switcher( u=self.MODE2, options=[0, 1, 2, 3, 4, 5, 6, np.nan], ) # Input signals self.sig = Algeb( tex_name='S_{ig}', info='Input signal', ) self.sig.v_str = 'SW_s1*(omega-1) + SW_s2*0 + SW_s3*(tm0/SnSb) + ' \ 'SW_s4*(tm-tm0) + SW_s5*v + SW_s6*0' self.sig.e_str = 'SW_s1*(omega-1) + SW_s2*(f-1) + SW_s3*(te/SnSb) + ' \ 'SW_s4*(tm-tm0) + SW_s5*v + SW_s6*dv_v - sig' self.sig2 = Algeb( tex_name='S_{ig2}', info='Input signal 2', ) self.sig2.v_str = 'SW2_s1*(omega-1) + SW2_s2*0 + SW2_s3*(tm0/SnSb) + ' \ 'SW2_s4*(tm-tm0) + SW2_s5*v2 + SW2_s6*0' self.sig2.e_str = 'SW2_s1*(omega-1) + SW2_s2*(f2-1) + SW2_s3*(te/SnSb) + ' \ 'SW2_s4*(tm-tm0) + SW2_s5*v2 + SW2_s6*dv2_v - sig2' self.L1 = Lag( u=self.sig, K=self.K1, T=self.T1, info='Transducer 1', ) self.L2 = Lag( u=self.sig2, K=self.K2, T=self.T2, info='Transducer 2', ) self.IN = Algeb( tex_name='I_N', info='Sum of inputs', v_str='L1_y + L2_y', e_str='L1_y + L2_y - IN', ) self.WO = WashoutOrLag( u=self.IN, K=self.T3, T=self.T4, ) self.LL1 = LeadLag( u=self.WO_y, T1=self.T5, T2=self.T6, zero_out=True, ) self.LL2 = LeadLag( u=self.LL1_y, T1=self.T7, T2=self.T8, zero_out=True, ) self.LL3 = LeadLag( u=self.LL2_y, T1=self.T9, T2=self.T10, zero_out=True, ) self.VSS = GainLimiter(u=self.LL3_y, K=1, lower=self.LSMIN, upper=self.LSMAX) self.VOU = ConstService(v_str='VCUr + v0') self.VOL = ConstService(v_str='VCLr + v0') self.OLIM = Limiter(u=self.v, lower=self.VOL, upper=self.VOU, info='output limiter') self.vsout.e_str = 'OLIM_zi * VSS_y - vsout'
def __init__(self, system, config): ExcBase.__init__(self, system, config) self.config.add(OrderedDict(( ('ksr', 2), ('ksm', 2), ))) self.config.add_extra( '_help', ksr='Tracking gain for outer PI controller', ksm='Tracking gain for inner PI controller', ) self.config.add_extra( '_tex', ksr='K_{sr}', ksm='K_{sm}', ) self.KPC = ConstService(v_str='KP * exp(1j * radians(THETAP))', tex_name='K_{PC}', info='KP polar THETAP', vtype=complex) # vd, vq, Id, Iq from SynGen self.vd = ExtAlgeb( src='vd', model='SynGen', indexer=self.syn, tex_name=r'V_d', info='d-axis machine voltage', ) self.vq = ExtAlgeb( src='vq', model='SynGen', indexer=self.syn, tex_name=r'V_q', info='q-axis machine voltage', ) self.Id = ExtAlgeb( src='Id', model='SynGen', indexer=self.syn, tex_name=r'I_d', info='d-axis machine current', ) self.Iq = ExtAlgeb( src='Iq', model='SynGen', indexer=self.syn, tex_name=r'I_q', info='q-axis machine current', ) # control block begin self.LG = Lag( self.v, T=self.TR, K=1, info='Voltage transducer', ) self.UEL = Algeb(info='Interface var for under exc. limiter', tex_name='U_{EL}', v_str='0', e_str='0 - UEL') # lower part: VB signal self.VE = VarService( tex_name='V_E', info='VE', v_str='Abs(KPC*(vd + 1j*vq) + 1j*(KI + KPC*XL)*(Id + 1j*Iq))', ) self.IN = Algeb( tex_name='I_N', info='Input to FEX', v_str='safe_div(KC * XadIfd, VE)', e_str='ue * (KC * XadIfd - VE * IN)', diag_eps=True, ) self.FEX = Piecewise( u=self.IN, points=(0, 0.433, 0.75, 1), funs=('1', '1 - 0.577*IN', 'sqrt(0.75 - IN ** 2)', '1.732*(1 - IN)', 0), info='Piecewise function FEX', ) self.VBMIN = dummify(-9999) self.VGMIN = dummify(-9999) self.VB = GainLimiter( u='VE*FEX_y', K=1, R=1, upper=self.VBMAX, lower=self.VBMIN, no_lower=True, info='VB with limiter', ) self.VG = GainLimiter( u=self.vout, K=self.KG, R=1, upper=self.VGMAX, lower=self.VGMIN, no_lower=True, info='Feedback gain with HL', ) self.vref = Algeb(info='Reference voltage input', tex_name='V_{ref}', unit='p.u.', v_str='v', e_str='vref0 - vref') self.vref0 = PostInitService( info='Const reference voltage', tex_name='V_{ref0}', v_str='vref', ) self.vi = Algeb( info='Total input voltages', tex_name='V_i', unit='p.u.', e_str='-LG_y + vref - vi', v_str='-v + vref', ) self.PI1 = PITrackAW(u=self.vi, kp=self.KPR, ki=self.KIR, ks=self.config.ksr, lower=self.VRMIN, upper=self.VRMAX, x0='VG_y') self.LA = Lag( u=self.PI1_y, T=self.TA, K=1.0, info='Regulation delay', ) self.PI2 = PITrackAW( u='LA_y - VG_y', kp=self.KPM, ki=self.KIM, ks=self.config.ksm, lower=self.VMMIN, upper=self.VMMAX, x0='safe_div(vf0, VB_y)', ) # TODO: add back LV Gate self.vout.e_str = 'VB_y * PI2_y - vout'
def __init__(self, system, config): Model.__init__(self, system, config) self.flags.tds = True self.group = 'RenGen' self.a = ExtAlgeb(model='Bus', src='a', indexer=self.bus, tex_name=r'\theta', info='Bus voltage angle', e_str='-Pe', ) self.v = ExtAlgeb(model='Bus', src='v', indexer=self.bus, tex_name=r'V', info='Bus voltage magnitude', e_str='-Qe', ) self.p0s = ExtService(model='StaticGen', src='p', indexer=self.gen, tex_name='P_{0s}', info='initial P of the static gen', ) self.q0s = ExtService(model='StaticGen', src='q', indexer=self.gen, tex_name='Q_{0s}', info='initial Q of the static gen', ) self.p0 = ConstService(v_str='p0s * gammap', tex_name='P_0', info='initial P of this gen', ) self.q0 = ConstService(v_str='q0s * gammaq', tex_name='Q_0', info='initial Q of this gen', ) self.ra = ExtParam(model='StaticGen', src='ra', indexer=self.gen, tex_name='r_a', export=False, ) self.xs = ExtParam(model='StaticGen', src='xs', indexer=self.gen, tex_name='x_s', export=False, ) # --- INITIALIZATION --- self.q0gt0 = ConstService('Indicator(q0> 0)', tex_name='z_{q0>0}', info='flags for q0 below zero', ) self.q0lt0 = ConstService('Indicator(q0< 0)', tex_name='z_{q0<0}', info='flags for q0 below zero', ) self.Ipcmd0 = ConstService('p0 / v', info='initial Ipcmd', tex_name='I_{pcmd0}', ) self.Iqcmd0 = ConstService('-q0 / v', info='initial Iqcmd', tex_name='I_{qcmd0}', ) self.Ipcmd = Algeb(tex_name='I_{pcmd}', info='current component for active power', e_str='Ipcmd0 - Ipcmd', v_str='Ipcmd0') self.Iqcmd = Algeb(tex_name='I_{qcmd}', info='current component for reactive power', e_str='Iqcmd0 - Iqcmd', v_str='Iqcmd0') # reactive power management # rate limiting logic (for fault recovery, although it does not detect any recovery) # - activate upper limit when q0 > 0 (self.q0gt0) # - activate lower limit when q0 < 0 (self.q0lt0) self.S1 = LagAntiWindupRate(u=self.Iqcmd, T=self.Tg, K=-1, lower=-9999, upper=9999, no_lower=True, no_upper=True, rate_lower=self.Iqrmin, rate_upper=self.Iqrmax, rate_lower_cond=self.q0lt0, rate_upper_cond=self.q0gt0, tex_name='S_1', info='Iqcmd delay', ) # output `S1_y` == `Iq` # piece-wise gain for low voltage active current mgnt. self.kLVG = ConstService(v_str='1 / (Lvpnt1 - Lvpnt0)', tex_name='k_{LVG}', ) self.LVG = Piecewise(u=self.v, points=('Lvpnt0', 'Lvpnt1'), funs=('0', '(v - Lvpnt0) * kLVG', '1'), info='Ip gain during low voltage', tex_name='L_{VG}', ) # piece-wise gain for LVPL self.kLVPL = ConstService(v_str='Lvplsw * Lvpl1 / (Brkpt - Zerox)', tex_name='k_{LVPL}', ) self.S2 = Lag(u=self.v, T=self.Tfltr, K=1.0, info='Voltage filter with no anti-windup', tex_name='S_2', ) self.LVPL = Piecewise(u=self.S2_y, points=('Zerox', 'Brkpt'), funs=('0 + 9999*(1-Lvplsw)', '(S2_y - Zerox) * kLVPL + 9999 * (1-Lvplsw)', '9999'), info='Low voltage Ipcmd upper limit', tex_name='L_{VPL}', ) self.S0 = LagAntiWindupRate(u=self.Ipcmd, T=self.Tg, K=1, upper=self.LVPL_y, rate_upper=self.Rrpwr, lower=-9999, rate_lower=-9999, no_lower=True, rate_no_lower=True, tex_name='S_0', ) # `S0_y` is the output `Ip` in the block diagram self.Ipout = Algeb(e_str='S0_y * LVG_y -Ipout', v_str='Ipcmd * LVG_y', info='Output Ip current', tex_name='I_{pout}', ) # high voltage part self.HVG = GainLimiter(u='v - Volim', K=self.Khv, info='High voltage gain block', lower=0, upper=999, no_upper=True, tex_name='H_{VG}' ) self.HVG.lim.no_warn = True self.Iqout = GainLimiter(u='S1_y- HVG_y', K=1, lower=self.Iolim, upper=9999, no_upper=True, info='Iq output block', tex_name='I^{qout}', ) # `Iqout_y` is the final Iq output self.Pe = Algeb(tex_name='P_e', info='Active power output', v_str='p0', e_str='Ipout * v - Pe') self.Qe = Algeb(tex_name='Q_e', info='Reactive power output', v_str='q0', e_str='Iqout_y * v - Qe')
def __init__(self, system, config): ExcBase.__init__(self, system, config) self.flags.nr_iter = True ExcVsum.__init__(self) self.UEL0.v_str = '-999' self.OEL0.v_str = '999' self.ulim = ConstService('9999') self.llim = ConstService('-9999') self.SWUEL = Switcher(u=self.UELc, options=[0, 1, 2, 3], tex_name='SW_{UEL}', cache=True) self.SWVOS = Switcher(u=self.VOSc, options=[0, 1, 2], tex_name='SW_{VOS}', cache=True) # control block begin self.LG = Lag( self.v, T=self.TR, K=1, info='Voltage transducer', ) self.SG0 = ConstService(v_str='0', info='SG initial value.') self.SG = Algeb( tex_name='SG', info='SG', v_str='SG0', e_str='SG0 - SG', ) self.zero = ConstService('0') self.LR = GainLimiter( u='XadIfd - ILR', K=self.KLR, R=1, upper=self.ulim, lower=self.zero, no_upper=True, info='Exciter output current gain limiter', ) self.VA0 = PostInitService(tex_name='V_{A0}', v_str='vf0 - SWVOS_s2 * SG + LR_y', info='VA (LA_y) initial value') self.vref.v_str = 'ue * (v + (vf0 - SWVOS_s2 * SG + LR_y) / KA - SWVOS_s1 * SG - SWUEL_s1 * UEL)' self.vref.v_iter = 'ue * (v + (vf0 - SWVOS_s2 * SG + LR_y) / KA - SWVOS_s1 * SG - SWUEL_s1 * UEL)' self.vref0 = PostInitService( info='Initial reference voltage input', tex_name='V_{ref0}', v_str='vref', ) self.vi = Algeb( info='Total input voltages', tex_name='V_i', unit='p.u.', e_str= 'ue * (-LG_y + vref - WF_y + SWUEL_s1 * UEL + SWVOS_s1 * SG + Vs) - vi', v_iter= 'ue * (-LG_y + vref - WF_y + SWUEL_s1 * UEL + SWVOS_s1 * SG + Vs)', v_str= 'ue * (-LG_y + vref - WF_y + SWUEL_s1 * UEL + SWVOS_s1 * SG + Vs)', ) self.vil = GainLimiter( u=self.vi, K=1, R=1, upper=self.VIMAX, lower=self.VIMIN, info='Exciter voltage input limiter', ) self.UEL2 = Algeb( tex_name='UEL_2', info='UEL_2 as HVG1 u1', v_str='ue * (SWUEL_s2 * UEL + (1 - SWUEL_s2) * llim)', e_str='ue * (SWUEL_s2 * UEL + (1 - SWUEL_s2) * llim) - UEL2', ) self.HVG1 = HVGate( u1=self.UEL2, u2=self.vil_y, info='HVGate after V_I', ) self.LL = LeadLag( u=self.HVG1_y, T1=self.TC, T2=self.TB, info='Lead-lag compensator', zero_out=True, ) self.LL1 = LeadLag( u=self.LL_y, T1=self.TC1, T2=self.TB1, info='Lead-lag compensator 1', zero_out=True, ) self.LA = LagAntiWindup( u=self.LL1_y, T=self.TA, K=self.KA, upper=self.VAMAX, lower=self.VAMIN, info='V_A, Anti-windup lag', ) # LA_y is VA self.vas = Algeb( tex_name=r'V_{As}', info='V_A after subtraction, as HVG u2', v_str='ue * (SWVOS_s2 * SG + LA_y - LR_y)', v_iter='ue * (SWVOS_s2 * SG + LA_y - LR_y)', e_str='ue * (SWVOS_s2 * SG + LA_y - LR_y) - vas', ) self.UEL3 = Algeb( tex_name='UEL_3', info='UEL_3 as HVG u1', v_str='ue * (SWUEL_s3 * UEL + (1 - SWUEL_s3) * llim)', e_str='ue * (SWUEL_s3 * UEL + (1 - SWUEL_s3) * llim) - UEL3', ) self.HVG = HVGate( u1=self.UEL3, u2=self.vas, info='HVGate for under excitation', ) self.LVG = LVGate( u1=self.HVG_y, u2=self.OEL, info='HVGate for over excitation', ) # vd, vq, Id, Iq from SynGen self.vd = ExtAlgeb( src='vd', model='SynGen', indexer=self.syn, tex_name=r'V_d', info='d-axis machine voltage', ) self.vq = ExtAlgeb( src='vq', model='SynGen', indexer=self.syn, tex_name=r'V_q', info='q-axis machine voltage', ) self.efdu = VarService( info='Output exciter voltage upper bound', tex_name=r'efd_{u}', v_str='Abs(vd + 1j*vq) * VRMAX - KC * XadIfd', ) self.efdl = VarService(info='Output exciter voltage lower bound', tex_name=r'efd_{l}', v_str='Abs(vd + 1j*vq) * VRMIN') self.vol = GainLimiter( u=self.LVG_y, K=1, R=1, upper=self.efdu, lower=self.efdl, info='Exciter output limiter', ) self.WF = Washout( u=self.LVG_y, T=self.TF, K=self.KF, info='V_F, Stablizing circuit feedback', ) self.vout.e_str = 'ue * vol_y - vout'