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,
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_ext: Union[int, float, BaseParam, BaseService] = 0.0,
trig: str = 'rise',
enable=True,
v_disabled=0,
extend_only=False,
vtype: Optional[type] = None,
name: Optional[str] = None,
tex_name=None,
info=None):
VarService.__init__(self,
v_numeric=self.check,
vtype=vtype,
name=name,
tex_name=tex_name,
info=info)
self.u = dummify(u)
self.t_ext = dummify(t_ext)
self.enable = dummify(enable)
self.v_disabled = v_disabled
self.extend_only = extend_only
self.t_final = None
self.trig = trig
self.v_event = None
self.u_last = None
self.z = None # if is in an extended event (from event start to extension end)
self.n_ext = 0 # number of extended events
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,
u,
lower=None,
upper=None,
equal=None,
not_equal=None,
enable=True,
error_out=False,
**kwargs):
super().__init__(**kwargs)
self.u = u
self.lower = dummify(lower) if lower is not None else None
self.upper = dummify(upper) if upper is not None else None
self.equal = dummify(equal) if equal is not None else None
self.not_equal = dummify(not_equal) if not_equal is not None else None
self.enable = enable
self.error_out = error_out
self.checks = [
(self.lower, np.less_equal, "out of typical lower limit", "limit"),
(self.upper, np.greater_equal, "out of typical upper limit",
"limit"),
(self.equal, lambda a, b: np.logical_not(np.isclose(a, b)),
'should be equal', "expected"),
(self.not_equal, np.equal, 'should not be equal', "not expected")
]
def __init__(self,
u,
K,
upper,
lower,
no_upper=False,
no_lower=False,
name=None,
tex_name=None,
info=None):
Block.__init__(self, name=name, tex_name=tex_name, info=info)
self.u = dummify(u)
self.K = dummify(K)
self.upper = upper
self.lower = lower
if (no_upper and no_lower) is True:
raise ValueError("no_upper or no_lower cannot both be True")
self.no_lower = no_lower
self.no_upper = no_upper
self.x = Algeb(info='Gain output before limiter', tex_name='x')
self.y = Algeb(info='Gain output after limiter', tex_name='y')
self.lim = HardLimiter(u=self.x,
lower=self.lower,
upper=self.upper,
no_upper=no_upper,
no_lower=no_lower,
tex_name='lim')
self.vars = {'lim': self.lim, 'x': self.x, 'y': self.y}
def __init__(self, u, hold, vtype=None, name=None, tex_name=None, info=None):
VarService.__init__(self, v_numeric=self.check, vtype=vtype,
name=name, tex_name=tex_name, info=info,
)
self.u = dummify(u)
self.hold = dummify(hold)
self._init = False
def __init__(self,
u,
lower,
upper,
enable=True,
name=None,
tex_name=None,
info=None,
min_iter: int = 2,
err_tol: float = 0.01,
no_lower=False,
no_upper=False,
sign_lower=1,
sign_upper=1,
equal=True,
no_warn=False,
zu=0.0,
zl=0.0,
zi=1.0):
Discrete.__init__(self,
name=name,
tex_name=tex_name,
info=info,
min_iter=min_iter,
err_tol=err_tol)
self.u = u
self.lower = dummify(lower)
self.upper = dummify(upper)
self.enable = enable
self.no_lower = no_lower
self.no_upper = no_upper
if sign_lower not in (1, -1):
raise ValueError("sign_lower must be 1 or -1, got %s" % sign_lower)
if sign_upper not in (1, -1):
raise ValueError("sign_upper must be 1 or -1, got %s" % sign_upper)
self.sign_lower = dummify(sign_lower)
self.sign_upper = dummify(sign_upper)
self.equal = equal
self.no_warn = no_warn
self.zu = np.array([zu])
self.zl = np.array([zl])
self.zi = np.array([zi])
self.has_check_var = True
self.export_flags.append('zi')
self.export_flags_tex.append('z_i')
if not self.no_lower:
self.export_flags.append('zl')
self.export_flags_tex.append('z_l')
self.warn_flags.append(('zl', 'lower'))
if not self.no_upper:
self.export_flags.append('zu')
self.export_flags_tex.append('z_u')
self.warn_flags.append(('zu', 'upper'))
def __init__(self, u, K, 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.enforce_tex_name((self.K,))
self.y = Algeb(info='Gain output', tex_name='y')
self.vars = {'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, lower=None, upper=None, equal=None, not_equal=None,
enable=True, error_out=False, **kwargs):
super().__init__(**kwargs)
self.u = u
self.lower = dummify(lower) if lower is not None else None
self.upper = dummify(upper) if upper is not None else None
self.equal = dummify(equal) if equal is not None else None
self.not_equal = dummify(not_equal) if not_equal is not None else None
self.enable = enable
self.error_out = error_out
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, 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, 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, u1, u2, name=None, tex_name=None, info=None):
super().__init__(name=name, tex_name=tex_name, info=info)
self.u1 = dummify(u1)
self.u2 = dummify(u2)
self.enforce_tex_name((u1, u2))
self.y = Algeb(info='LVGate output', tex_name='y')
self.sl = Selector(self.u1, self.u2, fun=np.minimum.reduce,
info='LVGate Selector',
)
self.vars = {'y': self.y, 'sl': self.sl}
def __init__(self, E1, SE1, E2, SE2, name=None, tex_name=None, info=None):
Block.__init__(self, name=name, tex_name=tex_name, info=info)
self._E1 = dummify(E1)
self._E2 = dummify(E2)
self._SE1 = SE1
self._SE2 = SE2
self.zSE2 = FlagValue(self._SE2,
value=0.,
info='Flag non-zeros in SE2',
tex_name='z^{SE2}')
# data correction for E1, E2, SE1 (TODO)
self.E1 = ConstService(
tex_name='E^{1c}',
info='Corrected E1 data',
)
self.E2 = ConstService(
tex_name='E^{2c}',
info='Corrected E2 data',
)
self.SE1 = ConstService(
tex_name='SE^{1c}',
info='Corrected SE1 data',
)
self.SE2 = ConstService(
tex_name='SE^{2c}',
info='Corrected SE2 data',
)
self.a = ConstService(
info='Intermediate Sat coeff',
tex_name='a',
)
self.A = ConstService(
info='Saturation start',
tex_name='A^q',
)
self.B = ConstService(
info='Saturation gain',
tex_name='B^q',
)
self.vars = {
'E1': self.E1,
'E2': self.E2,
'SE1': self.SE1,
'SE2': self.SE2,
'zSE2': self.zSE2,
'a': self.a,
'A': self.A,
'B': self.B,
}
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, 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, 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,
u,
period=1.0,
offset=0.0,
name=None,
tex_name=None,
info=None):
Discrete.__init__(self, name=name, tex_name=tex_name, info=info)
self.period = dummify(period)
self.offset = dummify(offset)
self.export_flags = ['v']
self.export_flags_tex = ['v']
def __init__(self, u, center, lower, upper, enable=True,
name=None, tex_name=None, info=None, namespace='local'):
Block.__init__(self, name=name, tex_name=tex_name, info=info, namespace=namespace)
self.u = dummify(u)
self.center = dummify(center)
self.lower = dummify(lower)
self.upper = dummify(upper)
self.enable = enable
self.db = DeadBand(u=u, center=center, lower=lower, upper=upper,
enable=enable, tex_name='db')
self.y = Algeb(info='Deadband type 1 output', tex_name='y', discrete=self.db)
self.vars = {'db': self.db, 'y': self.y}
def __init__(self,
u,
lower,
upper,
enable=True,
name=None,
tex_name=None,
info=None):
Discrete.__init__(self, name=name, tex_name=tex_name, info=info)
self.u = u
self.lower = dummify(lower)
self.upper = dummify(upper)
self.enable = enable
self.has_check_eq = True
def __init__(self,
u,
value=0.0,
flag=1,
equal=False,
name=None,
tex_name=None,
info=None,
cache=True):
self.value = dummify(value)
self.equal = equal
if self.equal is True:
self.func = lambda x: np.greater_equal(x, self.value.v)
else:
self.func = lambda x: np.greater(x, self.value.v)
FlagCondition.__init__(
self,
u,
func=self.func,
flag=flag,
name=name,
tex_name=tex_name,
info=info,
cache=cache,
)
def __init__(self,
u,
bound,
equal=False,
enable=True,
name=None,
tex_name=None,
info=None,
cache=False,
z0=0,
z1=1):
super().__init__(name=name, tex_name=tex_name, info=info)
self.u = u
self.bound = dummify(bound)
self.equal: bool = equal
self.enable: bool = enable
self.cache: bool = cache
self._eval: bool = False # if has been eval'ed and cached
self.z0 = np.array([z0]) # negation of `self.z1`
self.z1 = np.array(
[z1]) # if the less-than condition (u < bound) is True
self.export_flags = ['z0', 'z1']
self.export_flags_tex = ['z_0', 'z_1']
self.has_check_var = True
def __init__(self,
u,
vtype: Optional[type] = None,
name: Optional[str] = None, tex_name=None, info=None):
VarService.__init__(self, v_numeric=self.check,
vtype=vtype, name=name, tex_name=tex_name, info=info)
self.u = dummify(u)
def __init__(self,
u,
center,
lower,
upper,
enable=True,
equal=False,
zu=0.0,
zl=0.0,
zi=0.0,
name=None,
tex_name=None,
info=None):
Limiter.__init__(self,
u,
lower,
upper,
enable=enable,
equal=equal,
zi=zi,
zl=zl,
zu=zu,
name=name,
tex_name=tex_name,
info=info)
self.center = dummify(center) # CURRENTLY NOT IN USE
def __init__(self, old_val, flt, new_val, name=None, tex_name=None, info=None, cache=True):
BaseService.__init__(self, name=name, tex_name=tex_name, info=info)
self.cache = cache
self.filter = flt # function
self.old_val = old_val
self.new_val = dummify(new_val)
self._v = None
def __init__(self,
u,
lower,
upper,
enable=True,
no_lower=False,
no_upper=False,
lower_cond=None,
upper_cond=None,
name=None,
tex_name=None,
info=None):
Discrete.__init__(self, name=name, tex_name=tex_name, info=info)
self.u = u
self.rate_lower = dummify(lower)
self.rate_upper = dummify(upper)
# `lower_cond` and `upper_cond` are arrays of 0/1 indicating whether
# the corresponding rate limit should be *enabled*.
# 0 - disabled, 1 - enabled.
# If is `None`, all rate limiters will be enabled.
self.rate_lower_cond = dummify(lower_cond)
self.rate_upper_cond = dummify(upper_cond)
self.rate_no_lower = no_lower
self.rate_no_upper = no_upper
self.enable = enable
self.zur = np.array([0])
self.zlr = np.array([0])
self.has_check_eq = True
# Note: save ops by not calculating `zir`
# self.zir = np.array([1])
# self.export_flags = ['zir']
# self.export_flags_tex = ['z_{ir}']
if not self.rate_no_lower:
self.export_flags.append('zlr')
self.export_flags_tex.append('z_{lr}')
self.warn_flags.append(('zlr', 'lower'))
if not self.rate_no_upper:
self.export_flags.append('zur')
self.export_flags_tex.append('z_{ur}')
self.warn_flags.append(('zur', 'upper'))
def __init__(self, u, T, K, freeze, name=None, tex_name=None, info=None):
Lag.__init__(self, u, T, K, name=name, tex_name=tex_name, info=info)
self.freeze = dummify(freeze)
self.flag = EventFlag(u=self.freeze, tex_name='z^{flag}')
self.vars['flag'] = self.flag
self.y.diag_eps = 1e-6
def __init__(self, u, kp, ki, freeze, ref=0.0, x0=0.0, name=None,
tex_name=None, info=None):
PIController.__init__(self, u=u, kp=kp, ki=ki, ref=ref, x0=x0,
name=name, tex_name=tex_name, info=info)
self.freeze = dummify(freeze)
self.flag = EventFlag(u=self.freeze, tex_name='z^{flag}')
self.vars['flag'] = self.flag
self.y.diag_eps = 1e-6
