`G1` and `G4` must here be represented by [`StateSpace`](http://juliacontrol.github.io/ControlSystems.jl/latest/lib/constructors/#ControlSystems.ss) types from [`ControlSystems.jl`](https://github.com/JuliaControl/ControlSystems.jl).

`TransferFunction` types can easily be converted to a `StateSpace` by `Gss = ss(Gtf)`.

Continuous time systems can be discretized using `Gd = c2d(Gc, h)`. (The sample time of a process is available through `h = sampletime(P)`.)

Continuous time systems can be discretized using `Gd = c2d(Gc, h)[1]`. (The sample time of a process is available through `h = sampletime(P)`.)

# How to implement a Simulated Process

## Linear process

This is very easy, just get a discrete time `StateSpace` model of your process

(if you have a transfer function, `Gss = ss(Gtf)` will do the trick, if you have continuous time, `Gd = c2d(Gc,h)[1]` is your friend).

You now have to implement the methods `control` and `measure` for your simulated type.

The implementation for `BeamSimulator` is shown below

```julia

function control(p::BeamSimulator,u)

sysfilter!(p.state,p.sys,u)

end

measure(P)=vecdot(p.sys.C,p.state)

```

The `control` method accepts a control signal (`u`) and propagates the system state

(`p.state`) forward using the statespace model (`p.sys`) of the beam. The function

[`sysfilter!`](@ref) is familiar from the "Control" section above. What it does

is essentially

```julia

function sysfilter!(state,sys,input)

state.=sys.A*state+sys.B*input

output=sys.C*state+sys.D*input

end

```

hence, it just performs one iteration of

```math

x' = Ax + Bu

y = Cx + Du

```

The `measure` method performs the computation `y = Cx`, the reason for the call

to `vecdot` is that `vecdot` produces a scalar output, whereas `C*x` produces a

1-element `Matrix`. A scalar output is preferred in this case since the `Beam`

is SISO.

It should now be obvious which fields are required in the `BeamSimulator` type.

It must know which sample time it has been discretized with, as well as its

discrete-time system model. It must also remember the current state of the system.

This is not needed in a physical process since it kind of remembers its own state.

The full type specification for `BeamSimulator` is given below

```julia

struct BeamSimulator<:SimulatedProcess

h::Float64

state::Vector{Float64}# states defined by the file define_beam_system