Simulink Control Design

Block-by-Block Analytic Linearization

www.kxcad.net Home > CAE Software Index > MATLAB Index >

What Is Block-by-Block Analytic Linearization?

Block-by-block analytic linearization is the default linearization method in Simulink Control Design. Through this method, each block within the linearization path is first linearized individually.

There are two methods that Simulink Control Design uses to linearize the individual blocks in a model:

• Linearizing Individual Blocks Using Analytic Linearization

• Linearizing Individual Blocks Using Block Perturbation

Each method has options that you can control to create accurate linearized models.

The following section gives details of the methods used to linearize each block, with suggestions for controlling the linearizations to create more accurate linearized models.

Back to Top

Linearizing Individual Blocks Using Analytic Linearization

Many Simulink blocks contain analytic Jacobians for exact linearization. When linearizing a system using block-by-block analytic linearization, you can use these analytic linearizations instead of numerically perturbing the block. This approach is especially useful for blocks that contain discontinuities and do not give good results using numerical perturbation.

Note   The preprogrammed, analytic block linearizations are only used in block-by-block analytic linearization. When you use the numerical-perturbation linearization method, such blocks are numerically perturbed with the rest of the system.

Back to Top

Blocks that Support Analytic Linearization

The following table lists Simulink blocks and whether they contain analytic Jacobians for linearization.

Several blocks include options to control the linearization that you can adjust in the Block Parameters window. For example, you can change the order of the Padé approximation used in the Transport Delay block or select the Treat as gain when linearizing option in the Saturation block. The Notes column in the following table gives details on blocks that include options to control the linearization.

For more information on individual blocks, see the reference page for each block.

Blocks with Analytic Jacobians and Linearization Options

Back to Top

Linearizing Individual Blocks Using Block Perturbation

When you cannot use a preprogrammed block linearization, Simulink Control Design automatically computes the block linearization by numerically perturbing the states and inputs of the block about the operating point of the block. As opposed to the numerical-perturbation linearization method, this perturbation is local and its propagation through the rest of the model is restricted.

Block Perturbation Algorithm

The block perturbation algorithm introduces a small perturbation to the nonlinear block and measuring the response to this perturbation. Both the perturbation and the resulting response are used to create the matrices in the linear state-space model of this block. Changing the size of the perturbations changes the resulting linearized model.

As described in Linearizing Models, you can write a nonlinear Simulink block as a state-space system:

In these equations, x(t) represents the states of the block, u(t) represents the inputs of the block, and y(t) represents the outputs of the block.

A linearized model of this system is valid in a small region around the operating point t=t₀, x(t₀)=x₀, u(t₀)=u₀, and y(t₀)=g(x₀,u₀,t₀)=y₀. Subtracting the operating point values from the states, inputs, and outputs defines a set of variables centered about the operating point:

You can write the linearized model in terms of these new variables. The representation is usually valid when the variables are small, i.e., when the departure from the operating point is small:

The state-space matrices A, B, C, and D of this linearized model represent the Jacobians of the block, as defined in Linearizing Models. To compute the matrices, the states and inputs are perturbed, one at a time, and the response of the system to this perturbation is measured by computing and δy. The perturbation and response are then used to compute the matrices in the following way:

where

• x_p,i is the state vector whose ith component is perturbed from the operating point value.

• x_o is the state vector at the operating point.

• u_p,i is the input vector whose ith component is perturbed from the operating point value.

• u_o is the input vector at the operating point.

• is the value of at x_p,i, u_o.

• is the value of at u_p,i, x_o.

• is the value of at the operating point.

• is the value of at x_p,i, u_o.

• is the value of at u_p,i, x_o.

• y_o is the value of y at the operating point.

Linearized models of discrete-time are computed in a similar way. For more information, see Linearizing Models in the Simulink Control Design Getting Started documentation for the equations of linearized discrete-time and multirate systems.

Note   A perturbed value is one that has been changed by a very small amount from the operating point value. The default difference between the perturbed value and the operating point value is for block-by-block analytic linearization, where x is the operating point value.

Changing Perturbation Size

Changing the size of the perturbations changes the linearization results. The default perturbation size is 10^-5(1+|x|), where x is the operating point value of the state or input being perturbed. For example, to change the perturbation size of the states in the Magnetic Ball Plant block in the magball model to , type

