Engee Function

Information cell (non—editable) - automatically displays block variables Engee Function, attributes of input and output signals (dimension, type, discreteness) and other user-defined parameters. Its content is updated dynamically depending on the block settings. The cell is always active, but it is not selected in the method management menu. . It has a semi-transparent text that displays hints.

Define component structure — adds a cell Component struct code, which defines the structure of the block component Engee Function (inherited from the type AbstractCausalComponent). The fields of the structure are defined between non-editable lines struct Block <: AbstractCausalComponent and end. By default, the parameter is created g, initialized by the block value gain, and the constructor Block() it does not accept arguments.

Use common code — adds a 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 not suitable (due to non-editability struct Block <: AbstractCausalComponent), then you can disable Define component structure to delete the cell, and define the component structure manually in Common code. The same applies to any functions from the method management menu. — instead of standard cells, you can write your own code in Common code.

Define step method — adds a 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 port labels in the Ports tab. The method is represented as a functor (for more information, see here) and is called at each step of the simulation. Fields are defined between non-editable lines function (c::Block)(t::Real, in1) and end. The first argument t::Real — simulation time, then input signal variables are transmitted. Calculated output values are returned via a keyword return.

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

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

Override type inheritance method — adds the Types inheritance method cell, which overrides the type inheritance method.

function propagate_types(inputs_types::Vector{DataType})::Vector{DataType}
# A function that returns an array of output signal types.
# It is ignored if the default algorithm is used.
# In this case, the type of input signal and the type of
# the parameter of the 'gain` block.
    input_type = first(inputs_types)
    # promote_type returns the type to which the argument types are given.
    # during arithmetic operations with objects of these types.
    output_type = promote_type(input_type, eltype(gain))
    return [output_type]
end

Override dimensions inheritance method — adds a cell Dimensions inheritance method, which redefines the method of inheritance of dimensions.

function propagate_dimensions(inputs_dimensions::Vector{<:Dimensions})::Vector{<:Dimensions}
# A function that returns an array of output signal dimensions.
# It is ignored if the default algorithm is used.
# In this case, the dimensions of the input signal are taken into account and
# the parameter of the 'gain` block.
    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 redefine inheritance of types and dimensions simultaneously.

function propagate_types_and_dimensions(inputs_types::Vector{DataType}, inputs_dimensions::Vector{<:Dimensions})::Tuple{Vector{DataType}, Vector{<:Dimensions}}
# A function that returns an array of signal types and an array
# the dimensions of the output signals. This function can be used
# if necessary, redefine the inheritance algorithm at the same time.
# types of signals, and an algorithm for inheritance of 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 cell Sample times inheritance method, which redefines the inheritance method of the calculation step.

function propagate_sample_times(inputs_sample_times::Vector{SampleTime}, fixed_solver::Bool)::SampleTime
# A function that returns the sampling time of a block.
# It is used only in the `Custom` inheritance mode.
# The fixed_solver parameter indicates whether the solver is being used.
# with a constant step (true) or with a variable step (false).
# A more complex example of working with time inheritance
# The block sampling can be viewed in the documentation.
    return first(inputs_sample_times)
end

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

Override direct feeding setting method — adds a cell Direct feeding setting method that defines a direct end-to-end connection.

function direct_feedthroughs()::Vector{Bool}
# A function that returns an array of Boolean values defining,
# end-to-end connections. If the ith element of the array is true,
# the ith port has an end-to-end connection.
# It is ignored if the default algorithm is used.
    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 accessed through this constant. For example, you can refer to BLOCK_NAME during error initialization to output the block name in it.

START_TIME — start the simulation from the model settings.

STOP_TIME — end of the simulation from the model settings.

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

OUTPUT_SIGNAL_ATTRIBUTES — lists of attributes for each output port. For example, to find out the attributes of the first output signal, use OUTPUT_SIGNAL_ATTRIBUTES[1], where 1 — the first output port of the unit Engee Function.

