pydrake.systems.primitives
Bindings for the primitives portion of the Systems framework.
- class pydrake.systems.primitives.Adder
Bases:
pydrake.systems.framework.LeafSystem
An adder for arbitrarily many inputs of equal size.
u0→ ...→ u(N-1)→ Adder → sum Note
This class is templated; see
Adder_
for the list of instantiations.- __init__(self: pydrake.systems.primitives.Adder, num_inputs: int, size: int) None
Construct an Adder System.
- Parameter
num_inputs
: is the number of input ports to be added.
- Parameter
size
: number of elements in each input and output signal.
- Parameter
- template pydrake.systems.primitives.Adder_
Instantiations:
Adder_[float]
,Adder_[AutoDiffXd]
,Adder_[Expression]
- class pydrake.systems.primitives.Adder_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
An adder for arbitrarily many inputs of equal size.
u0→ ...→ u(N-1)→ Adder → sum - __init__(self: pydrake.systems.primitives.Adder_[AutoDiffXd], num_inputs: int, size: int) None
Construct an Adder System.
- Parameter
num_inputs
: is the number of input ports to be added.
- Parameter
size
: number of elements in each input and output signal.
- Parameter
- class pydrake.systems.primitives.Adder_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
An adder for arbitrarily many inputs of equal size.
u0→ ...→ u(N-1)→ Adder → sum - __init__(self: pydrake.systems.primitives.Adder_[Expression], num_inputs: int, size: int) None
Construct an Adder System.
- Parameter
num_inputs
: is the number of input ports to be added.
- Parameter
size
: number of elements in each input and output signal.
- Parameter
- pydrake.systems.primitives.AddRandomInputs(*args, **kwargs)
Overloaded function.
AddRandomInputs(sampling_interval_sec: float, builder: pydrake.systems.framework.DiagramBuilder) -> int
For each subsystem input port in
builder
that is (a) not yet connected and (b) labeled as random in the InputPort, this method will add a new RandomSource system of the appropriate type and connect it to the subsystem input port.- Parameter
sampling_interval_sec
: interval to be used for all new sources.
- Returns
the total number of RandomSource systems added.
See also
stochastic_systems
AddRandomInputs(sampling_interval_sec: float, builder: pydrake.systems.framework.DiagramBuilder_[AutoDiffXd]) -> int
For each subsystem input port in
builder
that is (a) not yet connected and (b) labeled as random in the InputPort, this method will add a new RandomSource system of the appropriate type and connect it to the subsystem input port.- Parameter
sampling_interval_sec
: interval to be used for all new sources.
- Returns
the total number of RandomSource systems added.
See also
stochastic_systems
- class pydrake.systems.primitives.AffineSystem
Bases:
pydrake.systems.framework.LeafSystem
A discrete OR continuous affine system (with constant coefficients).
u0→ AffineSystem → y0 Let
u
denote the input vector,x
denote the state vector, andy
denote the output vector.If
time_period > 0.0
, the affine system will have the following discrete-time state update:\[x(t+h) = A x(t) + B u(t) + f_0,\]where
h
is the time_period. Iftime_period == 0.0
, the affine system will have the following continuous-time state update:\[\dot{x} = A x + B u + f_0.\]In both cases, the system will have the output:
\[y = C x + D u + y_0,\]See also
LinearSystem
See also
MatrixGain
Note
This class is templated; see
AffineSystem_
for the list of instantiations.- __init__(self: pydrake.systems.primitives.AffineSystem, A: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), B: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), f0: numpy.ndarray[numpy.float64[m, 1]] = array([], dtype=float64), C: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), D: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), y0: numpy.ndarray[numpy.float64[m, 1]] = array([], dtype=float64), time_period: float = 0.0) None
Constructs an Affine system with a fixed set of coefficient matrices
A
, B,``C``, andD
as well as fixed initial velocity offsetxDot0
and output offsety0
. The coefficient matrices must obey the following dimensions : | Matrix | Num Rows | Num Columns | |:-------:|:———–:|:-----------:| | A | num states | num states | | B | num states | num inputs | | f0 | num_states | 1 | | C | num outputs | num states | | D | num outputs | num inputs | | y0 | num_outputs | 1 |Empty matrices are treated as zero matrices with the appropriate number of rows and columns.
- Parameter
time_period
: Defines the period of the discrete time system; use time_period=0.0 to denote a continuous time system. $*Default:* 0.0
Subclasses must use the protected constructor, not this one.
- Parameter
- A(self: pydrake.systems.primitives.AffineSystem) numpy.ndarray[numpy.float64[m, n]]
@name Helper getter methods.
- B(self: pydrake.systems.primitives.AffineSystem) numpy.ndarray[numpy.float64[m, n]]
- C(self: pydrake.systems.primitives.AffineSystem) numpy.ndarray[numpy.float64[m, n]]
- configure_default_state(self: pydrake.systems.primitives.AffineSystem, x0: numpy.ndarray[numpy.float64[m, 1]]) None
Configures the value that will be assigned to the state vector in
SetDefaultContext
. x0 must be a vector of lengthnum_states
.
- configure_random_state(self: pydrake.systems.primitives.AffineSystem, covariance: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]) None
Configures the Gaussian distribution over state vectors used in the
SetRandomContext
methods. The mean of the distribution will be the default state (See also
configure_default_state()).
covariance
must have sizenum_states
bynum_states
and must be symmetric and positive semi-definite.
- D(self: pydrake.systems.primitives.AffineSystem) numpy.ndarray[numpy.float64[m, n]]
- f0(self: pydrake.systems.primitives.AffineSystem) numpy.ndarray[numpy.float64[m, 1]]
- num_inputs(self: pydrake.systems.primitives.AffineSystem) int
- num_outputs(self: pydrake.systems.primitives.AffineSystem) int
- num_states(self: pydrake.systems.primitives.AffineSystem) int
- time_period(self: pydrake.systems.primitives.AffineSystem) float
- UpdateCoefficients(self: pydrake.systems.primitives.AffineSystem, A: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), B: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), f0: numpy.ndarray[numpy.float64[m, 1]] = array([], dtype=float64), C: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), D: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), y0: numpy.ndarray[numpy.float64[m, 1]] = array([], dtype=float64)) None
Updates the coefficients of the affine system. The new coefficients must have the same size as existing coefficients.
- y0(self: pydrake.systems.primitives.AffineSystem) numpy.ndarray[numpy.float64[m, 1]]
- template pydrake.systems.primitives.AffineSystem_
Instantiations:
AffineSystem_[float]
,AffineSystem_[AutoDiffXd]
,AffineSystem_[Expression]
- class pydrake.systems.primitives.AffineSystem_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
A discrete OR continuous affine system (with constant coefficients).
u0→ AffineSystem → y0 Let
u
denote the input vector,x
denote the state vector, andy
denote the output vector.If
time_period > 0.0
, the affine system will have the following discrete-time state update:\[x(t+h) = A x(t) + B u(t) + f_0,\]where
h
is the time_period. Iftime_period == 0.0
, the affine system will have the following continuous-time state update:\[\dot{x} = A x + B u + f_0.\]In both cases, the system will have the output:
\[y = C x + D u + y_0,\]See also
LinearSystem
See also
MatrixGain
- __init__(self: pydrake.systems.primitives.AffineSystem_[AutoDiffXd], A: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), B: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), f0: numpy.ndarray[numpy.float64[m, 1]] = array([], dtype=float64), C: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), D: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), y0: numpy.ndarray[numpy.float64[m, 1]] = array([], dtype=float64), time_period: float = 0.0) None
Constructs an Affine system with a fixed set of coefficient matrices
A
, B,``C``, andD
as well as fixed initial velocity offsetxDot0
and output offsety0
. The coefficient matrices must obey the following dimensions : | Matrix | Num Rows | Num Columns | |:-------:|:———–:|:-----------:| | A | num states | num states | | B | num states | num inputs | | f0 | num_states | 1 | | C | num outputs | num states | | D | num outputs | num inputs | | y0 | num_outputs | 1 |Empty matrices are treated as zero matrices with the appropriate number of rows and columns.
- Parameter
time_period
: Defines the period of the discrete time system; use time_period=0.0 to denote a continuous time system. $*Default:* 0.0
Subclasses must use the protected constructor, not this one.
- Parameter
- A(self: pydrake.systems.primitives.AffineSystem_[AutoDiffXd]) numpy.ndarray[numpy.float64[m, n]]
@name Helper getter methods.
- B(self: pydrake.systems.primitives.AffineSystem_[AutoDiffXd]) numpy.ndarray[numpy.float64[m, n]]
- C(self: pydrake.systems.primitives.AffineSystem_[AutoDiffXd]) numpy.ndarray[numpy.float64[m, n]]
- configure_default_state(self: pydrake.systems.primitives.AffineSystem_[AutoDiffXd], x0: numpy.ndarray[object[m, 1]]) None
Configures the value that will be assigned to the state vector in
SetDefaultContext
. x0 must be a vector of lengthnum_states
.
- configure_random_state(self: pydrake.systems.primitives.AffineSystem_[AutoDiffXd], covariance: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]) None
Configures the Gaussian distribution over state vectors used in the
SetRandomContext
methods. The mean of the distribution will be the default state (See also
configure_default_state()).
covariance
must have sizenum_states
bynum_states
and must be symmetric and positive semi-definite.
- D(self: pydrake.systems.primitives.AffineSystem_[AutoDiffXd]) numpy.ndarray[numpy.float64[m, n]]
- f0(self: pydrake.systems.primitives.AffineSystem_[AutoDiffXd]) numpy.ndarray[numpy.float64[m, 1]]
- num_inputs(self: pydrake.systems.primitives.AffineSystem_[AutoDiffXd]) int
- num_outputs(self: pydrake.systems.primitives.AffineSystem_[AutoDiffXd]) int
- num_states(self: pydrake.systems.primitives.AffineSystem_[AutoDiffXd]) int
- time_period(self: pydrake.systems.primitives.AffineSystem_[AutoDiffXd]) float
- UpdateCoefficients(self: pydrake.systems.primitives.AffineSystem_[AutoDiffXd], A: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), B: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), f0: numpy.ndarray[numpy.float64[m, 1]] = array([], dtype=float64), C: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), D: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), y0: numpy.ndarray[numpy.float64[m, 1]] = array([], dtype=float64)) None
Updates the coefficients of the affine system. The new coefficients must have the same size as existing coefficients.
- y0(self: pydrake.systems.primitives.AffineSystem_[AutoDiffXd]) numpy.ndarray[numpy.float64[m, 1]]
- class pydrake.systems.primitives.AffineSystem_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
A discrete OR continuous affine system (with constant coefficients).
u0→ AffineSystem → y0 Let
u
denote the input vector,x
denote the state vector, andy
denote the output vector.If
time_period > 0.0
, the affine system will have the following discrete-time state update:\[x(t+h) = A x(t) + B u(t) + f_0,\]where
h
is the time_period. Iftime_period == 0.0
, the affine system will have the following continuous-time state update:\[\dot{x} = A x + B u + f_0.\]In both cases, the system will have the output:
\[y = C x + D u + y_0,\]See also
LinearSystem
See also
MatrixGain
- __init__(self: pydrake.systems.primitives.AffineSystem_[Expression], A: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), B: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), f0: numpy.ndarray[numpy.float64[m, 1]] = array([], dtype=float64), C: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), D: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), y0: numpy.ndarray[numpy.float64[m, 1]] = array([], dtype=float64), time_period: float = 0.0) None
Constructs an Affine system with a fixed set of coefficient matrices
A
, B,``C``, andD
as well as fixed initial velocity offsetxDot0
and output offsety0
. The coefficient matrices must obey the following dimensions : | Matrix | Num Rows | Num Columns | |:-------:|:———–:|:-----------:| | A | num states | num states | | B | num states | num inputs | | f0 | num_states | 1 | | C | num outputs | num states | | D | num outputs | num inputs | | y0 | num_outputs | 1 |Empty matrices are treated as zero matrices with the appropriate number of rows and columns.
- Parameter
time_period
: Defines the period of the discrete time system; use time_period=0.0 to denote a continuous time system. $*Default:* 0.0
Subclasses must use the protected constructor, not this one.
- Parameter
- A(self: pydrake.systems.primitives.AffineSystem_[Expression]) numpy.ndarray[numpy.float64[m, n]]
@name Helper getter methods.
- B(self: pydrake.systems.primitives.AffineSystem_[Expression]) numpy.ndarray[numpy.float64[m, n]]
- C(self: pydrake.systems.primitives.AffineSystem_[Expression]) numpy.ndarray[numpy.float64[m, n]]
- configure_default_state(self: pydrake.systems.primitives.AffineSystem_[Expression], x0: numpy.ndarray[object[m, 1]]) None
Configures the value that will be assigned to the state vector in
SetDefaultContext
. x0 must be a vector of lengthnum_states
.
- configure_random_state(self: pydrake.systems.primitives.AffineSystem_[Expression], covariance: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]) None
Configures the Gaussian distribution over state vectors used in the
SetRandomContext
methods. The mean of the distribution will be the default state (See also
configure_default_state()).
covariance
must have sizenum_states
bynum_states
and must be symmetric and positive semi-definite.
- D(self: pydrake.systems.primitives.AffineSystem_[Expression]) numpy.ndarray[numpy.float64[m, n]]
- f0(self: pydrake.systems.primitives.AffineSystem_[Expression]) numpy.ndarray[numpy.float64[m, 1]]
- num_inputs(self: pydrake.systems.primitives.AffineSystem_[Expression]) int
- num_outputs(self: pydrake.systems.primitives.AffineSystem_[Expression]) int
- num_states(self: pydrake.systems.primitives.AffineSystem_[Expression]) int
- time_period(self: pydrake.systems.primitives.AffineSystem_[Expression]) float
- UpdateCoefficients(self: pydrake.systems.primitives.AffineSystem_[Expression], A: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), B: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), f0: numpy.ndarray[numpy.float64[m, 1]] = array([], dtype=float64), C: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), D: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), y0: numpy.ndarray[numpy.float64[m, 1]] = array([], dtype=float64)) None
Updates the coefficients of the affine system. The new coefficients must have the same size as existing coefficients.
- y0(self: pydrake.systems.primitives.AffineSystem_[Expression]) numpy.ndarray[numpy.float64[m, 1]]
- class pydrake.systems.primitives.BarycentricMeshSystem
Bases:
pydrake.systems.framework.LeafSystem
A (stateless) vector system implemented as a multi-linear (barycentric) interpolation on a mesh over the inputs.
u0→ BarycentricMeshSystem → y0 This has many potential uses, including representing the policies that are generated by numerical control design methods like approximate dynamic programming.
See also
math::BarycentricMesh
- __init__(self: pydrake.systems.primitives.BarycentricMeshSystem, arg0: pydrake.math.BarycentricMesh, arg1: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]) None
Constructs the system from a mesh and the associated mesh values.
output_values
is a matrix with each column representing the value to output if the input is the associated mesh point. It must have the same number of columns as mesh.get_num_mesh_points(); mesh.MeshValuesFrom(function) is one useful tool for creating it.
- get_mesh(self: pydrake.systems.primitives.BarycentricMeshSystem) pydrake.math.BarycentricMesh
Returns a reference to the mesh.
- get_output_values(self: pydrake.systems.primitives.BarycentricMeshSystem) numpy.ndarray[numpy.float64[m, n]]
Returns a reference to the output values.
- class pydrake.systems.primitives.ConstantValueSource
Bases:
pydrake.systems.framework.LeafSystem
A source block that always outputs a constant value.
ConstantValueSource → y0 Note
This class is templated; see
ConstantValueSource_
for the list of instantiations.- __init__(self: pydrake.systems.primitives.ConstantValueSource, value: pydrake.common.value.AbstractValue) None
- Parameter
value
: The constant value to emit, which is copied by this system.
- Parameter
- template pydrake.systems.primitives.ConstantValueSource_
Instantiations:
ConstantValueSource_[float]
,ConstantValueSource_[AutoDiffXd]
,ConstantValueSource_[Expression]
- class pydrake.systems.primitives.ConstantValueSource_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
A source block that always outputs a constant value.
ConstantValueSource → y0 - __init__(self: pydrake.systems.primitives.ConstantValueSource_[AutoDiffXd], value: pydrake.common.value.AbstractValue) None
- Parameter
value
: The constant value to emit, which is copied by this system.
- Parameter
- class pydrake.systems.primitives.ConstantValueSource_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
A source block that always outputs a constant value.
ConstantValueSource → y0 - __init__(self: pydrake.systems.primitives.ConstantValueSource_[Expression], value: pydrake.common.value.AbstractValue) None
- Parameter
value
: The constant value to emit, which is copied by this system.
- Parameter
- class pydrake.systems.primitives.ConstantVectorSource
Bases:
pydrake.systems.framework.LeafSystem
A source block with a constant output port at all times. The value of the output port is a parameter of the system (see Parameters).
ConstantVectorSource → y0 Note
This class is templated; see
ConstantVectorSource_
for the list of instantiations.- __init__(self: pydrake.systems.primitives.ConstantVectorSource, source_value: numpy.ndarray[numpy.float64[m, 1]]) None
Constructs a system with a vector output that is constant and equals the supplied
source_value
at all times.- Parameter
source_value
: the constant value of the output so that
y = source_value
at all times.
- Parameter
- get_mutable_source_value(self: pydrake.systems.primitives.ConstantVectorSource, context: pydrake.systems.framework.Context) pydrake.systems.framework.BasicVector
Return a mutable reference to the source value of this block in the given
context
.
- get_source_value(self: pydrake.systems.primitives.ConstantVectorSource, context: pydrake.systems.framework.Context) pydrake.systems.framework.BasicVector
Return a read-only reference to the source value of this block in the given
context
.
- template pydrake.systems.primitives.ConstantVectorSource_
Instantiations:
ConstantVectorSource_[float]
,ConstantVectorSource_[AutoDiffXd]
,ConstantVectorSource_[Expression]
- class pydrake.systems.primitives.ConstantVectorSource_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
A source block with a constant output port at all times. The value of the output port is a parameter of the system (see Parameters).
ConstantVectorSource → y0 - __init__(self: pydrake.systems.primitives.ConstantVectorSource_[AutoDiffXd], source_value: numpy.ndarray[object[m, 1]]) None
Constructs a system with a vector output that is constant and equals the supplied
source_value
at all times.- Parameter
source_value
: the constant value of the output so that
y = source_value
at all times.
- Parameter
- get_mutable_source_value(self: pydrake.systems.primitives.ConstantVectorSource_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd]) pydrake.systems.framework.BasicVector_[AutoDiffXd]
Return a mutable reference to the source value of this block in the given
context
.
- get_source_value(self: pydrake.systems.primitives.ConstantVectorSource_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd]) pydrake.systems.framework.BasicVector_[AutoDiffXd]
Return a read-only reference to the source value of this block in the given
context
.
- class pydrake.systems.primitives.ConstantVectorSource_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
A source block with a constant output port at all times. The value of the output port is a parameter of the system (see Parameters).
ConstantVectorSource → y0 - __init__(self: pydrake.systems.primitives.ConstantVectorSource_[Expression], source_value: numpy.ndarray[object[m, 1]]) None
Constructs a system with a vector output that is constant and equals the supplied
source_value
at all times.- Parameter
source_value
: the constant value of the output so that
y = source_value
at all times.
- Parameter
- get_mutable_source_value(self: pydrake.systems.primitives.ConstantVectorSource_[Expression], context: pydrake.systems.framework.Context_[Expression]) pydrake.systems.framework.BasicVector_[Expression]
Return a mutable reference to the source value of this block in the given
context
.
- get_source_value(self: pydrake.systems.primitives.ConstantVectorSource_[Expression], context: pydrake.systems.framework.Context_[Expression]) pydrake.systems.framework.BasicVector_[Expression]
Return a read-only reference to the source value of this block in the given
context
.
- pydrake.systems.primitives.ControllabilityMatrix(arg0: pydrake.systems.primitives.LinearSystem) numpy.ndarray[numpy.float64[m, n]]
Returns the controllability matrix: R = [B, AB, …, A^{n-1}B].
- class pydrake.systems.primitives.Demultiplexer
Bases:
pydrake.systems.framework.LeafSystem
This system splits a vector valued signal on its input into multiple outputs.
The input to this system directly feeds through to its output.
u0→ Demultiplexer → y0 → ... → y(N-1) Note
This class is templated; see
Demultiplexer_
for the list of instantiations.- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.Demultiplexer, size: int, output_ports_size: int = 1) -> None
Constructs Demultiplexer with one vector valued input port of size
size
and vector valued output ports of sizeoutput_ports_size
.u0→ Demultiplexer → y0 → ... → y((size / output_ports_size) - 1) - Raises
RuntimeError if output_ports_sizes can not exactly divide –
:raises size`. The number of output ports is therefore
size : :raises output_ports_size
.:- Parameter
size
: is the size of the input signal to be demultiplexed into its individual components.
- Parameter
output_ports_size
: The size of the output ports.
size
must be a multiple ofoutput_ports_size
.
__init__(self: pydrake.systems.primitives.Demultiplexer, output_ports_sizes: list[int]) -> None
Constructs Demultiplexer with one vector valued output ports with sizes specified as the vector
output_ports_sizes
. The number of output ports is the length of this vector. The size of each output port is the value of the corresponding element of the vectoroutput_ports_sizes
.u0→ Demultiplexer → y0 → ... → y(output_ports_sizes.size() - 1) - Raises
RuntimeError if output_ports_sizes is a zero length vector. –
RuntimeError if any element of the output_ports_sizes is zero. –
Therefore, the Demultiplexer does not allow zero size output –
ports. –
- Parameter
output_ports_sizes
: Contains the sizes of each output port. The number of output ports is determined by the length of
output_ports_sizes
. The accumulative value of the all the values inoutput_ports_sizes
will be the size of the input port.
- get_output_ports_sizes(self: pydrake.systems.primitives.Demultiplexer) list[int]
- template pydrake.systems.primitives.Demultiplexer_
Instantiations:
Demultiplexer_[float]
,Demultiplexer_[AutoDiffXd]
,Demultiplexer_[Expression]
- class pydrake.systems.primitives.Demultiplexer_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
This system splits a vector valued signal on its input into multiple outputs.
The input to this system directly feeds through to its output.
u0→ Demultiplexer → y0 → ... → y(N-1) - __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.Demultiplexer_[AutoDiffXd], size: int, output_ports_size: int = 1) -> None
Constructs Demultiplexer with one vector valued input port of size
size
and vector valued output ports of sizeoutput_ports_size
.u0→ Demultiplexer → y0 → ... → y((size / output_ports_size) - 1) - Raises
RuntimeError if output_ports_sizes can not exactly divide –
:raises size`. The number of output ports is therefore
size : :raises output_ports_size
.:- Parameter
size
: is the size of the input signal to be demultiplexed into its individual components.
- Parameter
output_ports_size
: The size of the output ports.
size
must be a multiple ofoutput_ports_size
.
__init__(self: pydrake.systems.primitives.Demultiplexer_[AutoDiffXd], output_ports_sizes: list[int]) -> None
Constructs Demultiplexer with one vector valued output ports with sizes specified as the vector
output_ports_sizes
. The number of output ports is the length of this vector. The size of each output port is the value of the corresponding element of the vectoroutput_ports_sizes
.u0→ Demultiplexer → y0 → ... → y(output_ports_sizes.size() - 1) - Raises
RuntimeError if output_ports_sizes is a zero length vector. –
RuntimeError if any element of the output_ports_sizes is zero. –
Therefore, the Demultiplexer does not allow zero size output –
ports. –
- Parameter
output_ports_sizes
: Contains the sizes of each output port. The number of output ports is determined by the length of
output_ports_sizes
. The accumulative value of the all the values inoutput_ports_sizes
will be the size of the input port.
- get_output_ports_sizes(self: pydrake.systems.primitives.Demultiplexer_[AutoDiffXd]) list[int]
- class pydrake.systems.primitives.Demultiplexer_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
This system splits a vector valued signal on its input into multiple outputs.
The input to this system directly feeds through to its output.
u0→ Demultiplexer → y0 → ... → y(N-1) - __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.Demultiplexer_[Expression], size: int, output_ports_size: int = 1) -> None
Constructs Demultiplexer with one vector valued input port of size
size
and vector valued output ports of sizeoutput_ports_size
.u0→ Demultiplexer → y0 → ... → y((size / output_ports_size) - 1) - Raises
RuntimeError if output_ports_sizes can not exactly divide –
:raises size`. The number of output ports is therefore
size : :raises output_ports_size
.:- Parameter
size
: is the size of the input signal to be demultiplexed into its individual components.
- Parameter
output_ports_size
: The size of the output ports.
size
must be a multiple ofoutput_ports_size
.
__init__(self: pydrake.systems.primitives.Demultiplexer_[Expression], output_ports_sizes: list[int]) -> None
Constructs Demultiplexer with one vector valued output ports with sizes specified as the vector
output_ports_sizes
. The number of output ports is the length of this vector. The size of each output port is the value of the corresponding element of the vectoroutput_ports_sizes
.u0→ Demultiplexer → y0 → ... → y(output_ports_sizes.size() - 1) - Raises
RuntimeError if output_ports_sizes is a zero length vector. –
RuntimeError if any element of the output_ports_sizes is zero. –
Therefore, the Demultiplexer does not allow zero size output –
ports. –
- Parameter
output_ports_sizes
: Contains the sizes of each output port. The number of output ports is determined by the length of
output_ports_sizes
. The accumulative value of the all the values inoutput_ports_sizes
will be the size of the input port.
- get_output_ports_sizes(self: pydrake.systems.primitives.Demultiplexer_[Expression]) list[int]
- class pydrake.systems.primitives.DiscreteDerivative
Bases:
pydrake.systems.framework.LeafSystem
System that outputs the discrete-time derivative of its input: y(t) = (u[n] - u[n-1])/h, where n = floor(t/h), where h is the time period.
This is implemented as the linear system
Click to expand C++ code...
x₀[n+1] = u[n], x₁[n+1] = x₀[n], y(t) = (x₀[n]-x₁[n])/h. x₀[0] and x₁[0] are initialized in the Context (default is zeros).
Alternatively, when
suppress_initial_transient = true
is passed to the constructor, the output remains zero until u[n] has been sampled twice.This is implemented as the non-linear system
Click to expand C++ code...
x₀[n+1] = u[n], x₁[n+1] = x₀[n], x₂[n+1] = x₂[n] + 1, y(t) = { 0.0 if x₂ < 2 } { (x₀[n]-x₁[n])/h if x₂ >= 2 } x₀[0], x₁[0], x₂[0] are initialized in the Context (default is zeros).
Note
Calling set_input_history() effectively disables the transient suppression by setting x_2 = 2.
Note
For dynamical systems, a derivative should not be computed in continuous-time, i.e.
y(t) = (u(t) - u[n])/(t-n*h)
. This is numerically unstable since the time intervalt-n*h
could be arbitrarily close to zero. Prefer the discrete-time implementation for robustness.u→ DiscreteDerivative → dudt Note
This class is templated; see
DiscreteDerivative_
for the list of instantiations.- __init__(self: pydrake.systems.primitives.DiscreteDerivative, num_inputs: int, time_step: float, suppress_initial_transient: bool = True) None
Constructor taking
num_inputs
, the size of the vector to be differentiated, andtime_step
, the sampling interval. Ifsuppress_initial_transient
is true (the default), then the output will be zero for the first two time steps (see the class documentation for details and exceptions).
- suppress_initial_transient(self: pydrake.systems.primitives.DiscreteDerivative) bool
Returns the
suppress_initial_transient
passed to the constructor.
- time_step(self: pydrake.systems.primitives.DiscreteDerivative) float
- template pydrake.systems.primitives.DiscreteDerivative_
Instantiations:
DiscreteDerivative_[float]
,DiscreteDerivative_[AutoDiffXd]
,DiscreteDerivative_[Expression]
- class pydrake.systems.primitives.DiscreteDerivative_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
System that outputs the discrete-time derivative of its input: y(t) = (u[n] - u[n-1])/h, where n = floor(t/h), where h is the time period.
This is implemented as the linear system
Click to expand C++ code...
x₀[n+1] = u[n], x₁[n+1] = x₀[n], y(t) = (x₀[n]-x₁[n])/h. x₀[0] and x₁[0] are initialized in the Context (default is zeros).
Alternatively, when
suppress_initial_transient = true
is passed to the constructor, the output remains zero until u[n] has been sampled twice.This is implemented as the non-linear system
Click to expand C++ code...
x₀[n+1] = u[n], x₁[n+1] = x₀[n], x₂[n+1] = x₂[n] + 1, y(t) = { 0.0 if x₂ < 2 } { (x₀[n]-x₁[n])/h if x₂ >= 2 } x₀[0], x₁[0], x₂[0] are initialized in the Context (default is zeros).
Note
Calling set_input_history() effectively disables the transient suppression by setting x_2 = 2.
Note
For dynamical systems, a derivative should not be computed in continuous-time, i.e.
y(t) = (u(t) - u[n])/(t-n*h)
. This is numerically unstable since the time intervalt-n*h
could be arbitrarily close to zero. Prefer the discrete-time implementation for robustness.u→ DiscreteDerivative → dudt - __init__(self: pydrake.systems.primitives.DiscreteDerivative_[AutoDiffXd], num_inputs: int, time_step: float, suppress_initial_transient: bool = True) None
Constructor taking
num_inputs
, the size of the vector to be differentiated, andtime_step
, the sampling interval. Ifsuppress_initial_transient
is true (the default), then the output will be zero for the first two time steps (see the class documentation for details and exceptions).
- suppress_initial_transient(self: pydrake.systems.primitives.DiscreteDerivative_[AutoDiffXd]) bool
Returns the
suppress_initial_transient
passed to the constructor.
- time_step(self: pydrake.systems.primitives.DiscreteDerivative_[AutoDiffXd]) float
- class pydrake.systems.primitives.DiscreteDerivative_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
System that outputs the discrete-time derivative of its input: y(t) = (u[n] - u[n-1])/h, where n = floor(t/h), where h is the time period.
This is implemented as the linear system
Click to expand C++ code...
x₀[n+1] = u[n], x₁[n+1] = x₀[n], y(t) = (x₀[n]-x₁[n])/h. x₀[0] and x₁[0] are initialized in the Context (default is zeros).
Alternatively, when
suppress_initial_transient = true
is passed to the constructor, the output remains zero until u[n] has been sampled twice.This is implemented as the non-linear system
Click to expand C++ code...
x₀[n+1] = u[n], x₁[n+1] = x₀[n], x₂[n+1] = x₂[n] + 1, y(t) = { 0.0 if x₂ < 2 } { (x₀[n]-x₁[n])/h if x₂ >= 2 } x₀[0], x₁[0], x₂[0] are initialized in the Context (default is zeros).
Note
Calling set_input_history() effectively disables the transient suppression by setting x_2 = 2.
Note
For dynamical systems, a derivative should not be computed in continuous-time, i.e.
y(t) = (u(t) - u[n])/(t-n*h)
. This is numerically unstable since the time intervalt-n*h
could be arbitrarily close to zero. Prefer the discrete-time implementation for robustness.u→ DiscreteDerivative → dudt - __init__(self: pydrake.systems.primitives.DiscreteDerivative_[Expression], num_inputs: int, time_step: float, suppress_initial_transient: bool = True) None
Constructor taking
num_inputs
, the size of the vector to be differentiated, andtime_step
, the sampling interval. Ifsuppress_initial_transient
is true (the default), then the output will be zero for the first two time steps (see the class documentation for details and exceptions).
- suppress_initial_transient(self: pydrake.systems.primitives.DiscreteDerivative_[Expression]) bool
Returns the
suppress_initial_transient
passed to the constructor.
- time_step(self: pydrake.systems.primitives.DiscreteDerivative_[Expression]) float
- class pydrake.systems.primitives.DiscreteTimeDelay
Bases:
pydrake.systems.framework.LeafSystem
A discrete time delay block with input u, which is vector-valued (discrete or continuous) or abstract, and output delayed_u which is previously received input, delayed by the given amount. The initial output will be a vector of zeros for vector-valued or a given value for abstract-valued until the delay time has passed.
u→ DiscreteTimeDelay → delayed_u Let t,z ∈ ℕ be the number of delay time steps and the input vector size. For abstract-valued DiscreteTimeDelay, z is 1. The state x ∈ ℝ⁽ᵗ⁺¹⁾ᶻ is partitioned into t+1 blocks x[0] x[1] … x[t], each of size z. The input and output are u,y ∈ ℝᶻ. The discrete state space dynamics of DiscreteTimeDelay is:
Click to expand C++ code...
xₙ₊₁ = xₙ[1] xₙ[2] ... xₙ[t] uₙ // update yₙ = xₙ[0] // output x₀ = xᵢₙᵢₜ // initialize
where xᵢₙᵢₜ = 0 for vector-valued DiscreteTimeDelay and xᵢₙᵢₜ is a given value for abstract-valued DiscreteTimeDelay.
See discrete_systems “Discrete Systems” for general information about discrete systems in Drake, including how they interact with continuous systems.
Note
While the output port can be sampled at any continuous time, this system does not interpolate.
Note
This class is templated; see
DiscreteTimeDelay_
for the list of instantiations.- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.DiscreteTimeDelay, update_sec: float, delay_time_steps: int, vector_size: int) -> None
Constructs a DiscreteTimeDelay system updating every
update_sec
and delaying a vector-valued input of sizevector_size
fordelay_time_steps
number of updates.__init__(self: pydrake.systems.primitives.DiscreteTimeDelay, update_sec: float, delay_time_steps: int, abstract_model_value: pydrake.common.value.AbstractValue) -> None
Constructs a DiscreteTimeDelay system updating every
update_sec
and delaying an abstract-valued input of typeabstract_model_value
fordelay_time_steps
number of updates.
- template pydrake.systems.primitives.DiscreteTimeDelay_
Instantiations:
DiscreteTimeDelay_[float]
,DiscreteTimeDelay_[AutoDiffXd]
,DiscreteTimeDelay_[Expression]
- class pydrake.systems.primitives.DiscreteTimeDelay_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
A discrete time delay block with input u, which is vector-valued (discrete or continuous) or abstract, and output delayed_u which is previously received input, delayed by the given amount. The initial output will be a vector of zeros for vector-valued or a given value for abstract-valued until the delay time has passed.
u→ DiscreteTimeDelay → delayed_u Let t,z ∈ ℕ be the number of delay time steps and the input vector size. For abstract-valued DiscreteTimeDelay, z is 1. The state x ∈ ℝ⁽ᵗ⁺¹⁾ᶻ is partitioned into t+1 blocks x[0] x[1] … x[t], each of size z. The input and output are u,y ∈ ℝᶻ. The discrete state space dynamics of DiscreteTimeDelay is:
Click to expand C++ code...
xₙ₊₁ = xₙ[1] xₙ[2] ... xₙ[t] uₙ // update yₙ = xₙ[0] // output x₀ = xᵢₙᵢₜ // initialize
where xᵢₙᵢₜ = 0 for vector-valued DiscreteTimeDelay and xᵢₙᵢₜ is a given value for abstract-valued DiscreteTimeDelay.
See discrete_systems “Discrete Systems” for general information about discrete systems in Drake, including how they interact with continuous systems.
Note
While the output port can be sampled at any continuous time, this system does not interpolate.
- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.DiscreteTimeDelay_[AutoDiffXd], update_sec: float, delay_time_steps: int, vector_size: int) -> None
Constructs a DiscreteTimeDelay system updating every
update_sec
and delaying a vector-valued input of sizevector_size
fordelay_time_steps
number of updates.__init__(self: pydrake.systems.primitives.DiscreteTimeDelay_[AutoDiffXd], update_sec: float, delay_time_steps: int, abstract_model_value: pydrake.common.value.AbstractValue) -> None
Constructs a DiscreteTimeDelay system updating every
update_sec
and delaying an abstract-valued input of typeabstract_model_value
fordelay_time_steps
number of updates.
- class pydrake.systems.primitives.DiscreteTimeDelay_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
A discrete time delay block with input u, which is vector-valued (discrete or continuous) or abstract, and output delayed_u which is previously received input, delayed by the given amount. The initial output will be a vector of zeros for vector-valued or a given value for abstract-valued until the delay time has passed.
u→ DiscreteTimeDelay → delayed_u Let t,z ∈ ℕ be the number of delay time steps and the input vector size. For abstract-valued DiscreteTimeDelay, z is 1. The state x ∈ ℝ⁽ᵗ⁺¹⁾ᶻ is partitioned into t+1 blocks x[0] x[1] … x[t], each of size z. The input and output are u,y ∈ ℝᶻ. The discrete state space dynamics of DiscreteTimeDelay is:
Click to expand C++ code...
xₙ₊₁ = xₙ[1] xₙ[2] ... xₙ[t] uₙ // update yₙ = xₙ[0] // output x₀ = xᵢₙᵢₜ // initialize
where xᵢₙᵢₜ = 0 for vector-valued DiscreteTimeDelay and xᵢₙᵢₜ is a given value for abstract-valued DiscreteTimeDelay.
See discrete_systems “Discrete Systems” for general information about discrete systems in Drake, including how they interact with continuous systems.
Note
While the output port can be sampled at any continuous time, this system does not interpolate.
- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.DiscreteTimeDelay_[Expression], update_sec: float, delay_time_steps: int, vector_size: int) -> None
Constructs a DiscreteTimeDelay system updating every
update_sec
and delaying a vector-valued input of sizevector_size
fordelay_time_steps
number of updates.__init__(self: pydrake.systems.primitives.DiscreteTimeDelay_[Expression], update_sec: float, delay_time_steps: int, abstract_model_value: pydrake.common.value.AbstractValue) -> None
Constructs a DiscreteTimeDelay system updating every
update_sec
and delaying an abstract-valued input of typeabstract_model_value
fordelay_time_steps
number of updates.
- class pydrake.systems.primitives.DiscreteTimeIntegrator
Bases:
pydrake.systems.framework.LeafSystem
A discrete-time integrator for a vector input, using explicit Euler integration.
u→ DiscreteTimeIntegrator → y The discrete state space dynamics of DiscreteTimeIntegrator with time step
h
is:Click to expand C++ code...
xₙ₊₁ = xₙ + h uₙ // update yₙ = xₙ // output x₀ = xᵢₙᵢₜ // initialize
where xᵢₙᵢₜ = 0 by default. Use set_integral_value() to set xₙ in the context. The output at time
t
isxₙ
wheren = ceil(t/h)
. See discrete_systems.Note
This class is templated; see
DiscreteTimeIntegrator_
for the list of instantiations.- __init__(self: pydrake.systems.primitives.DiscreteTimeIntegrator, size: int, time_step: float) None
Constructs an DiscreteTimeIntegrator system.
- Parameter
size
: number of elements in the signal to be processed.
- Parameter
time_step
: the discrete time step.
- Precondition:
size > 0. time_step > 0.
- Parameter
- set_integral_value(self: pydrake.systems.primitives.DiscreteTimeIntegrator, context: pydrake.systems.framework.Context, value: numpy.ndarray[numpy.float64[m, 1]]) None
Sets the value of the integral modifying the state in the context.
value
must be a column vector of the appropriate size.
- time_step(self: pydrake.systems.primitives.DiscreteTimeIntegrator) float
Returns the time_step used by the integrator.
- template pydrake.systems.primitives.DiscreteTimeIntegrator_
Instantiations:
DiscreteTimeIntegrator_[float]
,DiscreteTimeIntegrator_[AutoDiffXd]
,DiscreteTimeIntegrator_[Expression]
- class pydrake.systems.primitives.DiscreteTimeIntegrator_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
A discrete-time integrator for a vector input, using explicit Euler integration.
u→ DiscreteTimeIntegrator → y The discrete state space dynamics of DiscreteTimeIntegrator with time step
h
is:Click to expand C++ code...
xₙ₊₁ = xₙ + h uₙ // update yₙ = xₙ // output x₀ = xᵢₙᵢₜ // initialize
where xᵢₙᵢₜ = 0 by default. Use set_integral_value() to set xₙ in the context. The output at time
t
isxₙ
wheren = ceil(t/h)
. See discrete_systems.- __init__(self: pydrake.systems.primitives.DiscreteTimeIntegrator_[AutoDiffXd], size: int, time_step: float) None
Constructs an DiscreteTimeIntegrator system.
- Parameter
size
: number of elements in the signal to be processed.
- Parameter
time_step
: the discrete time step.
- Precondition:
size > 0. time_step > 0.
- Parameter
- set_integral_value(self: pydrake.systems.primitives.DiscreteTimeIntegrator_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd], value: numpy.ndarray[object[m, 1]]) None
Sets the value of the integral modifying the state in the context.
value
must be a column vector of the appropriate size.
- time_step(self: pydrake.systems.primitives.DiscreteTimeIntegrator_[AutoDiffXd]) float
Returns the time_step used by the integrator.
- class pydrake.systems.primitives.DiscreteTimeIntegrator_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
A discrete-time integrator for a vector input, using explicit Euler integration.
u→ DiscreteTimeIntegrator → y The discrete state space dynamics of DiscreteTimeIntegrator with time step
h
is:Click to expand C++ code...
xₙ₊₁ = xₙ + h uₙ // update yₙ = xₙ // output x₀ = xᵢₙᵢₜ // initialize
where xᵢₙᵢₜ = 0 by default. Use set_integral_value() to set xₙ in the context. The output at time
t
isxₙ
wheren = ceil(t/h)
. See discrete_systems.- __init__(self: pydrake.systems.primitives.DiscreteTimeIntegrator_[Expression], size: int, time_step: float) None
Constructs an DiscreteTimeIntegrator system.
- Parameter
size
: number of elements in the signal to be processed.
- Parameter
time_step
: the discrete time step.
- Precondition:
size > 0. time_step > 0.
- Parameter
- set_integral_value(self: pydrake.systems.primitives.DiscreteTimeIntegrator_[Expression], context: pydrake.systems.framework.Context_[Expression], value: numpy.ndarray[object[m, 1]]) None
Sets the value of the integral modifying the state in the context.
value
must be a column vector of the appropriate size.
- time_step(self: pydrake.systems.primitives.DiscreteTimeIntegrator_[Expression]) float
Returns the time_step used by the integrator.
- class pydrake.systems.primitives.FirstOrderLowPassFilter
Bases:
pydrake.systems.framework.LeafSystem
An element-wise first order low pass filter system that filters the i-th input uᵢ into the i-th output zᵢ. This system has one continuous state per filtered input signal. Therefore, the i-th state of the system zᵢ evolves according to:
Click to expand C++ code...
żᵢ = -1/τᵢ (zᵢ - uᵢ)
where τᵢ is the time constant of the i-th filter. The i-th output of the system is given by:
Click to expand C++ code...
yᵢ = zᵢ
The transfer function for the i-th filter corresponds to:
Click to expand C++ code...
H(s) = 1 / (1 + τᵢ s)
The Bode plot for the i-th filter exhibits a cutoff frequency (angular frequency) at 1/τᵢ and a gain of one. For frequencies higher than the cutoff frequency, the Bode plot approaches a 20 dB per decade negative slope. The Bode plot in phase exhibits a -90 degrees shift (lag) for frequencies much larger than the cutoff frequency and a zero shift for low frequencies.
u0→ FirstOrderLowPassFilter → y0 Note
This class is templated; see
FirstOrderLowPassFilter_
for the list of instantiations.- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.FirstOrderLowPassFilter, time_constant: float, size: int = 1) -> None
Constructs a FirstOrderLowPassFilter system that filters all input signals with the same time constant, i.e. τᵢ = τ, ∀ i.
- Parameter
time_constant
: the time constant τ of the filter. It must be a positive number.
- Parameter
size
: number of elements in the signal to be processed.
__init__(self: pydrake.systems.primitives.FirstOrderLowPassFilter, time_constants: numpy.ndarray[numpy.float64[m, 1]]) -> None
Constructs a FirstOrderLowPassFilter so that the i-th component of the input signal vector is low pass filtered with a time constant given in the i-th component τᵢ of the input
time_constants
vector.- Parameter
time_constants
: Vector of time constants. Each entry in this vector must be positive.
- get_time_constant(self: pydrake.systems.primitives.FirstOrderLowPassFilter) float
Returns the time constant of the filter for filters that have the same time constant τ for all signals. This method aborts if called on filters if with different time constants per input signal.
See also
get_time_constants_vector().
- get_time_constants_vector(self: pydrake.systems.primitives.FirstOrderLowPassFilter) numpy.ndarray[numpy.float64[m, 1]]
Returns the vector of time constants for
this
filter.
- set_initial_output_value(self: pydrake.systems.primitives.FirstOrderLowPassFilter, arg0: pydrake.systems.framework.Context, arg1: numpy.ndarray[numpy.float64[m, 1]]) None
Sets the initial conditions on the output value of the filtered signal.
- Parameter
context
: The current system context.
- Parameter
z0
: The vector on initial conditions on the output value.
- Parameter
- template pydrake.systems.primitives.FirstOrderLowPassFilter_
Instantiations:
FirstOrderLowPassFilter_[float]
,FirstOrderLowPassFilter_[AutoDiffXd]
,FirstOrderLowPassFilter_[Expression]
- class pydrake.systems.primitives.FirstOrderLowPassFilter_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
An element-wise first order low pass filter system that filters the i-th input uᵢ into the i-th output zᵢ. This system has one continuous state per filtered input signal. Therefore, the i-th state of the system zᵢ evolves according to:
Click to expand C++ code...
żᵢ = -1/τᵢ (zᵢ - uᵢ)
where τᵢ is the time constant of the i-th filter. The i-th output of the system is given by:
Click to expand C++ code...
yᵢ = zᵢ
The transfer function for the i-th filter corresponds to:
Click to expand C++ code...
H(s) = 1 / (1 + τᵢ s)
The Bode plot for the i-th filter exhibits a cutoff frequency (angular frequency) at 1/τᵢ and a gain of one. For frequencies higher than the cutoff frequency, the Bode plot approaches a 20 dB per decade negative slope. The Bode plot in phase exhibits a -90 degrees shift (lag) for frequencies much larger than the cutoff frequency and a zero shift for low frequencies.
u0→ FirstOrderLowPassFilter → y0 - __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.FirstOrderLowPassFilter_[AutoDiffXd], time_constant: float, size: int = 1) -> None
Constructs a FirstOrderLowPassFilter system that filters all input signals with the same time constant, i.e. τᵢ = τ, ∀ i.
- Parameter
time_constant
: the time constant τ of the filter. It must be a positive number.
- Parameter
size
: number of elements in the signal to be processed.
__init__(self: pydrake.systems.primitives.FirstOrderLowPassFilter_[AutoDiffXd], time_constants: numpy.ndarray[numpy.float64[m, 1]]) -> None
Constructs a FirstOrderLowPassFilter so that the i-th component of the input signal vector is low pass filtered with a time constant given in the i-th component τᵢ of the input
time_constants
vector.- Parameter
time_constants
: Vector of time constants. Each entry in this vector must be positive.
- get_time_constant(self: pydrake.systems.primitives.FirstOrderLowPassFilter_[AutoDiffXd]) float
Returns the time constant of the filter for filters that have the same time constant τ for all signals. This method aborts if called on filters if with different time constants per input signal.
See also
get_time_constants_vector().
- get_time_constants_vector(self: pydrake.systems.primitives.FirstOrderLowPassFilter_[AutoDiffXd]) numpy.ndarray[numpy.float64[m, 1]]
Returns the vector of time constants for
this
filter.
- set_initial_output_value(self: pydrake.systems.primitives.FirstOrderLowPassFilter_[AutoDiffXd], arg0: pydrake.systems.framework.Context_[AutoDiffXd], arg1: numpy.ndarray[object[m, 1]]) None
Sets the initial conditions on the output value of the filtered signal.
- Parameter
context
: The current system context.
- Parameter
z0
: The vector on initial conditions on the output value.
- Parameter
- class pydrake.systems.primitives.FirstOrderLowPassFilter_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
An element-wise first order low pass filter system that filters the i-th input uᵢ into the i-th output zᵢ. This system has one continuous state per filtered input signal. Therefore, the i-th state of the system zᵢ evolves according to:
Click to expand C++ code...
żᵢ = -1/τᵢ (zᵢ - uᵢ)
where τᵢ is the time constant of the i-th filter. The i-th output of the system is given by:
Click to expand C++ code...
yᵢ = zᵢ
The transfer function for the i-th filter corresponds to:
Click to expand C++ code...
H(s) = 1 / (1 + τᵢ s)
The Bode plot for the i-th filter exhibits a cutoff frequency (angular frequency) at 1/τᵢ and a gain of one. For frequencies higher than the cutoff frequency, the Bode plot approaches a 20 dB per decade negative slope. The Bode plot in phase exhibits a -90 degrees shift (lag) for frequencies much larger than the cutoff frequency and a zero shift for low frequencies.
u0→ FirstOrderLowPassFilter → y0 - __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.FirstOrderLowPassFilter_[Expression], time_constant: float, size: int = 1) -> None
Constructs a FirstOrderLowPassFilter system that filters all input signals with the same time constant, i.e. τᵢ = τ, ∀ i.
- Parameter
time_constant
: the time constant τ of the filter. It must be a positive number.
- Parameter
size
: number of elements in the signal to be processed.
__init__(self: pydrake.systems.primitives.FirstOrderLowPassFilter_[Expression], time_constants: numpy.ndarray[numpy.float64[m, 1]]) -> None
Constructs a FirstOrderLowPassFilter so that the i-th component of the input signal vector is low pass filtered with a time constant given in the i-th component τᵢ of the input
time_constants
vector.- Parameter
time_constants
: Vector of time constants. Each entry in this vector must be positive.
- get_time_constant(self: pydrake.systems.primitives.FirstOrderLowPassFilter_[Expression]) float
Returns the time constant of the filter for filters that have the same time constant τ for all signals. This method aborts if called on filters if with different time constants per input signal.
See also
get_time_constants_vector().
- get_time_constants_vector(self: pydrake.systems.primitives.FirstOrderLowPassFilter_[Expression]) numpy.ndarray[numpy.float64[m, 1]]
Returns the vector of time constants for
this
filter.
- set_initial_output_value(self: pydrake.systems.primitives.FirstOrderLowPassFilter_[Expression], arg0: pydrake.systems.framework.Context_[Expression], arg1: numpy.ndarray[object[m, 1]]) None
Sets the initial conditions on the output value of the filtered signal.
- Parameter
context
: The current system context.
- Parameter
z0
: The vector on initial conditions on the output value.
- Parameter
- pydrake.systems.primitives.FirstOrderTaylorApproximation(system: pydrake.systems.framework.System, context: pydrake.systems.framework.Context, input_port_index: Union[pydrake.systems.framework.InputPortSelection, pydrake.systems.framework.InputPortIndex] = <InputPortSelection.kUseFirstInputIfItExists: -2>, output_port_index: Union[pydrake.systems.framework.OutputPortSelection, pydrake.systems.framework.OutputPortIndex] = <OutputPortSelection.kUseFirstOutputIfItExists: -2>) pydrake.systems.primitives.AffineSystem
A first-order Taylor series approximation to a
system
in the neighborhood of an arbitrary point. When Taylor-expanding a system at a non-equilibrium point, it may be represented either of the form:\[\dot{x} - \dot{x}_0 = A (x - x_0) + B (u - u_0),\]for continuous time, or
\[x[n+1] - x_0[n+1] = A (x[n] - x_0[n]) + B (u[n] - u_0[n]),\]for discrete time. As above, we denote \(x_0, u_0\) to be the nominal state and input at the provided
context
. The system description is affine when the terms \(\dot{x}_0 - A x_0 - B u_0\) and \(x_0[n+1] - A x_0[n] - B u_0[n]\) are nonzero.More precisely, let x be a state and u be an input. This function returns an AffineSystem of the form:
\[\dot{x} = A x + B u + f_0,\](CT)
\[x[n+1] = A x[n] + B u[n] + f_0,\](DT) where \(f_0 = \dot{x}_0 - A x_0 - B u_0\) (CT) and \(f_0 = x_0[n+1] - A x[n] - B u[n]\) (DT).
This method currently supports approximating around at most a single vector input port and at most a single vector output port. For systems with more ports, use
input_port_index
andoutput_port_index
to select the input for the newly constructed system. Any additional input ports will be treated as constants (fixed at the value specified incontext)
.- Parameter
system
: The system or subsystem to linearize.
- Parameter
context
: Defines the nominal operating point about which the system should be linearized.
- Parameter
input_port_index
: A valid input port index for
system
or InputPortSelection. $*Default:* kUseFirstInputIfItExists.- Parameter
output_port_index
: A valid output port index for
system
or OutputPortSelection. $*Default:* kUseFirstOutputIfItExists.
- Returns
An AffineSystem at this linearization point.
- Raises
if any abstract inputs are connected, if any vector-valued inputs –
are unconnected, if the system is not (only) continuous or not –
(only) discrete time with a single periodic update. –
Note
x, u and y are in the same coordinate system as the original
system
, since the terms involving \(x_0, u_0\) reside in \(f_0\).Note
This method does not (yet) set the initial conditions (default nor random) of the AffineSystem based on
system
.- Parameter
- class pydrake.systems.primitives.Gain
Bases:
pydrake.systems.framework.LeafSystem
An element-wise gain block with input
u
and outputy = k * u
withk
a constant vector. The input to this system directly feeds through to its output.u0→ Gain → y0 Note
This class is templated; see
Gain_
for the list of instantiations.- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.Gain, k: float, size: int) -> None
Constructs a Gain system where the same gain is applied to every input value.
- Parameter
k
: the gain constant so that
y = k * u
.- Parameter
size
: number of elements in the signal to be processed.
__init__(self: pydrake.systems.primitives.Gain, k: numpy.ndarray[numpy.float64[m, 1]]) -> None
Constructs a Gain system where different gains can be applied to each input value.
- Parameter
k
: the gain vector constants so that
y_i = k_i * u_i
where subscripti
indicates the i-th element of the vector.
- template pydrake.systems.primitives.Gain_
Instantiations:
Gain_[float]
,Gain_[AutoDiffXd]
,Gain_[Expression]
- class pydrake.systems.primitives.Gain_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
An element-wise gain block with input
u
and outputy = k * u
withk
a constant vector. The input to this system directly feeds through to its output.u0→ Gain → y0 - __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.Gain_[AutoDiffXd], k: float, size: int) -> None
Constructs a Gain system where the same gain is applied to every input value.
- Parameter
k
: the gain constant so that
y = k * u
.- Parameter
size
: number of elements in the signal to be processed.
__init__(self: pydrake.systems.primitives.Gain_[AutoDiffXd], k: numpy.ndarray[numpy.float64[m, 1]]) -> None
Constructs a Gain system where different gains can be applied to each input value.
- Parameter
k
: the gain vector constants so that
y_i = k_i * u_i
where subscripti
indicates the i-th element of the vector.
- class pydrake.systems.primitives.Gain_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
An element-wise gain block with input
u
and outputy = k * u
withk
a constant vector. The input to this system directly feeds through to its output.u0→ Gain → y0 - __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.Gain_[Expression], k: float, size: int) -> None
Constructs a Gain system where the same gain is applied to every input value.
- Parameter
k
: the gain constant so that
y = k * u
.- Parameter
size
: number of elements in the signal to be processed.
__init__(self: pydrake.systems.primitives.Gain_[Expression], k: numpy.ndarray[numpy.float64[m, 1]]) -> None
Constructs a Gain system where different gains can be applied to each input value.
- Parameter
k
: the gain vector constants so that
y_i = k_i * u_i
where subscripti
indicates the i-th element of the vector.
- class pydrake.systems.primitives.Integrator
Bases:
pydrake.systems.framework.LeafSystem
A continuous-time integrator for a vector input.
u0→ Integrator → y0 Note
This class is templated; see
Integrator_
for the list of instantiations.- __init__(self: pydrake.systems.primitives.Integrator, arg0: int) None
Constructs an Integrator system.
- Parameter
size
: number of elements in the signal to be processed.
- Parameter
- set_integral_value(self: pydrake.systems.primitives.Integrator, context: pydrake.systems.framework.Context, value: numpy.ndarray[numpy.float64[m, 1]]) None
Sets the value of the integral modifying the state in the context.
value
must be a column vector of the appropriate size.
- template pydrake.systems.primitives.Integrator_
Instantiations:
Integrator_[float]
,Integrator_[AutoDiffXd]
,Integrator_[Expression]
- class pydrake.systems.primitives.Integrator_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
A continuous-time integrator for a vector input.
u0→ Integrator → y0 - __init__(self: pydrake.systems.primitives.Integrator_[AutoDiffXd], arg0: int) None
Constructs an Integrator system.
- Parameter
size
: number of elements in the signal to be processed.
- Parameter
- set_integral_value(self: pydrake.systems.primitives.Integrator_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd], value: numpy.ndarray[object[m, 1]]) None
Sets the value of the integral modifying the state in the context.
value
must be a column vector of the appropriate size.
- class pydrake.systems.primitives.Integrator_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
A continuous-time integrator for a vector input.
u0→ Integrator → y0 - __init__(self: pydrake.systems.primitives.Integrator_[Expression], arg0: int) None
Constructs an Integrator system.
- Parameter
size
: number of elements in the signal to be processed.
- Parameter
- set_integral_value(self: pydrake.systems.primitives.Integrator_[Expression], context: pydrake.systems.framework.Context_[Expression], value: numpy.ndarray[object[m, 1]]) None
Sets the value of the integral modifying the state in the context.
value
must be a column vector of the appropriate size.
- pydrake.systems.primitives.IsControllable(sys: pydrake.systems.primitives.LinearSystem, threshold: Optional[float] = None) bool
Returns true iff the controllability matrix is full row rank.
- pydrake.systems.primitives.IsDetectable(sys: pydrake.systems.primitives.LinearSystem, threshold: Optional[float] = None) bool
Returns true iff the system is detectable.
- pydrake.systems.primitives.IsObservable(sys: pydrake.systems.primitives.LinearSystem, threshold: Optional[float] = None) bool
Returns true iff the observability matrix is full column rank.
- pydrake.systems.primitives.IsStabilizable(sys: pydrake.systems.primitives.LinearSystem, threshold: Optional[float] = None) bool
Returns true iff the system is stabilizable.
- pydrake.systems.primitives.Linearize(system: pydrake.systems.framework.System, context: pydrake.systems.framework.Context, input_port_index: Union[pydrake.systems.framework.InputPortSelection, pydrake.systems.framework.InputPortIndex] = <InputPortSelection.kUseFirstInputIfItExists: -2>, output_port_index: Union[pydrake.systems.framework.OutputPortSelection, pydrake.systems.framework.OutputPortIndex] = <OutputPortSelection.kUseFirstOutputIfItExists: -2>, equilibrium_check_tolerance: float = 1e-06) pydrake.systems.primitives.LinearSystem
Takes the first-order Taylor expansion of a System around a nominal operating point (defined by the Context).
This method currently supports linearizing around at most a single vector input port and at most a single vector output port. For systems with more ports, use
input_port_index
andoutput_port_index
to select the input for the newly constructed system. Any additional vector input ports will be treated as constants (fixed at the value specified incontext
). Abstract-valued input ports must be unconnected (i.e., the system must treat the port as optional and it must be unused).- Parameter
system
: The system or subsystem to linearize.
- Parameter
context
: Defines the nominal operating point about which the system should be linearized. See note below.
- Parameter
input_port_index
: A valid input port index for
system
or InputPortSelection. All other inputs are assumed to be fixed to the value described by thecontext
. $*Default:* kUseFirstInputIfItExists.- Parameter
output_port_index
: A valid output port index for
system
or an OutputPortSelection. $*Default:* kUseFirstOutputIfItExists.- Parameter
equilibrium_check_tolerance
: Specifies the tolerance on ensuring that the derivative vector isZero at the nominal operating point. $*Default:* 1e-6.
- Returns
A LinearSystem that approximates the original system in the vicinity of the operating point. See note below.
- Raises
RuntimeError if the operating point is not an equilibrium point of –
the system (within the specified tolerance) –
RuntimeError if the system is not (only) continuous or (only) –
discrete time with a single periodic update. –
Note
All vector inputs in the system must be connected, either to the output of some upstream System within a Diagram (e.g., if system is a reference to a subsystem in a Diagram), or to a constant value using, e.g.
port.FixValue(context, default_input)
. Any abstract inputs in the system must be unconnected (the port must be both optional and unused).Note
The inputs, states, and outputs of the returned system are NOT the same as the original system. Denote x0,u0 as the nominal state and input defined by the Context, and y0 as the value of the output at (x0,u0), then the created systems inputs are (u-u0), states are (x-x0), and outputs are (y-y0).
Note
This method does not (yet) set the initial conditions (default nor random) of the LinearSystem based on
system
.- Parameter
- class pydrake.systems.primitives.LinearSystem
Bases:
pydrake.systems.primitives.AffineSystem
A discrete OR continuous linear system.
u0→ LinearSystem → y0 If time_period>0.0, then the linear system will have the following discrete- time state update:
\[x[n+1] = A x[n] + B u[n],\]or if time_period==0.0, then the linear system will have the following continuous-time state update:
\[\dot{x} = A x + B u.\]In both cases, the system will have the output:
\[y = C x + D u,\]where
u
denotes the input vector,x
denotes the state vector, andy
denotes the output vector.See also
AffineSystem
See also
MatrixGain
Note
This class is templated; see
LinearSystem_
for the list of instantiations.- __init__(self: pydrake.systems.primitives.LinearSystem, A: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), B: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), C: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), D: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), time_period: float = 0.0) None
Constructs a LinearSystem with a fixed set of coefficient matrices
A
, B,``C``, andD
. The coefficient matrices must obey the following dimensions: | Matrix | Num Rows | Num Columns | |:-------:|:———–:|:-----------:| | A | num states | num states | | B | num states | num inputs | | C | num outputs | num states | | D | num outputs | num inputs |Empty matrices are treated as zero matrices with the appropriate number of rows and columns.
Subclasses must use the protected constructor, not this one.
- template pydrake.systems.primitives.LinearSystem_
Instantiations:
LinearSystem_[float]
,LinearSystem_[AutoDiffXd]
,LinearSystem_[Expression]
- class pydrake.systems.primitives.LinearSystem_[AutoDiffXd]
Bases:
pydrake.systems.primitives.AffineSystem_[AutoDiffXd]
A discrete OR continuous linear system.
u0→ LinearSystem → y0 If time_period>0.0, then the linear system will have the following discrete- time state update:
\[x[n+1] = A x[n] + B u[n],\]or if time_period==0.0, then the linear system will have the following continuous-time state update:
\[\dot{x} = A x + B u.\]In both cases, the system will have the output:
\[y = C x + D u,\]where
u
denotes the input vector,x
denotes the state vector, andy
denotes the output vector.See also
AffineSystem
See also
MatrixGain
- __init__(self: pydrake.systems.primitives.LinearSystem_[AutoDiffXd], A: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), B: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), C: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), D: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), time_period: float = 0.0) None
Constructs a LinearSystem with a fixed set of coefficient matrices
A
, B,``C``, andD
. The coefficient matrices must obey the following dimensions: | Matrix | Num Rows | Num Columns | |:-------:|:———–:|:-----------:| | A | num states | num states | | B | num states | num inputs | | C | num outputs | num states | | D | num outputs | num inputs |Empty matrices are treated as zero matrices with the appropriate number of rows and columns.
Subclasses must use the protected constructor, not this one.
- class pydrake.systems.primitives.LinearSystem_[Expression]
Bases:
pydrake.systems.primitives.AffineSystem_[Expression]
A discrete OR continuous linear system.
u0→ LinearSystem → y0 If time_period>0.0, then the linear system will have the following discrete- time state update:
\[x[n+1] = A x[n] + B u[n],\]or if time_period==0.0, then the linear system will have the following continuous-time state update:
\[\dot{x} = A x + B u.\]In both cases, the system will have the output:
\[y = C x + D u,\]where
u
denotes the input vector,x
denotes the state vector, andy
denotes the output vector.See also
AffineSystem
See also
MatrixGain
- __init__(self: pydrake.systems.primitives.LinearSystem_[Expression], A: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), B: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), C: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), D: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous] = array([], shape=(0, 0), dtype=float64), time_period: float = 0.0) None
Constructs a LinearSystem with a fixed set of coefficient matrices
A
, B,``C``, andD
. The coefficient matrices must obey the following dimensions: | Matrix | Num Rows | Num Columns | |:-------:|:———–:|:-----------:| | A | num states | num states | | B | num states | num inputs | | C | num outputs | num states | | D | num outputs | num inputs |Empty matrices are treated as zero matrices with the appropriate number of rows and columns.
Subclasses must use the protected constructor, not this one.
- class pydrake.systems.primitives.LinearTransformDensity
Bases:
pydrake.systems.framework.LeafSystem
Performs linear transformation on the random signal w_in as w_out = A*w_in + b. The user can obtain the probability density of w_out. When the class is instantiated with autodiff scalar, the user can also obtain the gradient of the probability density of w_out.
w_in→ A→ b→ LinearTransformDensity → w_out → w_out_density The
b
port can remain disconnected, in which case it defaults to zero.A
should be a matrix using a column-major order.The user should make sure that the input port
w_in
is connected from the output port of a RandomSource with the same distribution. A recommended way is to useAddRandomInputs()
.Warning
The code cannot verify that the distribution type of w_in matches between where w_in comes from and the w_in input port of this system. This class will quietly produce incorrect behavior if the distribution types don’t match.
See also
stochastic_systems
Note
This class is templated; see
LinearTransformDensity_
for the list of instantiations.- __init__(self: pydrake.systems.primitives.LinearTransformDensity, distribution: pydrake.common.RandomDistribution, input_size: int, output_size: int) None
- Parameter
distribution
: The random input w_in should satisfy this distribution.
- Parameter
input_size
: The dimension of the input w_in.
- Parameter
output_size
: The dimension of the output w_out.
Note
The matrix A will have
output_size
columns andinput_size
rows. The vector b will haveoutput_size
columns.- Parameter
- CalcDensity(self: pydrake.systems.primitives.LinearTransformDensity, context: pydrake.systems.framework.Context) float
Compute the density (pdf) of a sampled output w_out.
When T=AutoDiffXd, this function computes the gradient of the function density(w_out_sample). Namely given an output sample, we want to know how the probability of drawing this sample would change, when the parameters of the distribution (like A and b) change. Such information is locally expressed in the gradient. Note this is different from computing the density of the input.
- Raises
RuntimeError if A is not an invertible matrix. –
- FixConstantA(self: pydrake.systems.primitives.LinearTransformDensity, context: pydrake.systems.framework.Context, A: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]) pydrake.systems.framework.FixedInputPortValue
Fix the input port
A
to a constant value in a given context.- Parameter
context
: The context into which A’s value is set.
- Parameter
A
: The value to which the port is fixed. The matrix A has num_output rows and num_input columns, note that A is column-majored.
- Parameter
- FixConstantB(self: pydrake.systems.primitives.LinearTransformDensity, context: pydrake.systems.framework.Context, b: numpy.ndarray[numpy.float64[m, 1]]) pydrake.systems.framework.FixedInputPortValue
Fix the input port
b
to a constant value in a given context.- Parameter
context
: The context into which b’s value is set.
- Parameter
b
: The value to which the port is fixed. The vector b has num_output rows.
- Parameter
- get_distribution(self: pydrake.systems.primitives.LinearTransformDensity) pydrake.common.RandomDistribution
Gets the random distribution type.
- get_input_port_A(self: pydrake.systems.primitives.LinearTransformDensity) pydrake.systems.framework.InputPort
Gets the input port for A.
- get_input_port_b(self: pydrake.systems.primitives.LinearTransformDensity) pydrake.systems.framework.InputPort
Gets the input port for b.
- get_input_port_w_in(self: pydrake.systems.primitives.LinearTransformDensity) pydrake.systems.framework.InputPort
Gets the input port for w_in.
- get_output_port_w_out(self: pydrake.systems.primitives.LinearTransformDensity) pydrake.systems.framework.OutputPort
- get_output_port_w_out_density(self: pydrake.systems.primitives.LinearTransformDensity) pydrake.systems.framework.OutputPort
- template pydrake.systems.primitives.LinearTransformDensity_
Instantiations:
LinearTransformDensity_[float]
,LinearTransformDensity_[AutoDiffXd]
- class pydrake.systems.primitives.LinearTransformDensity_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
Performs linear transformation on the random signal w_in as w_out = A*w_in + b. The user can obtain the probability density of w_out. When the class is instantiated with autodiff scalar, the user can also obtain the gradient of the probability density of w_out.
w_in→ A→ b→ LinearTransformDensity → w_out → w_out_density The
b
port can remain disconnected, in which case it defaults to zero.A
should be a matrix using a column-major order.The user should make sure that the input port
w_in
is connected from the output port of a RandomSource with the same distribution. A recommended way is to useAddRandomInputs()
.Warning
The code cannot verify that the distribution type of w_in matches between where w_in comes from and the w_in input port of this system. This class will quietly produce incorrect behavior if the distribution types don’t match.
See also
stochastic_systems
- __init__(self: pydrake.systems.primitives.LinearTransformDensity_[AutoDiffXd], distribution: pydrake.common.RandomDistribution, input_size: int, output_size: int) None
- Parameter
distribution
: The random input w_in should satisfy this distribution.
- Parameter
input_size
: The dimension of the input w_in.
- Parameter
output_size
: The dimension of the output w_out.
Note
The matrix A will have
output_size
columns andinput_size
rows. The vector b will haveoutput_size
columns.- Parameter
- CalcDensity(self: pydrake.systems.primitives.LinearTransformDensity_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd]) pydrake.autodiffutils.AutoDiffXd
Compute the density (pdf) of a sampled output w_out.
When T=AutoDiffXd, this function computes the gradient of the function density(w_out_sample). Namely given an output sample, we want to know how the probability of drawing this sample would change, when the parameters of the distribution (like A and b) change. Such information is locally expressed in the gradient. Note this is different from computing the density of the input.
- Raises
RuntimeError if A is not an invertible matrix. –
- FixConstantA(self: pydrake.systems.primitives.LinearTransformDensity_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd], A: numpy.ndarray[object[m, n], flags.f_contiguous]) pydrake.systems.framework.FixedInputPortValue
Fix the input port
A
to a constant value in a given context.- Parameter
context
: The context into which A’s value is set.
- Parameter
A
: The value to which the port is fixed. The matrix A has num_output rows and num_input columns, note that A is column-majored.
- Parameter
- FixConstantB(self: pydrake.systems.primitives.LinearTransformDensity_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd], b: numpy.ndarray[object[m, 1]]) pydrake.systems.framework.FixedInputPortValue
Fix the input port
b
to a constant value in a given context.- Parameter
context
: The context into which b’s value is set.
- Parameter
b
: The value to which the port is fixed. The vector b has num_output rows.
- Parameter
- get_distribution(self: pydrake.systems.primitives.LinearTransformDensity_[AutoDiffXd]) pydrake.common.RandomDistribution
Gets the random distribution type.
- get_input_port_A(self: pydrake.systems.primitives.LinearTransformDensity_[AutoDiffXd]) pydrake.systems.framework.InputPort_[AutoDiffXd]
Gets the input port for A.
- get_input_port_b(self: pydrake.systems.primitives.LinearTransformDensity_[AutoDiffXd]) pydrake.systems.framework.InputPort_[AutoDiffXd]
Gets the input port for b.
- get_input_port_w_in(self: pydrake.systems.primitives.LinearTransformDensity_[AutoDiffXd]) pydrake.systems.framework.InputPort_[AutoDiffXd]
Gets the input port for w_in.
- get_output_port_w_out(self: pydrake.systems.primitives.LinearTransformDensity_[AutoDiffXd]) pydrake.systems.framework.OutputPort_[AutoDiffXd]
- get_output_port_w_out_density(self: pydrake.systems.primitives.LinearTransformDensity_[AutoDiffXd]) pydrake.systems.framework.OutputPort_[AutoDiffXd]
- pydrake.systems.primitives.LogVectorOutput(*args, **kwargs)
Overloaded function.
LogVectorOutput(src: pydrake.systems.framework.OutputPort, builder: pydrake.systems.framework.DiagramBuilder, publish_period: float = 0.0) -> pydrake.systems.primitives.VectorLogSink
LogVectorOutput provides a convenience function for adding a VectorLogSink, initialized to the correct size, and connected to an output in a DiagramBuilder. This overload supports the default set of publish triggers. See vector_log_sink_default_triggers “default triggers description”.
- Parameter
src
: the output port to attach logging to.
- Parameter
builder
: the diagram builder.
- Parameter
publish_period
: Period that messages will be published (optional). If the publish period is zero, VectorLogSink will use per-step publishing instead; see LeafSystem::DeclarePerStepPublishEvent().
- Precondition:
publish_period is non-negative.
LogVectorOutput(src: pydrake.systems.framework.OutputPort, builder: pydrake.systems.framework.DiagramBuilder, publish_triggers: set[pydrake.systems.framework.TriggerType], publish_period: float = 0.0) -> pydrake.systems.primitives.VectorLogSink
LogVectorOutput provides a convenience function for adding a VectorLogSink, initialized to the correct size, and connected to an output in a DiagramBuilder. This overload supports the full variety of publish trigger behavior.
- Parameter
src
: the output port to attach logging to.
- Parameter
builder
: the diagram builder.
- Parameter
publish_triggers
: Set of triggers that determine when messages will be published. Supported TriggerTypes are {kForced, kPeriodic, kPerStep}. Will throw an error if empty or if unsupported types are provided.
- Parameter
publish_period
: Period that messages will be published (optional). publish_period should only be non-zero if one of the publish_triggers is kPeriodic.
- Precondition:
publish_period is non-negative.
- Precondition:
publish_period > 0 if and only if publish_triggers contains kPeriodic.
LogVectorOutput(src: pydrake.systems.framework.OutputPort_[AutoDiffXd], builder: pydrake.systems.framework.DiagramBuilder_[AutoDiffXd], publish_period: float = 0.0) -> pydrake.systems.primitives.VectorLogSink_[AutoDiffXd]
LogVectorOutput provides a convenience function for adding a VectorLogSink, initialized to the correct size, and connected to an output in a DiagramBuilder. This overload supports the default set of publish triggers. See vector_log_sink_default_triggers “default triggers description”.
- Parameter
src
: the output port to attach logging to.
- Parameter
builder
: the diagram builder.
- Parameter
publish_period
: Period that messages will be published (optional). If the publish period is zero, VectorLogSink will use per-step publishing instead; see LeafSystem::DeclarePerStepPublishEvent().
- Precondition:
publish_period is non-negative.
LogVectorOutput(src: pydrake.systems.framework.OutputPort_[AutoDiffXd], builder: pydrake.systems.framework.DiagramBuilder_[AutoDiffXd], publish_triggers: set[pydrake.systems.framework.TriggerType], publish_period: float = 0.0) -> pydrake.systems.primitives.VectorLogSink_[AutoDiffXd]
LogVectorOutput provides a convenience function for adding a VectorLogSink, initialized to the correct size, and connected to an output in a DiagramBuilder. This overload supports the full variety of publish trigger behavior.
- Parameter
src
: the output port to attach logging to.
- Parameter
builder
: the diagram builder.
- Parameter
publish_triggers
: Set of triggers that determine when messages will be published. Supported TriggerTypes are {kForced, kPeriodic, kPerStep}. Will throw an error if empty or if unsupported types are provided.
- Parameter
publish_period
: Period that messages will be published (optional). publish_period should only be non-zero if one of the publish_triggers is kPeriodic.
- Precondition:
publish_period is non-negative.
- Precondition:
publish_period > 0 if and only if publish_triggers contains kPeriodic.
LogVectorOutput(src: pydrake.systems.framework.OutputPort_[Expression], builder: pydrake.systems.framework.DiagramBuilder_[Expression], publish_period: float = 0.0) -> pydrake.systems.primitives.VectorLogSink_[Expression]
LogVectorOutput provides a convenience function for adding a VectorLogSink, initialized to the correct size, and connected to an output in a DiagramBuilder. This overload supports the default set of publish triggers. See vector_log_sink_default_triggers “default triggers description”.
- Parameter
src
: the output port to attach logging to.
- Parameter
builder
: the diagram builder.
- Parameter
publish_period
: Period that messages will be published (optional). If the publish period is zero, VectorLogSink will use per-step publishing instead; see LeafSystem::DeclarePerStepPublishEvent().
- Precondition:
publish_period is non-negative.
LogVectorOutput(src: pydrake.systems.framework.OutputPort_[Expression], builder: pydrake.systems.framework.DiagramBuilder_[Expression], publish_triggers: set[pydrake.systems.framework.TriggerType], publish_period: float = 0.0) -> pydrake.systems.primitives.VectorLogSink_[Expression]
LogVectorOutput provides a convenience function for adding a VectorLogSink, initialized to the correct size, and connected to an output in a DiagramBuilder. This overload supports the full variety of publish trigger behavior.
- Parameter
src
: the output port to attach logging to.
- Parameter
builder
: the diagram builder.
- Parameter
publish_triggers
: Set of triggers that determine when messages will be published. Supported TriggerTypes are {kForced, kPeriodic, kPerStep}. Will throw an error if empty or if unsupported types are provided.
- Parameter
publish_period
: Period that messages will be published (optional). publish_period should only be non-zero if one of the publish_triggers is kPeriodic.
- Precondition:
publish_period is non-negative.
- Precondition:
publish_period > 0 if and only if publish_triggers contains kPeriodic.
- class pydrake.systems.primitives.MatrixGain
Bases:
pydrake.systems.primitives.LinearSystem
A system that specializes LinearSystem by setting coefficient matrices
A
, B, andC
to all be zero. Thus, the only non-zero coefficient matrix isD
. Specifically, given an input signalu
and a statex
, the output of this system,y
, is:\[y = D u\]name: MatrixGain input_ports: - u0 output_ports: - y0
See also
AffineSystem
See also
LinearSystem
Note
This class is templated; see
MatrixGain_
for the list of instantiations.- __init__(self: pydrake.systems.primitives.MatrixGain, D: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]) None
A constructor where the gain matrix
D
isD
.
- template pydrake.systems.primitives.MatrixGain_
Instantiations:
MatrixGain_[float]
,MatrixGain_[AutoDiffXd]
,MatrixGain_[Expression]
- class pydrake.systems.primitives.MatrixGain_[AutoDiffXd]
Bases:
pydrake.systems.primitives.LinearSystem_[AutoDiffXd]
A system that specializes LinearSystem by setting coefficient matrices
A
, B, andC
to all be zero. Thus, the only non-zero coefficient matrix isD
. Specifically, given an input signalu
and a statex
, the output of this system,y
, is:\[y = D u\]name: MatrixGain input_ports: - u0 output_ports: - y0
See also
AffineSystem
See also
LinearSystem
- __init__(self: pydrake.systems.primitives.MatrixGain_[AutoDiffXd], D: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]) None
A constructor where the gain matrix
D
isD
.
- class pydrake.systems.primitives.MatrixGain_[Expression]
Bases:
pydrake.systems.primitives.LinearSystem_[Expression]
A system that specializes LinearSystem by setting coefficient matrices
A
, B, andC
to all be zero. Thus, the only non-zero coefficient matrix isD
. Specifically, given an input signalu
and a statex
, the output of this system,y
, is:\[y = D u\]name: MatrixGain input_ports: - u0 output_ports: - y0
See also
AffineSystem
See also
LinearSystem
- __init__(self: pydrake.systems.primitives.MatrixGain_[Expression], D: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]) None
A constructor where the gain matrix
D
isD
.
- class pydrake.systems.primitives.MultilayerPerceptron
Bases:
pydrake.systems.framework.LeafSystem
The MultilayerPerceptron (MLP) is one of the most common forms of neural networks used in reinforcement learning (RL) today. This implementation provides a System interface to distinguish between the network’s inputs and outputs (via ports), and the parameters, which are stored in the Context.
Each layer of the network is implemented as xₙ₊₁ = σ(Wₙxₙ+bₙ), where xₙ is the output of the preceding layer, W are the weights, b are the biases, and σ() is the activation function. We additionally use the shorthand x to denote the input layer and y to denote the output layer: y=xₘ for an m-layer network.
Note: For very large-scale neural network implementations, consider using a GPU-accelerated machine learning library like PyTorch, TensorFlow, or JAX. But most MLPs used in controls / RL are actually quite small. For those networks, the cost of transferring values/gradients from Drake to e.g. PyTorch is likely not worth the benefits. Another possible workflow might be to train a network in PyTorch, but then to copy the weights into an instance of this class for simulation.
x→ MultilayerPerceptron → y Note
This class is templated; see
MultilayerPerceptron_
for the list of instantiations.- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.MultilayerPerceptron, layers: list[int], activation_type: pydrake.systems.primitives.PerceptronActivationType = <PerceptronActivationType.kTanh: 2>) -> None
Constructs the MLP with the same activation type for every layer (except the output).
- Parameter
layers
: is the number of elements in each layer of the network (the activation function does not count as an additional layer). The first element specifies the number of inputs, and the last layer specifies the number of outputs.
- Parameter
activation_type
: specifies an activation function, σ(), used in every hidden layer of the network. kIdentity will be used for the output.
__init__(self: pydrake.systems.primitives.MultilayerPerceptron, layers: list[int], activation_types: list[pydrake.systems.primitives.PerceptronActivationType]) -> None
Constructs the MLP with an activation_type specified for each non-input layer.
- Parameter
layers
: is the number of elements in each layer of the network (the activation function does not count as an additional layer). The first element specifies the number of inputs, and the last layer specifies the number of outputs.
- Parameter
activation_type
: specifies the activation function, σ(), used in each non-input layer of the network (including the last layer).
activation_type
should have one less element thanlayers
.__init__(self: pydrake.systems.primitives.MultilayerPerceptron, use_sin_cos_for_input: list[bool], remaining_layers: list[int], activation_types: list[pydrake.systems.primitives.PerceptronActivationType]) -> None
Constructs the MLP with an additional option to transform the input vector so that the function is periodic in 2π.
For instance, for a rotary joint on a robot, this could be used to apply the transform [x, y] => [sin x, cos x, y]. This would be accomplished by passing
use_sin_cos_for_input = [true, false]
.Note that when this transformation is applied,
num_inputs() != layers()[0]
. num_inputs() == 2 != layers()[0] == 3.- Parameter
use_sin_cos_for_input
: is a boolean vector that determines whether the sin/cos transform is applied to each element.
- Parameter
remaining_layers
: is the number of elements in each layer of the network (the activation function does not count as an additional layer). The first element specifies the size of the first hidden layer, and the last layer specifies the number of outputs.
- Parameter
activation_type
: specifies the activation function, σ(), used in each non-input layer of the network (including the last layer).
activation_type
should have the same number of elements asremaining_layers
.
- activation_type(self: pydrake.systems.primitives.MultilayerPerceptron, layer: int) pydrake.systems.primitives.PerceptronActivationType
Returns the type of the activation function, σ(), used in the MLP.
- Backpropagation(self: pydrake.systems.primitives.MultilayerPerceptron, context: pydrake.systems.framework.Context, X: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], loss: Callable[[numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], Optional[numpy.ndarray[numpy.float64[m, n], flags.writeable, flags.f_contiguous]]], float], dloss_dparams: Optional[numpy.ndarray[numpy.float64[m, 1], flags.writeable]]) float
Implements the Backpropagation algorithm for the MLP to compute the gradients of a scalar loss function with respect to the network parameters.
Note: The class uses the System Cache to minimize the number of dynamic memory allocations for repeated calls to this function with the same sized
X
. Changing the batch size between calls to this method or BatchOutput requires memory allocations.- Parameter
X
: is a batch input, with one input per column.
- Parameter
loss
: is a scalar loss function, where
Y
is the columnwise batch output of the network. It should return the scalar loss and setdloss_dY
, the derivatives of the loss with respect toY
, which is pre-allocated to be the same size asY
.- Parameter
dloss_dparams
: are the gradients computed. We take the storage as an input argument to avoid memory allocations inside the algorithm.
- Returns
the calculated loss.
Note: It is expected that this algorithm will be used with T=double. It uses analytical gradients; AutoDiffXd is not required.
- Parameter
- BackpropagationMeanSquaredError(self: pydrake.systems.primitives.MultilayerPerceptron, context: pydrake.systems.framework.Context, X: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], Y_desired: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], dloss_dparams: Optional[numpy.ndarray[numpy.float64[m, 1], flags.writeable]]) float
Calls Backpropagation with the mean-squared error loss function: loss = 1/N ∑ᵢ |yᵢ−yᵢᵈ|², where yᵈ is the desired values for y. See Backpropagation for details.
- BatchOutput(*args, **kwargs)
Overloaded function.
BatchOutput(self: pydrake.systems.primitives.MultilayerPerceptron, context: pydrake.systems.framework.Context, X: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], Y: Optional[numpy.ndarray[numpy.float64[m, n], flags.writeable, flags.f_contiguous]], dYdX: Optional[numpy.ndarray[numpy.float64[m, n], flags.writeable, flags.f_contiguous]] = None) -> None
Evaluates the batch output for the MLP with a batch input vector. Each column of
X
represents an input, and each column ofY
will be assigned the corresponding output.If the output layer of the network has size 1 (scalar output), and
dYdX != nullptr
, thendYdX
is populated with the batch gradients of the scalar outputY
relative to the inputX
: the (i,j)th element represents the gradient dY(0,j) / dX(i,j).Note: In python, use numpy.asfortranarray() to allocate the writeable matrices
Y
and (if needed)dYdX
.This methods shares the cache with Backpropagation. If the size of X changes here or in Backpropagation, it may force dynamic memory allocations.
- Raises
RuntimeError if dYdX != nullptr and the network has more than one –
output. –
BatchOutput(self: pydrake.systems.primitives.MultilayerPerceptron, context: pydrake.systems.framework.Context, X: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]) -> numpy.ndarray[numpy.float64[m, n]]
Evaluates the batch output for the MLP with a batch input vector. See BatchOutput(context, X, Y) for a version that can avoid dynamic memory allocations of Y (e.g. if this is used inside an optimization loop).
- GetBiases(*args, **kwargs)
Overloaded function.
GetBiases(self: pydrake.systems.primitives.MultilayerPerceptron, context: pydrake.systems.framework.Context, layer: int) -> numpy.ndarray[numpy.float64[m, 1]]
Returns the biases used in the mapping from
layer
tolayer+1
.GetBiases(self: pydrake.systems.primitives.MultilayerPerceptron, params: numpy.ndarray[numpy.float64[m, 1]], layer: int) -> numpy.ndarray[numpy.float64[m, 1]]
Returns the biases in
params
used in the mapping fromlayer
tolayer+1
.
- GetMutableParameters(self: pydrake.systems.primitives.MultilayerPerceptron, context: pydrake.systems.framework.Context) numpy.ndarray[numpy.float64[m, 1], flags.writeable]
Returns a mutable reference to all of the parameters (weights and biases) as a single vector.
- GetParameters(self: pydrake.systems.primitives.MultilayerPerceptron, context: pydrake.systems.framework.Context) numpy.ndarray[numpy.float64[m, 1]]
Returns a reference to all of the parameters (weights and biases) as a single vector. Use GetWeights and GetBiases to extract the components.
- GetWeights(*args, **kwargs)
Overloaded function.
GetWeights(self: pydrake.systems.primitives.MultilayerPerceptron, context: pydrake.systems.framework.Context, layer: int) -> numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]
Returns the weights used in the mapping from
layer
tolayer+1
.GetWeights(self: pydrake.systems.primitives.MultilayerPerceptron, params: numpy.ndarray[numpy.float64[m, 1]], layer: int) -> numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]
Returns the weights in
params
used in the mapping fromlayer
tolayer+1
.
- layers(self: pydrake.systems.primitives.MultilayerPerceptron) list[int]
Returns the number of elements in each layer of the network.
- num_parameters(self: pydrake.systems.primitives.MultilayerPerceptron) int
Returns the total number of parameters in the network, including all weights and biases.
- SetBiases(*args, **kwargs)
Overloaded function.
SetBiases(self: pydrake.systems.primitives.MultilayerPerceptron, context: pydrake.systems.framework.Context, layer: int, b: numpy.ndarray[numpy.float64[m, 1]]) -> None
Sets the biases in the
context
used in the mapping fromlayer
tolayer+1
.SetBiases(self: pydrake.systems.primitives.MultilayerPerceptron, params: Optional[numpy.ndarray[numpy.float64[m, 1], flags.writeable]], layer: int, b: numpy.ndarray[numpy.float64[m, 1]]) -> None
Sets the biases in
params
used in the mapping fromlayer
tolayer+1
.
- SetParameters(self: pydrake.systems.primitives.MultilayerPerceptron, context: pydrake.systems.framework.Context, params: numpy.ndarray[numpy.float64[m, 1]]) None
Sets all of the parameters in the network (weights and biases) using a single vector. Use SetWeights and SetBiases to extract the components.
- SetWeights(*args, **kwargs)
Overloaded function.
SetWeights(self: pydrake.systems.primitives.MultilayerPerceptron, context: pydrake.systems.framework.Context, layer: int, W: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]) -> None
Sets the weights in the
context
used in the mapping fromlayer
tolayer+1
.SetWeights(self: pydrake.systems.primitives.MultilayerPerceptron, params: Optional[numpy.ndarray[numpy.float64[m, 1], flags.writeable]], layer: int, W: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]) -> None
Sets the weights in
params
used in the mapping fromlayer
tolayer+1
.
- template pydrake.systems.primitives.MultilayerPerceptron_
Instantiations:
MultilayerPerceptron_[float]
,MultilayerPerceptron_[AutoDiffXd]
,MultilayerPerceptron_[Expression]
- class pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
The MultilayerPerceptron (MLP) is one of the most common forms of neural networks used in reinforcement learning (RL) today. This implementation provides a System interface to distinguish between the network’s inputs and outputs (via ports), and the parameters, which are stored in the Context.
Each layer of the network is implemented as xₙ₊₁ = σ(Wₙxₙ+bₙ), where xₙ is the output of the preceding layer, W are the weights, b are the biases, and σ() is the activation function. We additionally use the shorthand x to denote the input layer and y to denote the output layer: y=xₘ for an m-layer network.
Note: For very large-scale neural network implementations, consider using a GPU-accelerated machine learning library like PyTorch, TensorFlow, or JAX. But most MLPs used in controls / RL are actually quite small. For those networks, the cost of transferring values/gradients from Drake to e.g. PyTorch is likely not worth the benefits. Another possible workflow might be to train a network in PyTorch, but then to copy the weights into an instance of this class for simulation.
x→ MultilayerPerceptron → y - __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd], layers: list[int], activation_type: pydrake.systems.primitives.PerceptronActivationType = <PerceptronActivationType.kTanh: 2>) -> None
Constructs the MLP with the same activation type for every layer (except the output).
- Parameter
layers
: is the number of elements in each layer of the network (the activation function does not count as an additional layer). The first element specifies the number of inputs, and the last layer specifies the number of outputs.
- Parameter
activation_type
: specifies an activation function, σ(), used in every hidden layer of the network. kIdentity will be used for the output.
__init__(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd], layers: list[int], activation_types: list[pydrake.systems.primitives.PerceptronActivationType]) -> None
Constructs the MLP with an activation_type specified for each non-input layer.
- Parameter
layers
: is the number of elements in each layer of the network (the activation function does not count as an additional layer). The first element specifies the number of inputs, and the last layer specifies the number of outputs.
- Parameter
activation_type
: specifies the activation function, σ(), used in each non-input layer of the network (including the last layer).
activation_type
should have one less element thanlayers
.__init__(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd], use_sin_cos_for_input: list[bool], remaining_layers: list[int], activation_types: list[pydrake.systems.primitives.PerceptronActivationType]) -> None
Constructs the MLP with an additional option to transform the input vector so that the function is periodic in 2π.
For instance, for a rotary joint on a robot, this could be used to apply the transform [x, y] => [sin x, cos x, y]. This would be accomplished by passing
use_sin_cos_for_input = [true, false]
.Note that when this transformation is applied,
num_inputs() != layers()[0]
. num_inputs() == 2 != layers()[0] == 3.- Parameter
use_sin_cos_for_input
: is a boolean vector that determines whether the sin/cos transform is applied to each element.
- Parameter
remaining_layers
: is the number of elements in each layer of the network (the activation function does not count as an additional layer). The first element specifies the size of the first hidden layer, and the last layer specifies the number of outputs.
- Parameter
activation_type
: specifies the activation function, σ(), used in each non-input layer of the network (including the last layer).
activation_type
should have the same number of elements asremaining_layers
.
- activation_type(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd], layer: int) pydrake.systems.primitives.PerceptronActivationType
Returns the type of the activation function, σ(), used in the MLP.
- Backpropagation(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd], X: numpy.ndarray[object[m, n], flags.f_contiguous], loss: Callable[[numpy.ndarray[object[m, n], flags.f_contiguous], Optional[numpy.ndarray[object[m, n], flags.writeable, flags.f_contiguous]]], pydrake.autodiffutils.AutoDiffXd], dloss_dparams: Optional[numpy.ndarray[object[m, 1], flags.writeable]]) pydrake.autodiffutils.AutoDiffXd
Implements the Backpropagation algorithm for the MLP to compute the gradients of a scalar loss function with respect to the network parameters.
Note: The class uses the System Cache to minimize the number of dynamic memory allocations for repeated calls to this function with the same sized
X
. Changing the batch size between calls to this method or BatchOutput requires memory allocations.- Parameter
X
: is a batch input, with one input per column.
- Parameter
loss
: is a scalar loss function, where
Y
is the columnwise batch output of the network. It should return the scalar loss and setdloss_dY
, the derivatives of the loss with respect toY
, which is pre-allocated to be the same size asY
.- Parameter
dloss_dparams
: are the gradients computed. We take the storage as an input argument to avoid memory allocations inside the algorithm.
- Returns
the calculated loss.
Note: It is expected that this algorithm will be used with T=double. It uses analytical gradients; AutoDiffXd is not required.
- Parameter
- BackpropagationMeanSquaredError(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd], X: numpy.ndarray[object[m, n], flags.f_contiguous], Y_desired: numpy.ndarray[object[m, n], flags.f_contiguous], dloss_dparams: Optional[numpy.ndarray[object[m, 1], flags.writeable]]) pydrake.autodiffutils.AutoDiffXd
Calls Backpropagation with the mean-squared error loss function: loss = 1/N ∑ᵢ |yᵢ−yᵢᵈ|², where yᵈ is the desired values for y. See Backpropagation for details.
- BatchOutput(*args, **kwargs)
Overloaded function.
BatchOutput(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd], X: numpy.ndarray[object[m, n], flags.f_contiguous], Y: Optional[numpy.ndarray[object[m, n], flags.writeable, flags.f_contiguous]], dYdX: Optional[numpy.ndarray[object[m, n], flags.writeable, flags.f_contiguous]] = None) -> None
Evaluates the batch output for the MLP with a batch input vector. Each column of
X
represents an input, and each column ofY
will be assigned the corresponding output.If the output layer of the network has size 1 (scalar output), and
dYdX != nullptr
, thendYdX
is populated with the batch gradients of the scalar outputY
relative to the inputX
: the (i,j)th element represents the gradient dY(0,j) / dX(i,j).Note: In python, use numpy.asfortranarray() to allocate the writeable matrices
Y
and (if needed)dYdX
.This methods shares the cache with Backpropagation. If the size of X changes here or in Backpropagation, it may force dynamic memory allocations.
- Raises
RuntimeError if dYdX != nullptr and the network has more than one –
output. –
BatchOutput(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd], X: numpy.ndarray[object[m, n], flags.f_contiguous]) -> numpy.ndarray[object[m, n]]
Evaluates the batch output for the MLP with a batch input vector. See BatchOutput(context, X, Y) for a version that can avoid dynamic memory allocations of Y (e.g. if this is used inside an optimization loop).
- GetBiases(*args, **kwargs)
Overloaded function.
GetBiases(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd], layer: int) -> numpy.ndarray[object[m, 1]]
Returns the biases used in the mapping from
layer
tolayer+1
.GetBiases(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd], params: numpy.ndarray[object[m, 1]], layer: int) -> numpy.ndarray[object[m, 1]]
Returns the biases in
params
used in the mapping fromlayer
tolayer+1
.
- GetMutableParameters(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd]) numpy.ndarray[object[m, 1], flags.writeable]
Returns a mutable reference to all of the parameters (weights and biases) as a single vector.
- GetParameters(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd]) numpy.ndarray[object[m, 1]]
Returns a reference to all of the parameters (weights and biases) as a single vector. Use GetWeights and GetBiases to extract the components.
- GetWeights(*args, **kwargs)
Overloaded function.
GetWeights(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd], layer: int) -> numpy.ndarray[object[m, n], flags.f_contiguous]
Returns the weights used in the mapping from
layer
tolayer+1
.GetWeights(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd], params: numpy.ndarray[object[m, 1]], layer: int) -> numpy.ndarray[object[m, n], flags.f_contiguous]
Returns the weights in
params
used in the mapping fromlayer
tolayer+1
.
- layers(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd]) list[int]
Returns the number of elements in each layer of the network.
- num_parameters(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd]) int
Returns the total number of parameters in the network, including all weights and biases.
- SetBiases(*args, **kwargs)
Overloaded function.
SetBiases(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd], layer: int, b: numpy.ndarray[object[m, 1]]) -> None
Sets the biases in the
context
used in the mapping fromlayer
tolayer+1
.SetBiases(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd], params: Optional[numpy.ndarray[object[m, 1], flags.writeable]], layer: int, b: numpy.ndarray[object[m, 1]]) -> None
Sets the biases in
params
used in the mapping fromlayer
tolayer+1
.
- SetParameters(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd], params: numpy.ndarray[object[m, 1]]) None
Sets all of the parameters in the network (weights and biases) using a single vector. Use SetWeights and SetBiases to extract the components.
- SetWeights(*args, **kwargs)
Overloaded function.
SetWeights(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd], layer: int, W: numpy.ndarray[object[m, n], flags.f_contiguous]) -> None
Sets the weights in the
context
used in the mapping fromlayer
tolayer+1
.SetWeights(self: pydrake.systems.primitives.MultilayerPerceptron_[AutoDiffXd], params: Optional[numpy.ndarray[object[m, 1], flags.writeable]], layer: int, W: numpy.ndarray[object[m, n], flags.f_contiguous]) -> None
Sets the weights in
params
used in the mapping fromlayer
tolayer+1
.
- class pydrake.systems.primitives.MultilayerPerceptron_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
The MultilayerPerceptron (MLP) is one of the most common forms of neural networks used in reinforcement learning (RL) today. This implementation provides a System interface to distinguish between the network’s inputs and outputs (via ports), and the parameters, which are stored in the Context.
Each layer of the network is implemented as xₙ₊₁ = σ(Wₙxₙ+bₙ), where xₙ is the output of the preceding layer, W are the weights, b are the biases, and σ() is the activation function. We additionally use the shorthand x to denote the input layer and y to denote the output layer: y=xₘ for an m-layer network.
Note: For very large-scale neural network implementations, consider using a GPU-accelerated machine learning library like PyTorch, TensorFlow, or JAX. But most MLPs used in controls / RL are actually quite small. For those networks, the cost of transferring values/gradients from Drake to e.g. PyTorch is likely not worth the benefits. Another possible workflow might be to train a network in PyTorch, but then to copy the weights into an instance of this class for simulation.
x→ MultilayerPerceptron → y - __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression], layers: list[int], activation_type: pydrake.systems.primitives.PerceptronActivationType = <PerceptronActivationType.kTanh: 2>) -> None
Constructs the MLP with the same activation type for every layer (except the output).
- Parameter
layers
: is the number of elements in each layer of the network (the activation function does not count as an additional layer). The first element specifies the number of inputs, and the last layer specifies the number of outputs.
- Parameter
activation_type
: specifies an activation function, σ(), used in every hidden layer of the network. kIdentity will be used for the output.
__init__(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression], layers: list[int], activation_types: list[pydrake.systems.primitives.PerceptronActivationType]) -> None
Constructs the MLP with an activation_type specified for each non-input layer.
- Parameter
layers
: is the number of elements in each layer of the network (the activation function does not count as an additional layer). The first element specifies the number of inputs, and the last layer specifies the number of outputs.
- Parameter
activation_type
: specifies the activation function, σ(), used in each non-input layer of the network (including the last layer).
activation_type
should have one less element thanlayers
.__init__(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression], use_sin_cos_for_input: list[bool], remaining_layers: list[int], activation_types: list[pydrake.systems.primitives.PerceptronActivationType]) -> None
Constructs the MLP with an additional option to transform the input vector so that the function is periodic in 2π.
For instance, for a rotary joint on a robot, this could be used to apply the transform [x, y] => [sin x, cos x, y]. This would be accomplished by passing
use_sin_cos_for_input = [true, false]
.Note that when this transformation is applied,
num_inputs() != layers()[0]
. num_inputs() == 2 != layers()[0] == 3.- Parameter
use_sin_cos_for_input
: is a boolean vector that determines whether the sin/cos transform is applied to each element.
- Parameter
remaining_layers
: is the number of elements in each layer of the network (the activation function does not count as an additional layer). The first element specifies the size of the first hidden layer, and the last layer specifies the number of outputs.
- Parameter
activation_type
: specifies the activation function, σ(), used in each non-input layer of the network (including the last layer).
activation_type
should have the same number of elements asremaining_layers
.
- activation_type(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression], layer: int) pydrake.systems.primitives.PerceptronActivationType
Returns the type of the activation function, σ(), used in the MLP.
- Backpropagation(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression], context: pydrake.systems.framework.Context_[Expression], X: numpy.ndarray[object[m, n], flags.f_contiguous], loss: Callable[[numpy.ndarray[object[m, n], flags.f_contiguous], Optional[numpy.ndarray[object[m, n], flags.writeable, flags.f_contiguous]]], pydrake.symbolic.Expression], dloss_dparams: Optional[numpy.ndarray[object[m, 1], flags.writeable]]) pydrake.symbolic.Expression
Implements the Backpropagation algorithm for the MLP to compute the gradients of a scalar loss function with respect to the network parameters.
Note: The class uses the System Cache to minimize the number of dynamic memory allocations for repeated calls to this function with the same sized
X
. Changing the batch size between calls to this method or BatchOutput requires memory allocations.- Parameter
X
: is a batch input, with one input per column.
- Parameter
loss
: is a scalar loss function, where
Y
is the columnwise batch output of the network. It should return the scalar loss and setdloss_dY
, the derivatives of the loss with respect toY
, which is pre-allocated to be the same size asY
.- Parameter
dloss_dparams
: are the gradients computed. We take the storage as an input argument to avoid memory allocations inside the algorithm.
- Returns
the calculated loss.
Note: It is expected that this algorithm will be used with T=double. It uses analytical gradients; AutoDiffXd is not required.
- Parameter
- BackpropagationMeanSquaredError(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression], context: pydrake.systems.framework.Context_[Expression], X: numpy.ndarray[object[m, n], flags.f_contiguous], Y_desired: numpy.ndarray[object[m, n], flags.f_contiguous], dloss_dparams: Optional[numpy.ndarray[object[m, 1], flags.writeable]]) pydrake.symbolic.Expression
Calls Backpropagation with the mean-squared error loss function: loss = 1/N ∑ᵢ |yᵢ−yᵢᵈ|², where yᵈ is the desired values for y. See Backpropagation for details.
- BatchOutput(*args, **kwargs)
Overloaded function.
BatchOutput(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression], context: pydrake.systems.framework.Context_[Expression], X: numpy.ndarray[object[m, n], flags.f_contiguous], Y: Optional[numpy.ndarray[object[m, n], flags.writeable, flags.f_contiguous]], dYdX: Optional[numpy.ndarray[object[m, n], flags.writeable, flags.f_contiguous]] = None) -> None
Evaluates the batch output for the MLP with a batch input vector. Each column of
X
represents an input, and each column ofY
will be assigned the corresponding output.If the output layer of the network has size 1 (scalar output), and
dYdX != nullptr
, thendYdX
is populated with the batch gradients of the scalar outputY
relative to the inputX
: the (i,j)th element represents the gradient dY(0,j) / dX(i,j).Note: In python, use numpy.asfortranarray() to allocate the writeable matrices
Y
and (if needed)dYdX
.This methods shares the cache with Backpropagation. If the size of X changes here or in Backpropagation, it may force dynamic memory allocations.
- Raises
RuntimeError if dYdX != nullptr and the network has more than one –
output. –
BatchOutput(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression], context: pydrake.systems.framework.Context_[Expression], X: numpy.ndarray[object[m, n], flags.f_contiguous]) -> numpy.ndarray[object[m, n]]
Evaluates the batch output for the MLP with a batch input vector. See BatchOutput(context, X, Y) for a version that can avoid dynamic memory allocations of Y (e.g. if this is used inside an optimization loop).
- GetBiases(*args, **kwargs)
Overloaded function.
GetBiases(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression], context: pydrake.systems.framework.Context_[Expression], layer: int) -> numpy.ndarray[object[m, 1]]
Returns the biases used in the mapping from
layer
tolayer+1
.GetBiases(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression], params: numpy.ndarray[object[m, 1]], layer: int) -> numpy.ndarray[object[m, 1]]
Returns the biases in
params
used in the mapping fromlayer
tolayer+1
.
- GetMutableParameters(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression], context: pydrake.systems.framework.Context_[Expression]) numpy.ndarray[object[m, 1], flags.writeable]
Returns a mutable reference to all of the parameters (weights and biases) as a single vector.
- GetParameters(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression], context: pydrake.systems.framework.Context_[Expression]) numpy.ndarray[object[m, 1]]
Returns a reference to all of the parameters (weights and biases) as a single vector. Use GetWeights and GetBiases to extract the components.
- GetWeights(*args, **kwargs)
Overloaded function.
GetWeights(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression], context: pydrake.systems.framework.Context_[Expression], layer: int) -> numpy.ndarray[object[m, n], flags.f_contiguous]
Returns the weights used in the mapping from
layer
tolayer+1
.GetWeights(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression], params: numpy.ndarray[object[m, 1]], layer: int) -> numpy.ndarray[object[m, n], flags.f_contiguous]
Returns the weights in
params
used in the mapping fromlayer
tolayer+1
.
- layers(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression]) list[int]
Returns the number of elements in each layer of the network.
- num_parameters(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression]) int
Returns the total number of parameters in the network, including all weights and biases.
- SetBiases(*args, **kwargs)
Overloaded function.
SetBiases(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression], context: pydrake.systems.framework.Context_[Expression], layer: int, b: numpy.ndarray[object[m, 1]]) -> None
Sets the biases in the
context
used in the mapping fromlayer
tolayer+1
.SetBiases(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression], params: Optional[numpy.ndarray[object[m, 1], flags.writeable]], layer: int, b: numpy.ndarray[object[m, 1]]) -> None
Sets the biases in
params
used in the mapping fromlayer
tolayer+1
.
- SetParameters(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression], context: pydrake.systems.framework.Context_[Expression], params: numpy.ndarray[object[m, 1]]) None
Sets all of the parameters in the network (weights and biases) using a single vector. Use SetWeights and SetBiases to extract the components.
- SetWeights(*args, **kwargs)
Overloaded function.
SetWeights(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression], context: pydrake.systems.framework.Context_[Expression], layer: int, W: numpy.ndarray[object[m, n], flags.f_contiguous]) -> None
Sets the weights in the
context
used in the mapping fromlayer
tolayer+1
.SetWeights(self: pydrake.systems.primitives.MultilayerPerceptron_[Expression], params: Optional[numpy.ndarray[object[m, 1], flags.writeable]], layer: int, W: numpy.ndarray[object[m, n], flags.f_contiguous]) -> None
Sets the weights in
params
used in the mapping fromlayer
tolayer+1
.
- class pydrake.systems.primitives.Multiplexer
Bases:
pydrake.systems.framework.LeafSystem
This system combines multiple vector-valued inputs into a vector-valued output. The input to this system directly feeds through to its output.
u0→ ...→ u(N-1)→ Multiplexer → y0 Note
This class is templated; see
Multiplexer_
for the list of instantiations.- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.Multiplexer, num_scalar_inputs: int) -> None
Constructs a Multiplexer with
num_scalar_inputs
scalar-valued input ports, and one vector-valued output port of sizenum_scalar_inputs
.u0→ ...→ u(num_scalar_inputs - 1)→ Multiplexer → y0 __init__(self: pydrake.systems.primitives.Multiplexer, input_sizes: list[int]) -> None
Constructs a Multiplexer with
input_sizes.size()
vector-valued input ports where the i-th input has sizeinput_sizes[i]
, and one vector- valued output port of sizesum(input_sizes)
.u0→ ...→ u(input_sizes.size() - 1)→ Multiplexer → y0 __init__(self: pydrake.systems.primitives.Multiplexer, model_vector: pydrake.systems.framework.BasicVector) -> None
Constructs a Multiplexer with model_vector.size() scalar-valued inputs and one vector-valued output port whose size equals the size of
model_vector
. In addition, the output type derives from that ofmodel_vector
.Note
Objects created using this constructor overload do not support system scalar conversion. See system_scalar_conversion.
- template pydrake.systems.primitives.Multiplexer_
Instantiations:
Multiplexer_[float]
,Multiplexer_[AutoDiffXd]
,Multiplexer_[Expression]
- class pydrake.systems.primitives.Multiplexer_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
This system combines multiple vector-valued inputs into a vector-valued output. The input to this system directly feeds through to its output.
u0→ ...→ u(N-1)→ Multiplexer → y0 - __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.Multiplexer_[AutoDiffXd], num_scalar_inputs: int) -> None
Constructs a Multiplexer with
num_scalar_inputs
scalar-valued input ports, and one vector-valued output port of sizenum_scalar_inputs
.u0→ ...→ u(num_scalar_inputs - 1)→ Multiplexer → y0 __init__(self: pydrake.systems.primitives.Multiplexer_[AutoDiffXd], input_sizes: list[int]) -> None
Constructs a Multiplexer with
input_sizes.size()
vector-valued input ports where the i-th input has sizeinput_sizes[i]
, and one vector- valued output port of sizesum(input_sizes)
.u0→ ...→ u(input_sizes.size() - 1)→ Multiplexer → y0 __init__(self: pydrake.systems.primitives.Multiplexer_[AutoDiffXd], model_vector: pydrake.systems.framework.BasicVector_[AutoDiffXd]) -> None
Constructs a Multiplexer with model_vector.size() scalar-valued inputs and one vector-valued output port whose size equals the size of
model_vector
. In addition, the output type derives from that ofmodel_vector
.Note
Objects created using this constructor overload do not support system scalar conversion. See system_scalar_conversion.
- class pydrake.systems.primitives.Multiplexer_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
This system combines multiple vector-valued inputs into a vector-valued output. The input to this system directly feeds through to its output.
u0→ ...→ u(N-1)→ Multiplexer → y0 - __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.Multiplexer_[Expression], num_scalar_inputs: int) -> None
Constructs a Multiplexer with
num_scalar_inputs
scalar-valued input ports, and one vector-valued output port of sizenum_scalar_inputs
.u0→ ...→ u(num_scalar_inputs - 1)→ Multiplexer → y0 __init__(self: pydrake.systems.primitives.Multiplexer_[Expression], input_sizes: list[int]) -> None
Constructs a Multiplexer with
input_sizes.size()
vector-valued input ports where the i-th input has sizeinput_sizes[i]
, and one vector- valued output port of sizesum(input_sizes)
.u0→ ...→ u(input_sizes.size() - 1)→ Multiplexer → y0 __init__(self: pydrake.systems.primitives.Multiplexer_[Expression], model_vector: pydrake.systems.framework.BasicVector_[Expression]) -> None
Constructs a Multiplexer with model_vector.size() scalar-valued inputs and one vector-valued output port whose size equals the size of
model_vector
. In addition, the output type derives from that ofmodel_vector
.Note
Objects created using this constructor overload do not support system scalar conversion. See system_scalar_conversion.
- pydrake.systems.primitives.ObservabilityMatrix(arg0: pydrake.systems.primitives.LinearSystem) numpy.ndarray[numpy.float64[m, n]]
Returns the observability matrix: O = [ C; CA; …; CA^{n-1} ].
- class pydrake.systems.primitives.PassThrough
Bases:
pydrake.systems.framework.LeafSystem
A pass through system with input
u
and outputy = u
. This is mathematically equivalent to a Gain system with its gain equal to one. However this system incurs no computational cost. The input to this system directly feeds through to its output.The system can also be used to provide default values for a port in any diagram. If the input port does not have a value, then the default value passed in the constructor is passed to the output.
This system is used, for instance, in PidController which is a Diagram composed of simple framework primitives. In this case a PassThrough is used to connect the exported input of the Diagram to the inputs of the Gain systems for the proportional and integral constants of the controller. This is necessary to provide an output port to which the internal Gain subsystems connect. In this case the PassThrough is effectively creating an output port that feeds through the input to the Diagram and that can now be connected to the inputs of the inner subsystems to the Diagram. A detailed discussion of the PidController can be found at https://github.com/RobotLocomotion/drake/pull/3132.
u→ PassThrough → y Note
This class is templated; see
PassThrough_
for the list of instantiations.- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.PassThrough, vector_size: int) -> None
Constructs a pass-through system.
- Parameter
vector_size
: number of elements in the signal to be processed. When no input is connected, the output will be a vector of all zeros.
__init__(self: pydrake.systems.primitives.PassThrough, value: numpy.ndarray[numpy.float64[m, 1]]) -> None
Constructs a pass-through system with vector-valued input/output ports.
- Parameter
value
: The model value, which defines the size of the ports and serves as the default when no input is connected.
__init__(self: pydrake.systems.primitives.PassThrough, abstract_model_value: pydrake.common.value.AbstractValue) -> None
Constructs a pass-through system with abstract-valued input/output ports.
- Parameter
abstract_model_value
: A model value, which defines the type of the ports and serves as the default when no input is connected.
- template pydrake.systems.primitives.PassThrough_
Instantiations:
PassThrough_[float]
,PassThrough_[AutoDiffXd]
,PassThrough_[Expression]
- class pydrake.systems.primitives.PassThrough_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
A pass through system with input
u
and outputy = u
. This is mathematically equivalent to a Gain system with its gain equal to one. However this system incurs no computational cost. The input to this system directly feeds through to its output.The system can also be used to provide default values for a port in any diagram. If the input port does not have a value, then the default value passed in the constructor is passed to the output.
This system is used, for instance, in PidController which is a Diagram composed of simple framework primitives. In this case a PassThrough is used to connect the exported input of the Diagram to the inputs of the Gain systems for the proportional and integral constants of the controller. This is necessary to provide an output port to which the internal Gain subsystems connect. In this case the PassThrough is effectively creating an output port that feeds through the input to the Diagram and that can now be connected to the inputs of the inner subsystems to the Diagram. A detailed discussion of the PidController can be found at https://github.com/RobotLocomotion/drake/pull/3132.
u→ PassThrough → y - __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.PassThrough_[AutoDiffXd], vector_size: int) -> None
Constructs a pass-through system.
- Parameter
vector_size
: number of elements in the signal to be processed. When no input is connected, the output will be a vector of all zeros.
__init__(self: pydrake.systems.primitives.PassThrough_[AutoDiffXd], value: numpy.ndarray[numpy.float64[m, 1]]) -> None
Constructs a pass-through system with vector-valued input/output ports.
- Parameter
value
: The model value, which defines the size of the ports and serves as the default when no input is connected.
__init__(self: pydrake.systems.primitives.PassThrough_[AutoDiffXd], abstract_model_value: pydrake.common.value.AbstractValue) -> None
Constructs a pass-through system with abstract-valued input/output ports.
- Parameter
abstract_model_value
: A model value, which defines the type of the ports and serves as the default when no input is connected.
- class pydrake.systems.primitives.PassThrough_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
A pass through system with input
u
and outputy = u
. This is mathematically equivalent to a Gain system with its gain equal to one. However this system incurs no computational cost. The input to this system directly feeds through to its output.The system can also be used to provide default values for a port in any diagram. If the input port does not have a value, then the default value passed in the constructor is passed to the output.
This system is used, for instance, in PidController which is a Diagram composed of simple framework primitives. In this case a PassThrough is used to connect the exported input of the Diagram to the inputs of the Gain systems for the proportional and integral constants of the controller. This is necessary to provide an output port to which the internal Gain subsystems connect. In this case the PassThrough is effectively creating an output port that feeds through the input to the Diagram and that can now be connected to the inputs of the inner subsystems to the Diagram. A detailed discussion of the PidController can be found at https://github.com/RobotLocomotion/drake/pull/3132.
u→ PassThrough → y - __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.PassThrough_[Expression], vector_size: int) -> None
Constructs a pass-through system.
- Parameter
vector_size
: number of elements in the signal to be processed. When no input is connected, the output will be a vector of all zeros.
__init__(self: pydrake.systems.primitives.PassThrough_[Expression], value: numpy.ndarray[numpy.float64[m, 1]]) -> None
Constructs a pass-through system with vector-valued input/output ports.
- Parameter
value
: The model value, which defines the size of the ports and serves as the default when no input is connected.
__init__(self: pydrake.systems.primitives.PassThrough_[Expression], abstract_model_value: pydrake.common.value.AbstractValue) -> None
Constructs a pass-through system with abstract-valued input/output ports.
- Parameter
abstract_model_value
: A model value, which defines the type of the ports and serves as the default when no input is connected.
- class pydrake.systems.primitives.PerceptronActivationType
Specifies one of the common activation functions in a neural network.
Members:
kIdentity :
kReLU :
kTanh :
- __init__(self: pydrake.systems.primitives.PerceptronActivationType, value: int) None
- kIdentity = <PerceptronActivationType.kIdentity: 0>
- kReLU = <PerceptronActivationType.kReLU: 1>
- kTanh = <PerceptronActivationType.kTanh: 2>
- property name
- property value
- class pydrake.systems.primitives.PortSwitch
Bases:
pydrake.systems.framework.LeafSystem
A simple system that passes through the value from just one of its input ports to the output. All inputs (except for the port_selector) must have the same data type as the output.
This system only evaluates the port_selector port and the input port that is indicated by port_selector at runtime. Because of the System framework’s “pull architecture”, this means that entire sub-diagrams can potentially be added with minimal runtime cost (their outputs will not be evaluated until they are selected). Just remember that their state dynamics will still be evaluated when the diagram’s dynamics are evaluated (e.g. during simulation), and their output ports could be evaluated via other connections.
port_selector→ (user assigned port name)→ ...→ (user assigned port name)→ PortSwitch → value Note
This class is templated; see
PortSwitch_
for the list of instantiations.- __init__(self: pydrake.systems.primitives.PortSwitch, vector_size: int) None
Constructs a vector-valued PortSwitch. All input ports declared via DeclareInputPort() will be vector-valued ports of size
vector_size
, which must be greater than zero.
- DeclareInputPort(self: pydrake.systems.primitives.PortSwitch, name: str) pydrake.systems.framework.InputPort
Declares a new input port to the switch with port name
name
. The type of this port is already defined by the type of the output port. This must be called before any Context is allocated.
- get_port_selector_input_port(self: pydrake.systems.primitives.PortSwitch) pydrake.systems.framework.InputPort
Returns the port-selector input port, which is an abstract-valued port of type InputPortIndex.
- template pydrake.systems.primitives.PortSwitch_
Instantiations:
PortSwitch_[float]
,PortSwitch_[AutoDiffXd]
,PortSwitch_[Expression]
- class pydrake.systems.primitives.PortSwitch_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
A simple system that passes through the value from just one of its input ports to the output. All inputs (except for the port_selector) must have the same data type as the output.
This system only evaluates the port_selector port and the input port that is indicated by port_selector at runtime. Because of the System framework’s “pull architecture”, this means that entire sub-diagrams can potentially be added with minimal runtime cost (their outputs will not be evaluated until they are selected). Just remember that their state dynamics will still be evaluated when the diagram’s dynamics are evaluated (e.g. during simulation), and their output ports could be evaluated via other connections.
port_selector→ (user assigned port name)→ ...→ (user assigned port name)→ PortSwitch → value - __init__(self: pydrake.systems.primitives.PortSwitch_[AutoDiffXd], vector_size: int) None
Constructs a vector-valued PortSwitch. All input ports declared via DeclareInputPort() will be vector-valued ports of size
vector_size
, which must be greater than zero.
- DeclareInputPort(self: pydrake.systems.primitives.PortSwitch_[AutoDiffXd], name: str) pydrake.systems.framework.InputPort_[AutoDiffXd]
Declares a new input port to the switch with port name
name
. The type of this port is already defined by the type of the output port. This must be called before any Context is allocated.
- get_port_selector_input_port(self: pydrake.systems.primitives.PortSwitch_[AutoDiffXd]) pydrake.systems.framework.InputPort_[AutoDiffXd]
Returns the port-selector input port, which is an abstract-valued port of type InputPortIndex.
- class pydrake.systems.primitives.PortSwitch_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
A simple system that passes through the value from just one of its input ports to the output. All inputs (except for the port_selector) must have the same data type as the output.
This system only evaluates the port_selector port and the input port that is indicated by port_selector at runtime. Because of the System framework’s “pull architecture”, this means that entire sub-diagrams can potentially be added with minimal runtime cost (their outputs will not be evaluated until they are selected). Just remember that their state dynamics will still be evaluated when the diagram’s dynamics are evaluated (e.g. during simulation), and their output ports could be evaluated via other connections.
port_selector→ (user assigned port name)→ ...→ (user assigned port name)→ PortSwitch → value - __init__(self: pydrake.systems.primitives.PortSwitch_[Expression], vector_size: int) None
Constructs a vector-valued PortSwitch. All input ports declared via DeclareInputPort() will be vector-valued ports of size
vector_size
, which must be greater than zero.
- DeclareInputPort(self: pydrake.systems.primitives.PortSwitch_[Expression], name: str) pydrake.systems.framework.InputPort_[Expression]
Declares a new input port to the switch with port name
name
. The type of this port is already defined by the type of the output port. This must be called before any Context is allocated.
- get_port_selector_input_port(self: pydrake.systems.primitives.PortSwitch_[Expression]) pydrake.systems.framework.InputPort_[Expression]
Returns the port-selector input port, which is an abstract-valued port of type InputPortIndex.
- class pydrake.systems.primitives.RandomSource
Bases:
pydrake.systems.framework.LeafSystem
A source block which generates random numbers at a fixed sampling interval, with a zero-order hold between samples. For continuous-time systems, this can be interpreted as a band-limited approximation of continuous white noise (with a power-spectral density of the form Ts * sinc^2( omega * Ts ), where Ts is the sampling interval.
RandomSource → output This system exposes a parameter named
seed
for the pseudo-random number generator that determines the noise output. Theseed
parameter behaves as follows:1. Each newly-created RandomSource chooses a new
per_instance_seed
member field value for itself. The value will be unique within the current executable process.2. By default,
source.CreateDefaultContext()
will set the returned context’sseed
parameter toper_instance_seed
. Therefore, for a given instance of this system, the parameters, state, and outputs will be identical for all simulations that start from a default context.3. By default,
source.SetRandomContext()
will choose a new, arbitrary value for the context’sseed
parameter, which means that the system’s parameters, state, and outputs will (almost certainly) differ from their defaults.4. The user may call
source.set_fixed_seed(new_seed)
on this system. When anew_seed
value is provided, it is used by bothCreateDefaultContext
andSetRandomContext
. Therefore, the system’s parameters, state, and outputs will be identical to any other instances that share the samenew_seed
value for theirseed
context parameter. Note thatset_fixed_seed
affects subsequently-created contexts; any pre-existing contexts are unaffected. The user may callsource.set_fixed_seed(nullopt)
to revert to the default the behaviors described in #2 and #3 again.5. The context returned by
source.AllocateContext()
does not contain a validseed
parameter; that context should not be used until its values are populated via another Context.Note
This system is only defined for the double scalar type.
Note
The exact distribution results may vary across multiple platforms or revisions of Drake, but will be consistent for all compilations on a given platform and Drake revision.
Note
The hard-coding of (default) distribution parameters is imposed intentionally to simplify analysis (by forcing systems taking noise inputs to implement the shifting/scaling, the system itself contains all of the necessary information for stochastic analysis).
See also
stochastic_systems
- __init__(self: pydrake.systems.primitives.RandomSource, distribution: pydrake.common.RandomDistribution, num_outputs: int, sampling_interval_sec: float) None
Constructs the RandomSource system.
- Parameter
distribution
: The RandomDistribution used for each of the outputs.
- Parameter
num_outputs
: The dimension of the (single) vector output port.
- Parameter
sampling_interval_sec
: The sampling interval in seconds.
- Parameter
- class pydrake.systems.primitives.Saturation
Bases:
pydrake.systems.framework.LeafSystem
An element-wise hard saturation block with inputs signal
u
, saturation values \(u_{min}\) and/or \(u_{max}\), and outputy
respectively as in:\[y = u, u_{min} < u < u_{max}\]\[y = u_{min}, u \le u_{min}\]\[y = u_{max}, u \ge u_{max}\]The input to this system directly feeds through to its output.
Note that \(u_{min}\), and \(u_{max}\), and \(u\) are all vectors of same dimension, and the following condition holds elementwise in runtime.
\[u_{min} <= u_{max}\]The quantities \(u_{min}\), and \(u_{max}\) can be supplied as inputs in separate ports or be initialised as constants using the appropriate constructor by passing their default value. If these quantities are not defined as constants but they are not connected to appropriate sources, their values are taken by default to be \(u_{min} = -\infty\), and \(u_{max} = \infty\) respectively. In this “variable” configuration, at least one of the input ports must be connected.
u0→ u1→ u2→ Saturation → y0 Ports show in <span style=”color:gray”>gray</span> may be absent, depending on how the system is constructed.
Note
This class is templated; see
Saturation_
for the list of instantiations.- __init__(self: pydrake.systems.primitives.Saturation, min_value: numpy.ndarray[numpy.float64[m, 1]], max_value: numpy.ndarray[numpy.float64[m, 1]]) None
Constructs a constant Saturation system where the upper and lower values are represented by vectors of identical size supplied via this constructor.
u0→ Saturation → y0 - Parameter
u_min
: the lower (vector) limit to the saturation.
- Parameter
u_max
: the upper (vector) limit to the saturation.
Please consult this class’s description for the requirements of
u_min
andu_max
.- Parameter
- template pydrake.systems.primitives.Saturation_
Instantiations:
Saturation_[float]
,Saturation_[AutoDiffXd]
,Saturation_[Expression]
- class pydrake.systems.primitives.Saturation_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
An element-wise hard saturation block with inputs signal
u
, saturation values \(u_{min}\) and/or \(u_{max}\), and outputy
respectively as in:\[y = u, u_{min} < u < u_{max}\]\[y = u_{min}, u \le u_{min}\]\[y = u_{max}, u \ge u_{max}\]The input to this system directly feeds through to its output.
Note that \(u_{min}\), and \(u_{max}\), and \(u\) are all vectors of same dimension, and the following condition holds elementwise in runtime.
\[u_{min} <= u_{max}\]The quantities \(u_{min}\), and \(u_{max}\) can be supplied as inputs in separate ports or be initialised as constants using the appropriate constructor by passing their default value. If these quantities are not defined as constants but they are not connected to appropriate sources, their values are taken by default to be \(u_{min} = -\infty\), and \(u_{max} = \infty\) respectively. In this “variable” configuration, at least one of the input ports must be connected.
u0→ u1→ u2→ Saturation → y0 Ports show in <span style=”color:gray”>gray</span> may be absent, depending on how the system is constructed.
- __init__(self: pydrake.systems.primitives.Saturation_[AutoDiffXd], min_value: numpy.ndarray[object[m, 1]], max_value: numpy.ndarray[object[m, 1]]) None
Constructs a constant Saturation system where the upper and lower values are represented by vectors of identical size supplied via this constructor.
u0→ Saturation → y0 - Parameter
u_min
: the lower (vector) limit to the saturation.
- Parameter
u_max
: the upper (vector) limit to the saturation.
Please consult this class’s description for the requirements of
u_min
andu_max
.- Parameter
- class pydrake.systems.primitives.Saturation_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
An element-wise hard saturation block with inputs signal
u
, saturation values \(u_{min}\) and/or \(u_{max}\), and outputy
respectively as in:\[y = u, u_{min} < u < u_{max}\]\[y = u_{min}, u \le u_{min}\]\[y = u_{max}, u \ge u_{max}\]The input to this system directly feeds through to its output.
Note that \(u_{min}\), and \(u_{max}\), and \(u\) are all vectors of same dimension, and the following condition holds elementwise in runtime.
\[u_{min} <= u_{max}\]The quantities \(u_{min}\), and \(u_{max}\) can be supplied as inputs in separate ports or be initialised as constants using the appropriate constructor by passing their default value. If these quantities are not defined as constants but they are not connected to appropriate sources, their values are taken by default to be \(u_{min} = -\infty\), and \(u_{max} = \infty\) respectively. In this “variable” configuration, at least one of the input ports must be connected.
u0→ u1→ u2→ Saturation → y0 Ports show in <span style=”color:gray”>gray</span> may be absent, depending on how the system is constructed.
- __init__(self: pydrake.systems.primitives.Saturation_[Expression], min_value: numpy.ndarray[object[m, 1]], max_value: numpy.ndarray[object[m, 1]]) None
Constructs a constant Saturation system where the upper and lower values are represented by vectors of identical size supplied via this constructor.
u0→ Saturation → y0 - Parameter
u_min
: the lower (vector) limit to the saturation.
- Parameter
u_max
: the upper (vector) limit to the saturation.
Please consult this class’s description for the requirements of
u_min
andu_max
.- Parameter
Bases:
pydrake.systems.framework.LeafSystem
SharedPointerSystem holds a single
shared_ptr
that will be released at System deletion time (i.e., the end of a Diagram lifespan). It has no input, output, state, nor parameters. This is useful for storing objects that will be pointed-to by other systems outside of the usual input/output port connections.Scalar conversion is supported and will simply increment the reference count for the contained object. The contained object will not be scalar-converted, so should not depend on
T
.Note
This class is templated; see
SharedPointerSystem_
for the list of instantiations.Creates a system holding the given value. The value is allowed to be
nullptr
.Note
To immediately give up ownership at the call site, remember to use
std::move
on thevalue_to_hold
.- Template parameter
Held
: The type used to store the given value. Calls to get<>() must provide the same type for retrieval.
- Template parameter
Creates a system holding the given value and adds it to the builder. The value is allowed to be
nullptr
. Returns an alias to the value (ornullptr
in casenullptr
was passed in as thevalue_to_hold
).Note
To immediately give up ownership at the call site, remember to use
std::move
on thevalue_to_hold
.- Template parameter
Held
: The type used to store the given value. Calls to get<>() must provide the same type for retrieval.
- Precondition:
builder is non-null
- Template parameter
(Advanced) Retrieves an alias to the stored value. Returns
nullptr
in casenullptr
was passed in as thevalue_to_hold
.- Template parameter
Held
: The type used to store the given value, per our constructor.
- Raises
RuntimeError if Held doesn't match the type used at construction. –
- Template parameter
Instantiations:
SharedPointerSystem_[float]
,SharedPointerSystem_[AutoDiffXd]
,SharedPointerSystem_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
SharedPointerSystem holds a single
shared_ptr
that will be released at System deletion time (i.e., the end of a Diagram lifespan). It has no input, output, state, nor parameters. This is useful for storing objects that will be pointed-to by other systems outside of the usual input/output port connections.Scalar conversion is supported and will simply increment the reference count for the contained object. The contained object will not be scalar-converted, so should not depend on
T
.Creates a system holding the given value. The value is allowed to be
nullptr
.Note
To immediately give up ownership at the call site, remember to use
std::move
on thevalue_to_hold
.- Template parameter
Held
: The type used to store the given value. Calls to get<>() must provide the same type for retrieval.
- Template parameter
Creates a system holding the given value and adds it to the builder. The value is allowed to be
nullptr
. Returns an alias to the value (ornullptr
in casenullptr
was passed in as thevalue_to_hold
).Note
To immediately give up ownership at the call site, remember to use
std::move
on thevalue_to_hold
.- Template parameter
Held
: The type used to store the given value. Calls to get<>() must provide the same type for retrieval.
- Precondition:
builder is non-null
- Template parameter
(Advanced) Retrieves an alias to the stored value. Returns
nullptr
in casenullptr
was passed in as thevalue_to_hold
.- Template parameter
Held
: The type used to store the given value, per our constructor.
- Raises
RuntimeError if Held doesn't match the type used at construction. –
- Template parameter
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
SharedPointerSystem holds a single
shared_ptr
that will be released at System deletion time (i.e., the end of a Diagram lifespan). It has no input, output, state, nor parameters. This is useful for storing objects that will be pointed-to by other systems outside of the usual input/output port connections.Scalar conversion is supported and will simply increment the reference count for the contained object. The contained object will not be scalar-converted, so should not depend on
T
.Creates a system holding the given value. The value is allowed to be
nullptr
.Note
To immediately give up ownership at the call site, remember to use
std::move
on thevalue_to_hold
.- Template parameter
Held
: The type used to store the given value. Calls to get<>() must provide the same type for retrieval.
- Template parameter
Creates a system holding the given value and adds it to the builder. The value is allowed to be
nullptr
. Returns an alias to the value (ornullptr
in casenullptr
was passed in as thevalue_to_hold
).Note
To immediately give up ownership at the call site, remember to use
std::move
on thevalue_to_hold
.- Template parameter
Held
: The type used to store the given value. Calls to get<>() must provide the same type for retrieval.
- Precondition:
builder is non-null
- Template parameter
(Advanced) Retrieves an alias to the stored value. Returns
nullptr
in casenullptr
was passed in as thevalue_to_hold
.- Template parameter
Held
: The type used to store the given value, per our constructor.
- Raises
RuntimeError if Held doesn't match the type used at construction. –
- Template parameter
- class pydrake.systems.primitives.Sine
Bases:
pydrake.systems.framework.LeafSystem
A sine system which outputs
y = a * sin(f * t + p)
and first and second derivatives w.r.t. the time parametert
. The block parameters are:a
the amplitude,f
the frequency (radians/second), andp
the phase (radians), all of which are constant vectors provided at construction time. This system has one or zero input ports and three vector valued output ports (y
and its first two derivatives). The user can specify whether to use simulation time as the source of values for the time variable or an external source. If an external time source is specified, the system is created with an input port for the time source. Otherwise, the system is created with zero input ports.u0→ Sine → y0 → y1 → y2 Port
u0
is present if and only if the constructor parameteris_time_based
is false.Port
y0
emits the valuey
; porty1
emits the first derivative; porty2
emits the second derivative.Note
This class is templated; see
Sine_
for the list of instantiations.- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.Sine, amplitude: float, frequency: float, phase: float, size: int, is_time_based: bool = True) -> None
Constructs a Sine system where the amplitude, frequency, and phase is applied to every input.
- Parameter
amplitude
: the sine wave amplitude
- Parameter
frequency
: the sine wave frequency (radians/second)
- Parameter
phase
: the sine wave phase (radians)
- Parameter
size
: number of elements in the output signal.
- Parameter
is_time_based
: indicates whether to use the simulation time as the source for the sine wave time variable, or use an external source, in which case an input port of size
size
is created.
__init__(self: pydrake.systems.primitives.Sine, amplitudes: numpy.ndarray[numpy.float64[m, 1]], frequencies: numpy.ndarray[numpy.float64[m, 1]], phases: numpy.ndarray[numpy.float64[m, 1]], is_time_based: bool = True) -> None
Constructs a Sine system where different amplitudes, frequencies, and phases can be applied to each sine wave.
- Parameter
amplitudes
: the sine wave amplitudes
- Parameter
frequencies
: the sine wave frequencies (radians/second)
- Parameter
phases
: the sine wave phases (radians)
- Parameter
is_time_based
: indicates whether to use the simulation time as the source for the sine wave time variable, or use an external source, in which case an input port is created.
- template pydrake.systems.primitives.Sine_
Instantiations:
Sine_[float]
,Sine_[AutoDiffXd]
,Sine_[Expression]
- class pydrake.systems.primitives.Sine_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
A sine system which outputs
y = a * sin(f * t + p)
and first and second derivatives w.r.t. the time parametert
. The block parameters are:a
the amplitude,f
the frequency (radians/second), andp
the phase (radians), all of which are constant vectors provided at construction time. This system has one or zero input ports and three vector valued output ports (y
and its first two derivatives). The user can specify whether to use simulation time as the source of values for the time variable or an external source. If an external time source is specified, the system is created with an input port for the time source. Otherwise, the system is created with zero input ports.u0→ Sine → y0 → y1 → y2 Port
u0
is present if and only if the constructor parameteris_time_based
is false.Port
y0
emits the valuey
; porty1
emits the first derivative; porty2
emits the second derivative.- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.Sine_[AutoDiffXd], amplitude: float, frequency: float, phase: float, size: int, is_time_based: bool = True) -> None
Constructs a Sine system where the amplitude, frequency, and phase is applied to every input.
- Parameter
amplitude
: the sine wave amplitude
- Parameter
frequency
: the sine wave frequency (radians/second)
- Parameter
phase
: the sine wave phase (radians)
- Parameter
size
: number of elements in the output signal.
- Parameter
is_time_based
: indicates whether to use the simulation time as the source for the sine wave time variable, or use an external source, in which case an input port of size
size
is created.
__init__(self: pydrake.systems.primitives.Sine_[AutoDiffXd], amplitudes: numpy.ndarray[numpy.float64[m, 1]], frequencies: numpy.ndarray[numpy.float64[m, 1]], phases: numpy.ndarray[numpy.float64[m, 1]], is_time_based: bool = True) -> None
Constructs a Sine system where different amplitudes, frequencies, and phases can be applied to each sine wave.
- Parameter
amplitudes
: the sine wave amplitudes
- Parameter
frequencies
: the sine wave frequencies (radians/second)
- Parameter
phases
: the sine wave phases (radians)
- Parameter
is_time_based
: indicates whether to use the simulation time as the source for the sine wave time variable, or use an external source, in which case an input port is created.
- class pydrake.systems.primitives.Sine_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
A sine system which outputs
y = a * sin(f * t + p)
and first and second derivatives w.r.t. the time parametert
. The block parameters are:a
the amplitude,f
the frequency (radians/second), andp
the phase (radians), all of which are constant vectors provided at construction time. This system has one or zero input ports and three vector valued output ports (y
and its first two derivatives). The user can specify whether to use simulation time as the source of values for the time variable or an external source. If an external time source is specified, the system is created with an input port for the time source. Otherwise, the system is created with zero input ports.u0→ Sine → y0 → y1 → y2 Port
u0
is present if and only if the constructor parameteris_time_based
is false.Port
y0
emits the valuey
; porty1
emits the first derivative; porty2
emits the second derivative.- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.Sine_[Expression], amplitude: float, frequency: float, phase: float, size: int, is_time_based: bool = True) -> None
Constructs a Sine system where the amplitude, frequency, and phase is applied to every input.
- Parameter
amplitude
: the sine wave amplitude
- Parameter
frequency
: the sine wave frequency (radians/second)
- Parameter
phase
: the sine wave phase (radians)
- Parameter
size
: number of elements in the output signal.
- Parameter
is_time_based
: indicates whether to use the simulation time as the source for the sine wave time variable, or use an external source, in which case an input port of size
size
is created.
__init__(self: pydrake.systems.primitives.Sine_[Expression], amplitudes: numpy.ndarray[numpy.float64[m, 1]], frequencies: numpy.ndarray[numpy.float64[m, 1]], phases: numpy.ndarray[numpy.float64[m, 1]], is_time_based: bool = True) -> None
Constructs a Sine system where different amplitudes, frequencies, and phases can be applied to each sine wave.
- Parameter
amplitudes
: the sine wave amplitudes
- Parameter
frequencies
: the sine wave frequencies (radians/second)
- Parameter
phases
: the sine wave phases (radians)
- Parameter
is_time_based
: indicates whether to use the simulation time as the source for the sine wave time variable, or use an external source, in which case an input port is created.
- class pydrake.systems.primitives.StateInterpolatorWithDiscreteDerivative
Bases:
pydrake.systems.framework.Diagram
Supports the common pattern of combining a (feed-through) position with a velocity estimated with the DiscreteDerivative into a single output vector with positions and velocities stacked. This assumes that the velocities are equal to the time derivative of the positions.
Click to expand C++ code...
┌─────┐ position ───┬───────────────────>│ │ │ │ Mux ├──> state │ ┌────────────┐ │ │ └──>│ Discrete ├──>│ │ │ Derivative │ └─────┘ └────────────┘
position→ StateInterpolatorWithDiscreteDerivative → state Note
This class is templated; see
StateInterpolatorWithDiscreteDerivative_
for the list of instantiations.- __init__(self: pydrake.systems.primitives.StateInterpolatorWithDiscreteDerivative, num_positions: int, time_step: float, suppress_initial_transient: bool = True) None
Constructor taking
num_positions
, the size of the position vector to be differentiated, andtime_step
, the sampling interval. Ifsuppress_initial_transient
is true (the default), then the velocity output will be zero for the first two time steps (see the DiscreteDerivative class documentation for details and exceptions).
- set_initial_position(*args, **kwargs)
Overloaded function.
set_initial_position(self: pydrake.systems.primitives.StateInterpolatorWithDiscreteDerivative, context: pydrake.systems.framework.Context, position: numpy.ndarray[numpy.float64[m, 1]]) -> None
Convenience method that sets the entire position history for the discrete-time derivative to a constant vector value (resulting in velocity estimate of zero). This is useful during initialization to avoid large derivative outputs.
position
must be the same size as the input/output ports. If suppress_initial_transient() is true, then also disables the suppression for thiscontext
.Warning
This only changes the position history used for the velocity half of the output port; it has no effect on the feedthrough position.
set_initial_position(self: pydrake.systems.primitives.StateInterpolatorWithDiscreteDerivative, state: pydrake.systems.framework.State, position: numpy.ndarray[numpy.float64[m, 1]]) -> None
Convenience method that sets the entire position history for the discrete-time derivative to a constant vector value (resulting in velocity estimate of zero). This is useful during initialization to avoid large derivative outputs.
position
must be the same size as the input/output ports. If suppress_initial_transient() is true, then also disables the suppression for thisstate
.Warning
This only changes the position history used for the velocity half of the output port; it has no effect on the feedthrough position.
- suppress_initial_transient(self: pydrake.systems.primitives.StateInterpolatorWithDiscreteDerivative) bool
Returns the
suppress_initial_transient
passed to the constructor.
- template pydrake.systems.primitives.StateInterpolatorWithDiscreteDerivative_
Instantiations:
StateInterpolatorWithDiscreteDerivative_[float]
,StateInterpolatorWithDiscreteDerivative_[AutoDiffXd]
,StateInterpolatorWithDiscreteDerivative_[Expression]
- class pydrake.systems.primitives.StateInterpolatorWithDiscreteDerivative_[AutoDiffXd]
Bases:
pydrake.systems.framework.Diagram_[AutoDiffXd]
Supports the common pattern of combining a (feed-through) position with a velocity estimated with the DiscreteDerivative into a single output vector with positions and velocities stacked. This assumes that the velocities are equal to the time derivative of the positions.
Click to expand C++ code...
┌─────┐ position ───┬───────────────────>│ │ │ │ Mux ├──> state │ ┌────────────┐ │ │ └──>│ Discrete ├──>│ │ │ Derivative │ └─────┘ └────────────┘
position→ StateInterpolatorWithDiscreteDerivative → state - __init__(self: pydrake.systems.primitives.StateInterpolatorWithDiscreteDerivative_[AutoDiffXd], num_positions: int, time_step: float, suppress_initial_transient: bool = True) None
Constructor taking
num_positions
, the size of the position vector to be differentiated, andtime_step
, the sampling interval. Ifsuppress_initial_transient
is true (the default), then the velocity output will be zero for the first two time steps (see the DiscreteDerivative class documentation for details and exceptions).
- set_initial_position(*args, **kwargs)
Overloaded function.
set_initial_position(self: pydrake.systems.primitives.StateInterpolatorWithDiscreteDerivative_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd], position: numpy.ndarray[object[m, 1]]) -> None
Convenience method that sets the entire position history for the discrete-time derivative to a constant vector value (resulting in velocity estimate of zero). This is useful during initialization to avoid large derivative outputs.
position
must be the same size as the input/output ports. If suppress_initial_transient() is true, then also disables the suppression for thiscontext
.Warning
This only changes the position history used for the velocity half of the output port; it has no effect on the feedthrough position.
set_initial_position(self: pydrake.systems.primitives.StateInterpolatorWithDiscreteDerivative_[AutoDiffXd], state: pydrake.systems.framework.State_[AutoDiffXd], position: numpy.ndarray[object[m, 1]]) -> None
Convenience method that sets the entire position history for the discrete-time derivative to a constant vector value (resulting in velocity estimate of zero). This is useful during initialization to avoid large derivative outputs.
position
must be the same size as the input/output ports. If suppress_initial_transient() is true, then also disables the suppression for thisstate
.Warning
This only changes the position history used for the velocity half of the output port; it has no effect on the feedthrough position.
- suppress_initial_transient(self: pydrake.systems.primitives.StateInterpolatorWithDiscreteDerivative_[AutoDiffXd]) bool
Returns the
suppress_initial_transient
passed to the constructor.
- class pydrake.systems.primitives.StateInterpolatorWithDiscreteDerivative_[Expression]
Bases:
pydrake.systems.framework.Diagram_[Expression]
Supports the common pattern of combining a (feed-through) position with a velocity estimated with the DiscreteDerivative into a single output vector with positions and velocities stacked. This assumes that the velocities are equal to the time derivative of the positions.
Click to expand C++ code...
┌─────┐ position ───┬───────────────────>│ │ │ │ Mux ├──> state │ ┌────────────┐ │ │ └──>│ Discrete ├──>│ │ │ Derivative │ └─────┘ └────────────┘
position→ StateInterpolatorWithDiscreteDerivative → state - __init__(self: pydrake.systems.primitives.StateInterpolatorWithDiscreteDerivative_[Expression], num_positions: int, time_step: float, suppress_initial_transient: bool = True) None
Constructor taking
num_positions
, the size of the position vector to be differentiated, andtime_step
, the sampling interval. Ifsuppress_initial_transient
is true (the default), then the velocity output will be zero for the first two time steps (see the DiscreteDerivative class documentation for details and exceptions).
- set_initial_position(*args, **kwargs)
Overloaded function.
set_initial_position(self: pydrake.systems.primitives.StateInterpolatorWithDiscreteDerivative_[Expression], context: pydrake.systems.framework.Context_[Expression], position: numpy.ndarray[object[m, 1]]) -> None
Convenience method that sets the entire position history for the discrete-time derivative to a constant vector value (resulting in velocity estimate of zero). This is useful during initialization to avoid large derivative outputs.
position
must be the same size as the input/output ports. If suppress_initial_transient() is true, then also disables the suppression for thiscontext
.Warning
This only changes the position history used for the velocity half of the output port; it has no effect on the feedthrough position.
set_initial_position(self: pydrake.systems.primitives.StateInterpolatorWithDiscreteDerivative_[Expression], state: pydrake.systems.framework.State_[Expression], position: numpy.ndarray[object[m, 1]]) -> None
Convenience method that sets the entire position history for the discrete-time derivative to a constant vector value (resulting in velocity estimate of zero). This is useful during initialization to avoid large derivative outputs.
position
must be the same size as the input/output ports. If suppress_initial_transient() is true, then also disables the suppression for thisstate
.Warning
This only changes the position history used for the velocity half of the output port; it has no effect on the feedthrough position.
- suppress_initial_transient(self: pydrake.systems.primitives.StateInterpolatorWithDiscreteDerivative_[Expression]) bool
Returns the
suppress_initial_transient
passed to the constructor.
- class pydrake.systems.primitives.SymbolicVectorSystem
Bases:
pydrake.systems.framework.LeafSystem
A LeafSystem that is defined by vectors of symbolic::Expression representing the dynamics and output. The resulting system has only zero or one vector input ports, zero or one vector of continuous or discrete state (depending on the specified time_period), zero or one vector of numeric parameters, and only zero or one vector output ports.
See SymbolicVectorSystemBuilder to make the construction a little nicer.
For example, to define the system: ẋ = -x + x³, y = x, we could write
Click to expand C++ code...
symbolic::Variable x("x"); auto system = SymbolicVectorSystemBuilder().state(x) .dynamics(-x + pow(x,3)) .output(x) .Build();
Note: This will not be as performant as writing your own LeafSystem. It is meant primarily for rapid prototyping.
u0→ SymbolicVectorSystem → y0 Either port
u0
or porty0
may be absent, depending on the values supplied at construction.Note
This class is templated; see
SymbolicVectorSystem_
for the list of instantiations.- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.SymbolicVectorSystem, time: Optional[pydrake.symbolic.Variable] = None, state: numpy.ndarray[object[m, 1]] = array([], dtype=object), input: numpy.ndarray[object[m, 1]] = array([], dtype=object), dynamics: numpy.ndarray[object[m, 1]] = array([], dtype=object), output: numpy.ndarray[object[m, 1]] = array([], dtype=object), time_period: float = 0.0) -> None
Construct the SymbolicVectorSystem.
- Parameter
time
: an (optional) Variable used to represent time in the dynamics.
- Parameter
state
: an (optional) vector of Variables representing the state. The order in this vector will determine the order of the elements in the state vector. Each element must be unique.
- Parameter
input
: an (optional) vector of Variables representing the input. The order in this vector will determine the order of the elements in the vector-valued input port. Each element must be unique.
- Parameter
dynamics
: a vector of Expressions representing the dynamics of the system. If
time_period
== 0, then this describes the continuous time derivatives. Iftime_period
> 0, then it defines the updates of the single discrete-valued state vector. The size of this vector must match the number of state variables.- Parameter
output
: a vector of Expressions representing the output of the system. If empty, then no output port will be allocated.
- Parameter
time_period
: a scalar representing the period of a periodic update. time_period == 0.0 implies that the state variables will be declared as continuous state and the dynamics will be implemented as time derivatives. time_period > 0.0 implies the state variables will be declared as discrete state and the dynamics will be implemented as a dicraete variable update.
__init__(self: pydrake.systems.primitives.SymbolicVectorSystem, time: Optional[pydrake.symbolic.Variable] = None, state: numpy.ndarray[object[m, 1]] = array([], dtype=object), input: numpy.ndarray[object[m, 1]] = array([], dtype=object), parameter: numpy.ndarray[object[m, 1]] = array([], dtype=object), dynamics: numpy.ndarray[object[m, 1]] = array([], dtype=object), output: numpy.ndarray[object[m, 1]] = array([], dtype=object), time_period: float = 0.0) -> None
Construct the SymbolicVectorSystem.
- Parameter
time
: an (optional) Variable used to represent time in the dynamics.
- Parameter
state
: an (optional) vector of Variables representing the state. The order in this vector will determine the order of the elements in the state vector. Each element must be unique.
- Parameter
input
: an (optional) vector of Variables representing the input. The order in this vector will determine the order of the elements in the vector-valued input port. Each element must be unique.
- Parameter
parameter
: an (optional) vector of Variables representing the numeric parameter. The order in this vector will determine the order of the elements in the vector-valued parameter. Each element must be unique.
- Parameter
dynamics
: a vector of Expressions representing the dynamics of the system. If
time_period
== 0, then this describes the continuous time derivatives. Iftime_period
> 0, then it defines the updates of the single discrete-valued state vector. The size of this vector must match the number of state variables.- Parameter
output
: a vector of Expressions representing the output of the system. If empty, then no output port will be allocated.
- Parameter
time_period
: a scalar representing the period of a periodic update. time_period == 0.0 implies that the state variables will be declared as continuous state and the dynamics will be implemented as time derivatives. time_period > 0.0 implies the state variables will be declared as discrete state and the dynamics will be implemented as a dicraete variable update.
- dynamics_for_variable(self: pydrake.systems.primitives.SymbolicVectorSystem, var: pydrake.symbolic.Variable) pydrake.symbolic.Expression
Returns the dynamics for the variable
var
. That is, it returns the scalar expression corresponding to either\dot{var}
(continuous case) orvar[n+1]
(discrete case).- Raises
RuntimeError if this system has no corresponding dynamics for the –
variable var. –
- template pydrake.systems.primitives.SymbolicVectorSystem_
Instantiations:
SymbolicVectorSystem_[float]
,SymbolicVectorSystem_[AutoDiffXd]
,SymbolicVectorSystem_[Expression]
- class pydrake.systems.primitives.SymbolicVectorSystem_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
A LeafSystem that is defined by vectors of symbolic::Expression representing the dynamics and output. The resulting system has only zero or one vector input ports, zero or one vector of continuous or discrete state (depending on the specified time_period), zero or one vector of numeric parameters, and only zero or one vector output ports.
See SymbolicVectorSystemBuilder to make the construction a little nicer.
For example, to define the system: ẋ = -x + x³, y = x, we could write
Click to expand C++ code...
symbolic::Variable x("x"); auto system = SymbolicVectorSystemBuilder().state(x) .dynamics(-x + pow(x,3)) .output(x) .Build();
Note: This will not be as performant as writing your own LeafSystem. It is meant primarily for rapid prototyping.
u0→ SymbolicVectorSystem → y0 Either port
u0
or porty0
may be absent, depending on the values supplied at construction.- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.SymbolicVectorSystem_[AutoDiffXd], time: Optional[pydrake.symbolic.Variable] = None, state: numpy.ndarray[object[m, 1]] = array([], dtype=object), input: numpy.ndarray[object[m, 1]] = array([], dtype=object), dynamics: numpy.ndarray[object[m, 1]] = array([], dtype=object), output: numpy.ndarray[object[m, 1]] = array([], dtype=object), time_period: float = 0.0) -> None
Construct the SymbolicVectorSystem.
- Parameter
time
: an (optional) Variable used to represent time in the dynamics.
- Parameter
state
: an (optional) vector of Variables representing the state. The order in this vector will determine the order of the elements in the state vector. Each element must be unique.
- Parameter
input
: an (optional) vector of Variables representing the input. The order in this vector will determine the order of the elements in the vector-valued input port. Each element must be unique.
- Parameter
dynamics
: a vector of Expressions representing the dynamics of the system. If
time_period
== 0, then this describes the continuous time derivatives. Iftime_period
> 0, then it defines the updates of the single discrete-valued state vector. The size of this vector must match the number of state variables.- Parameter
output
: a vector of Expressions representing the output of the system. If empty, then no output port will be allocated.
- Parameter
time_period
: a scalar representing the period of a periodic update. time_period == 0.0 implies that the state variables will be declared as continuous state and the dynamics will be implemented as time derivatives. time_period > 0.0 implies the state variables will be declared as discrete state and the dynamics will be implemented as a dicraete variable update.
__init__(self: pydrake.systems.primitives.SymbolicVectorSystem_[AutoDiffXd], time: Optional[pydrake.symbolic.Variable] = None, state: numpy.ndarray[object[m, 1]] = array([], dtype=object), input: numpy.ndarray[object[m, 1]] = array([], dtype=object), parameter: numpy.ndarray[object[m, 1]] = array([], dtype=object), dynamics: numpy.ndarray[object[m, 1]] = array([], dtype=object), output: numpy.ndarray[object[m, 1]] = array([], dtype=object), time_period: float = 0.0) -> None
Construct the SymbolicVectorSystem.
- Parameter
time
: an (optional) Variable used to represent time in the dynamics.
- Parameter
state
: an (optional) vector of Variables representing the state. The order in this vector will determine the order of the elements in the state vector. Each element must be unique.
- Parameter
input
: an (optional) vector of Variables representing the input. The order in this vector will determine the order of the elements in the vector-valued input port. Each element must be unique.
- Parameter
parameter
: an (optional) vector of Variables representing the numeric parameter. The order in this vector will determine the order of the elements in the vector-valued parameter. Each element must be unique.
- Parameter
dynamics
: a vector of Expressions representing the dynamics of the system. If
time_period
== 0, then this describes the continuous time derivatives. Iftime_period
> 0, then it defines the updates of the single discrete-valued state vector. The size of this vector must match the number of state variables.- Parameter
output
: a vector of Expressions representing the output of the system. If empty, then no output port will be allocated.
- Parameter
time_period
: a scalar representing the period of a periodic update. time_period == 0.0 implies that the state variables will be declared as continuous state and the dynamics will be implemented as time derivatives. time_period > 0.0 implies the state variables will be declared as discrete state and the dynamics will be implemented as a dicraete variable update.
- dynamics_for_variable(self: pydrake.systems.primitives.SymbolicVectorSystem_[AutoDiffXd], var: pydrake.symbolic.Variable) pydrake.symbolic.Expression
Returns the dynamics for the variable
var
. That is, it returns the scalar expression corresponding to either\dot{var}
(continuous case) orvar[n+1]
(discrete case).- Raises
RuntimeError if this system has no corresponding dynamics for the –
variable var. –
- class pydrake.systems.primitives.SymbolicVectorSystem_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
A LeafSystem that is defined by vectors of symbolic::Expression representing the dynamics and output. The resulting system has only zero or one vector input ports, zero or one vector of continuous or discrete state (depending on the specified time_period), zero or one vector of numeric parameters, and only zero or one vector output ports.
See SymbolicVectorSystemBuilder to make the construction a little nicer.
For example, to define the system: ẋ = -x + x³, y = x, we could write
Click to expand C++ code...
symbolic::Variable x("x"); auto system = SymbolicVectorSystemBuilder().state(x) .dynamics(-x + pow(x,3)) .output(x) .Build();
Note: This will not be as performant as writing your own LeafSystem. It is meant primarily for rapid prototyping.
u0→ SymbolicVectorSystem → y0 Either port
u0
or porty0
may be absent, depending on the values supplied at construction.- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.SymbolicVectorSystem_[Expression], time: Optional[pydrake.symbolic.Variable] = None, state: numpy.ndarray[object[m, 1]] = array([], dtype=object), input: numpy.ndarray[object[m, 1]] = array([], dtype=object), dynamics: numpy.ndarray[object[m, 1]] = array([], dtype=object), output: numpy.ndarray[object[m, 1]] = array([], dtype=object), time_period: float = 0.0) -> None
Construct the SymbolicVectorSystem.
- Parameter
time
: an (optional) Variable used to represent time in the dynamics.
- Parameter
state
: an (optional) vector of Variables representing the state. The order in this vector will determine the order of the elements in the state vector. Each element must be unique.
- Parameter
input
: an (optional) vector of Variables representing the input. The order in this vector will determine the order of the elements in the vector-valued input port. Each element must be unique.
- Parameter
dynamics
: a vector of Expressions representing the dynamics of the system. If
time_period
== 0, then this describes the continuous time derivatives. Iftime_period
> 0, then it defines the updates of the single discrete-valued state vector. The size of this vector must match the number of state variables.- Parameter
output
: a vector of Expressions representing the output of the system. If empty, then no output port will be allocated.
- Parameter
time_period
: a scalar representing the period of a periodic update. time_period == 0.0 implies that the state variables will be declared as continuous state and the dynamics will be implemented as time derivatives. time_period > 0.0 implies the state variables will be declared as discrete state and the dynamics will be implemented as a dicraete variable update.
__init__(self: pydrake.systems.primitives.SymbolicVectorSystem_[Expression], time: Optional[pydrake.symbolic.Variable] = None, state: numpy.ndarray[object[m, 1]] = array([], dtype=object), input: numpy.ndarray[object[m, 1]] = array([], dtype=object), parameter: numpy.ndarray[object[m, 1]] = array([], dtype=object), dynamics: numpy.ndarray[object[m, 1]] = array([], dtype=object), output: numpy.ndarray[object[m, 1]] = array([], dtype=object), time_period: float = 0.0) -> None
Construct the SymbolicVectorSystem.
- Parameter
time
: an (optional) Variable used to represent time in the dynamics.
- Parameter
state
: an (optional) vector of Variables representing the state. The order in this vector will determine the order of the elements in the state vector. Each element must be unique.
- Parameter
input
: an (optional) vector of Variables representing the input. The order in this vector will determine the order of the elements in the vector-valued input port. Each element must be unique.
- Parameter
parameter
: an (optional) vector of Variables representing the numeric parameter. The order in this vector will determine the order of the elements in the vector-valued parameter. Each element must be unique.
- Parameter
dynamics
: a vector of Expressions representing the dynamics of the system. If
time_period
== 0, then this describes the continuous time derivatives. Iftime_period
> 0, then it defines the updates of the single discrete-valued state vector. The size of this vector must match the number of state variables.- Parameter
output
: a vector of Expressions representing the output of the system. If empty, then no output port will be allocated.
- Parameter
time_period
: a scalar representing the period of a periodic update. time_period == 0.0 implies that the state variables will be declared as continuous state and the dynamics will be implemented as time derivatives. time_period > 0.0 implies the state variables will be declared as discrete state and the dynamics will be implemented as a dicraete variable update.
- dynamics_for_variable(self: pydrake.systems.primitives.SymbolicVectorSystem_[Expression], var: pydrake.symbolic.Variable) pydrake.symbolic.Expression
Returns the dynamics for the variable
var
. That is, it returns the scalar expression corresponding to either\dot{var}
(continuous case) orvar[n+1]
(discrete case).- Raises
RuntimeError if this system has no corresponding dynamics for the –
variable var. –
- class pydrake.systems.primitives.TrajectoryAffineSystem
Bases:
pydrake.systems.framework.LeafSystem
A continuous- or discrete-time Affine Time-Varying system with system matrices described by trajectories.
u0→ TrajectoryAffineSystem → y0 Note
This class is templated; see
TrajectoryAffineSystem_
for the list of instantiations.- __init__(self: pydrake.systems.primitives.TrajectoryAffineSystem, A: pydrake.trajectories.Trajectory, B: pydrake.trajectories.Trajectory, f0: pydrake.trajectories.Trajectory, C: pydrake.trajectories.Trajectory, D: pydrake.trajectories.Trajectory, y0: pydrake.trajectories.Trajectory, time_period: float = 0.0) None
Constructs a TrajectoryAffineSystem from trajectories of matrices.
- Parameter
time_period
: Defines the period of the discrete time system; use time_period=0.0 to denote a continuous time system. $*Default:* 0.0
- Parameter
- A(self: pydrake.systems.primitives.TrajectoryAffineSystem, arg0: float) numpy.ndarray[numpy.float64[m, n]]
@name Implementations of TimeVaryingAffineSystem<T>’s pure virtual methods.
- B(self: pydrake.systems.primitives.TrajectoryAffineSystem, arg0: float) numpy.ndarray[numpy.float64[m, n]]
- C(self: pydrake.systems.primitives.TrajectoryAffineSystem, arg0: float) numpy.ndarray[numpy.float64[m, n]]
- configure_default_state(self: pydrake.systems.primitives.TrajectoryAffineSystem, x0: numpy.ndarray[numpy.float64[m, 1]]) None
Configures the value that will be assigned to the state vector in
SetDefaultContext
. x0 must be a vector of lengthnum_states
.
- configure_random_state(self: pydrake.systems.primitives.TrajectoryAffineSystem, covariance: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]) None
Configures the Gaussian distribution over state vectors used in the
SetRandomContext
methods. The mean of the distribution will be the default state (See also
configure_default_state()).
covariance
must have sizenum_states
bynum_states
and must be symmetric and positive semi-definite.
- D(self: pydrake.systems.primitives.TrajectoryAffineSystem, arg0: float) numpy.ndarray[numpy.float64[m, n]]
- f0(self: pydrake.systems.primitives.TrajectoryAffineSystem, arg0: float) numpy.ndarray[numpy.float64[m, 1]]
- time_period(self: pydrake.systems.primitives.TrajectoryAffineSystem) float
- y0(self: pydrake.systems.primitives.TrajectoryAffineSystem, arg0: float) numpy.ndarray[numpy.float64[m, 1]]
- template pydrake.systems.primitives.TrajectoryAffineSystem_
Instantiations:
TrajectoryAffineSystem_[float]
,TrajectoryAffineSystem_[AutoDiffXd]
- class pydrake.systems.primitives.TrajectoryAffineSystem_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
A continuous- or discrete-time Affine Time-Varying system with system matrices described by trajectories.
u0→ TrajectoryAffineSystem → y0 - __init__(self: pydrake.systems.primitives.TrajectoryAffineSystem_[AutoDiffXd], A: pydrake.trajectories.Trajectory, B: pydrake.trajectories.Trajectory, f0: pydrake.trajectories.Trajectory, C: pydrake.trajectories.Trajectory, D: pydrake.trajectories.Trajectory, y0: pydrake.trajectories.Trajectory, time_period: float = 0.0) None
Constructs a TrajectoryAffineSystem from trajectories of matrices.
- Parameter
time_period
: Defines the period of the discrete time system; use time_period=0.0 to denote a continuous time system. $*Default:* 0.0
- Parameter
- A(self: pydrake.systems.primitives.TrajectoryAffineSystem_[AutoDiffXd], arg0: pydrake.autodiffutils.AutoDiffXd) numpy.ndarray[object[m, n]]
@name Implementations of TimeVaryingAffineSystem<T>’s pure virtual methods.
- B(self: pydrake.systems.primitives.TrajectoryAffineSystem_[AutoDiffXd], arg0: pydrake.autodiffutils.AutoDiffXd) numpy.ndarray[object[m, n]]
- C(self: pydrake.systems.primitives.TrajectoryAffineSystem_[AutoDiffXd], arg0: pydrake.autodiffutils.AutoDiffXd) numpy.ndarray[object[m, n]]
- configure_default_state(self: pydrake.systems.primitives.TrajectoryAffineSystem_[AutoDiffXd], x0: numpy.ndarray[object[m, 1]]) None
Configures the value that will be assigned to the state vector in
SetDefaultContext
. x0 must be a vector of lengthnum_states
.
- configure_random_state(self: pydrake.systems.primitives.TrajectoryAffineSystem_[AutoDiffXd], covariance: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]) None
Configures the Gaussian distribution over state vectors used in the
SetRandomContext
methods. The mean of the distribution will be the default state (See also
configure_default_state()).
covariance
must have sizenum_states
bynum_states
and must be symmetric and positive semi-definite.
- D(self: pydrake.systems.primitives.TrajectoryAffineSystem_[AutoDiffXd], arg0: pydrake.autodiffutils.AutoDiffXd) numpy.ndarray[object[m, n]]
- f0(self: pydrake.systems.primitives.TrajectoryAffineSystem_[AutoDiffXd], arg0: pydrake.autodiffutils.AutoDiffXd) numpy.ndarray[object[m, 1]]
- time_period(self: pydrake.systems.primitives.TrajectoryAffineSystem_[AutoDiffXd]) float
- y0(self: pydrake.systems.primitives.TrajectoryAffineSystem_[AutoDiffXd], arg0: pydrake.autodiffutils.AutoDiffXd) numpy.ndarray[object[m, 1]]
- class pydrake.systems.primitives.TrajectoryLinearSystem
Bases:
pydrake.systems.framework.LeafSystem
A continuous- or discrete-time Linear Time-Varying system with system matrices described by trajectories.
u0→ TrajectoryLinearSystem → y0 Note
This class is templated; see
TrajectoryLinearSystem_
for the list of instantiations.- __init__(self: pydrake.systems.primitives.TrajectoryLinearSystem, A: pydrake.trajectories.Trajectory, B: pydrake.trajectories.Trajectory, C: pydrake.trajectories.Trajectory, D: pydrake.trajectories.Trajectory, time_period: float = 0.0) None
Constructs a PiecewisePolynomialLinearSystem from a LinearTimeVaryingData structure.
- Parameter
time_period
: Defines the period of the discrete time system; use time_period=0.0 to denote a continuous time system. $*Default:* 0.0
- Parameter
- A(self: pydrake.systems.primitives.TrajectoryLinearSystem, arg0: float) numpy.ndarray[numpy.float64[m, n]]
@name Implementations of PiecewisePolynomialLinearSystem<T>’s pure virtual methods.
- B(self: pydrake.systems.primitives.TrajectoryLinearSystem, arg0: float) numpy.ndarray[numpy.float64[m, n]]
- C(self: pydrake.systems.primitives.TrajectoryLinearSystem, arg0: float) numpy.ndarray[numpy.float64[m, n]]
- configure_default_state(self: pydrake.systems.primitives.TrajectoryLinearSystem, x0: numpy.ndarray[numpy.float64[m, 1]]) None
Configures the value that will be assigned to the state vector in
SetDefaultContext
. x0 must be a vector of lengthnum_states
.
- configure_random_state(self: pydrake.systems.primitives.TrajectoryLinearSystem, covariance: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]) None
Configures the Gaussian distribution over state vectors used in the
SetRandomContext
methods. The mean of the distribution will be the default state (See also
configure_default_state()).
covariance
must have sizenum_states
bynum_states
and must be symmetric and positive semi-definite.
- D(self: pydrake.systems.primitives.TrajectoryLinearSystem, arg0: float) numpy.ndarray[numpy.float64[m, n]]
- time_period(self: pydrake.systems.primitives.TrajectoryLinearSystem) float
- template pydrake.systems.primitives.TrajectoryLinearSystem_
Instantiations:
TrajectoryLinearSystem_[float]
,TrajectoryLinearSystem_[AutoDiffXd]
- class pydrake.systems.primitives.TrajectoryLinearSystem_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
A continuous- or discrete-time Linear Time-Varying system with system matrices described by trajectories.
u0→ TrajectoryLinearSystem → y0 - __init__(self: pydrake.systems.primitives.TrajectoryLinearSystem_[AutoDiffXd], A: pydrake.trajectories.Trajectory, B: pydrake.trajectories.Trajectory, C: pydrake.trajectories.Trajectory, D: pydrake.trajectories.Trajectory, time_period: float = 0.0) None
Constructs a PiecewisePolynomialLinearSystem from a LinearTimeVaryingData structure.
- Parameter
time_period
: Defines the period of the discrete time system; use time_period=0.0 to denote a continuous time system. $*Default:* 0.0
- Parameter
- A(self: pydrake.systems.primitives.TrajectoryLinearSystem_[AutoDiffXd], arg0: pydrake.autodiffutils.AutoDiffXd) numpy.ndarray[object[m, n]]
@name Implementations of PiecewisePolynomialLinearSystem<T>’s pure virtual methods.
- B(self: pydrake.systems.primitives.TrajectoryLinearSystem_[AutoDiffXd], arg0: pydrake.autodiffutils.AutoDiffXd) numpy.ndarray[object[m, n]]
- C(self: pydrake.systems.primitives.TrajectoryLinearSystem_[AutoDiffXd], arg0: pydrake.autodiffutils.AutoDiffXd) numpy.ndarray[object[m, n]]
- configure_default_state(self: pydrake.systems.primitives.TrajectoryLinearSystem_[AutoDiffXd], x0: numpy.ndarray[object[m, 1]]) None
Configures the value that will be assigned to the state vector in
SetDefaultContext
. x0 must be a vector of lengthnum_states
.
- configure_random_state(self: pydrake.systems.primitives.TrajectoryLinearSystem_[AutoDiffXd], covariance: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]) None
Configures the Gaussian distribution over state vectors used in the
SetRandomContext
methods. The mean of the distribution will be the default state (See also
configure_default_state()).
covariance
must have sizenum_states
bynum_states
and must be symmetric and positive semi-definite.
- D(self: pydrake.systems.primitives.TrajectoryLinearSystem_[AutoDiffXd], arg0: pydrake.autodiffutils.AutoDiffXd) numpy.ndarray[object[m, n]]
- time_period(self: pydrake.systems.primitives.TrajectoryLinearSystem_[AutoDiffXd]) float
- class pydrake.systems.primitives.TrajectorySource
Bases:
pydrake.systems.framework.LeafSystem
Given a Trajectory, this System provides an output port with the value of the trajectory evaluated at the current time.
If the particular Trajectory is not available at the time the System / Diagram is being constructed, one can create a TrajectorySource with a placeholder trajectory (e.g. PiecewisePolynomimal(Eigen::VectorXd)) with the correct number of rows, and then use UpdateTrajectory().
TrajectorySource → y0 Note: Scalar conversion is supported from double to any other scalar, but the stored Trajectory is not automatically scalar converted. You must call UpdateTrajectory() with an updated Trajectory<T> in order to fully enable scalar-type support on the trajectory parameters/values.
Note
This class is templated; see
TrajectorySource_
for the list of instantiations.- __init__(self: pydrake.systems.primitives.TrajectorySource, trajectory: pydrake.trajectories.Trajectory, output_derivative_order: int = 0, zero_derivatives_beyond_limits: bool = True) None
- Parameter
trajectory
: Trajectory used by the system.
- Parameter
output_derivative_order
: The number of times to take the derivative. Must be greater than or equal to zero.
- Parameter
zero_derivatives_beyond_limits
: All derivatives will be zero before the start time or after the end time of
trajectory
. However, this clamping is ignored for T=Expression.- Precondition:
The value of
trajectory
is a column vector. More precisely, trajectory.cols() == 1.
- Parameter
- UpdateTrajectory(self: pydrake.systems.primitives.TrajectorySource, trajectory: pydrake.trajectories.Trajectory) None
Updates the stored trajectory.
trajectory
must have the same number of rows as the trajectory passed to the constructor.
- template pydrake.systems.primitives.TrajectorySource_
Instantiations:
TrajectorySource_[float]
,TrajectorySource_[AutoDiffXd]
,TrajectorySource_[Expression]
- class pydrake.systems.primitives.TrajectorySource_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
Given a Trajectory, this System provides an output port with the value of the trajectory evaluated at the current time.
If the particular Trajectory is not available at the time the System / Diagram is being constructed, one can create a TrajectorySource with a placeholder trajectory (e.g. PiecewisePolynomimal(Eigen::VectorXd)) with the correct number of rows, and then use UpdateTrajectory().
TrajectorySource → y0 Note: Scalar conversion is supported from double to any other scalar, but the stored Trajectory is not automatically scalar converted. You must call UpdateTrajectory() with an updated Trajectory<T> in order to fully enable scalar-type support on the trajectory parameters/values.
- __init__(self: pydrake.systems.primitives.TrajectorySource_[AutoDiffXd], trajectory: pydrake.trajectories.Trajectory_[AutoDiffXd], output_derivative_order: int = 0, zero_derivatives_beyond_limits: bool = True) None
- Parameter
trajectory
: Trajectory used by the system.
- Parameter
output_derivative_order
: The number of times to take the derivative. Must be greater than or equal to zero.
- Parameter
zero_derivatives_beyond_limits
: All derivatives will be zero before the start time or after the end time of
trajectory
. However, this clamping is ignored for T=Expression.- Precondition:
The value of
trajectory
is a column vector. More precisely, trajectory.cols() == 1.
- Parameter
- UpdateTrajectory(self: pydrake.systems.primitives.TrajectorySource_[AutoDiffXd], trajectory: pydrake.trajectories.Trajectory_[AutoDiffXd]) None
Updates the stored trajectory.
trajectory
must have the same number of rows as the trajectory passed to the constructor.
- class pydrake.systems.primitives.TrajectorySource_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
Given a Trajectory, this System provides an output port with the value of the trajectory evaluated at the current time.
If the particular Trajectory is not available at the time the System / Diagram is being constructed, one can create a TrajectorySource with a placeholder trajectory (e.g. PiecewisePolynomimal(Eigen::VectorXd)) with the correct number of rows, and then use UpdateTrajectory().
TrajectorySource → y0 Note: Scalar conversion is supported from double to any other scalar, but the stored Trajectory is not automatically scalar converted. You must call UpdateTrajectory() with an updated Trajectory<T> in order to fully enable scalar-type support on the trajectory parameters/values.
- __init__(self: pydrake.systems.primitives.TrajectorySource_[Expression], trajectory: pydrake.trajectories.Trajectory_[Expression], output_derivative_order: int = 0, zero_derivatives_beyond_limits: bool = True) None
- Parameter
trajectory
: Trajectory used by the system.
- Parameter
output_derivative_order
: The number of times to take the derivative. Must be greater than or equal to zero.
- Parameter
zero_derivatives_beyond_limits
: All derivatives will be zero before the start time or after the end time of
trajectory
. However, this clamping is ignored for T=Expression.- Precondition:
The value of
trajectory
is a column vector. More precisely, trajectory.cols() == 1.
- Parameter
- UpdateTrajectory(self: pydrake.systems.primitives.TrajectorySource_[Expression], trajectory: pydrake.trajectories.Trajectory_[Expression]) None
Updates the stored trajectory.
trajectory
must have the same number of rows as the trajectory passed to the constructor.
- class pydrake.systems.primitives.VectorLog
This utility class serves as an in-memory cache of time-dependent vector values. Note that this is a standalone class, not a Drake System. It is primarily intended to support the Drake System primitive VectorLogSink, but can be used independently.
When the log becomes full, adding more data will cause the allocated space to double in size. If avoiding memory allocation during some performance-critical phase is desired, clients can call Reserve() to pre-allocate log storage.
This object imposes no constraints on the stored data. For example, times passed to AddData() need not be increasing in order of insertion, values are allowed to be infinite, NaN, etc.
Note
This class is templated; see
VectorLog_
for the list of instantiations.- __init__(self: pydrake.systems.primitives.VectorLog, input_size: int) None
Constructs the vector log.
- Parameter
input_size
: Dimension of the per-time step data set.
- Parameter
- AddData(self: pydrake.systems.primitives.VectorLog, time: float, sample: numpy.ndarray[numpy.float64[m, 1]]) None
Adds a
sample
to the data set with the associatedtime
value. The new sample and time are added to the end of the log. No constraints are imposed on the values of`time` orsample
.- Parameter
time
: The time value for this sample.
- Parameter
sample
: A vector of data of the declared size for this log.
- Parameter
- Clear(self: pydrake.systems.primitives.VectorLog) None
Clears the logged data.
- data(self: pydrake.systems.primitives.VectorLog) numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]
Accesses the logged data.
The InnerPanel parameter of the return type indicates that the compiler can assume aligned access to the data.
- get_input_size(self: pydrake.systems.primitives.VectorLog) int
Reports the size of the log’s input vector.
- kDefaultCapacity = 1000
- num_samples(self: pydrake.systems.primitives.VectorLog) int
Returns the number of samples taken since construction or last Clear().
- Reserve(self: pydrake.systems.primitives.VectorLog, arg0: int) None
Reserve storage for at least
capacity
samples. At construction, there will be at leastkDefaultCapacity
; use this method to reserve more.
- sample_times(self: pydrake.systems.primitives.VectorLog) numpy.ndarray[numpy.float64[m, 1]]
Accesses the logged time stamps.
- template pydrake.systems.primitives.VectorLog_
Instantiations:
VectorLog_[float]
,VectorLog_[AutoDiffXd]
,VectorLog_[Expression]
- class pydrake.systems.primitives.VectorLog_[AutoDiffXd]
This utility class serves as an in-memory cache of time-dependent vector values. Note that this is a standalone class, not a Drake System. It is primarily intended to support the Drake System primitive VectorLogSink, but can be used independently.
When the log becomes full, adding more data will cause the allocated space to double in size. If avoiding memory allocation during some performance-critical phase is desired, clients can call Reserve() to pre-allocate log storage.
This object imposes no constraints on the stored data. For example, times passed to AddData() need not be increasing in order of insertion, values are allowed to be infinite, NaN, etc.
- __init__(self: pydrake.systems.primitives.VectorLog_[AutoDiffXd], input_size: int) None
Constructs the vector log.
- Parameter
input_size
: Dimension of the per-time step data set.
- Parameter
- AddData(self: pydrake.systems.primitives.VectorLog_[AutoDiffXd], time: pydrake.autodiffutils.AutoDiffXd, sample: numpy.ndarray[object[m, 1]]) None
Adds a
sample
to the data set with the associatedtime
value. The new sample and time are added to the end of the log. No constraints are imposed on the values of`time` orsample
.- Parameter
time
: The time value for this sample.
- Parameter
sample
: A vector of data of the declared size for this log.
- Parameter
- Clear(self: pydrake.systems.primitives.VectorLog_[AutoDiffXd]) None
Clears the logged data.
- data(self: pydrake.systems.primitives.VectorLog_[AutoDiffXd]) numpy.ndarray[object[m, n]]
Accesses the logged data.
The InnerPanel parameter of the return type indicates that the compiler can assume aligned access to the data.
- get_input_size(self: pydrake.systems.primitives.VectorLog_[AutoDiffXd]) int
Reports the size of the log’s input vector.
- kDefaultCapacity = 1000
- num_samples(self: pydrake.systems.primitives.VectorLog_[AutoDiffXd]) int
Returns the number of samples taken since construction or last Clear().
- Reserve(self: pydrake.systems.primitives.VectorLog_[AutoDiffXd], arg0: int) None
Reserve storage for at least
capacity
samples. At construction, there will be at leastkDefaultCapacity
; use this method to reserve more.
- sample_times(self: pydrake.systems.primitives.VectorLog_[AutoDiffXd]) numpy.ndarray[object[m, 1]]
Accesses the logged time stamps.
- class pydrake.systems.primitives.VectorLog_[Expression]
This utility class serves as an in-memory cache of time-dependent vector values. Note that this is a standalone class, not a Drake System. It is primarily intended to support the Drake System primitive VectorLogSink, but can be used independently.
When the log becomes full, adding more data will cause the allocated space to double in size. If avoiding memory allocation during some performance-critical phase is desired, clients can call Reserve() to pre-allocate log storage.
This object imposes no constraints on the stored data. For example, times passed to AddData() need not be increasing in order of insertion, values are allowed to be infinite, NaN, etc.
- __init__(self: pydrake.systems.primitives.VectorLog_[Expression], input_size: int) None
Constructs the vector log.
- Parameter
input_size
: Dimension of the per-time step data set.
- Parameter
- AddData(self: pydrake.systems.primitives.VectorLog_[Expression], time: pydrake.symbolic.Expression, sample: numpy.ndarray[object[m, 1]]) None
Adds a
sample
to the data set with the associatedtime
value. The new sample and time are added to the end of the log. No constraints are imposed on the values of`time` orsample
.- Parameter
time
: The time value for this sample.
- Parameter
sample
: A vector of data of the declared size for this log.
- Parameter
- Clear(self: pydrake.systems.primitives.VectorLog_[Expression]) None
Clears the logged data.
- data(self: pydrake.systems.primitives.VectorLog_[Expression]) numpy.ndarray[object[m, n]]
Accesses the logged data.
The InnerPanel parameter of the return type indicates that the compiler can assume aligned access to the data.
- get_input_size(self: pydrake.systems.primitives.VectorLog_[Expression]) int
Reports the size of the log’s input vector.
- kDefaultCapacity = 1000
- num_samples(self: pydrake.systems.primitives.VectorLog_[Expression]) int
Returns the number of samples taken since construction or last Clear().
- Reserve(self: pydrake.systems.primitives.VectorLog_[Expression], arg0: int) None
Reserve storage for at least
capacity
samples. At construction, there will be at leastkDefaultCapacity
; use this method to reserve more.
- sample_times(self: pydrake.systems.primitives.VectorLog_[Expression]) numpy.ndarray[object[m, 1]]
Accesses the logged time stamps.
- class pydrake.systems.primitives.VectorLogSink
Bases:
pydrake.systems.framework.LeafSystem
A discrete sink block which logs its vector-valued input to per-context memory. This data is then retrievable outside of System operation, e.g. after a simulation. See the warning below.
The stored log (a VectorLog) holds a large, Eigen matrix for data storage, where each column corresponds to a data point. The VectorLogSink saves a data point and the context time whenever it samples its input.
Warning
The logged data MUST NOT be used to modify the behavior of a simulation. In technical terms, the log is not stored as System State, so should not be considered part of that state. This distinction allows the implementation to use
Publish()
as the event handler, rather than one of the state-modifying handlers.By default, sampling is performed every time the Simulator completes a trajectory-advancing substep (that is, via a per-step Publish event), with the first sample occurring during Simulator::Initialize(). That means the samples will generally be unevenly spaced in time. If you prefer regular sampling, you may optionally specify a “publish period” in which case sampling occurs periodically, with the first sample occurring at time 0. Alternatively (not common), you can specify that logging should only occur at “forced publish” events, meaning at explicit calls to System::Publish(). The Simulator’s “publish every time step” option also results in forced publish events, so should be disabled (the default setting) if you want to control logging yourself.
See also
LogVectorOutput() for a convenient way to add logging to a Diagram.
data→ VectorLogSink Note
This class is templated; see
VectorLogSink_
for the list of instantiations.- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.VectorLogSink, input_size: int, publish_period: float = 0.0) -> None
Constructs the vector log sink.
Sets the default set of publish triggers: if publish_period = 0, publishes on forced events and per step, if publish_period > 0, publishes on forced events and periodically.
- Parameter
input_size
: Dimension of the (single) input port. This corresponds to the number of rows of the data matrix.
- Parameter
publish_period
: Period that messages will be published (optional). If the publish period is zero or not supplied, VectorLogSink will use per-step publishing instead; see LeafSystem::DeclarePerStepPublishEvent().
- Precondition:
publish_period is non-negative.
See also
LogVectorOutput() helper function for a convenient way to add logging.
__init__(self: pydrake.systems.primitives.VectorLogSink, input_size: int, publish_triggers: set[pydrake.systems.framework.TriggerType], publish_period: float = 0.0) -> None
Constructs the vector log sink with a specified set of publish triggers.
- Parameter
input_size
: Dimension of the (single) input port. This corresponds to the number of rows of the data matrix.
- Parameter
publish_triggers
: Set of triggers that determine when messages will be published. Supported TriggerTypes are {kForced, kPeriodic, kPerStep}. Will throw an error if empty or if unsupported types are provided.
- Parameter
publish_period
: Period that messages will be published (optional). publish_period should only be non-zero if one of the publish_triggers is kPeriodic.
- Precondition:
publish_period is non-negative.
- Precondition:
publish_period > 0 if and only if publish_triggers contains kPeriodic.
See also
LogVectorOutput() helper function for a convenient way to add logging.
- FindLog(self: pydrake.systems.primitives.VectorLogSink, context: pydrake.systems.framework.Context) pydrake.systems.primitives.VectorLog
Access the log within a containing root context.
- Raises
RuntimeError if supplied context is not a root context, or was not –
created for the containing diagram. –
- FindMutableLog(self: pydrake.systems.primitives.VectorLogSink, context: pydrake.systems.framework.Context) pydrake.systems.primitives.VectorLog
Access the log as a mutable object within a containing root context.
- Raises
RuntimeError if supplied context is not a root context, or was not –
created for the containing diagram. –
- GetLog(self: pydrake.systems.primitives.VectorLogSink, context: pydrake.systems.framework.Context) pydrake.systems.primitives.VectorLog
Access the log within this component’s context.
- Raises
RuntimeError if context was not created for this system. –
- GetMutableLog(self: pydrake.systems.primitives.VectorLogSink, context: pydrake.systems.framework.Context) pydrake.systems.primitives.VectorLog
Access the log as a mutable object within this component’s context.
- Raises
RuntimeError if context was not created for this system. –
- template pydrake.systems.primitives.VectorLogSink_
Instantiations:
VectorLogSink_[float]
,VectorLogSink_[AutoDiffXd]
,VectorLogSink_[Expression]
- class pydrake.systems.primitives.VectorLogSink_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
A discrete sink block which logs its vector-valued input to per-context memory. This data is then retrievable outside of System operation, e.g. after a simulation. See the warning below.
The stored log (a VectorLog) holds a large, Eigen matrix for data storage, where each column corresponds to a data point. The VectorLogSink saves a data point and the context time whenever it samples its input.
Warning
The logged data MUST NOT be used to modify the behavior of a simulation. In technical terms, the log is not stored as System State, so should not be considered part of that state. This distinction allows the implementation to use
Publish()
as the event handler, rather than one of the state-modifying handlers.By default, sampling is performed every time the Simulator completes a trajectory-advancing substep (that is, via a per-step Publish event), with the first sample occurring during Simulator::Initialize(). That means the samples will generally be unevenly spaced in time. If you prefer regular sampling, you may optionally specify a “publish period” in which case sampling occurs periodically, with the first sample occurring at time 0. Alternatively (not common), you can specify that logging should only occur at “forced publish” events, meaning at explicit calls to System::Publish(). The Simulator’s “publish every time step” option also results in forced publish events, so should be disabled (the default setting) if you want to control logging yourself.
See also
LogVectorOutput() for a convenient way to add logging to a Diagram.
data→ VectorLogSink - __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.VectorLogSink_[AutoDiffXd], input_size: int, publish_period: float = 0.0) -> None
Constructs the vector log sink.
Sets the default set of publish triggers: if publish_period = 0, publishes on forced events and per step, if publish_period > 0, publishes on forced events and periodically.
- Parameter
input_size
: Dimension of the (single) input port. This corresponds to the number of rows of the data matrix.
- Parameter
publish_period
: Period that messages will be published (optional). If the publish period is zero or not supplied, VectorLogSink will use per-step publishing instead; see LeafSystem::DeclarePerStepPublishEvent().
- Precondition:
publish_period is non-negative.
See also
LogVectorOutput() helper function for a convenient way to add logging.
__init__(self: pydrake.systems.primitives.VectorLogSink_[AutoDiffXd], input_size: int, publish_triggers: set[pydrake.systems.framework.TriggerType], publish_period: float = 0.0) -> None
Constructs the vector log sink with a specified set of publish triggers.
- Parameter
input_size
: Dimension of the (single) input port. This corresponds to the number of rows of the data matrix.
- Parameter
publish_triggers
: Set of triggers that determine when messages will be published. Supported TriggerTypes are {kForced, kPeriodic, kPerStep}. Will throw an error if empty or if unsupported types are provided.
- Parameter
publish_period
: Period that messages will be published (optional). publish_period should only be non-zero if one of the publish_triggers is kPeriodic.
- Precondition:
publish_period is non-negative.
- Precondition:
publish_period > 0 if and only if publish_triggers contains kPeriodic.
See also
LogVectorOutput() helper function for a convenient way to add logging.
- FindLog(self: pydrake.systems.primitives.VectorLogSink_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd]) pydrake.systems.primitives.VectorLog_[AutoDiffXd]
Access the log within a containing root context.
- Raises
RuntimeError if supplied context is not a root context, or was not –
created for the containing diagram. –
- FindMutableLog(self: pydrake.systems.primitives.VectorLogSink_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd]) pydrake.systems.primitives.VectorLog_[AutoDiffXd]
Access the log as a mutable object within a containing root context.
- Raises
RuntimeError if supplied context is not a root context, or was not –
created for the containing diagram. –
- GetLog(self: pydrake.systems.primitives.VectorLogSink_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd]) pydrake.systems.primitives.VectorLog_[AutoDiffXd]
Access the log within this component’s context.
- Raises
RuntimeError if context was not created for this system. –
- GetMutableLog(self: pydrake.systems.primitives.VectorLogSink_[AutoDiffXd], context: pydrake.systems.framework.Context_[AutoDiffXd]) pydrake.systems.primitives.VectorLog_[AutoDiffXd]
Access the log as a mutable object within this component’s context.
- Raises
RuntimeError if context was not created for this system. –
- class pydrake.systems.primitives.VectorLogSink_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
A discrete sink block which logs its vector-valued input to per-context memory. This data is then retrievable outside of System operation, e.g. after a simulation. See the warning below.
The stored log (a VectorLog) holds a large, Eigen matrix for data storage, where each column corresponds to a data point. The VectorLogSink saves a data point and the context time whenever it samples its input.
Warning
The logged data MUST NOT be used to modify the behavior of a simulation. In technical terms, the log is not stored as System State, so should not be considered part of that state. This distinction allows the implementation to use
Publish()
as the event handler, rather than one of the state-modifying handlers.By default, sampling is performed every time the Simulator completes a trajectory-advancing substep (that is, via a per-step Publish event), with the first sample occurring during Simulator::Initialize(). That means the samples will generally be unevenly spaced in time. If you prefer regular sampling, you may optionally specify a “publish period” in which case sampling occurs periodically, with the first sample occurring at time 0. Alternatively (not common), you can specify that logging should only occur at “forced publish” events, meaning at explicit calls to System::Publish(). The Simulator’s “publish every time step” option also results in forced publish events, so should be disabled (the default setting) if you want to control logging yourself.
See also
LogVectorOutput() for a convenient way to add logging to a Diagram.
data→ VectorLogSink - __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.VectorLogSink_[Expression], input_size: int, publish_period: float = 0.0) -> None
Constructs the vector log sink.
Sets the default set of publish triggers: if publish_period = 0, publishes on forced events and per step, if publish_period > 0, publishes on forced events and periodically.
- Parameter
input_size
: Dimension of the (single) input port. This corresponds to the number of rows of the data matrix.
- Parameter
publish_period
: Period that messages will be published (optional). If the publish period is zero or not supplied, VectorLogSink will use per-step publishing instead; see LeafSystem::DeclarePerStepPublishEvent().
- Precondition:
publish_period is non-negative.
See also
LogVectorOutput() helper function for a convenient way to add logging.
__init__(self: pydrake.systems.primitives.VectorLogSink_[Expression], input_size: int, publish_triggers: set[pydrake.systems.framework.TriggerType], publish_period: float = 0.0) -> None
Constructs the vector log sink with a specified set of publish triggers.
- Parameter
input_size
: Dimension of the (single) input port. This corresponds to the number of rows of the data matrix.
- Parameter
publish_triggers
: Set of triggers that determine when messages will be published. Supported TriggerTypes are {kForced, kPeriodic, kPerStep}. Will throw an error if empty or if unsupported types are provided.
- Parameter
publish_period
: Period that messages will be published (optional). publish_period should only be non-zero if one of the publish_triggers is kPeriodic.
- Precondition:
publish_period is non-negative.
- Precondition:
publish_period > 0 if and only if publish_triggers contains kPeriodic.
See also
LogVectorOutput() helper function for a convenient way to add logging.
- FindLog(self: pydrake.systems.primitives.VectorLogSink_[Expression], context: pydrake.systems.framework.Context_[Expression]) pydrake.systems.primitives.VectorLog_[Expression]
Access the log within a containing root context.
- Raises
RuntimeError if supplied context is not a root context, or was not –
created for the containing diagram. –
- FindMutableLog(self: pydrake.systems.primitives.VectorLogSink_[Expression], context: pydrake.systems.framework.Context_[Expression]) pydrake.systems.primitives.VectorLog_[Expression]
Access the log as a mutable object within a containing root context.
- Raises
RuntimeError if supplied context is not a root context, or was not –
created for the containing diagram. –
- GetLog(self: pydrake.systems.primitives.VectorLogSink_[Expression], context: pydrake.systems.framework.Context_[Expression]) pydrake.systems.primitives.VectorLog_[Expression]
Access the log within this component’s context.
- Raises
RuntimeError if context was not created for this system. –
- GetMutableLog(self: pydrake.systems.primitives.VectorLogSink_[Expression], context: pydrake.systems.framework.Context_[Expression]) pydrake.systems.primitives.VectorLog_[Expression]
Access the log as a mutable object within this component’s context.
- Raises
RuntimeError if context was not created for this system. –
- class pydrake.systems.primitives.WrapToSystem
Bases:
pydrake.systems.framework.LeafSystem
An element-wise wrapping block that transforms the specified indices of the input signal
u
into the interval[low, high)
. Precisely, the output elementi
is given the value:Click to expand C++ code...
outputᵢ = inputᵢ + kᵢ*(highᵢ-lowᵢ)
for the unique integer value
kᵢ
that lands the output in the desired interval.u0→ WrapToSystem → y0 Note
This class is templated; see
WrapToSystem_
for the list of instantiations.- __init__(self: pydrake.systems.primitives.WrapToSystem, arg0: int) None
Constructs a system to pass through a fixed-size input vector to the output. Additional calls to set_interval() are required to produce any wrapping behavior.
- set_interval(self: pydrake.systems.primitives.WrapToSystem, arg0: int, arg1: float, arg2: float) None
Sets the system to wrap the
index
element of the input vector to the interval[low, high)
. If this method is called multiple times for the same index, then only the last interval will be used.low
andhigh
should be finite, and low < high.
- template pydrake.systems.primitives.WrapToSystem_
Instantiations:
WrapToSystem_[float]
,WrapToSystem_[AutoDiffXd]
,WrapToSystem_[Expression]
- class pydrake.systems.primitives.WrapToSystem_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
An element-wise wrapping block that transforms the specified indices of the input signal
u
into the interval[low, high)
. Precisely, the output elementi
is given the value:Click to expand C++ code...
outputᵢ = inputᵢ + kᵢ*(highᵢ-lowᵢ)
for the unique integer value
kᵢ
that lands the output in the desired interval.u0→ WrapToSystem → y0 - __init__(self: pydrake.systems.primitives.WrapToSystem_[AutoDiffXd], arg0: int) None
Constructs a system to pass through a fixed-size input vector to the output. Additional calls to set_interval() are required to produce any wrapping behavior.
- set_interval(self: pydrake.systems.primitives.WrapToSystem_[AutoDiffXd], arg0: int, arg1: pydrake.autodiffutils.AutoDiffXd, arg2: pydrake.autodiffutils.AutoDiffXd) None
Sets the system to wrap the
index
element of the input vector to the interval[low, high)
. If this method is called multiple times for the same index, then only the last interval will be used.low
andhigh
should be finite, and low < high.
- class pydrake.systems.primitives.WrapToSystem_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
An element-wise wrapping block that transforms the specified indices of the input signal
u
into the interval[low, high)
. Precisely, the output elementi
is given the value:Click to expand C++ code...
outputᵢ = inputᵢ + kᵢ*(highᵢ-lowᵢ)
for the unique integer value
kᵢ
that lands the output in the desired interval.u0→ WrapToSystem → y0 - __init__(self: pydrake.systems.primitives.WrapToSystem_[Expression], arg0: int) None
Constructs a system to pass through a fixed-size input vector to the output. Additional calls to set_interval() are required to produce any wrapping behavior.
- set_interval(self: pydrake.systems.primitives.WrapToSystem_[Expression], arg0: int, arg1: pydrake.symbolic.Expression, arg2: pydrake.symbolic.Expression) None
Sets the system to wrap the
index
element of the input vector to the interval[low, high)
. If this method is called multiple times for the same index, then only the last interval will be used.low
andhigh
should be finite, and low < high.
- class pydrake.systems.primitives.ZeroOrderHold
Bases:
pydrake.systems.framework.LeafSystem
A zero order hold block with input u, which may be vector-valued (discrete or continuous) or abstract, and discrete output y, where the y is sampled from u with a fixed period (and optional offset).
u→ ZeroOrderHold → y The discrete state space dynamics of ZeroOrderHold is:
Click to expand C++ code...
xₙ₊₁ = uₙ // update yₙ = xₙ // output x₀ = xᵢₙᵢₜ // initialize
where xᵢₙᵢₜ = 0 for vector-valued ZeroOrderHold, and xᵢₙᵢₜ is a given value for abstract-valued ZeroOrderHold. Use SetVectorState() to set xₙ in the context for vector-valued ZeroOrderHold.
See discrete_systems “Discrete Systems” for general information about discrete systems in Drake, including how they interact with continuous systems.
Note
This system defaults to a periodic update with zero offset, in which case the first update occurs at t=0. When used with a Simulator, the output port is equal to xᵢₙᵢₜ after simulator.Initialize(), but is immediately updated to u₀ at the start of the first step. If you want to force that initial update, use simulator.AdvanceTo(0.0).
Note
For an abstract-valued ZeroOrderHold, scalar-type conversion is not supported since AbstractValue does not support it.
Note
This class is templated; see
ZeroOrderHold_
for the list of instantiations.- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.ZeroOrderHold, period_sec: float, vector_size: int, offset_sec: float = 0.0) -> None
Constructs a ZeroOrderHold system with the given
period_sec
, over a vector-valued input of sizevector_size
. The default initial value for this system will be zero. The first update occurs at t=offset_sec, which must be >= 0.__init__(self: pydrake.systems.primitives.ZeroOrderHold, period_sec: float, abstract_model_value: pydrake.common.value.AbstractValue, offset_sec: float = 0.0) -> None
Constructs a ZeroOrderHold system with the given
period_sec
, over a abstract-valued inputabstract_model_value
. The default initial value for this system will beabstract_model_value
. The first update occurs at t=offset_sec, which must be >= 0.
- offset(self: pydrake.systems.primitives.ZeroOrderHold) float
Reports the first update time of this hold (in seconds).
- period(self: pydrake.systems.primitives.ZeroOrderHold) float
Reports the period of this hold (in seconds).
- SetVectorState(self: pydrake.systems.primitives.ZeroOrderHold, arg0: pydrake.systems.framework.Context, arg1: numpy.ndarray[numpy.float64[m, 1]]) None
Sets the value of the state by modifying it in the context.
value
must be a column vector of the appropriate size. This can only be used to initialize a vector-valued state.
- template pydrake.systems.primitives.ZeroOrderHold_
Instantiations:
ZeroOrderHold_[float]
,ZeroOrderHold_[AutoDiffXd]
,ZeroOrderHold_[Expression]
- class pydrake.systems.primitives.ZeroOrderHold_[AutoDiffXd]
Bases:
pydrake.systems.framework.LeafSystem_[AutoDiffXd]
A zero order hold block with input u, which may be vector-valued (discrete or continuous) or abstract, and discrete output y, where the y is sampled from u with a fixed period (and optional offset).
u→ ZeroOrderHold → y The discrete state space dynamics of ZeroOrderHold is:
Click to expand C++ code...
xₙ₊₁ = uₙ // update yₙ = xₙ // output x₀ = xᵢₙᵢₜ // initialize
where xᵢₙᵢₜ = 0 for vector-valued ZeroOrderHold, and xᵢₙᵢₜ is a given value for abstract-valued ZeroOrderHold. Use SetVectorState() to set xₙ in the context for vector-valued ZeroOrderHold.
See discrete_systems “Discrete Systems” for general information about discrete systems in Drake, including how they interact with continuous systems.
Note
This system defaults to a periodic update with zero offset, in which case the first update occurs at t=0. When used with a Simulator, the output port is equal to xᵢₙᵢₜ after simulator.Initialize(), but is immediately updated to u₀ at the start of the first step. If you want to force that initial update, use simulator.AdvanceTo(0.0).
Note
For an abstract-valued ZeroOrderHold, scalar-type conversion is not supported since AbstractValue does not support it.
- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.ZeroOrderHold_[AutoDiffXd], period_sec: float, vector_size: int, offset_sec: float = 0.0) -> None
Constructs a ZeroOrderHold system with the given
period_sec
, over a vector-valued input of sizevector_size
. The default initial value for this system will be zero. The first update occurs at t=offset_sec, which must be >= 0.__init__(self: pydrake.systems.primitives.ZeroOrderHold_[AutoDiffXd], period_sec: float, abstract_model_value: pydrake.common.value.AbstractValue, offset_sec: float = 0.0) -> None
Constructs a ZeroOrderHold system with the given
period_sec
, over a abstract-valued inputabstract_model_value
. The default initial value for this system will beabstract_model_value
. The first update occurs at t=offset_sec, which must be >= 0.
- offset(self: pydrake.systems.primitives.ZeroOrderHold_[AutoDiffXd]) float
Reports the first update time of this hold (in seconds).
- period(self: pydrake.systems.primitives.ZeroOrderHold_[AutoDiffXd]) float
Reports the period of this hold (in seconds).
- SetVectorState(self: pydrake.systems.primitives.ZeroOrderHold_[AutoDiffXd], arg0: pydrake.systems.framework.Context_[AutoDiffXd], arg1: numpy.ndarray[object[m, 1]]) None
Sets the value of the state by modifying it in the context.
value
must be a column vector of the appropriate size. This can only be used to initialize a vector-valued state.
- class pydrake.systems.primitives.ZeroOrderHold_[Expression]
Bases:
pydrake.systems.framework.LeafSystem_[Expression]
A zero order hold block with input u, which may be vector-valued (discrete or continuous) or abstract, and discrete output y, where the y is sampled from u with a fixed period (and optional offset).
u→ ZeroOrderHold → y The discrete state space dynamics of ZeroOrderHold is:
Click to expand C++ code...
xₙ₊₁ = uₙ // update yₙ = xₙ // output x₀ = xᵢₙᵢₜ // initialize
where xᵢₙᵢₜ = 0 for vector-valued ZeroOrderHold, and xᵢₙᵢₜ is a given value for abstract-valued ZeroOrderHold. Use SetVectorState() to set xₙ in the context for vector-valued ZeroOrderHold.
See discrete_systems “Discrete Systems” for general information about discrete systems in Drake, including how they interact with continuous systems.
Note
This system defaults to a periodic update with zero offset, in which case the first update occurs at t=0. When used with a Simulator, the output port is equal to xᵢₙᵢₜ after simulator.Initialize(), but is immediately updated to u₀ at the start of the first step. If you want to force that initial update, use simulator.AdvanceTo(0.0).
Note
For an abstract-valued ZeroOrderHold, scalar-type conversion is not supported since AbstractValue does not support it.
- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.systems.primitives.ZeroOrderHold_[Expression], period_sec: float, vector_size: int, offset_sec: float = 0.0) -> None
Constructs a ZeroOrderHold system with the given
period_sec
, over a vector-valued input of sizevector_size
. The default initial value for this system will be zero. The first update occurs at t=offset_sec, which must be >= 0.__init__(self: pydrake.systems.primitives.ZeroOrderHold_[Expression], period_sec: float, abstract_model_value: pydrake.common.value.AbstractValue, offset_sec: float = 0.0) -> None
Constructs a ZeroOrderHold system with the given
period_sec
, over a abstract-valued inputabstract_model_value
. The default initial value for this system will beabstract_model_value
. The first update occurs at t=offset_sec, which must be >= 0.
- offset(self: pydrake.systems.primitives.ZeroOrderHold_[Expression]) float
Reports the first update time of this hold (in seconds).
- period(self: pydrake.systems.primitives.ZeroOrderHold_[Expression]) float
Reports the period of this hold (in seconds).
- SetVectorState(self: pydrake.systems.primitives.ZeroOrderHold_[Expression], arg0: pydrake.systems.framework.Context_[Expression], arg1: numpy.ndarray[object[m, 1]]) None
Sets the value of the state by modifying it in the context.
value
must be a column vector of the appropriate size. This can only be used to initialize a vector-valued state.