Engee Function

Information cell (non-editable) - automatically displays variables of the block Engee Function, attributes of input and output signals type (dimension, type, discreteness) and other parameters set by the user. Its content is updated dynamically depending on the block settings. The cell is always active, but is not selectable in the methods control menu . It has semi-transparent text, which is used to display tooltips.

Define component struct - adds the cell Component struct code, in which the structure of the block component Engee Function (inherited from type AbstractCausalComponent) is defined. The structure fields are defined between the uneditable lines struct Block <: AbstractCausalComponent and end. By default, a parameter g is created and initialised with the block value gain, and the Block() constructor takes no arguments.

Use common code - adds the cell Common code, in which the code is written in free form. By default the cell is empty. For example, if the standard structure declaration in Component struct code is not suitable (due to the uneditable struct Block <: AbstractCausalComponent), you can disable Define component struct to remove the cell, and define the component structure manually in Common code. The same goes for any functions from the method management menu of - you can write your own code in place of the standard cells in Common code.

Define step method - adds the cell Step method code, which defines the Step method that calculates the output signals of the block Engee Function. The method signature is generated automatically depending on the values of the corresponding labels (Label) of ports in the Ports tab. The method is represented as a functor (see here for details) and is called at each simulation step. The fields are defined between the uneditable lines function (c::Block)(t::Real, in1) and end. The first argument of t::Real is the simulation time, then the input variables are passed in. The calculated values of the outputs are returned via the return keyword.

Define update method - adds the Update method code cell, where the update! method updates the internal state of the block Engee Function at each simulation step. The first argument c::Block is the block structure, the second t::Real is the simulation time, then the input signals are passed. If the block has no internal state, the method can remain empty and just return c.

Define terminate method code - adds a Terminate method code cell that is executed when the simulation of the block Engee Function is terminated (using the terminate! method). The first argument of c::Block is the structure of the block. By default, the method does not perform any additional actions and simply returns c.

Override type inheritance method - adds Types inheritance method cell that overrides the type inheritance method.

function propagate_types(inputs_types::Vector{DataType})::Vector{DataType}
# Функция, возвращающая массив типов сигналов на выходе.
# Игнорируется, если используется алгоритм по умолчанию.
# В данном случае учитываются тип входного сигнала и тип
# параметра блока `gain`.
    input_type = first(inputs_types)
    # promote_type возвращает тип, к которому приводятся типы-аргументы
    # при арифметических операциях с объектами этих типов.
    output_type = promote_type(input_type, eltype(gain))
    return [output_type]
end

Override dimensions inheritance method - adds the Dimensions inheritance method cell, which overrides the method of dimensions inheritance.

function propagate_dimensions(inputs_dimensions::Vector{<:Dimensions})::Vector{<:Dimensions}
# Функция, возвращающая массив размерностей сигналов на выходе.
# Игнорируется, если используется алгоритм по умолчанию.
# В данном случае учитываются размерности входного сигнала и
# параметра блока `gain`.
    input_dimensions = first(inputs_dimensions)
    mock_input = zeros(input_dimensions)
    mock_output = mock_input .* gain
    return [size(mock_output)]
end

Use common method for types and dimensions inheritance - adds the Common types and dimensions inheritance method cell, which uses a common method to override inheritance of types and dimensions at the same time.

function propagate_types_and_dimensions(inputs_types::Vector{DataType}, inputs_dimensions::Vector{<:Dimensions})::Tuple{Vector{DataType}, Vector{<:Dimensions}}
# Функция, возвращающая массив типов сигналов и массив
# размерностей сигналов на выходе. Эту функцию можно использовать
# если необходимо одновременно переопределить и алгоритм наследования
# типов сигналов, и алгоритм наследования размерностей.
    outputs_types = propagate_types(inputs_types)
    outputs_dimensions = propagate_dimensions(inputs_dimensions)
    return outputs_types, outputs_dimensions
end

Override sample time inheritance method - adds a Sample times inheritance method cell that overrides the calculation step inheritance method.

