OutputResponse
OutputResponse[sys,u[t],{t,tmin,tmax}]
gives the numeric output response of systems model sys to the input u[t] for tmin≤t≤tmax.
OutputResponse[sys,{u[0],u[1],…}]
gives the output response of the discrete-time system sys to the input sequence u[i].
OutputResponse[sys,u[t],t]
gives the symbolic output response of system sys to the input u[t] as a function of time t.
OutputResponse[sys,{u1[t],…,um[t]},…]
gives the output response for multiple inputs ui[t].
Details
- OutputResponse is also known as impulse response, step response, and ramp response.
- OutputResponse solves the underlying differential or difference equations for the given input.
- The systems model sys can be a TransferFunctionModel, a StateSpaceModel, a continuous-time AffineStateSpaceModel, or a continuous-time NonlinearStateSpaceModel.
- A linear TransferFunctionModel or StateSpaceModel sys can also be a descriptor and delay system.
- The initial values for the differential and difference equations are taken to be zero for a TransferFunctionModel. For the state-space models, they are taken to be the state operating values of sys unless specified.
- OutputResponse[{sys,{x10,x20,…,xn0}},…] can be used to specify the initial state for a state-space model sys.
- For descriptor state-space systems, the initial states need to be consistent.
- For delay state-space systems, the initial states include history and can be given as xi0[t] for t≤0. »
Examples
open all close allBasic Examples (4)
The step response of a second-order system:
Simplify[OutputResponse[TransferFunctionModel[{{{ω^2}}, s^2 +
2*s*ζ*ω + ω^2}, s], UnitStep[t], t]]The output response of a transfer-function model to a sinusoidal input:
OutputResponse[TransferFunctionModel[{{{1}}, 1 + s}, s], Sin[10 t], t]Plot[%, {t, 0, 10}]The response of a state-space model from nonzero initial conditions:
OutputResponse[{StateSpaceModel[{{{-2, 0.8, 0}, {-0.8, -2, 0}, {0, 0, -1}}, {{1}, {0}, {-1}}, {{1, 0, 0}}, {{0}}},
SamplingPeriod -> None, SystemsModelLabels -> None], {1, 0.1, 1}}, 0, t]Plot[%, {t, 0, 3}, PlotRange -> All]The response of a discrete-time system to a sampled sinusoid:
or = OutputResponse[StateSpaceModel[{{{-0.1, 0}, {0, 0.3}}, {{1}, {-1}}, {{1, 0}}, {{0}}}, SamplingPeriod -> 0.1,
SystemsModelLabels -> None], Table[Sin[k], {k, 0, 20}]]ListStepPlot[or, DataRange -> {0, 19 0.1}]Scope (46)
Basic Uses (19)
Find the initial value response for a scalar continuous-time state-space model:
OutputResponse[{StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}},
SamplingPeriod -> None, SystemsModelLabels -> None], {x0}}, {0}, t]Find the zero initial condition response for a symbolic input:
OutputResponse[{StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}},
SamplingPeriod -> None, SystemsModelLabels -> None], {0}}, {u[t]}, t]Find the numeric response of a fourth-order system to a sinusoidal input:
OutputResponse[StateSpaceModel[{{{-1/3, 0, 1, 3}, {0, -2, 1, 2}, {-1, 0, -1, 0}, {0, 0, 1, -1/2}},
{{1}, {-1}, {0}, {0}}, {{1, 0, 0, 1}}, {{0}}}, SamplingPeriod -> None, SystemsModelLabels -> None], {Sin[2Pit]}, {t, 0, 10}]Plot[%, {t, 0, 10}, PlotRange -> All]Find the numeric step response for a continuous-time transfer-function model:
tfm = TransferFunctionModel[{{{1}}, 5 + s + s^2}, s];OutputResponse[tfm, UnitStep[t], {t, 0, 10}]Plot[%, {t, 0, 10}, PlotRange -> All]Simplify[OutputResponse[tfm, UnitStep[t], t]]Plot[%, {t, 0, 10}, PlotRange -> All]Find the numeric step response for a discrete-time state-space model:
OutputResponse[StateSpaceModel[{{{0, 1}, {-0.2, 0.5}}, {{0}, {1.}}, {{1., 1}}, {{0}}}, SamplingPeriod -> 0.5,
SystemsModelLabels -> None], {1}, {t, 0, 10}]Find the step response for a discrete-time transfer function with a numeric simulation:
Subscript[tfm, d] = TransferFunctionModel[{{{1. + z}}, 1/10 - (2*z)/3 + z^2},
z, SamplingPeriod -> 1, SystemsModelLabels -> None];orn = OutputResponse[Subscript[tfm, d], UnitStep[t], {t, 0, 11}]ListStepPlot[orn, DataRange -> {0, 10}]ors = OutputResponse[Subscript[tfm, d], UnitStep[t], t]ListStepPlot[Table[ors[[1]], {t, 0, 10}], DataRange -> {0, 10}]Find the symbolic response for an affine state-space model:
OutputResponse[AffineStateSpaceModel[{{-3 + 3*x}, {{4*x}}, {2*x}, {{0}}},
{x}, Automatic, {Automatic}, Automatic, SamplingPeriod -> None], {Sin[t]}, t]Find the symbolic response for an affine state-space model with a nonzero equilibrium:
OutputResponse[{AffineStateSpaceModel[{{-(3 + x)^2}, {{5}}, {x}, {{0}}},
{{x, -3}}, Automatic, {Automatic}, Automatic, SamplingPeriod -> None], -2}, {0}, t]Plot[%, {t, 0, 30}, PlotRange -> All]Find the numeric response for an affine state-space model with multiple equilibria:
OutputResponse[AffineStateSpaceModel[{{5*x - x^2}, {{10}}, {x}, {{0}}},
{x}, Automatic, {Automatic}, Automatic, SamplingPeriod -> None], {UnitStep[t - 2] UnitStep[5 - t]}, {t, 0, 10}];
Plot[%, {t, 0, 10}, PlotRange -> All]Find the symbolic response for a nonlinear state-space model:
StateResponse[{NonlinearStateSpaceModel[{{-x + u*x}, {x}},
{x}, {u}, {Automatic}, Automatic, SamplingPeriod -> None], x0}, {Sin[t]}, t]Find the numeric response for a nonlinear state-space model:
StateResponse[NonlinearStateSpaceModel[
{{u - Subscript[x, 1]*Subscript[x, 2],
Subscript[x, 1] - u*Subscript[x, 2]},
{Subscript[x, 1]}}, {Subscript[x, 1], Subscript[x, 2]},
{u}, {Automatic}, Automatic, SamplingPeriod -> None], {Sin[t]}, {t, 0, 20}];
Plot[%, {t, 0, 20}, PlotRange -> All]Find the numeric response of a two-output fourth-order system to a triangle wave:
OutputResponse[StateSpaceModel[{{{-1, 2, 2, 0}, {-1, -2, -1, -1}, {-2, 0, -2, -2}, {2, 1, 0, -1}},
{{1}, {2}, {0}, {-1}}, {{1, -1, 0, 0}, {0, 0, 1, -1}}, {{0}, {0}}}, SamplingPeriod -> None,
SystemsModelLabels -> None], {TriangleWave[t]}, {t, 0, 5}];
Plot[Evaluate@%, {t, 0, 5}]Find the symbolic response of a three-output transfer-function model:
Simplify[OutputResponse[TransferFunctionModel[{{{2}, {1}, {7}}, {{1 + 3*s},
{1 + (5*s)/4 + s^2}, {1}}}, s, SamplingPeriod -> None,
SystemsModelLabels -> None], {Sin[t]}, t]]Find the response of a state-space model with output delays:
OutputResponse[StateSpaceModel[{{{0, 1}, {-0.8, -2.}}, {{0}, {1}}, {{3*SystemsModelDelay[2], 0},
{0, SystemsModelDelay[1]}}, {{0}, {0}}}, SamplingPeriod -> None, SystemsModelLabels -> None], Sin[2 π t], {t, 0, 7}];
Plot[Evaluate@%, {t, 0, 7}]OutputResponse[StateSpaceModel[{{{1, -1, 0}, {0, 1, 1}, {0, 0, -1}}, {{1, 2}, {0, 0}, {0, 2}}, {{1, -1, 0}},
{{0, 0}}}, SamplingPeriod -> None, SystemsModelLabels -> None], {1, 3}, t]When a multiple-input system receives a single input, it is applied separately to each input:
OutputResponse[StateSpaceModel[{{{0}}, {{Subscript[b, 1], Subscript[b, 2]}}, {{1}},
{{0, 0}}}, SamplingPeriod -> None, SystemsModelLabels -> None], UnitStep[t], t]A numeric response for a multiple-input, multiple-output transfer-function model:
OutputResponse[TransferFunctionModel[{{{1, 1}, {1, 1}}, {{s, 1 + s},
{2 + s, 3 + s}}}, s], {Sin[2t - Pi / 2], Sin[t]}, {t, 0, 20}];
Plot[Evaluate@%, {t, 0, 20}]A second-order system settling from nonzero initial states:
OutputResponse[{StateSpaceModel[{{{0, 1}, {-1/10, -1/2}}, {{0}, {1}}, {{1, 0}}, {{0}}}, SamplingPeriod -> None,
SystemsModelLabels -> None], {0, 3}}, {0}, t]Plot[Evaluate@%, {t, 0, 40}]A nonlinear state-space model with multiple equilibria:
nssm = NonlinearStateSpaceModel[
{{u + (3 - x)*(5 - x)*(7 - x)},
{x}}, {x}, {u}, {Automatic}, Automatic,
SamplingPeriod -> None];The steady-state position depends on the initial condition:
Table[OutputResponse[{nssm, {x0}}, {0}, {t, 0, .7}], {x0, 2, 10, .5}];
Plot[%, {t, 0, .7}, PlotRange -> All]An alternating input signal can cause the system to switch between equilibria:
input = 2(SquareWave[t / 10] - SquareWave[t / 10 - .85]);
OutputResponse[nssm, input, {t, 0, 20}];
Plot[%, {t, 0, 20}, PlotRange -> All]Continuous-Time Systems (18)
The output response of a continuous-time system to a step input:
tf[ω_, ζ_] := TransferFunctionModel[{{{ω^2}}, s^2 +
2*s*ζ*ω + ω^2}, s]
OutputResponse[tf[1, (1/2)], UnitStep[t], t]The response for various damping ratios:
Plot[Evaluate@Table[Tooltip[OutputResponse[tf[1, ξ], UnitStep[t], t], ξ], {ξ, Range[0, 1.4, 0.2]}], {t, 0, 15}, Frame -> True, PlotRange -> All, GridLines -> Automatic]The response to a unit step input:
OutputResponse[{StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}},
SamplingPeriod -> None, SystemsModelLabels -> None], Subscript[x, 0]}, UnitStep[t], t]The response of a descriptor StateSpaceModel:
Expand[OutputResponse[{StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}},
{{e}}}, SamplingPeriod -> None, SystemsModelLabels -> None], Subscript[x, 0]}, u[t], t]]The response of a state-space model:
y = OutputResponse[StateSpaceModel[{{{-1, 1}, {0, -2}}, {{0}, {1}}, {{1, 0}}, {{0}}}, SamplingPeriod -> None,
SystemsModelLabels -> None], UnitStep[t], t]Plot[y, {t, 0, 7}]The initial values of the states are assumed to be zero:
OutputResponse[{StateSpaceModel[{{{-1, 1}, {0, -2}}, {{0}, {1}}, {{1, 0}}, {{0}}}, SamplingPeriod -> None,
SystemsModelLabels -> None], {0, 0}}, UnitStep[t], t] == yThe response of a two-output system to a delayed step input:
OutputResponse[TransferFunctionModel[{{{1}, {1}}, {{1 + s},
{1 + 2*s + s^2}}}, s], UnitStep[t - 1], t]Plot[Evaluate@%, {t, 0, 7}, PlotRange -> All]The output response for nonzero initial conditions:
OutputResponse[{StateSpaceModel[{{{-1, 1}, {0, -2}}, {{0}, {1}}, {{1, 0}}, {{0}}}, SamplingPeriod -> None,
SystemsModelLabels -> None], {2, 5}}, UnitStep[t], t]Plot[Evaluate@%, {t, 0, 7}]The output response for a system with two inputs:
OutputResponse[TransferFunctionModel[{{{s, 1}, {2 + s, s}},
{{1 + s, 3 + s}, {1 + s, 3 + s}}},
s], {Sin[t], Cos[2 t]}, t]A second-order system step response goes from oscillations at 
to overdamped at 
:
Plot3D[Evaluate[OutputResponse[TransferFunctionModel[{{{1}}, 1 + s^2 + 2*s*ζ},
s], UnitStep[t], t]], {ζ, 0, 1.2}, {t, 0, 15}, AxesLabel -> {"ζ", t, "y"}, MeshFunctions -> {#1&}, PlotRange -> All]If there are fewer input signals than system inputs, the remaining signals are set to zero:
Simplify[OutputResponse[TransferFunctionModel[{{{s, 1}, {2 + s, s}},
{{1 + s, 3 + s}, {1 + s, 3 + s}}},
s], {Sin[t]}, t]]tfm = TransferFunctionModel[{{{2 + s, 1}},
{{1 + s + s^2, 1 + s}}}, s];When a scalar input signal is given, it is applied to each input in turn:
OutputResponse[tfm, UnitStep[t], t] ==
(OutputResponse[tfm, #, t]& /@ Permutations[{UnitStep[t], 0}, {2}])If the time interval is specified, the result is computed numerically:
tfm = TransferFunctionModel[{{{80 + 72*s + 25*s^2 + 3*s^3}},
80 + 96*s + 40*s^2 + 8*s^3 + s^4},
s];
y1 = OutputResponse[tfm, UnitStep[t], {t, 6}]y2 = OutputResponse[tfm, UnitStep[t], t]Plot[{y1, y2}, {t, 0, 6}, PlotRange -> All]The response of a generic continuous-time system:
Expand[OutputResponse[{StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}},
SamplingPeriod -> None, SystemsModelLabels -> None], Subscript[x, 0]}, u[t], t]]Expand[OutputResponse[{StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}},
SamplingPeriod -> None, SystemsModelLabels -> None], Subscript[x, 0]}, Sin[t], t]]Step response of a time-delay transfer-function model:
OutputResponse[TransferFunctionModel[{{{E^(-3*s)}}, 6 + s^2}, s,
SamplingPeriod -> None, SystemsModelLabels -> None], {UnitStep[t]}, {t, 0, 7}];
Plot[%, {t, 0, 7}]Step response of a time-delay state-space model:
OutputResponse[StateSpaceModel[{{{0, 1}, {-3, 0.5*SystemsModelDelay[1]}}, {{0}, {1}}, {{SystemsModelDelay[2], 0}},
{{0}}}, SamplingPeriod -> None, SystemsModelLabels -> None], Sin[t], {t, 0, 20}];
Plot[%, {t, 0, 20}]A StateSpaceModel with a singular descriptor matrix:
OutputResponse[StateSpaceModel[{{{0, 2, 0, 0}, {2, 3, 1, 3}, {1, 0, 1, 3}, {-9, -6, -5, -11}},
{{0}, {1}, {0}, {1}}, {{1, 0, 0, 0}}, {{0}}, {{2, 3, 1, 3}, {0, 0, 0, 0}, {3, 3, 1, 1},
{1, 0, 1, 3}}}, SamplingPeriod -> None, SystemsModelLabels -> None], 1, t]Plot[%, {t, 0, 8}]The output response of an AffineStateSpaceModel to a UnitStep input:
OutputResponse[AffineStateSpaceModel[{{Subscript[x, 2], -Sin[Subscript[x, 1]] -
Subscript[x, 1]^3 - Subscript[x, 2]^2}, {{0}, {1}},
{Subscript[x, 1]}, {{0}}}, {Subscript[x, 1],
Subscript[x, 2]}, Automatic, {Automatic}, Automatic, SamplingPeriod -> None], UnitStep[t], {t, 0, 12}]Plot[%, {t, 0, 12}]The response from nonzero initial conditions:
OutputResponse[AffineStateSpaceModel[{{Subscript[x, 2], -Sin[Subscript[x, 1]] -
Subscript[x, 1]^3 - Subscript[x, 2]^2}, {{0}, {1}},
{Subscript[x, 1]}, {{0}}}, {{Subscript[x, 1], -1},
{Subscript[x, 2], 0.25}}, Automatic, {Automatic}, Automatic, SamplingPeriod -> None], UnitStep[t], {t, 0, 12}];
Plot[%, {t, 0, 12}]The output response of a NonlinearStateSpaceModel to a UnitStep input:
OutputResponse[NonlinearStateSpaceModel[{{Subscript[x, 2],
(Sin[u] - Sin[Subscript[x, 1]])*Subscript[x, 1]},
{Subscript[x, 1]}}, {{Subscript[x, 1], 0.1},
{Subscript[x, 2], 0}}, {u}, {Automatic}, Automatic,
SamplingPeriod -> None], UnitStep[t], {t, 0, 30}]Plot[%, {t, 0, 30}]Discrete-Time Systems (9)
The output response of a single-input system to a sampled sinusoid:
or = OutputResponse[StateSpaceModel[{{{0, 1}, {-0.5, 1.5}}, {{0}, {1}}, {{0, 1}}, {{0}}}, SamplingPeriod -> 1,
SystemsModelLabels -> None], Table[Sin[t], {t, 0, 15}]]Plot of the sampled output with a zero-order hold:
ListStepPlot[or, DataRange -> {0, 14}]The response for a generic discrete-time system:
OutputResponse[{StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}},
SamplingPeriod -> τ, SystemsModelLabels -> None], Subscript[x, 0]}, u[k], k]The response to a unit step sequence:
OutputResponse[{StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}},
SamplingPeriod -> τ, SystemsModelLabels -> None], Subscript[x, 0]}, 1, k]The response for a symbolic descriptor system:
Simplify[OutputResponse[{StateSpaceModel[{{{Subscript[a, 1], 0}, {0, Subscript[a, 2]}},
{{Subscript[b, 1]}, {Subscript[b, 2]}},
{{Subscript[c, 1], Subscript[c, 2]}}, {{Subscript[d, 1]}},
{{Subscript[e, 1], 0}, {0, 0}}}, SamplingPeriod -> τ,
SystemsModelLabels -> None], {Subscript[x, 1], Automatic}}, u[t], t]]The response of a two-input system:
or = OutputResponse[TransferFunctionModel[{{{z, -0.1 + z}, {1, 4}},
{{-0.5 + z, 0.5 + z}, {-0.5 + z, 0.5 + z}}},
z, SamplingPeriod -> 0.1], {Table[Sin[k], {k, 0, 3, 0.1}], Table[SquareWave[k], {k, 0, 3, 0.1}]}]ListStepPlot[or, DataRange -> {0, 2 0.1}, PlotRange -> All]The response of a first-order discrete-time system:
OutputResponse[{StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}},
SamplingPeriod -> τ, SystemsModelLabels -> None], Subscript[x, 0]}, u[k], k]The response to a unit step sequence:
OutputResponse[{StateSpaceModel[{{{a}}, {{b}}, {{c}}, {{d}}},
SamplingPeriod -> τ, SystemsModelLabels -> None], Subscript[x, 0]}, 1, k]The output response of a discrete-time system to a time-dependent input:
or = OutputResponse[TransferFunctionModel[{{{(1 + z)*τ^2}}, 2*(-1 + z)^2},
z, SamplingPeriod -> τ], Sqrt[k], k]ListStepPlot[Table[or /. τ -> 0.1, {k, Range[20]}], DataRange -> {0, 19 0.1}]Ramp response of a time-delay system:
or = OutputResponse[StateSpaceModel[{{{0, 1.}, {-1, -0.75}}, {{0}, {1}},
{{SystemsModelDelay[2], SystemsModelDelay[3]}}, {{0}}}, SamplingPeriod -> 0.2,
SystemsModelLabels -> None], {Range[10]}];
ListStepPlot[or, DataRange -> {0, 9 0.2}]Generalizations & Extensions (3)
If the initial time is not specified, it is assumed to be zero:
OutputResponse[StateSpaceModel[{{{-3}}, {{1}}, {{2}}, {{0}}}, SamplingPeriod -> None, SystemsModelLabels -> None], {UnitStep[t]}, {t, 2}];Plot[%, {t, 0, 2}]When a system has state delays, the initial states can include history:
OutputResponse[{StateSpaceModel[{{{-1 + SystemsModelDelay[2]/2}}, {{0}}, {{1}}, {{0}}}, SamplingPeriod -> None,
SystemsModelLabels -> None], {-t}}, {0}, {t, 10}];Plot[%, {t, 0, 10}]For discrete-time systems with delays, the initial states can be given as a sequence:
or = OutputResponse[{StateSpaceModel[{{{(-1 - SystemsModelDelay[3])/2}}, {{0}}, {{1}}, {{0}}}, SamplingPeriod -> 1,
SystemsModelLabels -> None], {{-3, -1, -3, -1}}}, {0}, {t, 0, 10}]ListStepPlot[or, DataRange -> {0, 9}]Applications (3)
Determine the steady-state output value of a stable first-order system in response to a unit step input:
y = OutputResponse[TransferFunctionModel[{{{1}}, 1 + 10*s}, s], UnitStep[t], t][[1]];Subscript[y, ss] = Limit[y, t -> ∞]τ = t /. FindRoot[y == (1 - (1/E)) Subscript[y, ss], {t, 1}]With[{y1 = y /. t -> τ}, Plot[y, {t, 0, 40}, Epilog -> {Dashed, Line[{{τ, 0}, {τ, y1}, {0, y1}}], PointSize[Medium], Point[{{τ, y1}}]}]]Visualize the response of an unstable system and its response after feedback stabilization:
antenna = TransferFunctionModel[{{{0.0019*(1 + z)}}, 0.9802 - 1.9802*z +
z^2}, z, SamplingPeriod -> 0.2, SystemsModelLabels -> None];or = OutputResponse[antenna, UnitStep[k], {k, 10}];
ListStepPlot[or, DataRange -> {0, 9 0.2}]A compensator for the antenna:
comp = TransferFunctionModel[{{{9.15*(-0.9802 + z)}}, -0.8187 + z},
z, SamplingPeriod -> 0.2, SystemsModelLabels -> None];csys = SystemsModelFeedbackConnect[
SystemsModelSeriesConnect[antenna, comp]]//Simplifyorcl = OutputResponse[csys, UnitStep[k], {k, 10}];
ListStepPlot[orcl, DataRange -> {0, 9 0.2}]The zero-input response of a system:
Simplify[OutputResponse[{StateSpaceModel[{{{0, 1}, {-0.18, 0.9}}, {{0}, {1}}, {{1, 0}}, {{0}}}, SamplingPeriod -> 0.5,
SystemsModelLabels -> None], {0.1, -0.1}}, 0, k]]Properties & Relations (4)
The natural response is determined by the poles of the system:
ssm = StateSpaceModel[{{{0, 1}, {-0.18, 0.9}}, {{0}, {1}}, {{1., 0}}, {{0}}}, SamplingPeriod -> 0.3,
SystemsModelLabels -> None];
Simplify[OutputResponse[{ssm, 0.02}, 0, k]]Eigenvalues[First[Normal[ssm]]]The results of StateResponse and OutputResponse match for state output:
ssm = StateSpaceModel[{{{0.5}}, {{0.1}}, {{1}}, {{0}}}, SamplingPeriod -> 1, SystemsModelLabels -> None];
With[{seq = RandomReal[1, 20]}, OutputResponse[ssm, seq] == StateResponse[ssm, seq]]A discrete-time system responding to a continuous-time input:
Length[OutputResponse[TransferFunctionModel[{{{z}}, -0.5 + z}, z,
SamplingPeriod -> 1], UnitStep[t], {t, 0, 50}][[1]]]For a smaller sampling period, more sample points are needed:
Length[OutputResponse[TransferFunctionModel[{{{z}}, -0.5 + z}, z,
SamplingPeriod -> 0.5], UnitStep[t], {t, 0, 50}][[1]]]The impulse response of a system:
sys = (2 s + 1/s^2 + 3 s + 2);
u = DiracDelta[t];
y = OutputResponse[TransferFunctionModel[sys, s], u, t][[1]]//SimplifyOutputResponse assumes that the input is zero for 
:
Refine[y, t < 0]Thus the solution obtained using InverseLaplaceTransform is different for 
:
InverseLaplaceTransform[sys LaplaceTransform[u, t, s], s, t]Refine[y, t > 0] == %Possible Issues (4)
A continuous-time system cannot be simulated with sampled inputs:
ssm = StateSpaceModel[{{{0, 1}, {-1, -10.2}}, {{0}, {1}}, {{0, -10}}, {{0}}}, SamplingPeriod -> None,
SystemsModelLabels -> None];
OutputResponse[ssm, RandomReal[{0, 1}, 10]]
OutputResponse[ToDiscreteTimeModel[ssm, 1], RandomReal[{0, 1}, 10]]Computations with machine numbers can be unstable:
tfm = TransferFunctionModel[{{{100*s}}, 1000000 + 100*s +
0.0001*s^2}, s, SamplingPeriod -> None, SystemsModelLabels -> None];
OutputResponse[tfm, UnitStep[t], t] /. t -> 1
orr = OutputResponse[Rationalize[tfm], UnitStep[t], t]Plot[orr, {t, 0, 0.0005}]Or compute the numeric response:
orn = OutputResponse[tfm, UnitStep[t], {t, 0, 0.0005}]Plot[orn, {t, 0, 0.0005}]Symbolic output responses do not support time delays:
dssm = StateSpaceModel[{{{-4 - SystemsModelDelay[3]}}, {{2}}, {{1}}, {{0}}}, SamplingPeriod -> None,
SystemsModelLabels -> None];
OutputResponse[dssm, {Sin[t]}, t]
OutputResponse[dssm, {Sin[t]}, {t, 0, 10}];
Plot[%, {t, 0, 10}]For descriptor systems, solutions only exist when Det[λ e - a]≠0 for some λ:
ssm = StateSpaceModel[{{{-1, 0}, {2, 0}}, {{1}, {-1}}, {{1, 0}}, {{0}}, {{1, 0}, {0, 0}}},
SamplingPeriod -> None, SystemsModelLabels -> None];
OutputResponse[ssm, {Sin[t]}, {t, 0, 10}]
Text
Wolfram Research (2010), OutputResponse, Wolfram Language function, https://reference.wolfram.com/language/ref/OutputResponse.html (updated 2014).
CMS
Wolfram Language. 2010. "OutputResponse." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2014. https://reference.wolfram.com/language/ref/OutputResponse.html.
APA
Wolfram Language. (2010). OutputResponse. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/OutputResponse.html