## About Operating Points

### What Is an Operating Point?

An *operating point* of a dynamic system defines the
states and root-level input signals of the model at a specific time. For
example, in a car engine model, variables such as engine speed, throttle
angle, engine temperature, and surrounding atmospheric conditions typically
describe the operating point.

The following Simulink^{®} model has an operating point that consists of two
variables:

A root-level input signal set to

`1`

An Integrator block state set to

`5`

The following table summarizes the signal values for the model at this operating point.

Block | Block Input | Block Operation | Block Output |
---|---|---|---|

Integrator | `1` | Integrate input | `5` , set by the initial
condition`x0 = 5` |

Square | `5` , set by the initial condition
of the Integrator block | Square input | `25` |

Sum | `25` from Square
block, `1` from
Constant block | Sum inputs | `26` |

Gain | `26` | Multiply input by 3 | `78` |

The following block diagram shows how the model input and the initial state of the Integrator block propagate through the model during simulation.

If your model initial states and inputs already represent the desired steady-state operating conditions, you can use this operating point for linearization or control design.

### What Is a Steady-State Operating Point?

A *steady-state operating point* of a model, also called
an equilibrium or *trim* condition, includes state variables that do not
change with time.

A model can have several steady-state operating points. For
example, a hanging damped pendulum has two steady-state operating
points at which the pendulum position does not change with time. A *stable
steady-state operating point* occurs when a pendulum hangs
straight down. When the pendulum position deviates slightly, the pendulum
always returns to equilibrium. In other words, small changes in the
operating point do not cause the system to leave the region of good
approximation around the equilibrium value.

An *unstable steady-state operating point* occurs
when a pendulum points upward. As long as the pendulum points *exactly* upward,
it remains in equilibrium. However, when the pendulum deviates slightly
from this position, it swings downward and the operating point leaves
the region around the equilibrium value.

When using optimization search to compute operating points for nonlinear systems, your initial guesses for the states and input levels must be near the desired operating point to ensure convergence.

When linearizing a model with multiple steady-state operating points, it is important to have the right operating point. For example, linearizing a pendulum model around the stable steady-state operating point produces a stable linear model, whereas linearizing around the unstable steady-state operating point produces an unstable linear model.

### Simulink Model States Included in Operating Point Object

In Simulink
Control Design™ software, an operating point for a Simulink model is represented by an
operating point (`operpoint`

) object. The
object stores the tunable model states and their values, along with other
data about the operating point. The states of blocks that have internal
representation, such as Backlash, Memory, and
Stateflow^{®} blocks, are excluded.

States that are excluded from the operating point object cannot be used in
trimming computations. These states cannot be captured with `operspec`

or
`operpoint`

, or written with `initopspec`

. Such states
are also excluded from operating point displays or computations using
**Model Linearizer**. The following table summarizes which
states are included and which are excluded from the operating point
object.

State Type | Included in Operating Point? |
---|---|

Double-precision real-valued states | Yes |

States whose value is not of type
`double` . For example,
complex-valued states,
`single` -type states,
`int8` -type states. | No |

States from root-level inport blocks with double-precision real-valued inputs | Yes |

Internal state representations that impact block output, such as states in Backlash, Memory, or Stateflow blocks. | No (see Handle Blocks with Internal State Representation) |

States that belong to a Unit Delay block whose input is a bus signal | No |