function propagate_sample_times(inputs_sample_times::Vector{SampleTime}, fixed_solver::Bool)::SampleTime
# Функция, возвращающая время дискретизации блока.
# Используется только в режиме наследования `Custom`.
# Параметр fixed_solver говорит о том, используется решатель
# с постоянным шагом (true) или с переменным (false).
# Более сложный пример работы с наследованием времени
# дискретизации блока можно посмотреть в документации.
    return first(inputs_sample_times)
end

const SampleTime = NamedTuple{(:period, :offset, :mode), Tuple{Rational{Int64}, Rational{Int64}, Symbol}}

Override direct feedthrough setting method - adds a Direct feedthrough setting method cell that defines a direct feedthrough connection.

function direct_feedthroughs()::Vector{Bool}
# Функция, возвращающая массив булевых значений, определяющих,
# сквозные соединения. Если i-ый элемент массива равен true,
# то i-ый порт имеет сквозное соединение.
# Игнорируется, если используется алгоритм по умолчанию.
    return [true]
end

function direct_feedthroughs()::Vector{Bool}
    if gain == 2
        return [false]
    else
        return [true]
    end
end

BLOCK_NAME - the name of the block. Each block added to the Engee canvas has a name that can be referenced via this constant. For example, you can refer to BLOCK_NAME during the initialisation of an error to print the name of the block in it.

START_TIME - the start of the simulation from the model settings.

STOP_TIME - the end of the simulation from the model settings.

INPUT_SIGNAL_ATTRIBUTES - lists from attributes for each input port. For example, to find out the attributes of the first input signal - use INPUT_SIGNAL_ATTRIBUTES[1], where 1 is the first input port of the block Engee Function.

OUTPUT_SIGNAL_ATTRIBUTES - lists from attributes for each output port. For example, to find out the attributes of the first output - use OUTPUT_SIGNAL_ATTRIBUTES[1], where 1 is the first output port of the block Engee Function.

dimensions - the dimensionality of the signal. It can be abbreviated to dims.

type - the type of the signal. Can be abbreviated to tp.

sample_time - calculation step. It represents a structure similar to the attributes of signals, which can be accessed through the point .. Two access functions are available:

direct_feedthrough - indicates whether the loop port opens. Used for input ports only (checks attributes for the input port only). Can be abbreviated to df.

FixedPoint - abstract type of all fixed numbers;

Fixed - concrete type of fixed number, created manually with bit representation;

fi(…​) - creation of a value of type Fixed using a numeric value and parameters of the representation;

fixdt(…​) - creation of Fixed type with specifying sign, width and number of fractional bits.

Pass as parameters;

Use them in a component structure (Component struct code cell);

Perform arithmetic with them via emul, esum, ediv in the Step method code cell (for more details see section Conversion functions and typed arithmetic operations: econvert, esum, emul, ediv.);

Apply to calculations in propagate_types(…​), propagate_dimensions(…​).

BusSignal{...} - bus type with names, types and dimensions;

get_bus_names(type) - get list of signal names;

get_bus_types(type) - get signal types;

get_bus_dimensions(type) - get signal dimensions;

get_names_types_dims(type) - get all at once;

get_bus_signal_type(::NamedTuple) - define BusSignal type by value.

In the block parameters - fixed point values can be set via fi(…​) and bus structures can be passed as NamedTuple. The bus type can be defined automatically via get_bus_signal_type(…​).

In the Common code cell - you can define data types (Fixed, BusSignal{…​}), component structures (struct Block), create auxiliary functions or initialise values. You can also move basic logic here if Step method code or Component struct code is disabled.

In the Component struct code cell - values of Fixed type can be used when describing fields of the structure, as well as BusSignal types if the fields represent composite signals.

In the Step method code cell - the basic logic of the block is implemented. Here fixed numbers and bus signals can participate in calculations, comparisons and structure processing.

In the Types inheritance method cell - you can use Fixed and BusSignal types to analyse the inputs and set the output type of the component.

In the Dimensions inheritance method cell - you can use Fixed data and values from buses to define the output dimensions.

