Engee documentation

The architecture of the models in Engee

Practical recommendations for building a model architecture using specific blocks are described in the article. Practical work with model architecture in Engee.

Any model, even the most complex one, can be assembled from separate blocks. However, as their number increases, difficulties inevitably arise. So, if the model consists of many blocks, then understanding the location of the necessary elements and their interaction becomes problematic. In such cases, it takes too long to maintain and modify the model. Therefore, for clarity and simplification, it is recommended to divide complex models into semantically homogeneous pieces using subsystems.

A subsystem is a block Subsystem, designed to create a hierarchy in the model. For example, using a subsystem, you can implement a model in which:

  • 20 blocks describing the behavior of the wheels are connected to a subsystem «Wheels»;

  • 300 blocks connected to the engine are connected to a subsystem «Engine»;

  • The 50 blocks responsible for the housing are connected into a subsystem «Body».

Such associations create an intermediate level of abstraction, where logical objects are used instead of individual blocks. As a result, we get the following conditional model:

subsystem model example 1

Such a transition to certain levels of abstraction with the help of subsystems allows:

  • Think in terms of real objects (engine, transmission, chassis) instead of signals and blocks;

  • Group some subsystems into other, larger subsystems, increasing the level of abstraction;

  • Disable or replace entire subsystems with a single action, rather than manually modifying blocks.

This, in turn, creates a number of advantages.:

  • Separate debugging — thanks to subsystems, individual parts of the model can be isolated and tested. For example, first make sure that the engine is working properly, and then check how it interacts with the transmission.;

  • Logic inside subsystems — subsystems are no longer just a set of blocks inside another block. They become objects with their own logic: they can react to external signals and activate under certain conditions (for more information, see Practical work with model architecture in Engee);

  • Using masks — masks allow you to hide complex internal details of subsystems and take out only important parameters or configure additional functionality on top of the subsystem.;

  • Flexibility and reuse — blocks can be reuse in different models. You can also experiment with structures by changing blocks or their parameters to evaluate the result.

To create abstraction levels in Engee not only subsystems can be used. Submodels (block Model) is the next stage that allows you to work with models as separate objects, which allows you to:

  • Implement parallel development — when using the Model block, you can distribute development between different specialists. For example, one engineer deals with a subsystem «Wheels» And the other one — «Engine». At the same time, they do not introduce potential errors or unnecessary edits into each other’s subsystems, being responsible only for their area of interest. Their changes can be easily implemented in «The main model» by simply updating the Model block in the desired model;

  • Versioning and reusing blocks — The Model block is perfect for saving entire models for further reuse or integration.

The main stages of creating models from subsystems/submodels

  1. The initial stage is modeling from separate blocks. This approach is suitable for small models where detail is more important than structure.

  2. The transition to subsystems — the model begins to be grouped into functional modules. For example, several subsystems are made from 100 blocks: engine, transmission, chassis.

  3. Using submodels and masks — there are opportunities:

    1. 1. Reuse of components.

    1. 2. Hiding implementation details (masks)/adding new functionality.

    1. 3. Simplify the interaction between modules (subsystems or submodels).

  4. The final stage is the creation of a common system that combines several submodels. This is a multi-level design approach typical for model-oriented design.

Recommendations for creating models

Number of blocks

Try to use no more than 10 blocks at the same nesting level to keep the model readable.

Organization of subsystems

Divide the model into logical nodes: each subsystem block should represent a functional element of the system.

What to put in submodels

For complex components with high detail, use submodels, leaving subsystems to group functional nodes.

Flexibility and modularity

Create a model so that it can be easily modified by replacing components or modifying logic.

General recommendations:

  • Break the models into logical parts.

  • Use masks to hide complex details and simplify interaction.

  • Follow a hierarchical approach: the top level should be simple and logical.

  • Check and test the subsystems at each stage to ensure that the model is working correctly.

  1. Subsystem

  2. Chart

  3. Model

  4. Building a model