Skip to content. | Skip to navigation

Personal tools
Log in

DIstributed Computing Environments (DICE) Team
We are a group of computer scientists and IT experts from the Department of Computer Science AGH and ACC Cyfronet AGH. We are a curiosity- and research-driven team, specializing in large-scale distributed computing, HPC, Web and Cloud technologies. We develop new methods, tools and environments and we apply these solutions in e-Science, healthcare and industrial domains.

You are here: Home DICE Blog Multisupport for Multiscale

Multisupport for Multiscale

Posted by Katarzyna Rycerz at Nov 05, 2012 02:35 PM |
Filed under:
Modern scientists are commonly faced with the challenge of modeling and simulating multiscale systems where several processes with differing scales interact. At DICE we have been developing support for simulating such systems. We aim at multiscale applications that can be described as a set of interconnected single-scale modules, i.e. modules that implement single-scale process models. Each application run may involve many invocations of a single-scale module. At the modeling stage such multiscale applications can be represented in the form of a coupling topology - a graph with instances of single-scale models as its nodes. Typically, constructing multiscale applications is not trivial and requires a lot of effort on the part of application designers. To support development of multiscale applications and facilitate their execution we have developed a set of tools, presented below.

Having defined a multiscale application as a set of interconnected single-scale models one can think of the possible ways to execute it on the available computing resources. Each of the conceptual models can be implemented as a software module connected to other modules. The main steps required for constructing the multiscale application are indicated in Fig 1.


Fig1. Process of constructing a multiscale application - the steps of the process are represented as rectangles while supporting tools correspond to circles. The following colors were used: MML support - orange; tools - blue; external services - green

First, all submodels of a single-scale phenomenon need to be created. These submodels have to be appropriately described to be composable with each other in a multiscale application. Furthermore, the corresponding software modules that implement submodels have to be designed. Having created the single-scale models as well as the required scale bridging methods, it is time to assemble them into a full-fledged multiscale application. This is first done on the conceptual level, whereupon the connection scheme has to be described. Finally, the application has to be executed on resources that fulfill the requirements of each individual component. Following execution, the results have to be fetched and presented to the user.

All these steps can be performed manually; however some stages of the presented process can be supported or even automated. In particular, it would be useful to facilitate visual joining of modules and automatic generation of the connection scheme from this visual view. Sharing of modules and describing their connections for reuse in different configurations would also present a desirable feature for end users. Another stage that requires support is execution itself. Having stored all required data, it is possible to automate the derivation of an executable from the connection schema. It would also be useful to facilitate selecting the required resources from a single entry point. Upon execution, the output data should be fetched and presented to the user. To support development and execution of multiscale applications we have developed a set of tools, useful at various stages of the process shown in Fig 2.


MAD aids users in composing applications usingMML-based submodule metadata stored in MAPPER Memory (MaMe). Once theapplication is composed, MAD translates its MML description to aportable  GridSpace experiment,which is then passed to the GridSpaceExperiment Workbench and executed on various resources. REST indicatesrepresentational state transfer protocol


Fig 2. Tool framework. MAD aids users in composing applications using MML-based submodule metadata stored in MAPPER Memory (MaMe). Once the application is composed, MAD translates its MML description to a portable GridSpace experiment, which is then passed to the GridSpace Experiment Workbench and executed on the available resources.

To describe single-scale models and their connections one can use the Multiscale Modeling Language developed by the University of Amsterdam. Information about single-scale models is saved in the MAPPER Memory (MaMe) tool for further use. Multiscale Application Designer (MAD) fetches data from MaMe and allows for visual composition of the application in gMML. The corresponding connection schema is generated from a visual view and then translated into a portable executable experiment format used by the GridSpace Experiment Workbench (EW) that runs the application on resources chosen by the user and fetches results. EW itself does not deal with low-level resource usage issues (such as reducing waiting time in a job queue), but provides a unified frontend, which includes not only simple SSH-based access, but also advanced external services (such as AHE or QCG).

Below we present a usage example where our tools are applied to set up a canal consisting of three segments connected with a gate and a spillway (developed at the University of Unige). The output of the simulation is then visualized as set of pictures and a movie. The tightly coupled part of the connection utilizes the Multiscale Coupling Library and Environment (MUSCLE).


Fig3. Irrigation Canals sample application being composed in MAD


Fig4. Sample GridSpace EW experiment which executes the Irrigation Canals application.

An example of using MAD and GridSpace EW can be also viewed in the video below.

Comments (0)

NOTE! This web site uses cookies and similar technologies (if you do not change the browser settings, you agree to this).

cyfronet agh