def __init__(self, system, config): AreaData.__init__(self) Model.__init__(self, system, config) self.group = 'Collection' self.flags.pflow = True self.flags.tds = True self.Bus = BackRef() self.ACTopology = BackRef() # --------------------Experiment Zone-------------------- self.Vn = ExtParam(model='Bus', src='Vn', indexer=self.ACTopology, export=False) self.Vn_sum = NumReduce(u=self.Vn, fun=np.sum, ref=self.Bus) self.Vn_sum_rep = NumRepeat(u=self.Vn_sum, ref=self.Bus) self.a = ExtAlgeb(model='ACTopology', src='a', indexer=self.ACTopology, info='Bus voltage angle') self.v = ExtAlgeb(model='ACTopology', src='v', indexer=self.ACTopology, info='Bus voltage magnitude')
def __init__(self, system, config): REECA1Model.__init__(self, system, config) self.busrocof = DeviceFinder( self.busroc, link=self.bus, idx_name='bus', ) self.df = ExtAlgeb( model='FreqMeasurement', src='WO_y', indexer=self.busrocof, export=False, info='Bus frequency deviation', ) self.dfdt = ExtAlgeb( model='FreqMeasurement', src='Wf_y', indexer=self.busrocof, export=False, info='Bus ROCOF', unit='p.u.', ) self.Pref.e_str += '- Kdf * dfdt - Kf * df'
def __init__(self, system, config): AreaData.__init__(self) Model.__init__(self, system, config) self.group = 'Collection' self.flags.update({'pflow': True, 'tds': True}) self.Bus = RefParam(export=False) self.ACTopology = RefParam(export=False) # --------------------Experiment Zone-------------------- self.Vn = ExtParam(model='Bus', src='Vn', indexer=self.ACTopology, export=False) self.Vn_sum = ReducerService(u=self.Vn, fun=np.sum, ref=self.Bus) self.Vn_sum_rep = RepeaterService(u=self.Vn_sum, ref=self.Bus) self.a = ExtAlgeb(model='ACTopology', src='a', indexer=self.ACTopology, info='Bus voltage angle') self.v = ExtAlgeb(model='ACTopology', src='v', indexer=self.ACTopology, info='Bus voltage magnitude')
def __init__(self, system, config): Model.__init__(self, system, config) self.group = 'DynLoad' self.flags.tds = True self.bus = ExtParam(model='PQ', src='bus', indexer=self.pq) self.p0 = ExtService( model='PQ', src='Ppf', indexer=self.pq, tex_name='P_0', ) self.q0 = ExtService( model='PQ', src='Qpf', indexer=self.pq, tex_name='Q_0', ) self.v0 = ExtService( model='Bus', src='v', indexer=self.bus, tex_name='V_0', ) self.busfreq = DeviceFinder( u=self.busf, link=self.bus, idx_name='bus', info='found idx of BusFreq', ) self.f = ExtAlgeb( model='FreqMeasurement', src='f', indexer=self.busfreq, tex_name='f', ) self.pv0 = ConstService(v_str='u * kp/100 * p0 / (v0) ** ap ') self.qv0 = ConstService(v_str='u * kq/100 * q0 / (v0) ** aq ') self.a = ExtAlgeb( model='Bus', src='a', indexer=self.bus, tex_name=r'\theta', e_str='pv0 * (v ** ap) * (f ** bp)', ) self.v = ExtAlgeb( model='Bus', src='v', indexer=self.bus, tex_name='V', e_str='qv0 * (v ** aq) * (f ** bq)', )
def __init__(self, system, config): ModelData.__init__(self) self.bus = IdxParam( model='Bus', info="linked bus idx", mandatory=True, ) self.tf = TimerParam( info='Fault start time for the bus', mandatory=True, callback=self.apply_fault, ) self.tc = TimerParam( info='Fault end time for the bus', callback=self.clear_fault, ) self.xf = NumParam( info='Fault to ground impedance', default=1e-4, tex_name='x_f', ) self.rf = NumParam( info='Fault to ground resistance', default=0, tex_name='x_f', ) Model.__init__(self, system, config) self.flags.update({'tds': True}) self.group = 'TimedEvent' self.gf = ConstService( tex_name='g_{f}', v_str='re(1/(rf + 1j * xf))', ) self.bf = ConstService( tex_name='b_{f}', v_str='im(1/(rf + 1j * xf))', ) self.uf = ConstService( tex_name='u_f', v_str='0', ) self.a = ExtAlgeb( model='Bus', src='a', indexer=self.bus, tex_name=r'\theta', e_str='u * uf * (v ** 2 * gf)', ) self.v = ExtAlgeb( model='Bus', src='v', indexer=self.bus, tex_name=r'V', e_str='u * uf * (v ** 2 * bf)', ) self._vstore = np.array([])
def __init__(self, system=None, config=None): super().__init__(system, config) self.group = 'StaticGen' self.flags.update({'pflow': True, 'collate': True}) self.config.add(OrderedDict((('pv2pq', 0), ('npv2pq', 1)))) self.config.add_extra( "_help", pv2pq="convert PV to PQ in PFlow at Q limits", npv2pq="max. # of pv2pq conversion in each iteration", ) self.config.add_extra("_alt", pv2pq=(0, 1), npv2pq=">=0") self.config.add_extra( "_tex", pv2pq="z_{pv2pq}", ) self.a = ExtAlgeb(model='Bus', src='a', indexer=self.bus, tex_name=r'\theta') self.v = ExtAlgeb(model='Bus', src='v', indexer=self.bus, v_setter=True, tex_name=r'V') self.p = Algeb(info='actual active power generation', unit='p.u.', tex_name=r'p', diag_eps=1e-6) self.q = Algeb(info='actual reactive power generation', unit='p.u.', tex_name='q', diag_eps=1e-6) # TODO: implement switching starting from the second iteration self.qlim = SortedLimiter(u=self.q, lower=self.qmin, upper=self.qmax, enable=self.config.pv2pq, n_select=self.config.npv2pq) # variable initialization equations self.v.v_str = 'v0' self.p.v_str = 'p0' self.q.v_str = 'q0' # injections into buses have negative values self.a.e_str = "-u * p" self.v.e_str = "-u * q" # power injection equations g(y) = 0 self.p.e_str = "u * (p0 - p)" self.q.e_str = "u*(qlim_zi * (v0-v) + "\ "qlim_zl * (qmin-q) + "\ "qlim_zu * (qmax-q))"
def __init__(self, system=None, config=None): ShuntData.__init__(self) Model.__init__(self, system, config) self.group = 'StaticShunt' self.flags['pflow'] = True self.a = ExtAlgeb(model='Bus', src='a', indexer=self.bus, tex_name=r'\theta') self.v = ExtAlgeb(model='Bus', src='v', indexer=self.bus, tex_name=r'V') self.a.e_str = 'u * v**2 * g' self.v.e_str = '-u * v**2 * b'
def __init__(self, system=None, config=None): LineData.__init__(self) Model.__init__(self, system, config) self.group = 'ACLine' self.flags.pflow = True self.flags.tds = True self.a1 = ExtAlgeb(model='Bus', src='a', indexer=self.bus1, tex_name='a_1', info='phase angle of the from bus') self.a2 = ExtAlgeb(model='Bus', src='a', indexer=self.bus2, tex_name='a_2', info='phase angle of the to bus') self.v1 = ExtAlgeb(model='Bus', src='v', indexer=self.bus1, tex_name='v_1', info='voltage magnitude of the from bus') self.v2 = ExtAlgeb(model='Bus', src='v', indexer=self.bus2, tex_name='v_2', info='voltage magnitude of the to bus') self.gh = ConstService(tex_name='g_h') self.bh = ConstService(tex_name='b_h') self.gk = ConstService(tex_name='g_k') self.bk = ConstService(tex_name='b_k') self.yh = ConstService(tex_name='y_h', vtype=np.complex) self.yk = ConstService(tex_name='y_k', vtype=np.complex) self.yhk = ConstService(tex_name='y_{hk}', vtype=np.complex) self.ghk = ConstService(tex_name='g_{hk}') self.bhk = ConstService(tex_name='b_{hk}') self.gh.v_str = 'g1 + 0.5 * g' self.bh.v_str = 'b1 + 0.5 * b' self.gk.v_str = 'g2 + 0.5 * g' self.bk.v_str = 'b2 + 0.5 * b' self.yh.v_str = 'u * (gh + 1j * bh)' self.yk.v_str = 'u * (gk + 1j * bk)' self.yhk.v_str = 'u/((r+1e-8) + 1j*(x+1e-8))' self.ghk.v_str = 're(yhk)' self.bhk.v_str = 'im(yhk)' self.a1.e_str = 'u * (v1 ** 2 * (gh + ghk) / tap ** 2 - \ v1 * v2 * (ghk * cos(a1 - a2 - phi) + \ bhk * sin(a1 - a2 - phi)) / tap)' self.v1.e_str = 'u * (-v1 ** 2 * (bh + bhk) / tap ** 2 - \ v1 * v2 * (ghk * sin(a1 - a2 - phi) - \ bhk * cos(a1 - a2 - phi)) / tap)' self.a2.e_str = 'u * (v2 ** 2 * (gh + ghk) - \ v1 * v2 * (ghk * cos(a1 - a2 - phi) - \ bhk * sin(a1 - a2 - phi)) / tap)' self.v2.e_str = 'u * (-v2 ** 2 * (bh + bhk) + \
def __init__(self, system, config): ModelData.__init__(self) self.node1 = IdxParam( default=None, tex_name='node_1', info='Node 1 index', mandatory=True, model='Node', ) self.node2 = IdxParam( default=None, tex_name='node_2', info='Node 2 index', mandatory=True, model='Node', ) self.Vdcn1 = NumParam( default=100, info='DC voltage rating on node 1', unit='kV', non_zero=True, tex_name='V_{dcn1}', ) self.Vdcn2 = NumParam( default=100, info='DC voltage rating on node 2', unit='kV', non_zero=True, tex_name='V_{dcn2}', ) self.Idcn = NumParam( default=1, info='DC current rating', unit='kA', non_zero=True, tex_name='I_{dcn}', ) Model.__init__(self, system, config) self.v1 = ExtAlgeb( model='Node', src='v', indexer=self.node1, info='DC voltage on node 1', ) self.v2 = ExtAlgeb( model='Node', src='v', indexer=self.node2, info='DC voltage on node 2', )
def __init__(self, system, config): ModelData.__init__(self) Model.__init__(self, system, config) self.flags.tds = True self.group = 'FreqMeasurement' # Parameters self.bus = IdxParam(info="bus idx", mandatory=True) self.Tf = NumParam(default=0.02, info="input digital filter time const", unit="sec", tex_name='T_f') self.Tw = NumParam(default=0.02, info="washout time const", unit="sec", tex_name='T_w') self.fn = NumParam(default=60.0, info="nominal frequency", unit='Hz', tex_name='f_n') # Variables self.iwn = ConstService(v_str='u / (2 * pi * fn)', tex_name=r'1/\omega_n') self.a0 = ExtService(src='a', model='Bus', indexer=self.bus, tex_name=r'\theta_0', info='initial phase angle', ) self.a = ExtAlgeb(model='Bus', src='a', indexer=self.bus, tex_name=r'\theta', ) self.v = ExtAlgeb(model='Bus', src='v', indexer=self.bus, tex_name=r'V', ) self.L = Lag(u='(a-a0)', T=self.Tf, K=1, info='digital filter', ) self.WO = Washout(u=self.L_y, K=self.iwn, T=self.Tw, info='angle washout', ) self.f = Algeb(info='frequency output', unit='p.u. (Hz)', tex_name='f', v_str='1', e_str='1 + WO_y - f', )
def __init__(self, system, config): ModelData.__init__(self) self.node = IdxParam( default=None, tex_name='node', info='Node index', mandatory=True, model='Node', ) self.voltage = NumParam( default=0.0, tex_name='V_0', info='Ground voltage (typically 0)', unit='p.u.', ) Model.__init__(self, system, config) self.flags.update({'pflow': True}) self.group = 'DCLink' self.v = ExtAlgeb( model='Node', src='v', indexer=self.node, e_str='-Idc', ) self.Idc = Algeb( tex_name='I_{dc}', info='Ficticious current injection from ground', e_str='u * (v - voltage)', v_str='0', diag_eps=1e-6, ) self.v.e_str = '-Idc'
def __init__(self, system, config): ACEData.__init__(self) Model.__init__(self, system, config) self.flags.tds = True 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.area = ExtParam(model='Bus', src='area', indexer=self.bus, export=False) self.busf.model = self.config.freq_model self.busfreq = DeviceFinder(self.busf, link=self.bus, idx_name='bus') self.f = ExtAlgeb( model='FreqMeasurement', src='f', indexer=self.busfreq, export=False, info='Bus frequency', ) self.ace = Algeb( info='area control error', unit='MW (p.u.)', tex_name='ace', e_str='10 * bias * (f - 1) - ace', )
def __init__(self, system, config): Model.__init__(self, system, config) self.flags.pflow = True self.flags.tds = True self.group = 'ACShort' self.a1 = ExtAlgeb(model='Bus', src='a', indexer=self.bus1, tex_name='a_1', info='phase angle of the from bus') self.a2 = ExtAlgeb(model='Bus', src='a', indexer=self.bus2, tex_name='a_2', info='phase angle of the to bus') self.v1 = ExtAlgeb(model='Bus', src='v', indexer=self.bus1, tex_name='v_1', info='voltage magnitude of the from bus') self.v2 = ExtAlgeb(model='Bus', src='v', indexer=self.bus2, tex_name='v_2', info='voltage magnitude of the to bus') self.p = Algeb( info='active power (1 to 2)', e_str='u * (a1 - a2)', tex_name='P', diag_eps=True, ) self.q = Algeb( info='active power (1 to 2)', e_str='u * (v1 - v2)', tex_name='Q', diag_eps=True, ) self.a1.e_str = 'p' self.a2.e_str = '-p' self.v1.e_str = 'q' self.v2.e_str = '-q'
def __init__(self, system, config): Model.__init__(self, system, config) self.group = 'TurbineGov' self.flags.update({'tds': True}) self.Sn = ExtParam( src='Sn', model='SynGen', indexer=self.syn, tex_name='S_m', info='Rated power from generator', unit='MVA', export=False, ) self.Vn = ExtParam( src='Vn', model='SynGen', indexer=self.syn, tex_name='V_m', info='Rated voltage from generator', unit='kV', export=False, ) self.tm0 = ExtService(src='tm', model='SynGen', indexer=self.syn, tex_name=r'\tau_{m0}', info='Initial mechanical input') self.omega = ExtState(src='omega', model='SynGen', indexer=self.syn, tex_name=r'\omega', info='Generator speed', unit='p.u.') self.gain = ConstService( v_str='u / R', tex_name='G', ) self.tm = ExtAlgeb( src='tm', model='SynGen', indexer=self.syn, tex_name=r'\tau_m', e_str='u * (pout - tm0)', info='Mechanical power to generator', ) self.pout = Algeb( info='Turbine final output power', tex_name='P_{out}', v_str='tm0', ) self.wref = Algeb( info='Speed reference variable', tex_name=r'\omega_{ref}', v_str='wref0', e_str='wref0 - wref', )
def __init__(self, system, config): DGPRCTBaseModel.__init__(self, system, config) self.v = ExtAlgeb(model='Bus', src='v', indexer=self.bus, export=False, info='Bus voltage', unit='p.u.', ) fProtect.__init__(self) VProtect.__init__(self)
def __init__(self, system, config): Model.__init__(self, system, config) self.flags.tds = True self.group = 'Experimental' self.a = ExtAlgeb( model='Bus', src='a', indexer=self.bus, tex_name=r'\theta', info='Bus voltage angle', e_str='-p0', ename='P', tex_ename='P', ) self.v = ExtAlgeb( model='Bus', src='v', indexer=self.bus, tex_name=r'V', info='Bus voltage magnitude', e_str='-q0', ename='P', tex_ename='P', ) self.p0 = ExtService( model='StaticGen', src='p', indexer=self.gen, tex_name='P_0', ) self.q0 = ExtService( model='StaticGen', src='q', indexer=self.gen, tex_name='Q_0', )
def __init__(self, system, config): ACEData.__init__(self) Model.__init__(self, system, config) self.flags.tds = True self.group = 'Calculation' self.config.add( OrderedDict([ ('freq_model', 'BusFreq'), ('interval', 4.0), ('offset', 0.0), ])) self.config.add_extra( '_help', { 'freq_model': 'default freq. measurement model', 'interval': 'sampling time interval', 'offset': 'sampling time offset' }) self.config.add_extra('_alt', {'freq_model': ('BusFreq', )}) self.area = ExtParam(model='Bus', src='area', indexer=self.bus, export=False) self.busf.model = self.config.freq_model self.busfreq = DeviceFinder(self.busf, link=self.bus, idx_name='bus') self.f = ExtAlgeb( model='FreqMeasurement', src='f', indexer=self.busfreq, export=False, info='Bus frequency', ) self.fs = Sampling( self.f, interval=self.config.interval, offset=self.config.offset, tex_name='f_s', info='Sampled freq.', ) self.ace = Algeb( info='area control error', unit='MW (p.u.)', tex_name='ace', e_str='10 * bias * (fs_v - 1) - ace', )
def __init__(self, system, config): PMUData.__init__(self) Model.__init__(self, system, config) self.flags.tds = True self.group = 'PhasorMeasurement' self.a = ExtAlgeb( model='Bus', src='a', indexer=self.bus, tex_name=r'\theta', info='Bus voltage phase angle', ) self.v = ExtAlgeb( model='Bus', src='v', indexer=self.bus, tex_name=r'V', info='Bus voltage magnitude', ) self.am = State( tex_name=r'\theta_m', info='phase angle measurement', unit='rad.', e_str='a - am', t_const=self.Ta, v_str='a', ) self.vm = State( tex_name='V_m', info='voltage magnitude measurement', unit='p.u.(kV)', e_str='v - vm', t_const=self.Tv, v_str='v', )
def __init__(self, system, config): ACEData.__init__(self) Model.__init__(self, system, config) self.flags.tds = True self.group = 'Calculation' 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.area = ExtParam(model='Bus', src='area', indexer=self.bus, export=False) self.busf.model = self.config.freq_model self.busfreq = DeviceFinder(self.busf, link=self.bus, idx_name='bus', default_model='BusFreq') self.imva = ConstService(v_str='1/sys_mva', info='reciprocal of system mva', tex_name='1/S_{b, sys}') self.f = ExtAlgeb(model='FreqMeasurement', src='f', indexer=self.busfreq, export=False, info='Bus frequency', unit='p.u. (Hz)') self.ace = Algeb( info='area control error', unit='p.u. (MW)', tex_name='ace', e_str='10 * (bias * imva) * sys_f * (f - 1) - ace', )
def __init__(self, system, config): super().__init__(system, config) self.flags.tds = True self.group = 'PLL' self.a = ExtAlgeb(model='Bus', src='a', indexer=self.bus, tex_name=r'\theta', info='Bus voltage angle') self.af = Lag( u=self.a, T=self.Tf, K=1, D=1, info='input angle signal filter', ) self.PI = PIController( u='u * (af_y - am)', kp=self.Kp, ki=self.Ki, tex_name='PI', info='PI controller', ) self.ae = State(info='PLL angle output before filter', e_str='2 * pi *fn * PI_y', v_str='a', tex_name=r'\theta_{est}') self.am = State(info='PLL output angle after filtering', e_str='ae - am', t_const=self.Tp, v_str='a', tex_name=r'\theta_{PLL}')
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): 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): ModelData.__init__(self) self.bus = IdxParam( model='Bus', info="linked bus idx", mandatory=True, ) self.tf = TimerParam( info='Bus fault start time', unit='second', mandatory=True, callback=self.apply_fault, ) self.tc = TimerParam( info='Bus fault end time', unit='second', callback=self.clear_fault, ) self.xf = NumParam( info='Fault to ground impedance (positive)', unit='p.u.(sys)', default=1e-4, tex_name='x_f', ) self.rf = NumParam( info='Fault to ground resistance (positive)', unit='p.u.(sys)', default=0, tex_name='x_f', ) Model.__init__(self, system, config) self.flags.update({'tds': True}) self.group = 'TimedEvent' self.gf = ConstService( tex_name='g_{f}', v_str='re(1/(rf + 1j * xf))', ) self.bf = ConstService( tex_name='b_{f}', v_str='im(1/(rf + 1j * xf))', ) # uf: an internal flag of whether the fault is in action (1) or not (0) self.uf = ConstService(tex_name='u_f', v_str='0') self.a = ExtAlgeb( model='Bus', src='a', indexer=self.bus, tex_name=r'\theta', info='Bus voltage angle', unit='p.u.(kV)', e_str='u * uf * (v ** 2 * gf)', ) self.v = ExtAlgeb( model='Bus', src='v', indexer=self.bus, tex_name=r'V', unit='p.u.(kV)', info='Bus voltage magnitude', e_str='-u * uf * (v ** 2 * bf)', ) self._vstore = np.array([])
def __init__(self, system, config): super().__init__(system, config) self.group = 'PSS' self.flags.update({'tds': True}) self.VCUr = Replace(self.VCU, lambda x: np.equal(x, 0.0), 999) self.VCLr = Replace(self.VCL, lambda x: np.equal(x, 0.0), -999) # retrieve indices of connected generator, bus, and bus freq self.syn = ExtParam(model='Exciter', src='syn', indexer=self.avr, export=False, info='Retrieved generator idx', dtype=str) self.bus = ExtParam( model='SynGen', src='bus', indexer=self.syn, export=False, info='Retrieved bus idx', dtype=str, default=None, ) self.buss = DataSelect(self.busr, self.bus, info='selected bus (bus or busr)') self.busfreq = DeviceFinder(self.busf, link=self.buss, idx_name='bus') # from SynGen self.Sn = ExtParam(model='SynGen', src='Sn', indexer=self.syn, tex_name='S_n', info='Generator power base', export=False) self.omega = ExtState( model='SynGen', src='omega', indexer=self.syn, tex_name=r'\omega', info='Generator speed', unit='p.u.', ) self.tm0 = ExtService( model='SynGen', src='tm', indexer=self.syn, tex_name=r'\tau_{m0}', info='Initial mechanical input', ) self.tm = ExtAlgeb( model='SynGen', src='tm', indexer=self.syn, tex_name=r'\tau_m', info='Generator mechanical input', ) self.te = ExtAlgeb( model='SynGen', src='te', indexer=self.syn, tex_name=r'\tau_e', info='Generator electrical output', ) # from Bus self.v = ExtAlgeb( model='Bus', src='v', indexer=self.buss, tex_name=r'V', info='Bus (or busr, if given) terminal voltage', ) self.v0 = ExtService( model='Bus', src='v', indexer=self.buss, tex_name="V_0", info='Initial bus voltage', ) # from BusFreq self.f = ExtAlgeb(model='FreqMeasurement', src='f', indexer=self.busfreq, export=False, info='Bus frequency') # from Exciter self.vi = ExtAlgeb(model='Exciter', src='vi', indexer=self.avr, tex_name='v_i', info='Exciter input voltage', e_str='u * vsout') self.vsout = Algeb( info='PSS output voltage to exciter', tex_name='v_{sout}', ) # `self.vsout.e_str` to be provided by specific models
def __init__(self, system, config): ModelData.__init__(self) self.bus = IdxParam( model='Bus', info="idx of connected bus", mandatory=True, ) self.node1 = IdxParam( default=None, tex_name='node_1', info='Node 1 index', mandatory=True, model='Node', ) self.node2 = IdxParam( default=None, tex_name='node_2', info='Node 2 index', mandatory=True, model='Node', ) self.Vn = NumParam( default=110.0, info="AC voltage rating", non_zero=True, tex_name=r'V_n', ) self.Vdcn1 = NumParam( default=100, info='DC voltage rating on node 1', unit='kV', non_zero=True, tex_name='V_{dcn1}', ) self.Vdcn2 = NumParam( default=100, info='DC voltage rating on node 2', unit='kV', non_zero=True, tex_name='V_{dcn2}', ) self.Idcn = NumParam( default=1, info='DC current rating', unit='kA', non_zero=True, tex_name='I_{dcn}', ) Model.__init__(self, system, config) self.a = ExtAlgeb( model='Bus', src='a', indexer=self.bus, info='AC bus voltage phase', ) self.v = ExtAlgeb( model='Bus', src='v', indexer=self.bus, info='AC bus voltage magnitude', ) self.v1 = ExtAlgeb( model='Node', src='v', indexer=self.node1, info='DC node 1 voltage', ) self.v2 = ExtAlgeb( model='Node', src='v', indexer=self.node2, info='DC node 2 voltage', )
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): Model.__init__(self, system, config) self.group = 'Exciter' self.flags.tds = True # from synchronous generators, get Sn, Vn, bus; tm0; omega self.Sn = ExtParam( src='Sn', model='SynGen', indexer=self.syn, tex_name='S_m', info='Rated power from generator', unit='MVA', export=False, ) self.Vn = ExtParam( src='Vn', model='SynGen', indexer=self.syn, tex_name='V_m', info='Rated voltage from generator', unit='kV', export=False, ) self.vf0 = ExtService(src='vf', model='SynGen', indexer=self.syn, tex_name='v_{f0}', info='Steady state excitation voltage') self.bus = ExtParam( src='bus', model='SynGen', indexer=self.syn, tex_name='bus', info='Bus idx of the generators', export=False, vtype=str, ) self.omega = ExtState( src='omega', model='SynGen', indexer=self.syn, tex_name=r'\omega', info='Generator speed', ) self.vf = ExtAlgeb( src='vf', model='SynGen', indexer=self.syn, tex_name=r'v_f', e_str='u * (vout - vf0)', info='Excitation field voltage to generator', ) self.XadIfd = ExtAlgeb( src='XadIfd', model='SynGen', indexer=self.syn, tex_name=r'X_{ad}I_{fd}', info='Armature excitation current', ) # from bus, get a and v self.a = ExtAlgeb( model='Bus', src='a', indexer=self.bus, tex_name=r'\theta', info='Bus voltage phase angle', ) self.v = ExtAlgeb( model='Bus', src='v', indexer=self.bus, tex_name=r'V', info='Bus voltage magnitude', ) # output excitation voltage self.vout = Algeb( info='Exciter final output voltage', tex_name='v_{out}', v_str='vf0', )
def __init__(self, system, config): super().__init__(system, config) self.group = 'SynGen' self.flags.update({ 'tds': True, 'nr_iter': False, }) self.config.add( vf_lower=1.0, vf_upper=5.0, ) self.config.add_extra( "_help", vf_lower="lower limit for vf warning", vf_upper="upper limit for vf warning", ) # state variables self.delta = State(info='rotor angle', unit='rad', v_str='delta0', tex_name=r'\delta', e_str='u * (2 * pi * fn) * (omega - 1)') self.omega = State(info='rotor speed', unit='pu (Hz)', v_str='u', tex_name=r'\omega', e_str='(u / M) * (tm - te - D * (omega - 1))') # network algebraic variables self.a = ExtAlgeb(model='Bus', src='a', indexer=self.bus, tex_name=r'\theta', info='Bus voltage phase angle', e_str='-u * (vd * Id + vq * Iq)') self.v = ExtAlgeb(model='Bus', src='v', indexer=self.bus, tex_name=r'V', info='Bus voltage magnitude', e_str='-u * (vq * Id - vd * Iq)') # algebraic variables # Need to be provided by specific generator models self.Id = Algeb(info='d-axis current', v_str='u * Id0', tex_name=r'I_d', e_str='') # to be completed by subclasses self.Iq = Algeb(info='q-axis current', v_str='u * Iq0', tex_name=r'I_q', e_str='') # to be completed self.vd = Algeb( info='d-axis voltage', v_str='u * vd0', e_str='u * v * sin(delta - a) - vd', tex_name=r'V_d', ) self.vq = Algeb( info='q-axis voltage', v_str='u * vq0', e_str='u * v * cos(delta - a) - vq', tex_name=r'V_q', ) self.tm = Algeb(info='mechanical torque', tex_name=r'\tau_m', v_str='tm0', e_str='tm0 - tm') self.te = Algeb( info='electric torque', tex_name=r'\tau_e', v_str='u * tm0', e_str='u * (psid * Iq - psiq * Id) - te', ) self.vf = Algeb(info='excitation voltage', unit='pu', v_str='u * vf0', e_str='u * vf0 - vf', tex_name=r'v_f') self._vfc = InitChecker( u=self.vf, info='(vf range)', lower=self.config.vf_lower, upper=self.config.vf_upper, ) self.XadIfd = Algeb(tex_name='X_{ad}I_{fd}', info='d-axis armature excitation current', unit='p.u (kV)', v_str='u * vf0', e_str='u * vf0 - XadIfd' ) # e_str to be provided. Not available in GENCLS self.subidx = ExtParam( model='StaticGen', src='subidx', indexer=self.gen, export=False, info='Generator idx in plant; only used by PSS/E data') # declaring `Vn_bus` as ExtParam will fail for PSS/E parser self.Vn_bus = ExtService( model='Bus', src='Vn', indexer=self.bus, ) self._vnc = InitChecker( u=self.Vn, info='Vn and Bus Vn', equal=self.Vn_bus, ) # ----------service consts for initialization---------- 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', )
def __init__(self, system, config): Model.__init__(self, system, config) self.group = 'Calculation' self.flags.update({'tds': True}) self.SynGen = BackRef(info='Back reference to SynGen idx') self.SynGenIdx = RefFlatten(ref=self.SynGen) self.M = ExtParam( model='SynGen', src='M', indexer=self.SynGenIdx, export=False, info='Linearly stored SynGen.M', ) self.wgen = ExtState( model='SynGen', src='omega', indexer=self.SynGenIdx, tex_name=r'\omega_{gen}', info='Linearly stored SynGen.omega', ) self.agen = ExtState( model='SynGen', src='delta', indexer=self.SynGenIdx, tex_name=r'\delta_{gen}', info='Linearly stored SynGen.delta', ) self.d0 = ExtService( model='SynGen', src='delta', indexer=self.SynGenIdx, tex_name=r'\delta_{gen,0}', info='Linearly stored initial delta', ) self.a0 = ExtService( model='SynGen', src='omega', indexer=self.SynGenIdx, tex_name=r'\omega_{gen,0}', info='Linearly stored initial omega', ) self.Mt = NumReduce( u=self.M, tex_name='M_t', fun=np.sum, ref=self.SynGen, info='Summation of M by COI index', ) self.Mr = NumRepeat( u=self.Mt, tex_name='M_{tr}', ref=self.SynGen, info='Repeated summation of M', ) self.Mw = ConstService(tex_name='M_w', info='Inertia weights', v_str='M/Mr') self.d0w = ConstService(tex_name=r'\delta_{gen,0,w}', v_str='d0 * Mw', info='Linearly stored weighted delta') self.a0w = ConstService(tex_name=r'\omega_{gen,0,w}', v_str='a0 * Mw', info='Linearly stored weighted omega') self.d0a = NumReduce( u=self.d0w, tex_name=r'\delta_{gen,0,avg}', fun=np.sum, ref=self.SynGen, info='Average initial delta', cache=False, ) self.a0a = NumReduce( u=self.a0w, tex_name=r'\omega_{gen,0,avg}', fun=np.sum, ref=self.SynGen, info='Average initial omega', cache=False, ) self.pidx = IdxRepeat(u=self.idx, ref=self.SynGen, info='Repeated COI.idx') # Note: # Even if d(omega) /d (omega) = 1, it is still stored as a lambda function. # When no SynGen is referencing any COI, j_update will not be called, # and Jacobian will become singular. `diag_eps = True` needs to be used. # Note: # Do not assign `v_str=1` for `omega`. Otherwise, COIs with no connected generators will # fail to initialize. self.omega = Algeb( tex_name=r'\omega_{coi}', info='COI speed', v_str='a0a', v_setter=True, e_str='-omega', diag_eps=True, ) self.delta = Algeb( tex_name=r'\delta_{coi}', info='COI rotor angle', v_str='d0a', v_setter=True, e_str='-delta', diag_eps=True, ) # Note: # `omega_sub` or `delta_sub` must not provide `v_str`. # Otherwise, values will be incorrectly summed for `omega` and `delta`. self.omega_sub = ExtAlgeb( model='COI', src='omega', e_str='Mw * wgen', indexer=self.pidx, info='COI frequency contribution of each generator') self.delta_sub = ExtAlgeb( model='COI', src='delta', e_str='Mw * agen', indexer=self.pidx, info='COI angle contribution of each generator')
def __init__(self, system, config): super().__init__(system, config) self.group = 'SynGen' self.flags.update({ 'tds': True, 'nr_iter': False, }) # state variables self.delta = State(info='rotor angle', unit='rad', v_str='delta0', tex_name=r'\delta', e_str='u * (2 * pi * fn) * (omega - 1)') self.omega = State(info='rotor speed', unit='pu (Hz)', v_str='u', tex_name=r'\omega', e_str='(u / M) * (tm - te - D * (omega - 1))') # network algebraic variables self.a = ExtAlgeb(model='Bus', src='a', indexer=self.bus, tex_name=r'\theta', info='Bus voltage phase angle', e_str='-u * (vd * Id + vq * Iq)') self.v = ExtAlgeb(model='Bus', src='v', indexer=self.bus, tex_name=r'V', info='Bus voltage magnitude', e_str='-u * (vq * Id - vd * Iq)') # algebraic variables # Need to be provided by specific generator models self.Id = Algeb(info='d-axis current', v_str='Id0', tex_name=r'I_d', e_str='') # to be completed by subclasses self.Iq = Algeb(info='q-axis current', v_str='Iq0', tex_name=r'I_q', e_str='') # to be completed self.vd = Algeb( info='d-axis voltage', v_str='vd0', e_str='v * sin(delta - a) - vd', tex_name=r'V_d', ) self.vq = Algeb( info='q-axis voltage', v_str='vq0', e_str='v * cos(delta - a) - vq', tex_name=r'V_q', ) self.tm = Algeb(info='mechanical torque', tex_name=r'\tau_m', v_str='tm0', v_setter=True, e_str='tm0 - tm') self.te = Algeb( info='electric torque', tex_name=r'\tau_e', v_str='p0', v_setter=True, e_str='psid * Iq - psiq * Id - te', ) self.vf = Algeb(info='excitation voltage', unit='pu', v_str='vf0', v_setter=True, e_str='vf0 - vf', tex_name=r'v_f') self.subidx = ExtParam( model='StaticGen', src='subidx', indexer=self.gen, tex_name='idx_{sub}', export=False, ) # ----------service consts for initialization---------- self.p0 = ExtService( model='StaticGen', src='p', indexer=self.gen, tex_name='P_0', ) self.q0 = ExtService( model='StaticGen', src='q', indexer=self.gen, tex_name='Q_0', )