# Evolution of Components

In Causal, the simulation of a model is performed by individual evolution of components (see Modeling and Simulation for more information of modeling and simulation adopted in Causal). Basically, when triggered through its `trigger`

pin, based on its type, a component takes a forward step as follows,

- The next clock time
`t`

is read from its`trigger`

pin. - The next input value
`u(t)`

is read from from its`input`

port, - The component evolves from its current time
`t - dt`

to the current clock time`t`

- Using the state variable
`x(t)`

at time`t`

, current clock time`t`

and`u(t)`

, the next output value`y(t)`

is computed. - The component writes
`true`

to its`handshake`

pin to signal that taking step is performed with success.

or a backward step as follows.

- The next clock time
`t`

is read from its`trigger`

pin. - Using the state variable
`x(t - dt)`

at time`t - dt`

, current component time`t - dt`

and`u(t - dt)`

, the next output value`y(t)`

is computed. - The next input value
`u(t)`

is read from from its`input`

port, - The component evolves from its current time
`t - dt`

to the current clock time`t`

- The component writes
`true`

to its`handshake`

pin to signal that taking step is performed with success.

Here `dt`

is the simulation step size.

## Reading Time

`Causal.readtime!`

— Function```
readtime!(comp)
```

Returns current time of `comp`

read from its `trigger`

link.

To read time of `comp`

, `comp`

must be launched. See also: `launch(comp::AbstractComponent)`

.

## Reading State

`Causal.readstate`

— Function```
readstate(comp)
```

Returns the state of `comp`

if `comp`

is `AbstractDynamicSystem`

. Otherwise, returns `nothing`

.

## Reading Input

`Causal.readinput!`

— Function```
readinput!(comp)
```

Returns the input value of `comp`

if the `input`

of `comp`

is `Inport`

. Otherwise, returns `nothing`

.

To read input value of `comp`

, `comp`

must be launched. See also: `launch(comp::AbstractComponent)`

## Writing Output

`Causal.writeoutput!`

— Function```
writeoutput!(comp, out)
```

Writes `out`

to the output of `comp`

if the `output`

of `comp`

is `Outport`

. Otherwise, does `nothing`

.

## Computing Output

`Causal.computeoutput`

— FunctionComputes the output of `comp`

according to its `readout`

if `readout`

is not `nothing`

. Otherwise, `nothing`

is done. `x`

is the state, `u`

is the value of input, `t`

is the time.

## Evolve

`Causal.evolve!`

— Function`evolve!(comp::AbstractSource, u, t)`

Does nothing. `u`

is the value of `input`

and `t`

is time.

`evolve!(comp::AbstractSink, u, t)`

Writes `t`

to time buffer `timebuf`

and `u`

to `databuf`

of `comp`

. `u`

is the value of `input`

and `t`

is time.

`evolve!(comp::AbstractStaticSystem, u, t)`

Writes `u`

to `buffer`

of `comp`

if `comp`

is an `AbstractMemory`

. Otherwise, `nothing`

is done. `u`

is the value of `input`

and `t`

is time.

`evolve!(comp::AbstractDynamicSystem, u, t)`

Solves the differential equation of the system of `comp`

for the time interval `(comp.t, t)`

for the inital condition `x`

where `x`

is the current state of `comp`

. `u`

is the input function defined for `(comp.t, t)`

. The `comp`

is updated with the computed state and time `t`

.

## Taking Steps

`Causal.takestep!`

— Function```
takestep!(comp)
```

Reads the time `t`

from the `trigger`

link of `comp`

. If `comp`

is an `AbstractMemory`

, a backward step is taken. Otherwise, a forward step is taken. See also: `forwardstep`

, `backwardstep`

.

```
takestep!(comp)
```

Makes `comp`

to take a step by making each subcomponent of `comp`

take a step. See also: `takestep!(comp::AbstractComponent)`

`Causal.forwardstep`

— Function```
forwardstep(comp, t)
```

Makes `comp`

takes a forward step. The input value `u`

and state `x`

of `comp`

are read. Using `x`

, `u`

and time `t`

, `comp`

is evolved. The output `y`

of `comp`

is computed and written into the output bus of `comp`

.

`Causal.backwardstep`

— Function```
backwardstep(comp, t)
```

Reads the state `x`

. Using the time `t`

and `x`

, computes and writes the ouput value `y`

of `comp`

. Then, the input value `u`

is read and `comp`

is evolved.

`Causal.launch`

— Method```
launch(comp)
```

Returns a tuple of tasks so that `trigger`

link and `output`

bus of `comp`

is drivable. When launched, `comp`

is ready to be driven from its `trigger`

link. See also: `drive!(comp::AbstractComponent, t)`

`Causal.launch`

— Method```
launch(comp)
```

Launches all subcomponents of `comp`

. See also: `launch(comp::AbstractComponent)`

`Causal.drive!`

— Function```
drive!(comp, t)
```

Writes `t`

to the `trigger`

link of `comp`

. When driven, `comp`

takes a step. See also: `takestep!(comp::AbstractComponent)`

```
drive!(comp, t)
```

Drives `comp`

by driving each subcomponent of `comp`

. See also: `drive!(comp::AbstractComponent, t)`

`Causal.approve!`

— Function```
approve!(comp)
```

Read `handshake`

link of `comp`

. When not approved or `false`

is read from the `handshake`

link, the task launched for the `trigger`

link of `comp`

gets stuck during `comp`

is taking step.

```
approve!(comp)
```

Approves `comp`

by approving each subcomponent of `comp`

. See also: `approve!(comp::AbstractComponent)`

`Causal.terminate!`

— Function```
terminate!(comp)
```

Closes the `trigger`

link and `output`

bus of `comp`

.

```
terminate!(comp)
```

Terminates `comp`

by terminating each subcomponent of `comp`

. See also: `terminate!(comp::AbstractComponent)`

```
terminate!(model)
```

Terminates `model`

by terminating all the components of the `model`

, i.e., the components tasks in the task manager of the `model`

is terminated.