In the Update method code cell - if the block has an internal state, fields like Fixed or BusSignal can be used to store or change that state at each simulation step.

In the Terminate method code cell - usage of these types to record the final state is allowed if the structure contains the appropriate fields.

In the Common types and dimensions inheritance method cell - if both types and dimensions are to be handled simultaneously, Fixed and BusSignal can also participate in the calculation logic.

Real: Float16, Float32, Float64.

Integer: Int8, Int16, Int32, Int64, Int128, UInt8, UInt16, UInt32, UInt64, UInt128.

Logical: Bool

Fixed: Fixed (created via fi(…​) or fixdt(…​))

Complex: Complex{T}, where T is any of the above types

type is the type into which the value is to be converted. If var is a complex number, the base real type is specified. For example, econvert(Float32, Complex{Int16}(1 + 2im)) will return Complex{Float32};

var - the value to convert;

rounding_mode - rounding method (RoundDown, RoundUp, RoundNearest, RoundNearestTiesAway, RoundToZero);

overflow - if true, wrap behaviour is used; if false, saturation is enabled - the value is limited by the type range.

x1, x2 - arguments of the operation (can be scalars or arrays);

out_type - the type in which the result is produced and returned;

overflow - enable overflow (true) or saturation (false);

rm - rounding method (see the list above).

Determines the output type when adding n values of the same type T:

sum_promote_type(::Type{T}, n::Integer=1, hdlsetup::Bool=false)

Determines the output type when adding two different types T1 and T2 by n values:

sum_promote_type(::Type{T1}, ::Type{T2}, n::Integer=1, hdlsetup::Bool=false)

Defines the output type when adding an arbitrary number of arguments with different types:

sum_promote_type_from_inputs(types::Type...; hdlsetup::Bool=false)

Determines the accumulator type when adding n values of the same type T:

sum_accumulator_promote_type(::Type{T}, n::Integer=1, hdlsetup::Bool=false)

Determines the type of accumulator when adding two different types T1 and T2 by n values:

sum_accumulator_promote_type(::Type{T1}, ::Type{T2}, n::Integer=1, hdlsetup::Bool=false)

Determines the accumulator type when adding an arbitrary number of arguments with different types:

sum_accumulator_promote_type_from_inputs(types::Type...; hdlsetup::Bool=false)

Determines the output type when multiplying values of the same type T:

mul_promote_type(::Type{T}, hdlsetup::Bool=false)

Defines the output type when multiplying two different types T1 and T2:

mul_promote_type(::Type{T1}, ::Type{T2}, hdlsetup::Bool=false)

Determines the output type when dividing a single value of type T:

div_promote_type(::Type{T}, hdlsetup::Bool=false)

Determines the output type when dividing a value of type T1 by a value of type T2:

div_promote_type(::Type{T1}, ::Type{T2}, hdlsetup::Bool=false)

Transforming input data into a vector with overriding output parameters;

Usage of caching and strictly typed structures to improve performance;

Implementing Direct feedthrough-free blocks to break algebraic loops;

Custom output sampling period.

*Ports: %<Inputs>, %<Outputs> - number of input and output ports; %<InputPort1Type>, %<OutputPort1Type>, %<InputPort1Size>, %<OutputPort1Size> - data type and dimensionality of signals.

*Temporal characteristics: %<SampleTime> - discretisation; %<SampleTimeInheritanceMethod> - discretisation inheritance method.

*Code blocks: %<ComponentStructCode>, %<StepMethodCode> - step structure and method code.

Parameters: %<Parameters>, %<Parameter1Name>, %<Parameter1Value> - names and values of parameters.

Inclusion flags: %<DefineComponentStruct>, %<UseCommonCode>, %<DefineStepMethod>, %<DefineUpdateMethod>, %<DefineTerminateMethod> - inclusion of corresponding code sections.

*Reference methods: %<OverrideTypesInhMethod>, %<OverrideDimsInhMethod>, %<OverrideSampleTimeInhMethod> - type inheritance settings.

Other: %<UseExternalCache> - usage of external cache.