Main Content

impulse

Impulse response plot of dynamic system; impulse response data

    Description

    Impulse Response Plots

    example

    impulse(sys) plots the response of a dynamic system model to an impulse input. The model sys can be continuous or discrete.

    • For continuous-time sys, the impulse input is the Dirac impulse δ(t). For continuous-time sys with direct feedthrough, impulse ignores the infinite pulse at t = 0.

    • For discrete-time sys with sample time Ts, the function computes the response to a unit-area pulse of length Ts and height 1/Ts. This pulse approaches the continuous-time Dirac impulse δ(t) as Ts goes to zero.

    sys can be SISO or MIMO. For MIMO systems, the plot displays the impulse responses for each I/O channel. impulse automatically determines the time steps and duration of the simulation based on the system dynamics.

    example

    impulse(sys,tFinal) simulates the impulse response from t = 0 to the final time t = tFinal. The function uses system dynamics to determine the intervening time steps.

    example

    impulse(sys,t) plots the impulse response at the times that you specify in the vector t.

    example

    impulse(sys1,sys2,...,sysN,___) plots the impulse response of multiple dynamic systems on the same plot. All systems must have the same number of inputs and outputs. You can use multiple dynamic systems with any of the previous input-argument combinations.

    example

    impulse(sys1,LineSpec1,...,sysN,LineSpecN,___) specifies a color, line style, and marker for each system in the plot. You can use LineSpec with any of the previous input-argument combinations. When you need additional plot customization options, use impulseplot instead.

    Impulse Response Data

    example

    y = impulse(sys,t) returns the impulse response sys at the times specified in the vector t. This syntax does not draw a plot.

    [y,tOut] = impulse(sys) also returns a vector of times tOut corresponding to the responses in y. If you do not provide an input vector t of times, impulse chooses the length and time step of tOut based on the system dynamics.

    [y,tOut] = impulse(sys,tFinal) computes the impulse response up to the end time tFinal. impulse chooses the time step of tOut based on the system dynamics.

    example

    [y,t,x] = impulse(sys) also returns the state trajectories x, when sys is a state-space model such as an ss or idss model.

    example

    [y,t,x,ysd] = impulse(sys) also computes the standard deviation ysd of the impulse response y, when sys is an identified model such as an idss, idtf, or idnlarx model.

    Examples

    collapse all

    Plot the impulse response of a continuous-time system represented by the following transfer function.

    sys(s)=4s2+2s+10

    For this example, create a tf model that represents the transfer function. You can similarly plot the impulse response of other dynamic system model types, such as zero-pole gain (zpk) or state-space (ss) models.

    sys = tf(4,[1 2 10]);

    Plot the impulse response.

    impulse(sys)

    Figure contains an axes object. The axes object contains an object of type line. This object represents sys.

    The impulse plot automatically includes a dotted horizontal line indicating the steady-state response. In a MATLAB® figure window, you can right-click on the plot to view other impulse-response characteristics such as peak response and transient time.

    Plot the impulse response of a discrete-time system. The system has a sample time of 0.2 s and is represented by the following state-space matrices.

    A = [1.6 -0.7;
          1  0];
    B = [0.5; 0];
    C = [0.1 0.1];
    D = 0;

    Create the state-space model and plot its impulse response.

    sys = ss(A,B,C,D,0.2);
    impulse(sys)

    Figure contains an axes object. The axes object contains an object of type line. This object represents sys.

    The impulse response reflects the discretization of the model, as it shows the response as computed every 0.2 seconds.

    Examine the impulse response of the following zero-pole-gain model.

    sys = zpk(-1,[-0.2+3j,-0.2-3j],1) * tf([1 1],[1 0.05]) 
    sys =
     
                (s+1)^2
      ----------------------------
      (s+0.05) (s^2 + 0.4s + 9.04)
     
    Continuous-time zero/pole/gain model.
    
    impulse(sys)

    Figure contains an axes object. The axes object contains an object of type line. This object represents sys.

    By default, impulse chooses an end time that shows the steady state that the response is trending toward. To get a closer look at the transient response, limit the impulse plot to t = 20 s.

    impulse(sys,20)

    Figure contains an axes object. The axes object contains an object of type line. This object represents sys.

    Alternatively, you can specify the exact times at which you want to examine the impulse response, provided they are separated by a constant interval. For instance, examine the response from the end of the transient until the system reaches steady state.

    t = 20:0.2:120;
    impulse(sys,t)

    Figure contains an axes object. The axes object contains an object of type line. This object represents sys.

    Even though this plot begins at t = 20, impulse always applies the impulse input at t = 0.

    Consider the following second-order state-space model:

    [x˙1x˙2]=[-0.5572-0.78140.78140][x1x2]+[1-102][u1u2]y=[1.96916.4493][x1x2]

    A = [-0.5572,-0.7814;0.7814,0];
    B = [1,-1;0,2];
    C = [1.9691,6.4493];
    sys = ss(A,B,C,0);

    This model has two inputs and one output, so it has two channels: from the first input to the output and from the second input to the output. Each channel has its own impulse response.

    When you use impulse, it computes the responses of all channels.

    impulse(sys)

    Figure contains 2 axes objects. Axes object 1 with title From: In(1) contains an object of type line. This object represents sys. Axes object 2 with title From: In(2) contains an object of type line. This object represents sys.

    The left plot shows the impulse response of the first input channel, and the right plot shows the impulse response of the second input channel. Whenever you use impulse to plot the responses of a MIMO model, it generates an array of plots representing all the I/O channels of the model. For instance, create a random state-space model with five states, three inputs, and two outputs, and plot its impulse response.

    sys = rss(5,2,3);
    impulse(sys)

    Figure contains 6 axes objects. Axes object 1 with title From: In(1) contains an object of type line. This object represents sys. Axes object 2 contains an object of type line. This object represents sys. Axes object 3 with title From: In(2) contains an object of type line. This object represents sys. Axes object 4 contains an object of type line. This object represents sys. Axes object 5 with title From: In(3) contains an object of type line. This object represents sys. Axes object 6 contains an object of type line. This object represents sys.

    In a MATLAB figure window, you can restrict the plot to a subset of channels by right-clicking on the plot and selecting I/O Selector.

    impulse allows you to plot the responses of multiple dynamic systems on the same axis. For instance, compare the closed-loop response of a system with a PI controller and a PID controller. Create a transfer function of the system and tune the controllers.

    H = tf(4,[1 2 10]);
    C1 = pidtune(H,'PI');
    C2 = pidtune(H,'PID');

    Form the closed-loop systems and plot their impulse responses.

    sys1 = feedback(H*C1,1);
    sys2 = feedback(H*C2,1);
    impulse(sys1,sys2)
    legend('PI','PID','Location','SouthEast')

    Figure contains an axes object. The axes object contains 2 objects of type line. These objects represent PI, PID.

    By default, impulse chooses distinct colors for each system that you plot. You can specify colors and line styles using the LineSpec input argument.

     impulse(sys1,'r--',sys2,'b')
     legend('PI','PID','Location','SouthEast')

    Figure contains an axes object. The axes object contains 2 objects of type line. These objects represent PI, PID.

    The first LineSpec 'r--' specifies a dashed red line for the response with the PI controller. The second LineSpec 'b' specifies a solid blue line for the response with the PID controller. The legend reflects the specified colors and linestyles. For more plot customization options, use impulseplot.

    The example Compare Impulse Response of Multiple Systems shows how to plot responses of several individual systems on a single axis. When you have multiple dynamic systems arranged in a model array, impulse plots all their responses at once.

    Create a model array. For this example, use a one-dimensional array of second-order transfer functions having different natural frequencies. First, preallocate memory for the model array. The following command creates a 1-by-5 row of zero-gain SISO transfer functions. The first two dimensions represent the model outputs and inputs. The remaining dimensions are the array dimensions.

     sys = tf(zeros(1,1,1,5));

    Populate the array.

    w0 = 1.5:1:5.5;    % natural frequencies
    zeta = 0.5;        % damping constant
    for i = 1:length(w0)
       sys(:,:,1,i) = tf(w0(i)^2,[1 2*zeta*w0(i) w0(i)^2]);
    end

    (For more information about model arrays and how to create them, see Model Arrays (Control System Toolbox).) Plot the impulse responses of all models in the array.

    impulse(sys)

    Figure contains an axes object. The axes object contains 5 objects of type line. This object represents sys.

    impulse uses the same linestyle for the responses of all entries in the array. One way to distinguish among entries is to use the SamplingGrid property of dynamic system models to associate each entry in the array with the corresponding w0 value.

    sys.SamplingGrid = struct('frequency',w0);

    Now, when you plot the responses in a MATLAB figure window, you can click a trace to see which frequency value it corresponds to.

    When you give it an output argument, impulse returns an array of response data. For a SISO system, the response data is returned as a column vector of length equal to the number of time points at which the response is sampled. You can provide the vector t of time points, or allow impulse to select time points for you based on system dynamics. For instance, extract the impulse response of a SISO system at 101 time points between t = 0 and t = 5 s.

    sys = tf(4,[1 2 10]);
    t = 0:0.05:5;
    y = impulse(sys,t);
    size(y)
    ans = 1×2
    
       101     1
    
    

    For a MIMO system, the response data is returned in an array of dimensions N-by-Ny-by-Nu, where Ny and Nu are the number of outputs and inputs of the dynamic system. For instance, consider the following state-space model, representing a two-input, one-output system.

    A = [-0.5572,-0.7814;0.7814,0];
    B = [1,-1;0,2];
    C = [1.9691,6.4493];
    sys = ss(A,B,C,0);

    Extract the impulse response of this system at 200 time points between t = 0 and t = 20 s.

    t = linspace(0,20,200);
    y = impulse(sys,t);
    size(y)
    ans = 1×3
    
       200     1     2
    
    

    y(:,i,j) is a column vector containing the impulse response from the jth input to the ith output at the times t. For instance, extract the impulse response from the second input to the output.

    y12 = y(:,1,2);
    plot(t,y12)

    Figure contains an axes object. The axes object contains an object of type line.

    Compare the impulse response of a parametric identified model to a non-parametric (empirical) model. Also view their 3 σ confidence regions.

    Load the data.

    load iddata1 z1

    Estimate a parametric model.

    sys1 = ssest(z1,4);

    Estimate a non-parametric model.

    sys2 = impulseest(z1);

    Plot the impulse responses for comparison.

    t = (0:0.1:10)';
    [y1, ~, ~, ysd1] = impulse(sys1,t);
    [y2, ~, ~, ysd2] = impulse(sys2,t);
    plot(t, y1, 'b', t, y1+3*ysd1, 'b:', t, y1-3*ysd1, 'b:')
    hold on
    plot(t, y2, 'g', t, y2+3*ysd2, 'g:', t, y2-3*ysd2, 'g:')

    Figure contains an axes object. The axes object contains 6 objects of type line.

    Compute the impulse response of an identified time-series model.

    A time-series model, also called a signal model, is one without measured input signals. The impulse plot of this model uses its (unmeasured) noise channel as the input channel to which the impulse signal is applied.

    Load the data.

    load iddata9;

    Estimate a time-series model.

    sys = ar(z9, 4);

    sys is a model of the form A y(t) = e(t) , where e(t) represents the noise channel. For computation of impulse response, e(t) is treated as an input channel, and is named e@y1.

    Plot the impulse response.

    impulse(sys)

    Figure contains an axes object. The axes object with title From: e@y1 To: y1 contains 2 objects of type line. This object represents sys.

    Input Arguments

    collapse all

    Dynamic system, specified as a SISO or MIMO dynamic system model or array of dynamic system models. Dynamic systems that you can use include:

    • Continuous-time or discrete-time numeric LTI models, such as tf, zpk, or ss models.

    • Generalized or uncertain LTI models such as genss or uss models. (Using uncertain models requires Robust Control Toolbox™ software.)

      • For tunable control design blocks, the function evaluates the model at its current value for both plotting and returning response data.

      • For uncertain control design blocks, the function plots the nominal value and random samples of the model. When you use output arguments, the function returns response data for the nominal model only.

    • Sparse state-space models such as sparss and mechss models. You must specify final time tFinal for sparse state-space models.

    • Identified LTI models, such as idtf, idss, or idproc models. For such models, the function can also plot confidence intervals and return standard deviations of the frequency response.

    impulse does not support frequency-response data models such as frd, genfrd, or idfrd models.

    If sys is an array of models, the function plots the responses of all models in the array on the same axes.

    End time for impulse response, specified as a positive scalar value. impulse simulates the impulse response from t = 0 to t = tFinal.

    • For continuous-time systems, the function determines the step size and number of points automatically from system dynamics. Express tFinal in the system time units, specified in the TimeUnit property of sys.

    • For discrete-time systems, the function uses the sample time of sys as the step size. Express tFinal in the system time units, specified in the TimeUnit property of sys.

    • For discrete-time systems with unspecified sample time (Ts = -1), impulse interprets tFinal as the number of sampling periods to simulate.

    Time vector at which to compute the impulse response, specified as a vector of positive scalar values. Express t in the system time units, specified in the TimeUnit property of sys.

    • For continuous-time models, specify t in the form Ti:dt:Tf. To obtain the response at each time step, the function uses dt as the sample time of a discrete approximation to the continuous system.

    • For discrete-time models, specify t in the form Ti:Ts:Tf, where Ts is the sample time of sys.

    impulse always applies the impulse input at t = 0, regardless of Ti.

    Line style, marker, and color, specified as a string or vector of one, two, or three characters. The characters can appear in any order. You do not need to specify all three characteristics (line style, marker, and color). For example, if you omit the line style and specify the marker, then the plot shows only the marker and no line. For more information about configuring this argument, see the LineSpec input argument of the plot function.

    Example: 'r--' specifies a red dashed line

    Example: '*b' specifies blue asterisk markers

    Example: 'y' specifies a yellow line

    Output Arguments

    collapse all

    Impulse response data, returned as an array.

    • For SISO systems, y is a column vector of the same length as t (if provided) or tOut (if you do not provide t).

    • For single-input, multi-output systems, y is a matrix with as many rows as time samples and as many columns as outputs. Thus, the jth column of y, or y(:,j), contains the impulse response of from the input to the jth output.

    • For MIMO systems, the impulse responses of each input channel are stacked up along the third dimension of y. The dimensions of y are then N-by-Ny-by-Nu, where:

      • N is the number of time samples.

      • Ny is the number of system outputs.

      • Nu is the number of system inputs.

      Thus, y(:,i,j) is a column vector containing the impulse response from the jth input to the ith output at the times specified in t or tOut.

    Times at which impulse response is computed, returned as a vector. When you do not provide a specific vector t of times, impulse chooses this time vector based on the system dynamics. The times are expressed in the time units of sys.

    State trajectories, returned as an array. When sys is a state-space model, x contains the evolution of the states of sys at each time in t or tOut. The dimensions of x are N-by-Nx-by-Nu, where:

    • N is the number of time samples.

    • Nx is the number of states.

    • Nu is the number of system inputs.

    Thus, the evolution of the states in response to an impulse injected at the kth input is given by the array x(:,:,k). The row vector x(i,:,k) contains the state values at the ith time step.

    Standard deviation of the impulse response of an identified model, returned as an array of the same dimensions as y. If sys does not contain parameter covariance information, then ysd is empty.

    Limitations

    • The impulse response of a continuous system with nonzero D matrix is infinite at t = 0. impulse ignores this discontinuity and returns the lower continuity value Cb at t = 0.

    • The impulse command does not work on continuous-time models with internal delays. For such models, use pade (Control System Toolbox) to approximate the time delay before computing the impulse response.

    Tips

    • When you need additional plot customization options, use impulseplot instead.

    • To simulate system responses to arbitrary input signals, use lsim.

    Algorithms

    Continuous-time models are first converted to state-space form. The impulse response of a single-input state-space model

    x˙=Ax+buy=Cx

    is equivalent to the following unforced response with initial state b.

    x˙=Ax,x(0)=by=Cx

    To simulate this response, the system is discretized using zero-order hold on the inputs. The sample time is chosen automatically based on the system dynamics, except when a time vector t = 0:dt:Tf is supplied. Hence, dt is used as sample time.

    Version History

    Introduced before R2006a

    See Also

    (Control System Toolbox) | | | | (Control System Toolbox) |