def __init__( self, parent, motor_constant, resistance, inductance, moment_of_inertia, initial_speed=None, initial_current=None, ): Block.__init__(self, parent) self.motor_constant = motor_constant self.resistance = resistance self.inductance = inductance self.moment_of_inertia = moment_of_inertia # Create the velocity and current state # These can also be used as signals which export the exact value of # the respective state. self.omega = State( self, derivative_function=self.omega_dt, initial_condition=initial_speed, ) self.current = State( self, derivative_function=self.current_dt, initial_condition=initial_current, ) # Create (input) ports for voltage and external torque load self.voltage = Port() self.external_torque = Port()
def __init__( self, parent, motor_constant, resistance, inductance, moment_of_inertia, initial_omega=0, initial_current=0, ): Block.__init__(self, parent) self.motor_constant = motor_constant self.resistance = resistance self.inductance = inductance self.moment_of_inertia = moment_of_inertia self.voltage = Port() self.external_torque = Port() self.omega = State( self, derivative_function=self.omega_dot, initial_condition=initial_omega, ) self.current = State( self, derivative_function=self.current_dot, initial_condition=initial_current, )
def __init__(self, parent, thrust_coefficient, power_coefficient, diameter): Block.__init__(self, parent) self.thrust_coefficient = thrust_coefficient self.power_coefficient = power_coefficient self.diameter = diameter # Define the input ports for propeller speed and air density self.speed_rps = Port() self.density = Port()
class Engine(Block): """ An engine block consisting of a propeller and a DC-motor. """ def __init__(self, parent, thrust_coefficient, power_coefficient, diameter, motor_constant, resistance, inductance, moment_of_inertia, direction, vector, arm): Block.__init__(self, parent) # Create ports for the motor voltage and the air density self.voltage = Port() self.density = Port() # Create the motor self.dcmotor = DCMotor(self, motor_constant, resistance, inductance, moment_of_inertia, initial_omega=1) # Create the propeller self.propeller = Propeller(self, thrust_coefficient=thrust_coefficient, power_coefficient=power_coefficient, diameter=diameter) # Create a thruster that converts the scalar thrust and torque into # thrust and torque vectors, considering the arm of the engine # relative to the center of gravity self.thruster = Thruster(self, direction=direction, vector=vector, arm=arm) # Provide output ports for the thrust and torque vectors self.thrust_vector = Port(shape=3) self.torque_vector = Port(shape=3) # Connect the voltage to the motor self.dcmotor.voltage.connect(self.voltage) # Connect the density to the propeller self.propeller.density.connect(self.density) # Connect the motor and propeller to each other self.dcmotor.external_torque.connect(self.propeller.torque) self.propeller.speed_rps.connect(self.dcmotor.speed_rps) # Provide the scalar thrust and torque to the thruster self.thruster.scalar_thrust.connect(self.propeller.thrust) self.thruster.scalar_torque.connect(self.dcmotor.torque) # Connect the thrust and torque vectors to the outputs self.thrust_vector.connect(self.thruster.thrust_vector) self.torque_vector.connect(self.thruster.torque_vector)
def __init__(self, parent, vector, arm, direction=1): Block.__init__(self, parent) self.vector = vector self.arm = arm self.direction = direction self.scalar_thrust = Port() self.scalar_torque = Port()
def __init__( self, owner, mass, moment_of_inertia, initial_velocity_earth=None, initial_position_earth=None, initial_transformation=None, initial_angular_rates_earth=None, ): Block.__init__(self, owner) self.mass = mass self.moment_of_inertia = moment_of_inertia self.forces_body = Port(shape=3) self.moments_body = Port(shape=3) if initial_transformation is None: initial_transformation = np.eye(3) self.velocity_earth = State( self, shape=3, derivative_function=self.velocity_earth_dot, initial_condition=initial_velocity_earth, ) self.position_earth = State( self, shape=3, derivative_function=self.position_earth_dot, initial_condition=initial_position_earth, ) self.omega_earth = State( self, shape=3, derivative_function=self.omega_earth_dot, initial_condition=initial_angular_rates_earth, ) self.dcm = State( self, shape=(3, 3), derivative_function=self.dcm_dot, initial_condition=initial_transformation, )
def __init__(self, parent, thrust_coefficient, power_coefficient, diameter): Block.__init__(self, parent) if not callable(thrust_coefficient): thrust_coeff_value = thrust_coefficient thrust_coefficient = (lambda n: thrust_coeff_value) if not callable(power_coefficient): power_coeff_value = power_coefficient power_coefficient = (lambda n: power_coeff_value) self.thrust_coefficient = thrust_coefficient self.power_coefficient = power_coefficient self.diameter = diameter self.speed_rps = Port() self.density = Port()
def __init__(self, parent, channel_weights, output_size=1): Block.__init__(self, parent) self.channel_weights = np.asarray(channel_weights) self.output_size = output_size self.inputs = [ Port(shape=self.output_size) for _ in range(self.channel_weights.shape[0]) ] self.output = Signal(shape=self.output_size, value=self.output_function)
def __init__(self, owner, shape=1, initial_condition=None): """ Constructor for ``ZeroOrderHold`` Args: owner: The owner of the block (system or block) shape: The shape of the input and output signal initial_condition: The initial state of the sampling output (before the first tick of the block) """ Block.__init__(self, owner) self.event_input = EventPort(self) self.event_input.register_listener(self.update_state) self.input = Port(shape=shape) self.output = State( self, shape=shape, initial_condition=initial_condition, derivative_function=None, )
def __init__(self, parent): Block.__init__(self, parent) self.dcm = Port(shape=(3, 3))
def __init__( self, parent, system_matrix, input_matrix, output_matrix, feed_through_matrix, initial_condition=None, ): Block.__init__(self, parent) # Determine the number of states and the shape of the state if np.isscalar(system_matrix): self.state_shape = () num_states = 1 else: system_matrix = np.asarray(system_matrix) if (system_matrix.ndim == 2 and system_matrix.shape[0] > 0 and system_matrix.shape[0] == system_matrix.shape[1]): self.state_shape = system_matrix.shape[0] num_states = self.state_shape else: raise InvalidLTIException("The system matrix must be a scalar " "or a non-empty square matrix") # Determine the number of inputs and the shape of the input signal if np.isscalar(input_matrix): if num_states > 1: raise InvalidLTIException("There is more than one state, but " "the input matrix is neither empty, " "nor a vector or a matrix") num_inputs = 1 self.input_shape = () else: input_matrix = np.asarray(input_matrix) if input_matrix.ndim == 1: # The input matrix is a column vector => one input if num_states != input_matrix.shape[0]: raise InvalidLTIException( "The height of the input matrix " "must match the number of states") num_inputs = 1 elif input_matrix.ndim == 2: # The input matrix is a matrix if num_states != input_matrix.shape[0]: raise InvalidLTIException("The height of the input matrix " "does not match the number of " "states") num_inputs = input_matrix.shape[1] else: raise InvalidLTIException("The input matrix must be empty," "a scalar, a vector or a matrix") self.input_shape = num_inputs # Determine the number of outputs and the shape of the output array if np.isscalar(output_matrix): if num_states > 1: raise InvalidLTIException("There is more than one state, but " "the output matrix is neither an " "empty, a vector nor a matrix") num_outputs = 1 self.output_shape = () else: output_matrix = np.asarray(output_matrix) if output_matrix.ndim == 1: # The output matrix is a row vector => one output if num_states != output_matrix.shape[0]: raise InvalidLTIException("The width of the output matrix " "does not match the number of " "states") num_outputs = 1 elif output_matrix.ndim == 2: # The output matrix is a matrix if num_states != output_matrix.shape[1]: raise InvalidLTIException("The width of the output matrix " "does not match the number of " "states") num_outputs = output_matrix.shape[0] else: raise InvalidLTIException("The output matrix must be empty, a" "scalar, a vector or a matrix") self.output_shape = num_outputs if np.isscalar(feed_through_matrix): if not (num_inputs == 1 and num_outputs == 1): raise InvalidLTIException("A scalar feed-through matrix is " "only allowed for systems with " "exactly one input and one output") else: feed_through_matrix = np.asarray(feed_through_matrix) if feed_through_matrix.ndim == 1: # A vector feed_through_matrix is interpreted as row vector, # so there must be exactly one output. if num_outputs == 0: raise InvalidLTIException("The feed-through matrix for a " "system without outputs must be" "empty") elif num_outputs > 1: raise InvalidLTIException("The feed-through matrix for a " "system with more than one " "output must be a matrix") if feed_through_matrix.shape[0] != num_inputs: raise InvalidLTIException( "The width of the feed-through " "matrix must match the number of " "inputs") elif feed_through_matrix.ndim == 2: if feed_through_matrix.shape[0] != num_outputs: raise InvalidLTIException( "The height of the feed-through " "matrix must match the number of " "outputs") if feed_through_matrix.shape[1] != num_inputs: raise InvalidLTIException( "The width of the feed-through " "matrix must match the number of " "inputs") else: raise InvalidLTIException("The feed-through matrix must be " "empty, a scalar, a vector or a " "matrix") self.system_matrix = system_matrix self.input_matrix = input_matrix self.output_matrix = output_matrix self.feed_through_matrix = feed_through_matrix self.input = Port(shape=self.input_shape) self.state = State( self, shape=self.state_shape, derivative_function=self.state_derivative, initial_condition=initial_condition, ) self.output = Signal(shape=self.output_shape, value=self.output_function)
def __init__(self, parent, k): Block.__init__(self, parent) self.k = np.atleast_2d(k) self.input = Port(shape=self.k.shape[0]) self.output = Signal(shape=self.k.shape[1], value=self.output_function)