Book a Demo
Prev Next

Simulation and Visualization

One of the great benefits of creating system models is the ability to see the system in motion by running simulations - effectively you to visualize and analyze a system. Enterprise Architect provides a suite of tools to simulate the execution and behavior of the processes that your models define. The tools provide facilities to dynamically simulate a range of types of model including SImulation of Activity and State Machine diagrams, Parametric diagrams, Decision Models and more. Executable State Machines provide rich support for programming language-specific implementations. OpenModelica and MATLAB Simulink can be used to support rapid and robust evaluation of how a SysML model will behave in different circumstances.

Dynamic Simulation

Model Simulation brings your behavioral models to life with instant, real-time behavioral model execution. Coupled with tools to manage triggers, events, guards, effects, breakpoints and Simulation variables, plus the ability to visually track execution at run-time, the Simulator is a multi-featured means of 'watching the wheels turn' and verifying the correctness of your behavioral models. With Simulation you can explore and test the dynamic behavior of models. In the Corporate, Unified and Ultimate Editions, you can also use JavaScript as a run-time execution language for evaluating guards, effects and other scriptable items of behavior.

Extensive support for triggers, trigger sets, nested states, concurrency, dynamic effects and other advanced Simulation capabilities, provides a remarkable environment in which to build interactive and working models that help explore, test and visually trace complex business, software and system behavior. With JavaScript enabled, it is also possible to create embedded COM objects that will do the work of evaluating guards and executing effects - allowing the Simulation to be tied into a much larger set of dependent processes. For example, a COM object evaluating a guard condition on a State Transition might query a locally running process, read and use a set of test data, or even connect to an SOA web service to obtain some current information.

As Enterprise Architect uses a dynamic, script driven Simulation mechanism that analyzes and works with UML constructs directly, there is no need to generate intermediary code or compile simulation 'executables' before running a Simulation. This results in a very rapid and dynamic Simulation environment in which changes can be made and tested quickly. It is even possible to update Simulation variables in real time using the Simulation Console window. This is useful for testing alternative branches and conditions 'on the fly', either at a set Simulation break point or when the Simulation reaches a point of stability (for example, when the Simulation is 'blocked').

In the Professional Edition of Enterprise Architect, you can manually walk through Simulations - although no JavaScript will execute - so all choices are manual decisions. This is useful for testing the flow of a behavioral model and highlighting possible choices and processing paths. In the Corporate, Unified and Ultimate Editions it is possible to:

  • Dynamically execute your behavioral models
  • Assess guards and effects written in standard JavaScript
  • Define and fire triggers into running Simulations
  • Define and use sets of triggers to simulate different event sequences
  • Auto-fire trigger sets to simulate complex event histories without user intervention
  • Update Simulation variables 'on the fly' to change how Simulations proceed
  • Create and call COM objects during a Simulation to extend the Simulation's reach and input/output possibilities
  • Inspect Simulation variables at run time
  • Set a script 'prologue' for defining variables, constants and functions prior to execution
  • Use multiple Analyzer Scripts with differing 'prologues' for running the Simulation under a wide range of conditions

In the Unified and Ultimate Editions it is also possible to simulate BPMN models.

Using the Model Simulator, you can simulate the execution of conceptual model designs containing behavior. When you start a Simulation, the current model Package is analyzed and a dynamic Simulation process is triggered to execute the model.

To get up and running with Simulation, the only steps required are:

  • Build a behavioral diagram (State or Activity for manual or dynamic execution, Sequence for manual interaction only)
  • Optional: load the 'Simulation Workspace' layout - a fast way of bringing up all the frequently used Simulation windows
  • Click on the Simulator Play button

If the diagram contains any external elements (those not in the same Package as the diagram) you will have to create an Import connector from the diagram's Package to the Package containing the external elements. To do this, drag both Packages from the Browser window onto a diagram and then use the Quick Linker arrow to create the connector between them.

Mathematical Simulations

Enterprise Architect provides a wide range of options for introducing advanced mathematical tools and capabilities into your simulations.

You can bring the power of integrated external tools such as MATLAB into your models through the use of Solver Classes, and can also export your models for execution in other external tools such as MATLAB Simulink, Stateflow and Simscape, or OpenModelica.

Enterprise Architect includes an extensive library of mathematical functions within the JavaScript engine, providing the benefits of a significantly expanded Simulation capability.

Enterprise Architect also provides a wide range of Dynamic Charts; without the need for external tools, you can configure these Charts to extract and plot information from Simulations that have been directly executed inside Enterprise Architect.

Explore the:

  • Solver classes in Enterprise Architect that call MATLAB or Octave to incorporate complex mathematics into your model-based simulations
  • Extensive internal Math Library based on the popular Cephes function library
  • Integration with the OMG SysPhS standard, enabling you to configure your model for export to common tools
  • Support for exporting models to MATLAB Simulink, Simscape and Stateflow; you can create your model in Enterprise Architect and execute it in MATLAB
  • Extensive support for Modelica; you can create and configure your model in Enterprise Architect and execute it in Modelica
  • Presentation of the results of your modeling and simulation in Chart formats, either within a dedicated graphics presentation tool or through the Dynamic Charting facilities of Enterprise Architect

Executable State Machines

Executable StateMachines provide a means of rapidly generating, executing and simulating complex state models. In contrast to dynamic simulation of State Charts using Enterprise Architect's Simulation engine, Executable StateMachines provide a complete language-specific implementation that can form the behavioral 'engine' for multiple software products on multiple platforms. Visualization of the execution is based on a seamless integration with the Simulation capability. Evolution of the model now presents fewer coding challenges. The code generation, compilation and execution is taken care of by Enterprise Architect. For those having particular requirements, each language is provided with a set of code templates. Templates can be customized by you to tailor the generated code in any ways you see fit.

Enterprise Architect screenshot of running executable state machine simulation

Decision Model Simulation

Organizations face increasingly difficult operating environments with fierce and often unpredictable competition from existing and new market players, changes in government and industry regulations, and upheavals in the social fabric of their customer base. An organization's decisions in this context are critical to its success and its ability to steer a safe path through these uncharted corporate waters. Using Enterprise Architects Decision Model and Notation (DMN) features, you can not only model your organization's decisions, but you can also run simulations from these models to predict outcomes based on example data sets. The power of the language is that business people can readily understand and work with expressive but straightforward Decision Requirements diagrams that detail the decisions, including their inputs and the expected outputs. A modeler can document the rules in several ways, including easy to define decision tables. Once completed, these diagrams with accompanying input data examples, can be simulated to show the results of the decisions.