# Control Systems/System Metrics

## System Metrics

When a system is being designed and analyzed, it doesn\'t make any sense
to test the system with all manner of strange input functions, or to
measure all sorts of arbitrary performance metrics. Instead, it is in
everybody\'s best interest to test the system with a set of standard,
simple reference functions. Once the system is tested with the reference
functions, there are a number of different metrics that we can use to
determine the system performance.

It is worth noting that the metrics presented in this chapter represent
only a small number of possible metrics that can be used to evaluate a
given system. This wikibook will present other useful metrics along the
way, as their need becomes apparent.

## Standard Inputs

There are a number of standard inputs that are considered simple enough
and universal enough that they are considered when designing a system.
These inputs are known as a **unit step**, a **ramp**, and a
**parabolic** input.

Also, sinusoidal and exponential functions are considered basic, but
they are too difficult to use in initial analysis of a system.

## Steady State

When a unit-step function is input to a system, the **steady-state**
value of that system is the output value at time $t = \infty$. Since it
is impractical (if not completely impossible) to wait till infinity to
observe the system, approximations and mathematical calculations are
used to determine the steady-state value of the system. Most system
responses are **asymptotic**, that is that the response approaches a
particular value. Systems that are asymptotic are typically obvious from
viewing the graph of that response.

### Step Response

The step response of a system is most frequently used to analyze
systems, and there is a large amount of terminology involved with step
responses. When exposed to the step input, the system will initially
have an undesirable output period known as the **transient response**.
The transient response occurs because a system is approaching its final
output value. The steady-state response of the system is the response
after the transient response has ended.

The amount of time it takes for the system output to reach the desired
value (before the transient response has ended, typically) is known as
the **rise time**. The amount of time it takes for the transient
response to end and the steady-state response to begin is known as the
**settling time**.

It is common for a systems engineer to try and improve the step response
of a system. In general, it is desired for the transient response to be
reduced, the rise and settling times to be shorter, and the steady-state
to approach a particular desired \"reference\" output.

+----------------------------------+----------------------------------+
| ![](Step_Function.svg "          | ![](Step_Response.svg "          |
| Step_Function.svg"){width="400"} | Step_Response.svg"){width="400"} |
+----------------------------------+----------------------------------+
| ```{=html}                       | ```{=html}                       |
| <center>                         | <center>                         |
| ```                              | ```                              |
| An arbitrary step function with  | A step response graph of input   |
| $x(t) = Mu(t)$                   | *x(t)* to a made-up system       |
|                                  |                                  |
| ```{=html}                       | ```{=html}                       |
| </center>                        | </center>                        |
| ```                              | ```                              |
+----------------------------------+----------------------------------+

{{-}}

## Target Value

The target output value is the value that our system attempts to obtain
for a given input. This is not the same as the steady-state value, which
is the actual value that the system does obtain. The target value is
frequently referred to as the **reference value**, or the \"reference
function\" of the system. In essence, this is the value that we want the
system to produce. When we input a \"5\" into an elevator, we want the
output (the final position of the elevator) to be the fifth floor.
Pressing the \"5\" button is the reference input, and is the expected
value that we want to obtain. If we press the \"5\" button, and the
elevator goes to the third floor, then our elevator is poorly designed.

## Rise Time

**Rise time** is the amount of time that it takes for the system
response to reach the target value from an initial state of zero. Many
texts on the subject define the rise time as being the time it takes to
rise between the initial position and 80% of the target value. This is
because some systems never rise to 100% of the expected, target value,
and therefore they would have an infinite rise-time. This book will
specify which convention to use for each individual problem. Rise time
is typically denoted *t~r~*, or *t~rise~*.

## Percent Overshoot

Underdamped systems frequently overshoot their target value initially.
This initial surge is known as the \"overshoot value\". The ratio of the
amount of overshoot to the target steady-state value of the system is
known as the **percent overshoot**. Percent overshoot represents an
overcompensation of the system, and can output dangerously large output
signals that can damage a system. Percent overshoot is typically denoted
with the term *PO*.

## Steady-State Error

Sometimes a system might never achieve the desired steady-state value,
but instead will settle on an output value that is not desired. The
difference between the steady-state output value to the reference input
value at steady state is called the **steady-state error** of the
system. We will use the variable *e~ss~* to denote the steady-state
error of the system.

## Settling Time

After the initial rise time of the system, some systems will oscillate
and vibrate for an amount of time before the system output settles on
the final value. The amount of time it takes to reach steady state after
the initial rise time is known as the **settling time**. Notice that
damped oscillating systems may never settle completely, so we will
define settling time as being the amount of time for the system to
reach, and stay in, a certain acceptable range. The acceptable range for
settling time is typically determined on a per-problem basis, although
common values are 20%, 10%, or 5% of the target value. The settling time
will be denoted as *t~s~*.

## System Order

