# Breaking Algebraic Loops

It this tutorial, we will simulate model consisting a closed loop feedback system. The model has an algebraic loop.

## Algebraic Loops

An algebraic loop is a closed-loop consisting of one or more components whose outputs are directly dependent on their inputs. If algebraic loops exist in a model, the simulation gets stuck because none of the components in the loop can generate output to break the loop. Such a problem can be broken by rearranging the model without algebraic loops, solving the feed-forward algebraic equation of the loop, or inserting a memory component with a certain initial condition anywhere in the loop. Causal provides all these loop-breaking solutions. During the inspection stage, in case they are detected, all the loops are broken. Otherwise, a report is printed to notify the user to insert memory components to break the loops.

## Breaking Algebraic Loops Automatically

Before initializing and running the simulation, Causal inspects the model first. See Simulation Stages for more information of simulation stages. In case the they exist in the model, all the algebraic loops are tried to be broken automatically without requiring a user intervention. Consider the following model

where

\[\begin{array}{l} r(t) = t \\[0.25cm] u(t) = r(t) - y(t) \\[0.25cm] y(t) = u(t) \end{array}\]

Note that there exist an algebraic loop consisting of `adder`

and `gain`

. Solving this algebraic loop, we have

\[ y(t) = u(t) = r(t) - y(t) \quad \Rightarrow \quad y(t) = \dfrac{r(t)}{2} = \dfrac{t}{2}\]

The following script constructs and simulates the model.

```
using Causal
# Describe the model
@defmodel model begin
@nodes begin
gen = RampGenerator()
adder = Adder(signs=(+,-))
gain = Gain()
writerout = Writer()
writerin = Writer()
end
@branches begin
gen[1] => adder[1]
adder[1] => gain[1]
gain[1] => adder[2]
gen[1] => writerin[1]
gain[1] => writerout[1]
end
end
# Simulate the model
ti, dt, tf = 0., 1. / 64., 1.
sim = simulate!(model, ti, dt, tf, withbar=false)
# Read the simulation data and plot
using Plots
t, y = read(getnode(model, :writerout).component)
t, r = read(getnode(model, :writerin).component)
plot(t, r, label="r(t)", marker=(:circle, 3))
plot!(t, y, label="y(t)", marker=(:circle, 3))
```

