Home Up [Motivation] [Implementation] [Applications]

Multi-Physics Simulation System for Discrete and Continuum Dynamics


MulPhys is a model development environment for complex multi-physics simulations. It is based on a multi-domain and multi-model approach, which enables different physical models to co-exist in different geometrical domains and interact with each - other.


The idea behind this project is to provide an object-oriented environment for multi-physics modeling. The focus of the system is on the simulation of complex discrete and continuum dynamics. The modeling framework is based on the efficient library routines for manipulating geometrical primitives, which currently include particles, nodes, segments, faces, and cells. There are two basic features that are inherent in all primitives: dynamic creation/destruction and dynamic connectivity. The former allows for modeling of complex events when the number of elements is constantly changing, like particle dynamics, structure failures, mechanical interactions etc. Dynamic connectivity enables modeling of complex mechanical and fluid-dynamical events with interactions between different physical entities, like particle-fluid, fluid-structure, solid-solid interactions. While broadening the scope of possible mechanical events that the system is capable of simulating these features can also be used on parallel computer platforms for dynamic load balancing.

Schematic of a modeling paradigm

Problem Setup

In contrast to conventional simulation environments where the simulation process involves three distinct stages: pre-processing, simulation and post-processing, MulPhys environment is based a single simulation/visualization process, where a GUI-controlled visualizer displays the state of the system at any time during the simulation. Because of the multi-model design it is possible to integrate pre- and post-processing into one continuous simulation process. For example, some elements of pre-processing, like mesh-generation, become the integral part of the simulation process, since mesh-generation itself is considered as just another model in the system. This general approach also facilitates modeling of complex systems, like those with changing geometries and moving boundaries.


  1. Elements

    Each geometric primitive is represented by an object of a respective class with a common parent class Element. To enable dynamic creation/destruction of the elements all objects of the same class are connected into a linked-list structure, inherited from the parent Element class.

    class Element
          Element *next,*prev;

    The connectivity lists themselves can be represented by arrays or linked lists. For example, in the case of unstructured tetrahedral gridding the connectivities are constant-size arrays, whereas in other cases they can be realized as dynamic linked lists (see the inter-atomic bonding problem, or structural collapse).

    A library of functions to compute areas, volumes, momenta, stresses, fluxes etc. is compiled for each class of elements and used in computations of complex dynamics.

  2. Domains

    There can be any number of domains. Each domain includes a collection of elements and a corresponding physical model. For example, the geometry of a particulate flow problem is defined as a connected list of nodes and tetrahedral elements (unstructured grid) and a collection of particles (points) dynamically connected to the grid. The problem setup is completed by specifying the appropriate models of fluid and particulate flow.

  3. Domain coupling

    Several domains can be coupled together using a DOVE scheme. This enables an interaction of different physical models with each other, and also creates a parallel simulation environment which can be easily implemented on distributed memory computer platforms.

  4. Model encapsulation

    Each particular physical model is encapsulated into a separate C++ namespace with an interface to the main executable routine. The interface consist of standard functions, such as declarator, initializer, and iterator. Each domain contains pointers to these interface functions, which are assigned during domain initialization so as to execute specific models.

    This encapsulation enables to use many different models in a single modeling paradigm. For example, in the current version the grid generator is encapsulated in a Model_Grid namespace, and implemented in a separate file. The flow-solver has a different model-space - Model-Flow, etc. This enables the coexistence of different models on different domains during one execution. All domains and geometries are specified in a separate configuration file together with information on which model is to be used at which domain.

Read more


Biomechanics and biofluids

Fluid Structure interactions

Solid structure dynamics


Particle interactions

Flame propagation studies

Fuel Cells

Home Up