Vector support in ports?

[seanmcleod70]

@milanofthe Matlab/Simulink has support for vectors in addition to scalars in ports, for example:

Are there plans to add support for vectors as elements of an input/output port?

[seanmcleod70]

Couple of examples so far in terms of implementing Matlab/Simulink block equivalents where the question of vectors arises.

class DynamicPressure(Function):
    """Calculate the dynamic pressure, given the velocity and air density.
    """

    input_port_labels = {
        "V1": 0,
        "V2": 1,
        "V3": 2,
        "rho": 3
    }

    output_port_labels = {
        "q": 0
    }

    def __init__(self):
        super().__init__(func=self._eval)
    
    def _eval(self, V1, V2, V3, density):
        V_mag = math.sqrt(V1**2 + V2**2 + V3**2)
        return 0.5 * density * V_mag**2


class IncidenceSideslipAirspeed(Function):
    """Calculates the angles between the velocity vector and the body and the total airspeed, 
    given the velocity components in the body-fixed coordinate frame. 
    """

    input_port_labels = {
        "u": 0,
        "v": 1,
        "w": 2
    }

    output_port_labels = {
        "alpha": 0,
        "beta": 1,
        "V": 2
    }

    def __init__(self):
        super().__init__(func=self._eval)

    def _eval(self, u, v, w):
        V = math.sqrt(u**2 + v**2 + w**2)
        alpha = math.atan2(w, u) if u != 0 else 0
        uw2 = u**2 + w**2
        beta = math.atan2(v / math.sqrt(uw2)) if uw2 != 0 else 0
        return (alpha, beta, V)


class CrossProduct(Function):
    """Calculate the cross product of two 3D vectors.
    """
    input_port_labels = {
        "A1": 0,
        "A2": 1,
        "A3": 2,
        "B1": 3,
        "B2": 4,
        "B3": 5
    }

    output_port_labels = {
        "C1": 0,
        "C2": 1,
        "C3": 2
    }

    def __init__(self):
        super().__init__(func=self._eval)

    def _eval(self, A1, A2, A3, B1, B2, B3):
        A = np.array([A1, A2, A3])
        B = np.array([B1, B2, B3])
        C = np.cross(A, B)
        return (C[0], C[1], C[2])

[seanmcleod70]

Also the ability to operate on a scalar or a vector/array. For example from Matlab/Simulink Angle Conversion block.

So convert a scalar from/to deg/rad or a whole array depending on what is connected to the port.

class AngleConversion(Function):
    """Convert an angle from degrees to radians or from radians to degrees.
    """
    input_port_labels = {
        "angle": 0,
    }

    output_port_labels = {
        "angle": 0
    }

    def __init__(self, input_units="deg"):      # TODO String, or a global enum of units?
        super().__init__(func=self._eval)
        self.input_units = input_units

    def _eval(self, angle):
        if self.input_units == "deg":
            return math.radians(angle)
        elif self.input_units == "rad":
            return math.degrees(angle)
        raise ValueError("Invalid input_units. Must be 'deg' or 'rad'.")

[milanofthe]

Currently ports are scalar values. So for vectors there would be one port per component.

There are paths to vector ports though. I will think about a good way to approach this.

[seanmcleod70]

One more thing along these lines, being able to enter a matrix.

For example I'm busy implementing the rigid body 6DOF block which requires a 3x3 inertia matrix as a parameter.

In Matlab entered as [a, b, c; d, e, f; g, h, i]

[milanofthe]

@seanmcleod70 matrices as parameters are no problem. Just pass a numpy array. For reference, see the StateSpace block.

[milanofthe]

For the angle conversion you could implement the block with arbitrary inputs and use the numpy angle conversions since they act on arrays element wise naturally. See the Math blocks as a reference.

[milanofthe]

On the vector note. Ports are scalar but connections support vector port indices and slices. For example this works:

b1 = Block()
b2 = Block()

c1 = Connection(b1[0:3], b2[0:3])
c2 = Connection(b1[0,1,2], b2[0,1,2]) #its the same

[seanmcleod70]

Understood in terms of numpy arrays for a matrix, and slicing for connections when writing python PathSim code, but what about via the PathView GUI?

So for example a 3x3 matrix for inertia as a parameter in the PathView GUI, can the user type the numpy equivalent to the Matlab example above, i.e..

[ [a,b,c], [d,e,f], [g,h,i] ]

Also in terms of the PathView GUI experience in terms of vector slicing for creating connections between blocks?

I will definitely test out the inertia matrix, vector slicing for connections etc. while creating the 6DOF block and testing it with python PathSim code. Just wondering about the PathView experience for users.

[milanofthe]

yes the user can type the matrix as numpy/python code