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