By using `when`

, we can express conditions we are interested in
reacting to and what we wish to do in response to them. In this
section, we’ll review the key ideas behind `when`

statements. A
`when`

statement has the following general form:

```
when expr then
// Statements
end when;
```

`if`

vs. `when`

¶In our discussion on Hysteresis, we briefly discussed the
difference between an `if`

statement and a `when`

statement. The
statements in a `when`

statement become active only for an instant
when the triggering conditional expression becomes true. At all other
times, the `when`

statement has no effect. An `if`

statement or
`if`

expression remains active as long as the conditional expression
is true. If the `if`

statement or `if`

expression includes an
`else`

clause then some branch will always be active.

Most of the time, the expression `expr`

is going to be a conditional
expression and usually it will involve relational operators. Typical
examples of expressions frequently used with a `when`

statement
would be `time>=2.0`

, `x>=y+2`

, `phi<=prev_phi`

and so on.
Recall from our discussion of the Interval Measurement speed
estimation algorithm that you should **almost always** put the `pre`

operator around any variables in `expr`

that also appear inside the
`when`

statement.

In the Bouncing Ball example, we saw a case where `expr`

was
not a (scalar) conditional expression, but rather a vector of
conditional expressions. Recall from that discussion that the
`when`

statement becomes active if **any** of the conditions in the
vector of expressions becomes true.

A `when`

statement is used to define new values for some variables.
These new values can be assigned in one of two ways. The first is by
introducing an equation of the form:

```
var = expr;
```

In this case, the variable `var`

will be given the value of
`expr`

. Within `expr`

, the `pre`

operator should be used when
referring to the pre-event value for a variable. Any variable
assigned in this way is a discrete variable. This means that its
value only changes during events. In other words, it will be a
piecewise constant function. Note, a variable assigned in this way
cannot be continuous over any interval in the simulation.

If you want to explicitly mark a variable as discrete, you can prefix
it with the `discrete`

qualifier (as we saw in the
Sample and Hold example earlier in this chapter) although this
is not strictly necessary. By adding the `discrete`

qualifier you
ensure that the variable’s value must be determined within a `when`

statement.

The other way a variable can be given a value within a `when`

statement, as demonstrated in the Bouncing Ball example, is by
using the `reinit`

operator. In that case, the statement within the
`when`

statement will take the form:

```
reinit(var, expr);
```

When using the `reinit`

operator, the variable, `var`

, **must be a
state**. In other words, its solution must arise from solving a
differential equation. The use of `reinit`

on such a variable has
the effect of stopping the integration process, changing the value of
the state (and any other states that have the `reinit`

operator
applied to them within the same `when`

statement) and then resuming
integration using what are effectively a new set of initial
conditions. The values of all other states not re-initialized with the
`reinit`

operator remain unchanged.

`algorithm`

Sections¶One final note about `when`

statements is how they interact with the
“single assignment” rule in Modelica. This rule, from the
specification, states that there must be exactly one equation used to
determine the value of each variable. As we saw in the sections on
Speed Measurement and Hysteresis, it is sometimes
necessary (or at least clearer) to express behavior in terms of multiple
assignments. In those cases, if all the assignments are included
within a single `algorithm`

section, they are effectively combined
into a single equation. However, doing so will limit the compiler’s
ability to perform symbolic manipulation and, therefore, may impact
simulation performance and/or reusability of the models.

It is also worth noting that if the semantics of an `algorithm`

section are needed during initialization, Modelica includes an
`initial algorithm`

section that is analogous to the ```
initial
equation
```

section discussed in the previous discussion on
Initialization. The `initial algorithm`

section will be
applied only during the initialization phase to determine initial
conditions, just like an `initial equation`

section, but the
`initial algorithm`

section will allow multiple assignments to the
same variable. The same caveats apply with respect to symbolic
manipulation.