blockname='magball/Magnetic Ball Plant'
set_param(blockname,'StatePerturbationForJacobian','1e-7')

To change the perturbation size of the input of the Magnetic Ball Plant block to , where u is the input signal level, follow these steps:

1. Get the block's port handles:

   ph=get_param('magball/Magnetic Ball Plant','PortHandles')
   

2. Next, get the inport:

   pin=ph.Inport(1)
   

3. Finally, set the perturbation level for this inport:

   set_param(pin,'PerturbationForJacobian','1e-7')
   

Blocks Containing Two Inputs

If there is more than one inport, you can choose to assign a different perturbation level to each. The following figure shows an S-Function block with two input signals, the actual signal and an index variable. To avoid perturbing the index signal, you can assign a perturbation level of 0 to this inport.

Model Reference Blocks

When linearizing model reference blocks with accelerated mode, Simulink Control Design automatically uses block perturbation. If you instead want to linearize these referenced models using block-by-block analytical linearization, then change the block mode from accelerated to normal.

Note   Model blocks with multiple sample times and accelerated mode cannot be linearized using block perturbation. To linearize blocks with multiple sample times, you must set the block mode to normal.

Note   If your model contains multiple model blocks referencing the same Simulink model, you must set all of the blocks to accelerator mode.

Blocks with Nondouble Data Types

Blocks that have nondouble data type signals as either inputs or outputs, and which do not have a preprogrammed exact linearization, automatically linearize to zero as they cannot be numerically perturbed. For example, many logical operator blocks have Boolean outputs and therefore linearize to 0.

Workarounds for Blocks with Nondouble Data Types.   To work around the problem of blocks with nondouble data types linearizing to zero, you can use a Data Type Conversion block. This block has a preprogrammed exact linearization, to convert your signals to doubles before linearizing the model. The following example illustrates this concept. The model in this example is configured to linearize the Square block at an operating point where the input is 1. The resulting linearized model should be 2, but the input to the Square block is Boolean and the linearization is zero.

However, by inserting a Data Type Conversion block before the linearization input point, you can make the input signal to the Square block a double. Thus, the linearized model gives the correct response of 2.

Overriding Nondouble Data Types.   When you linearize a model that contains nondouble data types but still runs correctly in full double precision, you can choose to override all data types with doubles. To perform this override, in the model window select Tools > Fixed-Point Settings from the menu. This selection opens the Fixed-Point Settings window. Within this window select True doubles from the Data type override menu. Now, when you linearize and simulate the model, it uses doubles for all data types.

Note   This method does not work when the model relies on other data types in its algorithm, such as relying on integer data types to perform truncation from floats.

Back to Top

Linearizing Models with Time Delays

You can linearize models with time delays using:

• Padé approximation provides the following results:

  • An approximate representation of continuous delays using the Padé order you specify in the block dialog for the delay Simulink blocks

  • Discrete delays as states

  For more information, see Finding Linearized Models with Padé Approximation of Delays.

• Exact linearization provides the following results:

  • An exact representation of continuous delays

  • An internal representation of discrete delays

    These discrete delays do not appear as states in the linearized model but are accounted for as internal delays.

  For more information, see Finding Linearized Models with Exact Delays.

Blocks with Delays

The delays in your model can arise from any of the following Simulink blocks:

• Transport Delay

• Variable Time Delay

• Variable Transport Delay

• Integer Delay

• Unit Delay

For more information on time delays, see Time Delays in the Control System Toolbox documentation.

Finding Linearized Models with Padé Approximation of Delays

To find linearized models with Padé approximations of delays, first adjust the order of the Padé approximation in the Block Parameters window for any block with delay. Then, perform the linearization.

Note   To use a Padé approximation for continuous delay blocks, set the UseExactDelayModel option of the linoptions function to the default setting, off.

For more information on Padé approximations, see Eliminating Time Delays: Padé Approximation in the Control System Toolbox documentation.

Finding Linearized Models with Exact Delays

You can use block-by-block analytic linearization to find linear models with exact time delays. You can do this in the following ways:

• In the Linearizations Options dialog box, select the Return linear model with exact delay(s) option.

  For more information on the Linearization Option dialog box, see Changing Linearization Options.

