Evolution of Components

readtime(comp::AbstractComponent)

Returns current time of comp read from its trigger link.

readstate(comp::AbstractComponent)

Returns the state of comp if comp is AbstractDynamicSystem. Otherwise, returns nothing.

readinput(comp::AbstractComponent)

Returns the input value of comp if the input of comp is Bus. Otherwise, returns nothing.

writeoutput(comp::AbstractComponent, out)

Writes out to the output of comp if the output of comp is Bus. Otherwise, does nothing.

computeoutput(comp, x, u, t)

Computes the output of comp according to its outputfunc if outputfunc is not nothing. Otherwise, nothing is done. x is the state, u is the value of input, t is the time.

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.

takestep(comp::AbstractComponent)

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::AbstractSubSystem)

Makes comp to take a step by making each subcomponent of comp take a step. See also: takestep(comp::AbstractComponent)

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.

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.

launch(comp::AbstractComponent)

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)

launch(comp::AbstractSubSystem)

Launches all subcomponents of comp. See also: launch(comp::AbstractComponent)

drive(comp::AbstractComponent, t)

Writes t to the trigger link of comp. When driven, comp takes a step. See also: takestep(comp::AbstractComponent)

drive(comp::AbstractSubSystem, t)

Drives comp by driving each subcomponent of comp. See also: drive(comp::AbstractComponent, t)

approve(comp::AbstractComponent)

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::AbstractSubSystem)

Approves comp by approving each subcomponent of comp. See also: approve(comp::AbstractComponent)

release(comp::AbstractComponent)

Releases the input and output bus of comp.

release(comp::AbstractSubSystem)

Releases comp by releasing each subcomponent of comp. See also: release(comp::AbstractComponent)

terminate(model::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. See also: ComponentTask, TaskManager.

terminate(comp::AbstractComponent)

Closes the trigger link and output bus of comp.

terminate(comp::AbstractSubSystem)

Terminates comp by terminating each subcomponent of comp. See also: terminate(comp::AbstractComponent)