def __init__(self, u, T1, T2, T3, T4, zero_out=False, name=None, tex_name=None, info=None):
super(LeadLag2ndOrd, self).__init__(name=name, tex_name=tex_name, info=info)
self.u = dummify(u)
self.T1 = dummify(T1)
self.T2 = dummify(T2)
self.T3 = dummify(T3)
self.T4 = dummify(T4)
self.zero_out = zero_out
self.enforce_tex_name((self.T1, self.T2, self.T3, self.T4))
self.x1 = State(info='State #1 in 2nd order lead-lag', tex_name="x'", t_const=self.T2)
self.x2 = State(info='State #2 in 2nd order lead-lag', tex_name="x''")
self.y = Algeb(info='Output of 2nd order lead-lag', tex_name='y', diag_eps=1e-6)
self.vars = {'x1': self.x1, 'x2': self.x2, 'y': self.y}
if self.zero_out is True:
self.LT1 = LessThan(T1, dummify(0), equal=True, enable=zero_out, tex_name='LT',
cache=True, z0=1, z1=0)
self.LT2 = LessThan(T2, dummify(0), equal=True, enable=zero_out, tex_name='LT',
cache=True, z0=1, z1=0)
self.LT3 = LessThan(T4, dummify(0), equal=True, enable=zero_out, tex_name='LT',
cache=True, z0=1, z1=0)
self.LT4 = LessThan(T4, dummify(0), equal=True, enable=zero_out, tex_name='LT',
cache=True, z0=1, z1=0)
self.x2.discrete = (self.LT1, self.LT2, self.LT3, self.LT4)
self.vars['LT1'] = self.LT1
self.vars['LT2'] = self.LT2
self.vars['LT3'] = self.LT3
self.vars['LT4'] = self.LT4
def __init__(self,
u,
T1,
T2,
T3,
T4,
name=None,
tex_name=None,
info='2nd-order lead-lag'):
super(LeadLag2ndOrd, self).__init__(name=name,
tex_name=tex_name,
info=info)
self.u = u
self.T1 = dummify(T1)
self.T2 = dummify(T2)
self.T3 = dummify(T3)
self.T4 = dummify(T4)
self.enforce_tex_name((self.T1, self.T2, self.T3, self.T4))
self.x1 = State(info='State #1 in 2nd order lead-lag',
tex_name="x'",
t_const=self.T2)
self.x2 = State(info='State #2 in 2nd order lead-lag', tex_name="x''")
self.y = Algeb(info='Output of 2nd order lead-lag',
tex_name='y',
diag_eps=1e-6)
self.vars = {'x1': self.x1, 'x2': self.x2, 'y': self.y}
def __init__(self, system, config):
DC2Term.__init__(self, system, config)
self.flags.pflow = True
self.group = 'DCLink'
self.R = NumParam(
unit='p.u.',
tex_name='R',
info='DC line resistance',
non_zero=True,
default=0.01,
r=True,
)
self.L = NumParam(
unit='p.u.',
tex_name='L',
info='DC line inductance',
non_zero=True,
default=0.001,
r=True,
)
self.C = NumParam(
unit='p.u.',
tex_name='C',
info='DC capacitance',
non_zero=True,
default=0.001,
g=True,
)
self.IL = State(
tex_name='I_L',
info='Inductance current',
unit='p.u.',
v_str='0',
e_str='u * vC',
t_const=self.L,
)
self.vC = State(
tex_name='v_C',
info='Capacitor current',
unit='p.u.',
e_str='-u * (Idc - vC/R - IL)',
v_str='v1 - v2',
t_const=self.C,
)
self.Idc = Algeb(
tex_name='I_{dc}',
info='Current from node 2 to 1',
unit='p.u.',
e_str='u * (vC - (v1 - v2)) + '
'(1 - u) * Idc',
v_str='-(v1 - v2) / R',
diag_eps=True,
)
self.v1.e_str = '-Idc'
self.v2.e_str = '+Idc'
def __init__(self):
self.psid = State(tex_name=r'\psi_d',
v_str='psid0',
e_str='u * 2 * pi * fn * (ra * Id + vd + omega * psiq)',
)
self.psiq = State(tex_name=r'\psi_q',
v_str='psiq0',
e_str='u * 2 * pi * fn * (ra * Iq + vq - omega * psid)',
)
self.Id.e_str += '+ psid'
self.Iq.e_str += '+ psiq'
def __init__(self, system, config):
DC2Term.__init__(self, system, config)
self.flags['pflow'] = True
self.group = 'DCLink'
self.R = NumParam(
unit='p.u.',
info='DC line resistance',
non_zero=True,
default=0.01,
r=True,
)
self.L = NumParam(
unit='p.u.',
info='DC line inductance',
non_zero=True,
default=0.001,
r=True,
)
self.C = NumParam(
unit='p.u.',
info='DC capacitance',
non_zero=True,
default=0.001,
g=True,
)
self.IL = State(
tex_name='I_L',
info='Inductance current',
unit='p.u.',
e_str='u * (v1 - v2 - R * IL - vC) / L',
v_str='0',
)
self.vC = State(
tex_name='v_C',
info='Capacitor current',
unit='p.u.',
e_str='u * IL / C',
v_str='v1 - v2',
)
self.Idc = Algeb(
tex_name='I_{dc}',
info='Current from node 2 to 1',
unit='p.u.',
e_str='-IL - Idc',
v_str='0',
diag_eps=1e-6,
)
self.v1.e_str = '-Idc'
self.v2.e_str = '+Idc'
def __init__(self, u, K, T1, T2, name=None, tex_name=None, info=None):
super(Lag2ndOrd, self).__init__(name=name, tex_name=tex_name, info=info)
self.u = dummify(u)
self.K = dummify(K)
self.T1 = dummify(T1)
self.T2 = dummify(T2)
self.enforce_tex_name((self.K, self.T1, self.T2))
self.x = State(info='State in 2nd order LPF', tex_name="x'", t_const=self.T2)
self.y = State(info='Output of 2nd order LPF', tex_name='y')
self.vars = {'x': self.x, 'y': self.y}
def __init__(self, system, config):
TGBase.__init__(self, system, config)
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='u * (wref - omega) - wd',
)
self.pd = Algeb(info='Pref plus under speed times gain',
unit='p.u.',
tex_name="P_d",
v_str='tm0',
e_str='(wd + pref) * gain - pd')
self.LAG_y = State(
info='State in lag transfer function',
tex_name=r"x'_{LAG}",
e_str='LAG_lim_zi * (1 * pd - LAG_y)',
t_const=self.T1,
v_str='pd',
)
self.LAG_lim = AntiWindup(
u=self.LAG_y,
lower=self.VMIN,
upper=self.VMAX,
tex_name='lim_{lag}',
)
self.LL_x = State(info='State in lead-lag transfer function',
tex_name="x'_{LL}",
v_str='LAG_y',
e_str='(LAG_y - LL_x)',
t_const=self.T3)
self.LL_y = Algeb(
info='Lead-lag Output',
tex_name='y_{LL}',
v_str='LAG_y',
e_str='T2 / T3 * (LAG_y - LL_x) + LL_x - LL_y',
)
self.pout.e_str = '(LL_y + Dt * wd) - pout'
def __init__(self,
u,
T,
K,
y0,
lower,
upper,
name=None,
tex_name=None,
info=None):
super().__init__(name=name, tex_name=tex_name, info=info)
self.u = dummify(u)
self.T = dummify(T)
self.K = dummify(K)
self.y0 = dummify(y0)
self.lower = dummify(lower)
self.upper = dummify(upper)
self.enforce_tex_name((self.K, self.T))
self.y = State(info='AW Integrator output',
tex_name='y',
t_const=self.T)
self.lim = AntiWindup(
u=self.y,
lower=self.lower,
upper=self.upper,
tex_name='lim',
info='Limiter in integrator',
)
self.vars = {'y': self.y, 'lim': self.lim}
def __init__(self,
u,
T1,
T2,
lower,
upper,
name=None,
tex_name=None,
info=None):
super().__init__(name=name, tex_name=tex_name, info=info)
self.u = dummify(u)
self.T1 = dummify(T1)
self.T2 = dummify(T2)
self.lower = lower
self.upper = upper
self.enforce_tex_name((self.T1, self.T2))
self.x = State(info='State in lead-lag TF',
tex_name="x'",
t_const=self.T2)
self.ynl = Algeb(info='Output of lead-lag TF before limiter',
tex_name=r'y_{nl}')
self.y = Algeb(info='Output of lead-lag TF after limiter',
tex_name=r'y',
diag_eps=1e-6)
self.lim = AntiWindup(u=self.ynl, lower=self.lower, upper=self.upper)
self.vars = {
'x': self.x,
'ynl': self.ynl,
'y': self.y,
'lim': self.lim
}
def __init__(self, system, config):
DC2Term.__init__(self, system, config)
self.flags.pflow = True
self.group = 'DCLink'
self.R = NumParam(unit='p.u.',
tex_name='R',
info='DC line resistance',
non_zero=True,
default=0.01,
r=True,
)
self.L = NumParam(unit='p.u.',
tex_name='L',
info='DC line inductance',
non_zero=True,
default=0.001,
r=True,
)
self.IL = State(tex_name='I_L',
info='Inductance current',
unit='p.u.',
e_str='u * (v1 - v2 - R * IL) / L',
v_str='(v1 - v2) / R',
)
self.Idc = Algeb(tex_name='I_{dc}',
info='Current from node 2 to 1',
unit='p.u.',
e_str='-u * IL - Idc',
v_str='-u * (v1 - v2) / R',
)
self.v1.e_str = '-Idc'
self.v2.e_str = '+Idc'
def __init__(self,
u,
T,
K,
lower,
upper,
name=None,
tex_name=None,
info=None):
super().__init__(name=name, tex_name=tex_name, info=info)
self.u = dummify(u)
self.T = dummify(T)
self.K = dummify(K)
self.lower = lower
self.upper = upper
self.enforce_tex_name((self.T, self.K))
self.y = State(info='State in lag TF', tex_name="y", t_const=self.T)
self.lim = AntiWindup(u=self.y,
lower=self.lower,
upper=self.upper,
tex_name='lim',
info='Limiter in Lag')
self.vars = {'y': self.y, 'lim': self.lim}
def __init__(self, u, T, K,
lower, upper, rate_lower, rate_upper,
no_lower=False, no_upper=False, rate_no_lower=False, rate_no_upper=False,
rate_lower_cond=None, rate_upper_cond=None,
name=None, tex_name=None, info=None):
super().__init__(name=name, tex_name=tex_name, info=info)
self.u = dummify(u)
self.T = dummify(T)
self.K = dummify(K)
self.lower = dummify(lower)
self.upper = dummify(upper)
self.enforce_tex_name((self.T, self.K))
self.y = State(info='State in lag TF', tex_name="y",
t_const=self.T,
)
self.lim = AntiWindupRate(u=self.y, lower=self.lower, upper=self.upper,
rate_lower=rate_lower, rate_upper=rate_upper,
no_lower=no_lower, no_upper=no_upper,
rate_no_lower=rate_no_lower, rate_no_upper=rate_no_upper,
rate_lower_cond=rate_lower_cond, rate_upper_cond=rate_upper_cond,
tex_name='lim',
info='Limiter in Lag',
)
self.vars = {'y': self.y, 'lim': self.lim}
def __init__(self, system, config):
DC2Term.__init__(self, system, config)
self.flags['pflow'] = True
self.group = 'DCLink'
self.C = NumParam(
unit='p.u.',
info='DC capacitance',
non_zero=True,
default=0.001,
g=True,
)
self.vC = State(
tex_name='v_C',
info='Capacitor current',
unit='p.u.',
v_str='0',
e_str='-u * Idc / C',
)
self.Idc = Algeb(
tex_name='I_{dc}',
info='Current from node 2 to 1',
unit='p.u.',
v_str='0',
e_str='u * (vC - (v1 - v2)) + '
'(1 - u) * Idc',
diag_eps=1e-6,
)
self.v1.e_str = '-Idc'
self.v2.e_str = '+Idc'
def __init__(self,
u,
T1,
T2,
lower,
upper,
name=None,
info='Lead-lag transfer function'):
super().__init__(name=name, info=info)
self.T1 = T1
self.T2 = T2
self.u = u
self.lower = lower
self.upper = upper
self.x = State(info='State in lead-lag transfer function',
tex_name="x'")
self.ynl = Algeb(
info='Output of lead-lag transfer function before limiter',
tex_name=r'y_{nl}')
self.y = Algeb(
info='Output of lead-lag transfer function after limiter',
tex_name=r'y')
self.lim = HardLimiter(u=self.ynl, lower=self.lower, upper=self.upper)
self.vars = {
'x': self.x,
'ynl': self.ynl,
'y': self.y,
'lim': self.lim
}
def __init__(self,
u,
T,
K,
lower,
upper,
name=None,
info='Lag transfer function with non-windup limiter'):
super().__init__(name=name, info=info)
if isinstance(K, (int, float)):
self.K = DummyValues(K)
else:
self.K = K
self.u = u
self.T = T
self.lower = lower
self.upper = upper
self.x = State(info='State in lag transfer function', tex_name="x'")
self.lim = AntiWindupLimiter(u=self.x,
lower=self.lower,
upper=self.upper,
tex_name='lim')
self.vars = {'x': self.x, 'lim': self.lim}
def __init__(self,
u,
T,
K,
lower,
upper,
name=None,
info='Lag transfer function with non-windup limiter'):
super().__init__(name=name, info=info)
self.u = u
self.T = dummify(T)
self.K = dummify(K)
self.lower = lower
self.upper = upper
self.enforce_tex_name((self.T, self.K))
self.x = State(info='State in lag transfer function',
tex_name="x'",
t_const=self.T)
self.lim = AntiWindupLimiter(u=self.x,
lower=self.lower,
upper=self.upper,
tex_name='lim')
self.vars = {'x': self.x, 'lim': self.lim}
def __init__(self, system, config):
MotorBaseModel.__init__(self, system, config)
self.x2 = ConstService(
v_str='xs + xr1*xr2*xm / (xr1*xr2 + xr1*xm + xr2*xm)',
tex_name="x''",
)
self.T20 = ConstService(
v_str='(xr2 + xr1*xm / (xr1 + xm) ) / (wb * rr2)',
tex_name="T''_0",
)
self.e2d = State(
info='real part of 2nd cage voltage',
e_str='u * '
'(-wb*slip*(e1q - e2q) + '
'(wb*slip*e1q - (e1d + (x0 - x1) * Iq)/T10) + '
'(e1d - e2d - (x1 - x2) * Iq)/T20)',
v_str='0.05 * u',
tex_name="e''_d",
diag_eps=True,
)
self.e2q = State(
info='imag part of 2nd cage voltage',
e_str='u * '
'(wb*slip*(e1d - e2d) + '
'(-wb*slip*e1d - (e1q - (x0 - x1) * Id)/T10) + '
'(e1q - e2q + (x1 - x2) * Id) / T20)',
v_str='0.9 * u',
tex_name="e''_q",
diag_eps=True,
)
self.Id.e_str = 'u * (vd - e2d - rs * Id + x2 * Iq)'
self.Id.v_str = '0.9 * u'
self.Iq.e_str = 'u * (vq - e2q - rs * Iq - x2 * Id)'
self.Iq.v_str = '0.1 * u'
self.te.v_str = 'u * (e2d * Id + e2q * Iq)'
self.te.e_str = f'{self.te.v_str} - te'
def __init__(self, system, config):
Model.__init__(self, system, config)
self.group = 'Experimental'
self.flags.update({'tds': True})
self.uin = State(
v_str=0,
e_str=
'Piecewise((0, dae_t<= 0), (1, dae_t <= 2), (-1, dae_t <6), (1, True))',
)
self.x = State(
e_str='uin * Ki * HL_zi',
v_str=0.05,
)
self.y = Algeb(e_str='uin * Kp + x - y', v_str=0.05)
self.HL = HardLimiter(u=self.y, lower=self.Wmin, upper=self.Wmax)
self.w = Algeb(e_str='HL_zi * y + HL_zl * Wmin + HL_zu * Wmax - w',
v_str=0.05)
def __init__(self, u, T, K, name=None, tex_name=None, info=None):
super().__init__(name=name, tex_name=tex_name, info=info)
self.u = dummify(u)
self.T = dummify(T)
self.K = dummify(K)
self.enforce_tex_name((self.K, self.T))
self.x = State(info='State in washout filter', tex_name="x'", t_const=self.T)
self.y = Algeb(info='Output of washout filter', tex_name=r'y', diag_eps=1e-6)
self.vars.update({'x': self.x, 'y': self.y})
def __init__(self, u, T, K, y0, name=None, tex_name=None, info=None):
super().__init__(name=name, tex_name=tex_name, info=info)
self.u = dummify(u)
self.K = dummify(K)
self.T = dummify(T)
self.y0 = dummify(y0)
self.enforce_tex_name((self.K, self.T))
self.y = State(info='Integrator output', tex_name='y', t_const=self.T)
self.vars = {'y': self.y}
def __init__(self, u, T, K, name=None, tex_name=None, info=None):
super().__init__(name=name, tex_name=tex_name, info=info)
self.u = dummify(u)
self.T = dummify(T)
self.K = dummify(K)
self.enforce_tex_name((self.K, self.T))
self.y = State(info='State in lag transfer function', tex_name="y",
t_const=self.T)
self.vars = {'y': self.y}
def __init__(self, u, T, K, name=None, info='Lag transfer function'):
super().__init__(name=name, info=info)
self.u = u
self.T = dummify(T)
self.K = dummify(K)
self.enforce_tex_name((self.K, self.T))
self.x = State(info='State in lag transfer function',
tex_name="x'",
t_const=self.T)
self.vars = {'x': self.x}
def __init__(self, u, T1, T2, name=None, info='Lead-lag transfer function', safe_div=True):
super().__init__(name=name, info=info)
self.T1 = T1
self.T2 = T2
self.u = u
self.safe_div = safe_div # TODO: implement me
self.enforce_tex_name((self.T1, self.T2))
self.x = State(info='State in lead-lag transfer function', tex_name="x'")
self.y = Algeb(info='Output of lead-lag transfer function', tex_name=r'y')
self.vars = {'x': self.x, 'y': self.y}
def __init__(self, u, ref, kp, ki, name=None, info=None):
super().__init__(name=name, info=info)
self.u = u
self.ref = ref
self.kp = kp
self.ki = ki
self.xi = State(info="Integration value of PI controller")
self.y = Algeb(info="Output value")
self.vars = {'xi': self.xi, 'y': self.y}
def __init__(self, u, T, K, name=None, info='Lag transfer function'):
super().__init__(name=name, info=info)
self.u = u
self.T = T
if isinstance(K, (int, float)):
self.K = DummyValues(K)
else:
self.K = K
self.enforce_tex_name((self.K, self.T))
self.x = State(info='State in lag transfer function', tex_name="x'")
self.vars = {'x': self.x}
def __init__(self, u, kp, ki, ref=0.0, x0=0.0, name=None, tex_name=None, info=None):
Block.__init__(self, name=name, tex_name=tex_name, info=info)
self.u = u
self.kp = dummify(kp)
self.ki = dummify(ki)
self.ref = dummify(ref)
self.x0 = dummify(x0)
self.xi = State(info="Integrator output", tex_name='xi')
self.y = Algeb(info="PI output", tex_name='y')
self.vars = {'xi': self.xi, 'y': self.y}
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, u, kp, ki, ref=0.0, name=None, tex_name=None, info=None):
super().__init__(name=name, tex_name=tex_name, info=info)
self.u = u
self.ref = dummify(ref)
self.kp = dummify(kp)
self.ki = dummify(ki)
self.xi = State(info="Integrator value")
self.y = Algeb(info="PI output")
self.vars = {'xi': self.xi, 'y': self.y}
self.flags.update({'f_num': True, 'g_num': True, 'j_num': True})
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,
u,
T1,
T2,
K=1,
zero_out=True,
name=None,
tex_name=None,
info=None):
super().__init__(name=name, tex_name=tex_name, info=info)
self.u = dummify(u)
self.T1 = dummify(T1)
self.T2 = dummify(T2)
self.K = dummify(K)
self.zero_out = zero_out
self.enforce_tex_name((self.T1, self.T2))
self.x = State(info='State in lead-lag',
tex_name="x'",
t_const=self.T2)
self.y = Algeb(info='Output of lead-lag', tex_name=r'y', diag_eps=1e-6)
self.vars = {'x': self.x, 'y': self.y}
if self.zero_out is True:
self.LT1 = LessThan(T1,
dummify(0),
equal=True,
enable=zero_out,
tex_name='LT',
cache=True,
z0=1,
z1=0)
self.LT2 = LessThan(T2,
dummify(0),
equal=True,
enable=zero_out,
tex_name='LT',
cache=True,
z0=1,
z1=0)
self.x.discrete = (self.LT1, self.LT2)
self.vars['LT1'] = self.LT1
self.vars['LT2'] = self.LT2