• At the command line, set thelinoptions function option UseExactDelayModel to on.

  For more information, see the "Linearizing Models with Time Delays" demo listed under the Simulink Control Design Demos in the demos browser.

Back to Top

Blocks with Discontinuities

There are several Simulink blocks that contain discontinuities, such as the Sign block, whose behavior is shown in the following figure.

The very large derivatives that occur at the point of discontinuity can cause problems with linearization. For example, the Sign block has the following linearization

where D is a state-space matrix, and u is the input signal to the block.

When these blocks are within the linearization path of your model, the resulting linearized model could potentially have very large values. There is no obvious solution to this problem and it is recommended that you remove or replace these blocks. However, when your model operates in a region away from the point of discontinuity, the linearization will be zero. This should not cause any problems, although when the linearizations of several blocks are multiplied together (as in a feedback path) it can cause the linearization of the system to be zero.

When these blocks are outside the linearization path, they can still contribute to the definition of the operating point of the model but will not otherwise affect the linearization. It is safe to use them for reference signals, disturbances, and any other signals and blocks that are not being linearized.

Other examples of blocks with discontinuities include

• Relational Operator blocks

• Relay block

• Logical Operator blocks

• Stateflow blocks

• Quantizer block (has an option to treat as a gain when linearizing)

• Saturation block (has an option to treat as a gain when linearizing)

• Deadzone block (has an option to treat as a gain when linearizing)

Back to Top

Integrator Blocks Near Saturation or a Reset Point

When an Integrator block has an external reset condition or output limitations (saturation) and the model is operating near the point where the Integrator is reset or the output is limited, it might be more meaningful for the linearization to ignore the effect of the saturation or reset. To linearize a model around an operating point that causes the integrator to reset or saturate, select Ignore limit and reset when linearizing in the Integrator block parameters dialog box. Selecting this option causes the linearization to treat this block as unresettable and as having no limits on its output, regardless of the settings of the block's reset and output limitation (saturation) options.

Back to Top

Event-Based Models and Triggered Subsystems

The linearization of triggered subsystems and other event-based models can be particularly difficult because of the system's dependence on previous events. In particular, the execution of a triggered system depends on previous signal events such as zero crossings. Therefore, for linearization, which takes place at a particular moment in time, a trigger event will never happen. Thus, while the event-based dynamics contribute to the definition of the system's operating point, this information is not captured by the list of values of states and inputs that typically describe the operating point for linearization.

Triggered events describe many different systems. One such system is an internal combustion (IC) engine. When an engine piston approaches the top of a compression stroke, a spark is introduced and combustion occurs. The timing of the spark for combustion is dependent on the speed and position of the engine crankshaft. An example of a Simulink model that models this behavior is engine.mdl which is included as a demonstration model in Simulink.

In engine.mdl, triggered subsystems generate events when the pistons reach both the top and bottom of the compression stroke. The linearization will not be meaningful because of the presence of these triggered subsystems. However, you can get a meaningful linearization while still preserving the simulation behavior by recasting the event-based dynamics. For example, you can use curve fitting to approximate the event-based behavior. This is done in scdspeed.mdl, a demonstration model included in Simulink Control Design and shown in the figure below:

The basic functional approximation in scdspeed is included within the Convert to mass charge block inside the subsystem scdspeed/Throttle & Manifold/Intake Manifold where a quadratic polynomial is used to approximate the relationship between the Air Charge, the Manifold Pressure, and the Engine Speed.

The approximation has the following form:

Simulation data from the original model is used to compute the unknown parameters p₁, p₂, p₃, p₄, and p₅ using a least squares fitting technique.

When measured data for internal signals is available, you can use Simulink Parameter Estimation to compute the unknown parameters. This method is outlined in the Simulink Parameter Estimation demo called Engine Speed Model Parameter Estimation. The demo also shows how to linearize this model and use the linearization to design a feedback controller.

The approximated model can now accurately simulate and linearize the engine from approximately 1500 to 5500 RPM. The following figure shows the comparison between a simulation of the original event-based model, and a simulation of the new approximated model.

Back to Top

Choosing a Linearization Algorithm Method

Numerical-Perturbation Linearization

© 1984-2007 The MathWorks, Inc. • Terms of Use • Patents • Trademarks • Acknowledgments