dimensions — the dimension of the signal. Can be shortened to dims.

type — the type of signal. Can be shortened to tp.

sample_time — the calculation step. It is a structure similar to the attributes of signals, which can be accessed through a dot. .. Two conversion functions are available:

direct_feedthrough — indicates whether the loop port opens. It is used only for input ports (checks attributes only for the input port). Can be shortened to df.

FixedPoint — the abstract type of all fixed numbers;

Fixed — a specific type of fixed number, created manually with the bit representation specified;

fi(…​) — creating a type value Fixed using a numeric value and representation parameters;

fixdt(…​) — creation of the Fixed type with indication of the sign, width and number of fractional bits.

Send as parameters;

Use in the component structure (cell Component struct code);

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

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

BusSignal{…​} — type of bus with names, types and dimensions;

get_bus_names(type) — get a list of signal names;

get_bus_types(type) — get the types of signals;

get_bus_dimensions(type) — get the dimensions of the signals;

get_names_types_dims(type) — get everything at once;

get_bus_signal_type(::NamedTuple) — identify the type BusSignal by value.

In the block parameters, you can set fixed point values using fi(…​), and also transfer the bus structures as NamedTuple. The type of bus can be determined 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 initialize values. You can also move the main logic here if Step method code or Component struct code are disabled.

In the cell Component structure code — when describing the fields of the structure, you can use values like Fixed, as well as the types BusSignal if the fields are composite signals.

The Step method code cell implements the main logic of the block. Here, fixed numbers and bus signals can participate in calculations, comparisons, and structure processing.

In the cell Types inheritance method — you can use the types Fixed and BusSignal to analyze the inputs and specify the output type of the component.

In the Dimensions inheritance method cell, you can use the data Fixed and the values from the buses to determine the dimensions of the output signals.

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

In the Terminate method code cell, these types can be used to record the final state if the structure contains the appropriate fields.

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

The real ones: Float16, Float32, Float64

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

Logical: Bool

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

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

type — the type to convert the value to. If var — a complex number, the basic real type is indicated. For example, econvert(Float32, Complex{Int16}(1 + 2im)) it will return Complex{Float32};

var — value for conversion;

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

overflow — if true, then the overflow behavior (wrap) is used; if false saturation is enabled — the value is limited by the type range.

x1, x2 — operation arguments (scalars or arrays are allowed);

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

overflow — enabling overflow (true) or saturation (false);

rm — the rounding method (see the list above).

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

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

Defines the output type when two different types are added together 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 type of accumulator when adding up n values of the same type T:

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

Determines the type of battery when two different types are added together T1 and T2 by n values:

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

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

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

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

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

Defines the output type when two different types are multiplied. T1 and T2:

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

Defines the output type when dividing a single type value T:

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

Defines the output type when dividing the type value T1 on the type value T2:

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

Converting input data into a vector with redefinition of output parameters;

Using caching and strongly typed structures to improve performance;

Implementation of blocks without direct feedthrough for breaking algebraic loops;

Setting the user sampling period of the output signal.

Ports: %<Inputs>, %<Outputs> — number of input and output ports; %<InputPort1Type>, %<OutputPort1Type>, %<InputPort1Size>, %<OutputPort1Size> — the type of data and the dimension of the signals.

Temporary characteristics: %<SampleTime> — discreteness; %<SampleTimeInheritanceMethod> — the method of inheritance of discreteness.

Code blocks: %<ComponentStructCode>, %<StepMethodCode> — the code of the step structure and method.

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

Enable flags: %<DefineComponentStruct>, %<UseCommonCode>, %<DefineStepMethod>, %<DefineUpdateMethod>, %<DefineTerminateMethod> — inclusion of the relevant sections of the code.

Redefinition methods: %<OverrideTypesInhMethod>, %<OverrideDimsInhMethod>, %<OverrideSampleTimeInhMethod> — type inheritance settings.

Other: %<UseExternalCache> — using an external cache.