The **order** of the system is defined by the number of independent
energy storage elements in the system, and intuitively by the highest
order of the linear differential equation that describes the system. In
a transfer function representation, the order is the highest exponent in
the transfer function. In a **proper system**, the system order is
defined as the degree of the denominator polynomial. In a state-space
equation, the system order is the number of state-variables used in the
system. The order of a system will frequently be denoted with an *n* or
*N*, although these variables are also used for other purposes. This
book will make clear distinction on the use of these variables.

### Proper Systems

A **proper system** is a system where the degree of the denominator is
larger than or equal to the degree of the numerator polynomial. A
**strictly proper system** is a system where the degree of the
denominator polynomial is larger than (but never equal to) the degree of
the numerator polynomial. A **biproper system** is a system where the
degree of the denominator polynomial equals the degree of the numerator
polynomial.

It is important to note that only proper systems can be physically
realized. In other words, a system that is not proper cannot be built.
It makes no sense to spend a lot of time designing and analyzing
imaginary systems.

### Example: System Order

In the above example, G(s) is a second-order transfer function because
in the denominator one of the s variables has an exponent of 2.
Second-order functions are the easiest to work with.

## System Type

Let\'s say that we have a process transfer function (or combination of
functions, such as a controller feeding in to a process), all in the
forward branch of a unity feedback loop. Say that the overall forward
branch transfer function is in the following generalized form (known as
**pole-zero form**):

$$G(s) = \frac {K \prod_i (s - s_i)}{s^M \prod_j (s - s_j)}$$

we call the parameter *M* the **system type**. Note that increased
system type number correspond to larger numbers of poles at s = 0. More
poles at the origin generally have a beneficial effect on the system,
but they increase the order of the system, and make it increasingly
difficult to implement physically. System type will generally be denoted
with a letter like *N*, *M*, or *m*. Because these variables are
typically reused for other purposes, this book will make clear
distinction when they are employed.

Now, we will define a few terms that are commonly used when discussing
system type. These new terms are **Position Error**, **Velocity Error**,
and **Acceleration Error**. These names are throwbacks to physics terms
where acceleration is the derivative of velocity, and velocity is the
derivative of position. Note that none of these terms are meant to deal
with movement, however.

Position Error:The position error, denoted by the **position error constant** *$K_p$*. This is the amount of steady-state error of the system when stimulated by a unit step input. We define the position error constant as follows:

$$K_p = \lim_{s \to 0} G(s)$$

:   Where G(s) is the transfer function of our system.

```{=html}
<!-- -->
```

Velocity Error:The velocity error is the amount of steady-state error when the system is stimulated with a ramp input. We define the **velocity error constant** as such:

$$K_v = \lim_{s \to 0} s G(s)$$

Acceleration Error:The acceleration error is the amount of steady-state error when the system is stimulated with a parabolic input. We define the **acceleration error constant** to be:

$$K_a = \lim_{s \to 0} s^2 G(s)$$

Now, this table will show briefly the relationship between the system
type, the kind of input (step, ramp, parabolic), and the steady-state
error of the system:

:   {\| class=\"wikitable\"

! ! colspan=3 \| Unit System Input \|- ! Type, *M* !! *Au(t)* !! *Ar(t)*
!! *Ap(t)* \|- \|0 \|\| $e_{ss} = \frac{A}{1 + K_p}$ \|\|
$e_{ss} = \infty$ \|\| $e_{ss} = \infty$ \|- \|1 \|\| $e_{ss} = 0$ \|\|
$e_{ss} = \frac{A}{K_v}$ \|\| $e_{ss} = \infty$ \|- \|2 \|\|
$e_{ss} = 0$ \|\| $e_{ss} = 0$ \|\| $e_{ss} = \frac{A}{K_a}$ \|- \| \> 2
\|\| $e_{ss} = 0$ \|\| $e_{ss} = 0$ \|\| $e_{ss} = 0$ \|}

### Z-Domain Type

Likewise, we can show that the system order can be found from the
following generalized transfer function in the *Z* domain:

$$G(z) = \frac {K \prod_i (z - z_i)}{(z - 1)^M \prod_j (z - z_j)}$$

Where the constant *M* is the **type** of the digital system. Now, we
will show how to find the various error constants in the Z-Domain:


:   {\| class=\"wikitable\"

! Error Constant !! Equation \|- \| Kp \|\| $K_p = \lim_{z \to 1} G(z)$
\|- \| Kv \|\| $K_v = \lim_{z \to 1} (z - 1) G(z)$ \|- \| Ka \|\|
$K_a = \lim_{z \to 1} (z - 1)^2 G(z)$ \|}

## Visually

Here is an image of the various system metrics, acting on a system in
response to a step input:

![](System_Metrics_Diagram.svg "System_Metrics_Diagram.svg"){width="500"}

The target value is the value of the input step response. The rise time
is the time at which the waveform first reaches the target value. The
overshoot is the amount by which the waveform exceeds the target value.
The settling time is the time it takes for the system to settle into a
particular bounded region. This bounded region is denoted with two short
dotted lines above and below the target value.

