def __init__(self, system, config):
TGBase.__init__(self, system, config, add_sn=False)
# check if K1-K8 sums up to 1
self._sumK18 = ConstService(v_str='K1+K2+K3+K4+K5+K6+K7+K8',
info='summation of K1-K8',
tex_name=r"\sum_{i=1}^8 K_i")
self._K18c1 = InitChecker(
u=self._sumK18,
info='summation of K1-K8 and 1.0',
equal=1,
)
# check if `tm0 * (K2 + k4 + K6 + K8) = tm02 *(K1 + K3 + K5 + K7)
self._tm0K2 = PostInitService(
info='mul of tm0 and (K2+K4+K6+K8)',
v_str='zsyn2*tm0*(K2+K4+K6+K8)',
)
self._tm02K1 = PostInitService(
info='mul of tm02 and (K1+K3+K5+K6)',
v_str='tm02*(K1+K3+K5+K7)',
)
self._Pc = InitChecker(
u=self._tm0K2,
info='proportionality of tm0 and tm02',
equal=self._tm02K1,
)
self.Sg2 = ExtParam(
src='Sn',
model='SynGen',
indexer=self.syn2,
allow_none=True,
default=0.0,
tex_name='S_{n2}',
info='Rated power of Syn2',
unit='MVA',
export=False,
)
self.Sg12 = ParamCalc(
self.Sg,
self.Sg2,
func=np.add,
tex_name="S_{g12}",
info='Sum of generator power ratings',
)
self.Sn = NumSelect(
self.Tn,
fallback=self.Sg12,
tex_name='S_n',
info='Turbine or Gen rating',
)
self.zsyn2 = FlagValue(
self.syn2,
value=None,
tex_name='z_{syn2}',
info='Exist flags for syn2',
)
self.tm02 = ExtService(
src='tm',
model='SynGen',
indexer=self.syn2,
tex_name=r'\tau_{m02}',
info='Initial mechanical input of syn2',
allow_none=True,
default=0.0,
)
self.tm012 = ConstService(
info='total turbine power',
v_str='tm0 + tm02',
)
self.tm2 = ExtAlgeb(
src='tm',
model='SynGen',
indexer=self.syn2,
allow_none=True,
tex_name=r'\tau_{m2}',
e_str='zsyn2 * u * (PLP - tm02)',
info='Mechanical power to syn2',
)
self.wd = Algeb(
info='Generator under speed',
unit='p.u.',
tex_name=r'\omega_{dev}',
v_str='0',
e_str='(wref - omega) - wd',
)
self.LL = LeadLag(
u=self.wd,
T1=self.T2,
T2=self.T1,
K=self.K,
info='Signal conditioning for wd',
)
# `P0` == `tm0`
self.vs = Algeb(
info='Valve speed',
tex_name='V_s',
v_str='0',
e_str='(LL_y + tm012 + paux - IAW_y) / T3 - vs',
)
self.HL = HardLimiter(
u=self.vs,
lower=self.UC,
upper=self.UO,
info='Limiter on valve acceleration',
)
self.vsl = Algeb(
info='Valve move speed after limiter',
tex_name='V_{sl}',
v_str='vs * HL_zi + UC * HL_zl + UO * HL_zu',
e_str='vs * HL_zi + UC * HL_zl + UO * HL_zu - vsl',
)
self.IAW = IntegratorAntiWindup(
u=self.vsl,
T=1,
K=1,
y0=self.tm012,
lower=self.PMIN,
upper=self.PMAX,
info='Valve position integrator',
)
self.L4 = Lag(
u=self.IAW_y,
T=self.T4,
K=1,
info='first process',
)
self.L5 = Lag(
u=self.L4_y,
T=self.T5,
K=1,
info='second (reheat) process',
)
self.L6 = Lag(
u=self.L5_y,
T=self.T6,
K=1,
info='third process',
)
self.L7 = Lag(
u=self.L6_y,
T=self.T7,
K=1,
info='fourth (second reheat) process',
)
self.PHP = Algeb(
info='HP output',
tex_name='P_{HP}',
v_str='K1*L4_y + K3*L5_y + K5*L6_y + K7*L7_y',
e_str='K1*L4_y + K3*L5_y + K5*L6_y + K7*L7_y - PHP',
)
self.PLP = Algeb(
info='LP output',
tex_name='P_{LP}',
v_str='K2*L4_y + K4*L5_y + K6*L6_y + K8*L7_y',
e_str='K2*L4_y + K4*L5_y + K6*L6_y + K8*L7_y - PLP',
)
self.pout.e_str = 'PHP - pout'
def __init__(self, system, config):
Model.__init__(self, system, config)
self.group = 'RenPlant'
self.flags.tds = True
self.config.add(OrderedDict((
('kqs', 2),
('ksg', 2),
('freeze', 1),
)))
self.config.add_extra(
'_help',
kqs='Tracking gain for reactive power PI controller',
ksg='Tracking gain for active power PI controller',
freeze='Voltage dip freeze flag; 1-enable, 0-disable',
)
self.config.add_extra('_tex',
kqs='K_{qs}',
ksg='K_{sg}',
freeze='f_{rz}')
# --- from RenExciter ---
self.reg = ExtParam(
model='RenExciter',
src='reg',
indexer=self.ree,
export=False,
info='Retrieved RenGen idx',
vtype=str,
default=None,
)
self.Pext = ExtAlgeb(
model='RenExciter',
src='Pref',
indexer=self.ree,
info='Pref from RenExciter renamed as Pext',
tex_name='P_{ext}',
)
self.Qext = ExtAlgeb(
model='RenExciter',
src='Qref',
indexer=self.ree,
info='Qref from RenExciter renamed as Qext',
tex_name='Q_{ext}',
)
# --- from RenGen ---
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.busfreq = DeviceFinder(self.busf, link=self.buss, idx_name='bus')
# from Bus
self.v = ExtAlgeb(
model='Bus',
src='v',
indexer=self.buss,
tex_name='V',
info='Bus (or busr, if given) terminal voltage',
)
self.a = ExtAlgeb(
model='Bus',
src='a',
indexer=self.buss,
tex_name=r'\theta',
info='Bus (or busr, if given) phase angle',
)
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',
unit='p.u.')
# from Line
self.bus1 = ExtParam(
model='ACLine',
src='bus1',
indexer=self.line,
export=False,
info='Retrieved Line.bus1 idx',
vtype=str,
default=None,
)
self.bus2 = ExtParam(
model='ACLine',
src='bus2',
indexer=self.line,
export=False,
info='Retrieved Line.bus2 idx',
vtype=str,
default=None,
)
self.r = ExtParam(
model='ACLine',
src='r',
indexer=self.line,
export=False,
info='Retrieved Line.r',
vtype=str,
default=None,
)
self.x = ExtParam(
model='ACLine',
src='x',
indexer=self.line,
export=False,
info='Retrieved Line.x',
vtype=str,
default=None,
)
self.v1 = ExtAlgeb(
model='ACLine',
src='v1',
indexer=self.line,
tex_name='V_1',
info='Voltage at Line.bus1',
)
self.v2 = ExtAlgeb(
model='ACLine',
src='v2',
indexer=self.line,
tex_name='V_2',
info='Voltage at Line.bus2',
)
self.a1 = ExtAlgeb(
model='ACLine',
src='a1',
indexer=self.line,
tex_name=r'\theta_1',
info='Angle at Line.bus1',
)
self.a2 = ExtAlgeb(
model='ACLine',
src='a2',
indexer=self.line,
tex_name=r'\theta_2',
info='Angle at Line.bus2',
)
# -- begin services ---
self.Isign = CurrentSign(self.bus,
self.bus1,
self.bus2,
tex_name='I_{sign}')
Iline = '(Isign * (v1*exp(1j*a1) - v2*exp(1j*a2)) / (r + 1j*x))'
self.Iline = VarService(
v_str=Iline,
vtype=complex,
info='Complex current from bus1 to bus2',
tex_name='I_{line}',
)
self.Iline0 = ConstService(
v_str='Iline',
vtype=complex,
info='Initial complex current from bus1 to bus2',
tex_name='I_{line0}',
)
Pline = 're(Isign * v1*exp(1j*a1) * conj((v1*exp(1j*a1) - v2*exp(1j*a2)) / (r + 1j*x)))'
self.Pline = VarService(
v_str=Pline,
vtype=float,
info='Complex power from bus1 to bus2',
tex_name='P_{line}',
)
self.Pline0 = ConstService(
v_str='Pline',
vtype=float,
info='Initial vomplex power from bus1 to bus2',
tex_name='P_{line0}',
)
Qline = 'im(Isign * v1*exp(1j*a1) * conj((v1*exp(1j*a1) - v2*exp(1j*a2)) / (r + 1j*x)))'
self.Qline = VarService(
v_str=Qline,
vtype=float,
info='Complex power from bus1 to bus2',
tex_name='Q_{line}',
)
self.Qline0 = ConstService(
v_str='Qline',
vtype=float,
info='Initial complex power from bus1 to bus2',
tex_name='Q_{line0}',
)
self.Rcs = NumSelect(
self.Rc,
self.r,
info='Line R (Rc if provided, otherwise line.r)',
tex_name='R_{cs}',
)
self.Xcs = NumSelect(
self.Xc,
self.x,
info='Line X (Xc if provided, otherwise line.x)',
tex_name='X_{cs}',
)
self.Vcomp = VarService(
v_str='abs(v*exp(1j*a) - (Rcs + 1j * Xcs) * Iline)',
info='Voltage after Rc/Xc compensation',
tex_name='V_{comp}')
self.SWVC = Switcher(u=self.VCFlag,
options=(0, 1),
tex_name='SW_{VC}',
cache=True)
self.SWRef = Switcher(u=self.RefFlag,
options=(0, 1),
tex_name='SW_{Ref}',
cache=True)
self.SWF = Switcher(u=self.Fflag,
options=(0, 1),
tex_name='SW_{F}',
cache=True)
self.SWPL = Switcher(u=self.PLflag,
options=(0, 1),
tex_name='SW_{PL}',
cache=True)
VCsel = '(SWVC_s1 * Vcomp + SWVC_s0 * (Qline * Kc + v))'
self.Vref0 = ConstService(
v_str='(SWVC_s1 * Vcomp + SWVC_s0 * (Qline0 * Kc + v))',
tex_name='V_{ref0}',
)
self.s0 = Lag(
VCsel,
T=self.Tfltr,
K=1,
tex_name='s_0',
info='V filter',
) # s0_y is the filter output of voltage deviation
self.s1 = Lag(self.Qline, T=self.Tfltr, K=1, tex_name='s_1')
self.Vref = Algeb(v_str='Vref0',
e_str='Vref0 - Vref',
tex_name='Q_{ref}')
self.Qlinef = Algeb(v_str='Qline0',
e_str='Qline0 - Qlinef',
tex_name='Q_{linef}')
Refsel = '(SWRef_s0 * (Qlinef - s1_y) + SWRef_s1 * (Vref - s0_y))'
self.Refsel = Algeb(v_str=Refsel,
e_str=f'{Refsel} - Refsel',
tex_name='R_{efsel}')
self.dbd = DeadBand1(
u=self.Refsel,
lower=self.dbd1,
upper=self.dbd2,
center=0.0,
tex_name='d^{bd}',
)
# --- e Hardlimit and hold logic ---
self.eHL = Limiter(
u=self.dbd_y,
lower=self.emin,
upper=self.emax,
tex_name='e_{HL}',
info='Hardlimit on deadband output',
)
self.zf = VarService(
v_str='Indicator(v < Vfrz) * freeze',
tex_name='z_f',
info='PI Q input freeze signal',
)
self.enf = Algeb(
tex_name='e_{nf}',
info='e Hardlimit output before freeze',
v_str='dbd_y*eHL_zi + emax*eHL_zu + emin*eHL_zl',
e_str='dbd_y*eHL_zi + emax*eHL_zu + emin*eHL_zl - enf',
)
# --- hold of `enf` when v < vfrz
self.eHld = VarHold(
u=self.enf,
hold=self.zf,
tex_name='e_{hld}',
info='e Hardlimit output after conditional hold',
)
self.s2 = PITrackAW(
u='eHld',
kp=self.Kp,
ki=self.Ki,
ks=self.config.kqs,
lower=self.Qmin,
upper=self.Qmax,
info='PI controller for eHL output',
tex_name='s_2',
)
self.s3 = LeadLag(
u=self.s2_y,
T1=self.Tft,
T2=self.Tfv,
K=1,
tex_name='s_3',
) # s3_y == Qext
# Active power part
self.s4 = Lag(
self.Pline,
T=self.Tp,
K=1,
tex_name='s_4',
info='Pline filter',
)
self.Freq_ref = ConstService(v_str='1.0',
tex_name='f_{ref}',
info='Initial Freq_ref')
self.ferr = Algeb(
tex_name='f_{err}',
info='Frequency deviation',
unit='p.u. (Hz)',
v_str='(Freq_ref - f)',
e_str='(Freq_ref - f) - ferr',
)
self.fdbd = DeadBand1(
u=self.ferr,
center=0.0,
lower=self.fdbd1,
upper=self.fdbd2,
tex_name='f^{dbd}',
info='frequency error deadband',
)
self.fdlt0 = LessThan(
self.fdbd_y,
0.0,
tex_name='f_{dlt0}',
info='frequency deadband output less than zero',
)
fdroop = '(fdbd_y * Ddn * fdlt0_z1 + fdbd_y * Dup * fdlt0_z0)'
self.Plant_pref = Algeb(
tex_name='P_{ref}',
info='Plant P ref',
v_str='Pline0',
e_str='Pline0 - Plant_pref',
)
self.Plerr = Algeb(
tex_name='P_{lerr}',
info='Pline error',
v_str='- s4_y + Plant_pref',
e_str='- s4_y + Plant_pref - Plerr',
)
self.Perr = Algeb(
tex_name='P_{err}',
info='Power error before fe limits',
v_str=f'{fdroop} + Plerr * SWPL_s1',
e_str=f'{fdroop} + Plerr * SWPL_s1 - Perr',
)
self.feHL = Limiter(
self.Perr,
lower=self.femin,
upper=self.femax,
tex_name='f_{eHL}',
info='Limiter for power (frequency) error',
)
feout = '(Perr * feHL_zi + femin * feHL_zl + femax * feHL_zu)'
self.s5 = PITrackAW(
u=feout,
kp=self.Kpg,
ki=self.Kig,
ks=self.config.ksg,
lower=self.Pmin,
upper=self.Pmax,
tex_name='s_5',
info='PI for fe limiter output',
)
self.s6 = Lag(
u=self.s5_y,
T=self.Tg,
K=1,
tex_name='s_6',
info='Output filter for Pext',
)
Qext = '(s3_y)'
Pext = '(SWF_s1 * s6_y)'
self.Pext.e_str = Pext
self.Qext.e_str = Qext
def __init__(self, system, config):
Model.__init__(self, system, config)
self.flags.tds = True
self.group = 'RenTorque'
self.kp1 = ConstService(v_str='(sp2 - sp1) / (p2 - p1)',
tex_name='k_{p1}',
)
self.kp2 = ConstService(v_str='(sp3 - sp2) / (p3 - p2)',
tex_name='k_{p2}',
)
self.kp3 = ConstService(v_str='(sp4 - sp3) / (p4 - p3)',
tex_name='k_{p3}',
)
self.rea = ExtParam(model='RenPitch', src='rea', indexer=self.rep, export=False,
)
self.rego = ExtParam(model='RenAerodynamics', src='rego', indexer=self.rea,
export=False,
)
self.ree = ExtParam(model='RenGovernor', src='ree', indexer=self.rego,
export=False,
)
self.reg = ExtParam(model='RenExciter', src='reg', indexer=self.ree,
export=False,)
self.Sngo = ExtParam(model='RenGovernor', src='Sn', indexer=self.rego,
tex_name='S_{n,go}', export=False,
)
self.Sn = NumSelect(self.Tn,
fallback=self.Sngo,
tex_name='S_n',
info='Turbine or RenGovernor rating',
)
self.Pe = ExtAlgeb(model='RenGen', src='Pe', indexer=self.reg,
tex_name='P_e', export=False,
)
self.s1 = Lag(u=self.Pe, T=self.Tp, K=1.0, tex_name='s_1',
info='Pe filter',
)
self.fPe = Piecewise(u=self.s1_y,
points=('p1', 'p2', 'p3', 'p4'),
funs=('sp1',
f'sp1 + ({self.s1_y.name} - p1) * kp1',
f'sp2 + ({self.s1_y.name} - p2) * kp2',
f'sp3 + ({self.s1_y.name} - p3) * kp3',
'sp4'),
tex_name='f_{Pe}',
info='Piecewise Pe to wref mapping',
)
# Overwrite `wg` and `wt` initial values in turbine governors
self.wg = ExtState(model='RenGovernor', src='wg', indexer=self.rego,
tex_name=r'\omega_g', export=False,
v_str='fPe_y',
v_setter=True,
)
self.wt = ExtState(model='RenGovernor', src='wt', indexer=self.rego,
tex_name=r'\omega_t', export=False,
v_str='fPe_y',
v_setter=True,
)
self.s3_y = ExtState(model='RenGovernor', src='s3_y', indexer=self.rego,
tex_name='y_{s3}', export=False,
v_str='Pref0 / wg / Kshaft',
v_setter=True,
)
self.w0 = ExtParam(model='RenGovernor', src='w0', indexer=self.rego,
tex_name=r'\omega_0', export=False,
)
self.Kshaft = ExtService(model='RenGovernor', src='Kshaft', indexer=self.rego,
tex_name='K_{shaft}',
)
self.wr0 = ExtAlgeb(model='RenGovernor', src='wr0', indexer=self.rego,
tex_name=r'\omega_{r0}', export=False,
info='Retrieved initial w0 from RenGovernor',
v_str='fPe_y',
e_str='-w0 + fPe_y',
v_setter=True,
ename='dwr',
tex_ename=r'\Delta \omega_r',
)
self.s2 = Lag(u=self.fPe_y, T=self.Twref, K=1.0,
tex_name='s_2', info='speed filter',
)
self.SWT = Switcher(u=self.Tflag, options=(0, 1),
tex_name='SW_{T}',
cache=True,
)
self.Tsel = Algeb(tex_name='T_{sel}',
info='Output after Tflag selector',
discrete=self.SWT
)
self.Tsel.v_str = 'SWT_s1 * (Pe - Pref0) / wg +' \
'SWT_s0 * (s2_y - wg)'
self.Tsel.e_str = f'{self.Tsel.v_str} - Tsel'
self.PI = PIAWHardLimit(u=self.Tsel, kp=self.Kpp, ki=self.Kip,
aw_lower=self.Temin, aw_upper=self.Temax,
lower=self.Temin, upper=self.Temax,
tex_name='PI',
info='PI controller',
x0='Pref0 / fPe_y',
)
# Note:
# Reset `wg` of REECA1 to 1.0 becase `wg` has already been multiplied
# in the toeque model.
# This effectively sets `PFLAG` to 0 if the torque model is connected.
self.wge = ExtAlgeb(model='RenExciter', src='wg', indexer=self.ree,
tex_name=r'\omega_{ge}', export=False,
v_str='1.0',
e_str='-fPe_y + 1',
v_setter=True,
ename='dwg',
tex_ename=r'\Delta \omega_g',
)
self.Pref0 = ExtService(model='RenExciter', src='p0', indexer=self.ree,
tex_name='P_{ref0}',
)
self.Pref = ExtAlgeb(model='RenExciter', src='Pref', indexer=self.ree,
tex_name='P_{ref}', export=False,
e_str='-Pref0 / wge + PI_y * wg',
v_str='PI_y * wg',
v_setter=True,
ename='Pref',
tex_ename='P_{ref}',
)
def __init__(self, system, config, add_sn=True, add_tm0=True):
Model.__init__(self, system, config)
self.group = 'TurbineGov'
self.flags.update({'tds': True})
self.Sg = ExtParam(
src='Sn',
model='SynGen',
indexer=self.syn,
tex_name='S_n',
info='Rated power from generator',
unit='MVA',
export=False,
)
if add_sn is True:
self.Sn = NumSelect(
self.Tn,
fallback=self.Sg,
tex_name='S_n',
info='Turbine or Gen rating',
)
self.Vn = ExtParam(
src='Vn',
model='SynGen',
indexer=self.syn,
tex_name='V_n',
info='Rated voltage from generator',
unit='kV',
export=False,
)
# Note: changing `tm0` is not allowed in any time!!
if add_tm0 is True:
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.')
# Note: changing `paux0` is allowed.
# It is a way how one can input from external programs such as reinforcement learning.
self.paux0 = ConstService(v_str='0',
tex_name='P_{aux0}',
info='const. auxiliary input')
self.tm = ExtAlgeb(
src='tm',
model='SynGen',
indexer=self.syn,
tex_name=r'\tau_m',
e_str='u * (pout - tm0)',
info='Mechanical power interface to SynGen',
)
# `paux` must be zero upon initialization
self.paux = Algeb(
info='Auxiliary power input',
tex_name='P_{aux}',
v_str='paux0',
e_str='paux0 - paux',
)
self.pout = Algeb(
info='Turbine final output power',
tex_name='P_{out}',
v_str='u*tm0',
)
self.wref = Algeb(
info='Speed reference variable',
tex_name=r'\omega_{ref}',
v_str='wref0',
e_str='wref0 - wref',
)