[ Info: 2021-05-10T17:05:09.062 Started simulation... [ Info: 2021-05-10T17:05:09.100 Inspecting model... ┌ Info: The model has algrebraic loops:[[2, 3]] └ Trying to break these loops... [ Info: Loop [2, 3] is broken [ Info: 2021-05-10T17:05:10.153 Done. [ Info: 2021-05-10T17:05:10.153 Initializing the model... [ Info: 2021-05-10T17:05:11.009 Done... [ Info: 2021-05-10T17:05:17.133 Running the simulation... [ Info: 2021-05-10T17:05:22.960 Done... [ Info: 2021-05-10T17:05:22.960 Terminating the simulation... [ Info: 2021-05-10T17:05:23.298 Done. QStandardPaths: XDG_RUNTIME_DIR not set, defaulting to '/tmp/runtime-juliateam' QPainter::begin: Paint device returned engine == 0, type: 3 QPainter::setCompositionMode: Painter not active QWidget::paintEngine: Should no longer be called QPainter::begin: Paint device returned engine == 0, type: 1

## Breaking Algebraic Loops With a Memory

It is also possible to break algebraic loops by inserting a `Memory`

component at some point the loop. For example, consider the model consider following the model which is the model in which a memory component is inserted in the feedback path.

Note that the input to `adder`

is not $y(t)$, but instead is $\hat{y}(t)$ which is one sample delayed form of $y(t)$. That is, we have, $\hat{y}(t) = y(t - dt)$ where $dt$ is the step size of the simulation. If $dt$ is small enough, $\hat{y}(t) \approx y(t)$.

The script given below simulates this case.

```
using Causal
# Simulation time settings.
ti, dt, tf = 0., 1. / 64., 1.
# Describe the model
@defmodel model begin
@nodes begin
gen = RampGenerator()
adder = Adder(signs=(+,-))
gain = Gain()
writerout = Writer()
writerin = Writer()
mem = Memory(delay=dt, initial=zeros(1))
end
@branches begin
gen[1] => adder[1]
adder[1] => gain[1]
gain[1] => mem[1]
mem[1] => adder[2]
gen[1] => writerin[1]
gain[1] => writerout[1]
end
end
# Simulate the model
sim = simulate!(model, ti, dt, tf, withbar=false)
# Plot the simulation data
using Plots
t, r = read(getnode(model, :writerin).component)
t, y = read(getnode(model, :writerout).component)
plot(t, r, label="r(t)", marker=(:circle, 3))
plot!(t, y, label="y(t)", marker=(:circle, 3))
```

[ Info: 2021-05-10T17:06:23.721 Started simulation... [ Info: 2021-05-10T17:06:23.721 Inspecting model... ┌ Info: The model has algrebraic loops:[[2, 3, 6]] └ Trying to break these loops... [ Info: Loop [2, 3, 6] has a Memory component. The loops is broken [ Info: 2021-05-10T17:06:23.736 Done. [ Info: 2021-05-10T17:06:23.736 Initializing the model... [ Info: 2021-05-10T17:06:23.800 Done... [ Info: 2021-05-10T17:06:24.081 Running the simulation... [ Info: 2021-05-10T17:06:24.093 Done... [ Info: 2021-05-10T17:06:24.093 Terminating the simulation... [ Info: 2021-05-10T17:06:24.097 Done. QStandardPaths: XDG_RUNTIME_DIR not set, defaulting to '/tmp/runtime-juliateam'

The fluctuation in $y(t)$ because of one-sample-time delay introduced by the `mem`

component is apparent. The smaller the step size is, the smaller the amplitude of the fluctuation introduced by the `mem`

component.

One other important issue with using the memory component is that the initial value of `mem`

directly affects the accuracy of the simulation. By solving the loop equation, we know that

\[ y(t) = \dfrac{r(t)}{2} = \dfrac{t}{2} \quad \Rightarrow \quad y(0) = 0\]

That is the memory should be initialized with an initial value of zero, which is the case in the script above. To observe that how incorrect initialization of a memory to break an algebraic loop, consider the following example in which memory is initialized randomly.

```
using Causal
using Plots
# Simulation time settings.
ti, dt, tf = 0., 1. / 64., 1.
# Describe the model
@defmodel model begin
@nodes begin
gen = RampGenerator()
adder = Adder(signs=(+,-))
gain = Gain()
writerout = Writer()
writerin = Writer()
mem = Memory(delay=dt, initial=rand(1))
end
@branches begin
gen[1] => adder[1]
adder[1] => gain[1]
gain[1] => mem[1]
mem[1] => adder[2]
gen[1] => writerin[1]
gain[1] => writerout[1]
end
end
# Simulate the model
sim = simulate!(model, ti, dt, tf, withbar=false)
# Plot the results
using Plots
t, r = read(getnode(model, :writerin).component)
t, y = read(getnode(model, :writerout).component)
plot(t, r, label="r(t)", marker=(:circle, 3))
plot!(t, y, label="y(t)", marker=(:circle, 3))
```

[ Info: 2021-05-10T17:06:24.506 Started simulation... [ Info: 2021-05-10T17:06:24.506 Inspecting model... ┌ Info: The model has algrebraic loops:[[2, 3, 6]] └ Trying to break these loops... [ Info: Loop [2, 3, 6] has a Memory component. The loops is broken [ Info: 2021-05-10T17:06:24.506 Done. [ Info: 2021-05-10T17:06:24.506 Initializing the model... [ Info: 2021-05-10T17:06:24.513 Done... [ Info: 2021-05-10T17:06:24.513 Running the simulation... [ Info: 2021-05-10T17:06:24.526 Done... [ Info: 2021-05-10T17:06:24.526 Terminating the simulation... [ Info: 2021-05-10T17:06:24.529 Done. QStandardPaths: XDG_RUNTIME_DIR not set, defaulting to '/tmp/runtime-juliateam'