Correct implementation of LessThan logic in Lag2ndOrd

[KhaledAleikish]

Hi,

I noticed that if I set the IEEEST PSS model A1 A2 parameters to zero, I would get incorrect eigenvalues. I am trying to reproduce results from "Benchmark Systems for Small-Signal Stability Analysis and Control". In the two-area system, A1 to A6 are zeros.

I saw that LeadLag2ndOrd has a zero_out / LessThan implemented, but I can't figure out how to implement it for Lag2ndOrd. Here is my attempt

class Lag2ndOrdV2(Block):
r"""
Second order lag transfer function (low-pass filter).

::

         ┌──────────────────┐
         │         K        │
    u -> │ ──────────────── │ -> y
         │ 1 + sT1 + s^2 T2 │
         └──────────────────┘

Exports one two state variables (`x`, `y`), where `y` is the output.

Parameters
----------
u
    Input
K
    Gain
T1
    First order time constant
T2
    Second order time constant
zero_out
    If True, sets y = Ku when T1 = 0 and T2 = 0
"""

def __init__(self, u, K, T1, T2, zero_out=False, name=None, tex_name=None, info=None):
    super(Lag2ndOrdV2, 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.zero_out = zero_out

    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}

    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


def define(self):
    r"""

    Notes
    -----
    Implemented equations and initial values are

    .. math ::

        T_2 \dot{x} &= Ku - y - T_1 x \\
        \dot{y} &= x \\
        x^{(0)} &= 0 \\
        y^{(0)} &= K u \text{ if } T_1 = 0 \text{ and } T_2 = 0 \text{ and } zero\_out = \text{True}
    """

    self.x.v_str = 0
    self.x.e_str = f'{self.u.name} * {self.K.name} - ' \
                   f'{self.name}_y - ' \
                   f'{self.T1.name} * {self.name}_x'

    self.y.v_str = f'{self.u.name} * {self.K.name}'
    self.y.e_str = f'{self.name}_x'


    # Add condition to handle zero_out case
    if self.zero_out is True:
        self.y.e_str += f' + {self.name}_LT1_z1 * {self.name}_LT2_z1 * ' \
                        f'({self.u.name} * {self.K.name} - {self.name}_y)'

[cuihantao]

In my current implementation, when both T1 and T2 are zero, the current implementation will leave

$0 = Ku - y$ and $\dot{y} = x$, associated with two states, x and y.

• The first equation yields what we want
• Variable x becomes unbounded, thus \dot{y} = x has no meaning. We want to take out this equation.

Maybe introduce a flag zz to indicate if any of T1 or T2 is non-zero, then change the second equation to $zz * \dot{y} = zz * x$. This equation will be trivial when zz == 0. You can implement zz using the LessThan blocks. Also, for this state, set diag_eps=True because the derivative can potentially be zero.

Give it a try and post an update.