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 AbstractCausalComponent type). The structure fields are defined between the non-editable strings struct Block <: AbstractCausalComponent and end'. By default, the `g parameter is created, initialized by the value of the gain block, and the Block() constructor 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 if it is not suitable (due to the non-editability of struct Block <: AbstractCausalComponent), then you can disable Define component struct 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 the non-editable lines of function (c::Block)(t::Real, in1)`and `end'. The first argument is `t::Real is the simulation time, then the input signal variables are transmitted. The calculated values of the outputs are returned using the 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 is the block structure, the second t::Real is the simulation time, then the input signals are transmitted. If the block has no internal state, 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 terminate! method). The first argument of `c::Block' is the 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' is 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' — the start of the simulation from the model settings.

'STOP_TIME' — the 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 is the first input port of the block. 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 is the first output port of the block. Engee Function.

`dimensions' — the dimension of the signal. It can be shortened to `dims'.

type — the type of the signal. It can be shortened to `tp'.

'sample_time' is 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). It can be shortened to `df'.

'FixedPoint' is the abstract type of all fixed numbers`;

Fixed is a specific type of fixed number, created manually with an indication of the bit representation.;

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

fixdt(…​) — creating a Fixed type with an 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{...} is the 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) — determine the type of BusSignal by value.

In the block parameters, you can set fixed point values via fi(…​), and also pass the bus structures as `NamedTuple'. The bus type 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 Component structure code cell, when describing the fields of the structure, you can use values of the Fixed type, as well as the BusSignal types, 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 Types inheritance method cell, you can use the Fixed and BusSignal types to analyze the inputs and set the output type of the component.

In the Dimensions inheritance method cell, you can use the Fixed data and 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 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 can also participate in the calculation logic.

Real numbers: Float16, Float32, Float64

Integers: 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 — the type to convert the value to. If 'var` is a complex number, the base real type is specified. For example, econvert(Float32, Complex{Int16}(1 + 2im))`returns `Complex{Float32};

'var` — value for conversion;

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

overflow' — if `true, the overflow behavior (wrap) is used; if false, saturation is enabled — the value is limited to the range of the type.

'x1`, x2 — arguments of the operation (scalars or arrays are allowed);

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

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

`rm' is 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 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)

Defines the type of accumulator 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)

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 multiplying two different types T1 and T2:

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

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

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

Defines 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)

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> — data type and signal dimension.

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

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

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

Enable flags: %<DefineComponentStruct>, %<UseCommonCode>, %<DefineStepMethod>, %<definupdatemethod>, %<DefineTerminateMethod> — enable the corresponding code sections.

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

Other: %<UseExternalCache> — external cache usage.