def __init__(self, system, config):
ExcBase.__init__(self, system, config)
self.TA = ConstService(v_str='TATB * TB')
self.vref0 = ConstService(
info='Initial reference voltage input',
tex_name='V_{ref0}',
v_str='vf0/K + v',
)
self.vref = Algeb(info='Reference voltage input',
tex_name='V_{ref}',
unit='p.u.',
v_str='vref0',
e_str='vref0 - vref')
# input excitation voltages; PSS outputs summed at vi
self.vi = Algeb(
info='Total input voltages',
tex_name='V_i',
unit='p.u.',
)
self.vi.e_str = '(vref - v) - vi'
self.vi.v_str = 'vref0 - v'
self.LL = LeadLag(u=self.vi, T1=self.TA, T2=self.TB, zero_out=True)
self.LAW = LagAntiWindup(
u=self.LL_y,
T=self.TE,
K=self.K,
lower=self.EMIN,
upper=self.EMAX,
)
self.vout.e_str = 'LAW_y - vout'
def __init__(self, system, config):
TGBase.__init__(self, system, config)
self.gain = ConstService(v_str='u/R',
tex_name='G',
)
self.pref = Algeb(info='Reference power input',
tex_name='P_{ref}',
v_str='tm0 * R',
e_str='tm0 * R - pref',
)
self.wd = Algeb(info='Generator under speed',
unit='p.u.',
tex_name=r'\omega_{dev}',
v_str='0',
e_str='(wref - omega) - wd',
)
self.pd = Algeb(info='Pref plus under speed times gain',
unit='p.u.',
tex_name="P_d",
v_str='u * tm0',
e_str='u*(wd + pref + paux) * gain - pd')
self.LAG = LagAntiWindup(u=self.pd,
K=1,
T=self.T1,
lower=self.VMIN,
upper=self.VMAX,
)
self.LL = LeadLag(u=self.LAG_y,
T1=self.T2,
T2=self.T3,
)
self.pout.e_str = '(LL_y + Dt * wd) - pout'
def __init__(self, system, config):
ExcBase.__init__(self, system, config)
self.SAT = ExcQuadSat(self.E1, self.SE1, self.E2, self.SE2,
info='Field voltage saturation',
)
# calculate `Se0` ahead of time in order to calculate `vr0`
# The term `1-ug` is to prevent division by zero when generator is off
self.Se0 = ConstService(info='Initial saturation output',
tex_name='S_{e0}',
v_str='Indicator(vf0>SAT_A) * SAT_B * (SAT_A - vf0) ** 2 / (vf0 + 1 - ug)',
)
self.vr0 = ConstService(info='Initial vr',
tex_name='V_{r0}',
v_str='(KE + Se0) * vf0')
self.vb0 = ConstService(info='Initial vb',
tex_name='V_{b0}',
v_str='vr0 / KA')
self.vref = Algeb(info='Reference voltage input',
tex_name='V_{ref}',
unit='p.u.',
v_str='v + vb0',
e_str='vref0 - vref'
)
self.vref0 = PostInitService(info='Constant v ref',
tex_name='V_{ref0}',
v_str='vref',
)
self.SL = LessThan(u=self.vout,
bound=self.SAT_A,
equal=False,
enable=True,
cache=False,
)
self.Se = Algeb(tex_name=r"S_e(|V_{out}|)", info='saturation output',
v_str='Se0',
e_str='SL_z0 * (vp - SAT_A) ** 2 * SAT_B - Se * vp',
diag_eps=True,
)
self.vp = State(info='Voltage after saturation feedback, before speed term',
tex_name='V_p',
unit='p.u.',
v_str='vf0',
e_str='ue * (LA_y - KE*vp - Se*vp)',
t_const=self.TE,
)
self.LS = Lag(u=self.v, T=self.TR, K=1.0, info='Sensing lag TF')
# input excitation voltages; PSS outputs summed at vi
self.vi = Algeb(info='Total input voltages',
tex_name='V_i',
unit='p.u.',
)
self.vi.v_str = 'vb0'
self.vi.e_str = '(vref - LS_y - W_y) - vi'
self.LL = LeadLag(u=self.vi,
T1=self.TC,
T2=self.TB,
info='Lead-lag for internal delays',
zero_out=True,
)
self.LA = LagAntiWindup(u=self.LL_y,
T=self.TA,
K=self.KA,
upper=self.VRMAX,
lower=self.VRMIN,
info='Anti-windup lag',
)
self.W = Washout(u=self.vp,
T=self.TF1,
K=self.KF1,
info='Signal conditioner'
)
self.vout.e_str = 'ue * omega * vp - vout'
def __init__(self, system, config):
ExcBase.__init__(self, system, config)
ExcVsum.__init__(self)
self.UEL0.v_str = '-999'
self.OEL0.v_str = '999'
self.flags.nr_iter = True
# NOTE: e_str `KC*XadIfd / INT_y - IN` causes numerical inaccuracies
self.IN = Algeb(tex_name='I_N',
info='Input to FEX',
v_str='1',
v_iter='KC * XadIfd - INT_y * IN',
e_str='ue * (KC * XadIfd - INT_y * 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.FEX.y.v_str = '1'
self.FEX.y.v_iter = self.FEX.y.e_str
# control block begin
self.LG = Lag(self.v, T=self.TR, K=1,
info='Voltage transducer',
)
# input excitation voltages;
self.vi = Algeb(info='Total input voltages',
tex_name='V_i',
unit='p.u.',
e_str='ue * (-LG_y + vref + UEL + OEL + Vs - vi)',
v_str='-v + vref',
diag_eps=True,
)
self.LL = LeadLag(u=self.vi, T1=self.TC, T2=self.TB,
info='V_A, Lead-lag compensator',
zero_out=True,
) # LL_y == VA
self.VAMAXu = ConstService('VAMAX * ue + (1-ue) * 999')
self.VAMINu = ConstService('VAMIN * ue + (1-ue) * -999')
self.LA = LagAntiWindup(u=self.LL_y,
T=self.TA,
K=self.KA,
upper=self.VAMAXu,
lower=self.VAMINu,
info='V_A, Anti-windup lag',
) # LA_y == VA
self.HVG = HVGate(u1=self.UEL,
u2=self.LA_y,
info='HVGate for under excitation',
)
self.LVG = LVGate(u1=self.HVG_y,
u2=self.OEL,
info='HVGate for under excitation',
)
self.INTin = 'ue * (LVG_y - VFE)'
ExcACSat.__init__(self)
self.vref.v_str = 'v + VFE / KA'
self.vref0 = PostInitService(info='Initial reference voltage input',
tex_name='V_{ref0}',
v_str='vref',
)
self.WF = Washout(u=self.VFE,
T=self.TF,
K=self.KF,
info='Stablizing circuit feedback',
)
self.vout.e_str = 'ue * FEX_y * INT_y - vout'
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):
ExcBase.__init__(self, system, config)
self.vref0 = ConstService(
info='Initial reference voltage input',
tex_name='V_{ref0}',
v_str='v + vf0 / KA',
)
self.vref = Algeb(info='Reference voltage input',
tex_name='V_{ref}',
unit='p.u.',
v_str='vref0',
e_str='vref0 - vref')
# input excitation voltages; PSS outputs summed at vi
self.vi = Algeb(
info='Total input voltages',
tex_name='V_i',
unit='p.u.',
)
self.vi.v_str = 'vf0 / KA'
self.vi.e_str = '(vref - LG_y - WF_y) - vi'
self.LG = Lag(
u=self.v,
T=self.TR,
K=1,
info='Sensing delay',
)
self.HLI = HardLimiter(
u=self.vi,
lower=self.VIMIN,
upper=self.VIMAX,
info='Hard limiter on input',
)
self.vl = Algeb(
info='Input after limiter',
tex_name='V_l',
v_str='HLI_zi*vi + HLI_zu*VIMAX + HLI_zl*VIMIN',
e_str='HLI_zi*vi + HLI_zu*VIMAX + HLI_zl*VIMIN - vl',
)
self.LL = LeadLag(u=self.vl,
T1=self.TC,
T2=self.TB,
info='Lead-lag compensator',
zero_out=True)
self.LR = Lag(u=self.LL_y, T=self.TA, K=self.KA, info='Regulator')
self.WF = Washout(u=self.LR_y,
T=self.TF,
K=self.KF,
info='Stablizing circuit feedback')
# the following uses `XadIfd` for `IIFD` in the PSS/E manual
self.vfmax = Algeb(
info='Upper bound of output limiter',
tex_name='V_{fmax}',
v_str='VRMAX - KC * XadIfd',
e_str='VRMAX - KC * XadIfd - vfmax',
)
self.vfmin = Algeb(
info='Lower bound of output limiter',
tex_name='V_{fmin}',
v_str='VRMIN - KC * XadIfd',
e_str='VRMIN - KC * XadIfd - vfmin',
)
self.HLR = HardLimiter(u=self.WF_y,
lower=self.vfmin,
upper=self.vfmax,
info='Hard limiter on regulator output')
self.vout.e_str = 'LR_y*HLR_zi + vfmin*HLR_zl + vfmax*HLR_zu - vout'
def __init__(self, system, config):
ExcBase.__init__(self, system, config)
# Set VRMAX to 999 when VRMAX = 0
self._zVRM = FlagValue(
self.VRMAX,
value=0,
tex_name='z_{VRMAX}',
)
self.VRMAXc = ConstService(
v_str='VRMAX + 999*(1-_zVRM)',
info='Set VRMAX=999 when zero',
)
self.LG = Lag(
u=self.v,
T=self.TR,
K=1,
info='Transducer delay',
)
self.SAT = ExcQuadSat(
self.E1,
self.SE1,
self.E2,
self.SE2,
info='Field voltage saturation',
)
self.Se0 = ConstService(
tex_name='S_{e0}',
v_str='(vf0>SAT_A) * SAT_B*(SAT_A-vf0) ** 2 / vf0',
)
self.vfe0 = ConstService(
v_str='vf0 * (KE + Se0)',
tex_name='V_{FE0}',
)
self.vref0 = ConstService(
info='Initial reference voltage input',
tex_name='V_{ref0}',
v_str='v + vfe0 / KA',
)
self.vref = Algeb(info='Reference voltage input',
tex_name='V_{ref}',
unit='p.u.',
v_str='vref0',
e_str='vref0 - vref')
self.vi = Algeb(
info='Total input voltages',
tex_name='V_i',
unit='p.u.',
v_str='vref0 - v',
e_str='(vref - v - WF_y) - vi',
)
self.LL = LeadLag(
u=self.vi,
T1=self.TC,
T2=self.TB,
info='Lead-lag compensator',
zero_out=True,
)
self.UEL = Algeb(info='Interface var for under exc. limiter',
tex_name='U_{EL}',
v_str='0',
e_str='0 - UEL')
self.HG = HVGate(
u1=self.UEL,
u2=self.LL_y,
info='HVGate for under excitation',
)
self.VRU = VarService(
v_str='VRMAXc * v',
tex_name='V_T V_{RMAX}',
)
self.VRL = VarService(
v_str='VRMIN * v',
tex_name='V_T V_{RMIN}',
)
# TODO: WARNING: HVGate is temporarily skipped
self.LA = LagAntiWindup(
u=self.LL_y,
T=self.TA,
K=self.KA,
upper=self.VRU,
lower=self.VRL,
info='Anti-windup lag',
) # LA_y == VR
# `LessThan` may be causing memory issue in (SL_z0 * vout) - uncertain yet
self.SL = LessThan(u=self.vout,
bound=self.SAT_A,
equal=False,
enable=True,
cache=False)
self.Se = Algeb(
tex_name=r"S_e(|V_{out}|)",
info='saturation output',
v_str='Se0',
e_str='SL_z0 * (INT_y - SAT_A) ** 2 * SAT_B / INT_y - Se',
)
self.VFE = Algeb(info='Combined saturation feedback',
tex_name='V_{FE}',
unit='p.u.',
v_str='vfe0',
e_str='INT_y * (KE + Se) - VFE')
self.INT = Integrator(
u='LA_y - VFE',
T=self.TE,
K=1,
y0=self.vf0,
info='Integrator',
)
self.WF = Washout(u=self.INT_y,
T=self.TF1,
K=self.KF,
info='Feedback to input')
self.vout.e_str = 'INT_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):
PSSBase.__init__(self, system, 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.dv = Derivative(self.v)
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=[1, 2, 3, 4, 5, 6],
)
self.sig = Algeb(
tex_name='S_{ig}',
info='Input signal',
)
self.sig.v_str = 'SW_s0*(omega-1) + SW_s1*0 + SW_s2*(tm0/SnSb) + ' \
'SW_s3*(tm-tm0) + SW_s4*v + SW_s5*0'
self.sig.e_str = 'SW_s0*(omega-1) + SW_s1*(f-1) + SW_s2*(te/SnSb) + ' \
'SW_s3*(tm-tm0) + SW_s4*v + SW_s5*dv_v - sig'
self.F1 = Lag2ndOrd(u=self.sig, K=1, T1=self.A1, T2=self.A2)
self.F2 = LeadLag2ndOrd(u=self.F1_y,
T1=self.A3,
T2=self.A4,
T3=self.A5,
T4=self.A6,
zero_out=True)
self.LL1 = LeadLag(u=self.F2_y, T1=self.T1, T2=self.T2, zero_out=True)
self.LL2 = LeadLag(u=self.LL1_y, T1=self.T3, T2=self.T4, zero_out=True)
self.Vks = Gain(u=self.LL2_y, K=self.KS)
self.WO = WashoutOrLag(u=self.Vks_y,
T=self.T6,
K=self.T5,
name='WO',
zero_out=True) # WO_y == Vss
self.VLIM = Limiter(u=self.WO_y,
lower=self.LSMIN,
upper=self.LSMAX,
info='Vss limiter')
self.Vss = Algeb(
tex_name='V_{ss}',
info='Voltage output before output limiter',
e_str='VLIM_zi * WO_y + VLIM_zu * LSMAX + VLIM_zl * LSMIN - Vss')
self.OLIM = Limiter(u=self.v,
lower=self.VCLr,
upper=self.VCUr,
info='output limiter')
self.vsout.e_str = 'OLIM_zi * Vss - vsout'
def __init__(self, system, config):
ExcBase.__init__(self, system, config)
self.Se0 = ConstService(
info='Initial saturation output',
tex_name='S_{e0}',
v_str='Ae * exp(Be * vf0)',
)
self.vr0 = ConstService(info='Initial vr',
tex_name='V_{r0}',
v_str='(KE + Se0) * vf0')
self.vb0 = ConstService(info='Initial vb',
tex_name='V_{b0}',
v_str='vr0 / KA')
self.vref0 = ConstService(info='Initial reference voltage input',
tex_name='V_{ref0}',
v_str='vb0 + v')
self.Se = Algeb(info='Saturation output',
tex_name='S_e',
unit='p.u.',
v_str='Se0',
e_str='Ae * exp(Be * vout) - Se')
self.vp = State(
info='Voltage after saturation feedback, before speed term',
tex_name='V_p',
unit='p.u.',
v_str='vf0',
e_str='(LA_x - KE * vp - Se * vp) / TE')
self.LS = Lag(u=self.v, T=self.TR, K=1.0, info='Sensing lag TF')
self.vref = Algeb(info='Reference voltage input',
tex_name='V_{ref}',
unit='p.u.',
v_str='vref0',
e_str='vref0 - vref')
self.vi = Algeb(
info='Total input voltages',
tex_name='V_i',
unit='p.u.',
v_str='vb0',
e_str='(vref - LS_x - W_y) - vi',
)
self.LL = LeadLag(
u=self.vi,
T1=self.TC,
T2=self.TB,
info='Lead-lag for internal delays',
)
self.LA = LagAntiWindup(
u=self.LL_y,
T=self.TA,
K=self.KA,
upper=self.VRMAX,
lower=self.VRMIN,
info='Anti-windup lag',
)
self.W = Washout(
u=self.vp,
T=self.TF1,
K=self.KF1,
)
self.vout.e_str = 'omega * vp - vout'
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):
TG2Data.__init__(self)
TGBase.__init__(self, system, config)
self.config.add({'deadband': 0, 'hardlimit': 1})
self.config.add_extra("_help",
deadband="enable input dead band",
hardlimit="enable output hard limit")
self.config.add_extra(
"_alt",
deadband=(0, 1),
hardlimit=(0, 1),
)
self.config.add_extra(
"_tex",
deadband="z_{deadband}",
hardlimit="z_{hardlimit}",
)
self.gain = ConstService(
v_str='u / R',
tex_name='G',
)
self.w_d = Algeb(
info=
'Generator speed deviation before dead band (positive for under speed)',
tex_name=r'\omega_{dev}',
v_str='0',
e_str='u*(wref-omega) - w_d',
)
self.w_db = DeadBandRT(
u=self.w_d,
center=self.dbc,
lower=self.dbl,
upper=self.dbu,
enable=self.config.deadband,
)
self.w_dm = Algeb(info='Measured speed deviation after dead band',
tex_name=r'\omega_{dm}',
v_str='0',
e_str='(1 - w_db_zi) * w_d + '
'w_db_zlr * dbl + '
'w_db_zur * dbu - '
'w_dm')
self.w_dmg = Algeb(
info='Speed deviation after dead band after gain',
tex_name=r'\omega_{dmG}',
v_str='0',
e_str='gain * w_dm - w_dmg',
)
self.ll = LeadLag(
u=self.w_dmg,
T1=self.T1,
T2=self.T2,
)
self.pnl = Algeb(
info='Power output before hard limiter',
tex_name='P_{nl}',
v_str='tm0',
e_str='tm0 + ll_y - pnl',
)
self.plim = HardLimiter(
u=self.pnl,
lower=self.pmin,
upper=self.pmax,
enable=self.config.hardlimit,
)
self.pout.e_str = 'pnl * plim_zi + pmax * plim_zu + pmin * plim_zl - pout'
def __init__(self, system, config):
ExcBase.__init__(self, system, config)
self.flags.nr_iter = True
self.SAT = ExcQuadSat(self.E1, self.SE1, self.E2, self.SE2,
info='Field voltage saturation',
)
self.SL = LessThan(u=self.vout, bound=self.SAT_A, equal=False, enable=True, cache=False)
self.Se0 = ConstService(info='Initial saturation output',
tex_name='S_{e0}',
v_str='Indicator(vf0>SAT_A) * SAT_B * (SAT_A - vf0) ** 2 / vf0',
)
self.IN = Algeb(tex_name='I_N',
info='Input to FEX',
v_str='1',
v_iter='KC * XadIfd - INT_y * IN',
e_str='KC * XadIfd / INT_y - 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.FEX.y.v_iter = '1'
self.FEX.y.v_iter = self.FEX.y.e_str
self.LG = Lag(self.v, T=self.TR, K=1,
info='Voltage transducer',
)
self.vi = Algeb(info='Total input voltages',
tex_name='V_i',
unit='p.u.',
e_str='-v + vref - WF_y - vi',
v_str='-v + vref',
)
self.LL = LeadLag(u=self.vi, T1=self.TC, T2=self.TB,
info='Regulator',
zero_out=True,
)
self.LA = LagAntiWindup(u=self.LL_y,
T=self.TA,
K=self.KA,
lower=self.VRMIN,
upper=self.VRMAX,
info='Lag AW on VR',
)
self.INT = Integrator(u='LA_y - VFE',
T=self.TE,
K=1,
y0=0,
info='Integrator',
)
self.INT.y.v_str = 0.1
self.INT.y.v_iter = 'INT_y * FEX_y - vf0'
self.Se = Algeb(tex_name=r"S_e(|V_{out}|)", info='saturation output',
v_str='Se0',
e_str='SL_z0 * (INT_y - SAT_A) ** 2 * SAT_B / INT_y - Se',
)
self.VFE = Algeb(info='Combined saturation feedback',
tex_name='V_{FE}',
unit='p.u.',
v_str='INT_y * (KE + Se) + XadIfd * KD',
e_str='INT_y * (KE + Se) + XadIfd * KD - VFE'
)
self.vref = Algeb(info='Reference voltage input',
tex_name='V_{ref}',
unit='p.u.',
v_str='v + VFE / KA',
e_str='vref0 - vref',
)
self.vref0 = PostInitService(info='Initial reference voltage input',
tex_name='V_{ref0}',
v_str='vref',
)
self.WF = Washout(u=self.VFE,
T=self.TF,
K=self.KF,
info='Stablizing circuit feedback',
)
self.vout.e_str = 'INT_y * FEX_y - vout'
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'
