Supporting Simulation Experiments with Megamodeling

Sema C¸ am

1,2

, Orc¸un Dayıbas¸

, Bilge K. G

, Halit O

guzt

, Levent Yilmaz

Sritika Chakladar

, Kyle Doud

, Alice E. Smith

and Alejandro Teran-Somohano

Department of Command Control and Combat Systems, HAVELSAN A.S¸., Ankara, Turkey

Department of Computer Engineering, Middle East Technical University, Ankara, Turkey

Department of Computer Engineering, Hacettepe University, Ankara, Turkey

Department of Computer Science and Software Engineering, Auburn University, Alabama, U.S.A.

Department of Industrial and Systems Engineering, Auburn University, Alabama, U.S.A.

Keywords:

Model-Driven Engineering, Global Model Management, Megamodel.

Abstract:

Recent developments in computational science and engineering allow a great deal of experimental work to be

conducted through computer simulation. In a simulation experiment, a model of the phenomena to be studied

is run in a computing environment under varying model and environment settings. As models are adjusted

to experimental procedures and execution environments, variations arise. Models also evolve in time. Thus,

models must be managed. We propose to bring Global Model Management (GMM) to bear on simulation

experiment management by using techniques and tools from megamodeling. The proposed approach will

facilitate model management tasks by providing an interface to query the model repository, relate models

with each other, and apply model transformations from/to simulation models. Our proposed Megamodel for

Simulation Experiments is based on SED-ML (Simulation Experiment Description Markup Language).

1 INTRODUCTION

In many science and engineering problems, theories

and hypotheses about what makes a system work,

or to explain some phenomena in terms of cause

and effect relationships, are put forth. Then, exper-

iments are conducted to test the hypotheses. Values

of the input variables of the system are changed in-

tentionally, and the resulting output values are ob-

served and measured. Experiments produce evi-

dence whether proposed theories are supported or not

(Montgomery, 2006). With recent developments in

computational science and engineering, modeling and

simulation technologies, experiments are now per-

formed on computers to avoid the risk, or even the

practical impossibility, of conducting experiments in

the real world. Furthermore, simulation experiments

usually require less time, cost and effort. Such exper-

iments are known as in silico experiments. Therefore,

the use of simulation experiments is common among

the experimental scientists and engineers. There is

a growing number of simulation experiment projects

such as myExperiment (Goble et al., 2010) and Ex-

periment (Denny Luan, 2017) projects, which are es-

sentially social web sites for researchers sharing sci-

entiﬁc workﬂows. These projects involve the develop-

ment of various kinds of simulation experiment mod-

els. However, these models need a supporting envi-

ronment that is easy to use by non-programmers to be

sustainable and manageable. The experiment models

in the environment should be accessible and manip-

ulable (e.g. loading/saving/editing/deleting/search-

ing/executing models). In that respect, Global Model

Management (GMM) is a suitable concept for this

problem. GMM aims to manage a large and var-

ied set of artifacts produced in modeling-in-the-large

(globally dealing with models, metamodels and their

properties and relations (B

ezivin et al., 2005) ef-

forts in projects that adopt Model Driven Engineering

(MDE).

The main objective of this paper is to apply the

GMM concept for simulation experiments to provide

an environment for scientists, who deal with stand-

alone simulations, simulation data (conﬁguration, pa-

rameter, and input and output data), and multiple sim-

ulation models over time. Although a single model

372

Çam, S., Dayıba¸s, O., Görür, B., O

guztüzün, H., Yilmaz, L., Chakladar, S., Doud, K., Smith, A. and Teran-Somohano, A.

Supporting Simulation Experiments with Megamodeling.

DOI: 10.5220/0006586703720378

In Proceedings of the 6th International Conference on Model-Driven Engineering and Software Development (MODELSWARD 2018), pages 372-378

ISBN: 978-989-758-283-7

might be relatively easy to manage, in real-life sit-

uations experimenters have to deal with large sets

of interacting simulation models and associated data

which are difﬁcult to maintain manually. Manage-

ment of the evolution of models and related arti-

facts requires conﬁguration management support, es-

pecially because, developers need to search and reuse

models from previous projects. Also, collaboration

among multiple developers require cooperative man-

agement of models (Koegel and Helming, 2010).

Models keep evolving along with the scientiﬁc en-

deavor. Their sophistication and variety tend to in-

crease over time. When a large number of models

are involved, users are faced with formidable system

management issues, including the need to maintain

consistency. New types of relations between models

can be conﬁgured during model evolution. Addition-

ally, the system should be extensible so that it can be

readily adjusted to new domains. Furthermore, simu-

lation experimentation brings about logical complex-

ity at multiple levels such as domain modeling (con-

ceptual modeling) issues, model complexity, simula-

tion complexity (method for generating behavior from

a model), complexity of operational environments for

simulation execution, heterogeneity of the experiment

design, complexity of the management of simulation

input and output data and other scenario-related data,

and challenges about presentation of results (includ-

ing visualization).

To alleviate the above mentioned problems, we

propose to carry Simulation Experiments into an

MDE environment and provide a user interface for

Simulation Experiment models that enables the query,

relating and applying model transformation from/to

available models. We contend that a megamodel will

be helpful to manage the models involved in a family

of simulation experiments. More speciﬁcally, in this

article we report on ongoing work about how to sup-

port simulation experiments through megamodeling

techniques. Our work takes advantage of the Xper-

imenter. Xperimenter is a domain speciﬁc language

(DSL) that aims to provide a declarative medium for

experiment speciﬁcations. We also present a case

study that aims to query Xperimenter models. The

case study is realized by using Xtend (Efftinge, 2017),

a programming language that is a ﬂexible and expres-

sive dialect of Java, particularly effective for dealing

with model transformations.

The rest of this paper is organized as follows: in

Section 2, some related works about GMM and meg-

amodeling are discussed. Then, Xperimenter DSL for

Simulation Experiment overview is given in Section

3 for background. In Section 4, our megamodel is in-

troduced. Further, we have a small case study, intro-

duced in Section 5, for querying Xperimenter mod-

els. Finally, conclusions and future work directions

are given in Section 6.

2 RELATED WORK

Global Model Management (GMM) aims to handle

models and metamodels, and their properties and re-

lations, in a model-engineering environment. It is a

sophisticated way of creating, storing, viewing, ac-

cessing, modifying, and using the information asso-

ciated with all these modeling elements. As for a

megamodel, it is a model that contains models and

relations between them. The megamodel represents

the Model Driven Engineering artifacts, including the

transformation composition and execution within a

model. Basically, GMM provides a framework for

managing the large sets of heterogeneous and com-

plex MDE artifacts and a megamodel is a model de-

ﬁned in GMM that contains MDE artifacts.

The proposed approaches for GMM are summa-

rized in (Hebig et al., 2011). In (Jouault et al., 2010),

megamodels are combined with model weaving and

proposed as a new infrastructure for GMM. However,

the proposed technique does not support automated

production of traceability links for model navigation

nor does it provide model synchronization. As for

identiﬁcation of the model relationships, the GEMOC

initiative (Combemale et al., 2014) deﬁnes three re-

lations: interoperability, collaboration, and composi-

tion. Interoperability provides information exchange

among the models. Collaboration supports coupling

between models and coupled models affect each oth-

ers development. Finally, composition enables one to

combine information from different models to create

a new one.

As for megamodel, it is a model that contains

models and relations between them. The megamodel

represents the Model Driven Engineering artifacts,

including transformation composition and execution

within a model. Megamodeling is applied for sev-

eral practical purposes. In (Favre and NGuyen, 2005),

it is applied for modeling software evolution through

transformations. In (Fritzsche et al., 2009), the model

driven concept is utilized for a non-functional prop-

erty and megamodeling is applied to Model Driven

Performance Engineering. Furthermore, megamodel-

ing is reportedly applied in such diverse areas such as

data analysis (Ceri et al., 2013), consistency checking

of industrial product lines (Vierhauser et al., 2012)

and an e-government project (B

uttner et al., 2014).

In particular, Simmonds and coworkers (Simmonds

et al., 2015) undertook a megamodel study for Soft-

Supporting Simulation Experiments with Megamodeling

373

ware Process Line modeling and evolution. They as-

sert that megamodeling facilitates achieving a uni-

form mechanism for process deﬁnition, variability,

tailoring and evolution.

In our work, we aim to build a megamodel that fa-

cilitates scientiﬁc experiments with simulation mod-

els. The Xperimenter DSL is used to specify and exe-

cute simulation models. Unlike prior work, our study

aims to contribute to the management of simulation

models, the abstraction of simulation experiments at

design and execution levels, and the management of

simulation artifacts. We intend to specify and run sim-

ulation experiments and analyze the results with the

support of megamodeling techniques. Additionally,

we propose to create an extendable environment that

adapts existing simulation models developed with dif-

ferent technologies.

3 BACKGROUND

3.1 Xperimenter for Simulation

Experiment

Xperimenter is a DSL for simulation experiment de-

sign and execution. The DSL has three main objec-

tives. The ﬁrst one is to provide a medium for specify-

ing simulation experiments. The second is to manage

simulation experiment variability by mapping frag-

ments of an experiment speciﬁcation to higher level

abstractions, namely, features. The third is running a

simulation experiment on a target platform, such as a

scientiﬁc workﬂow management system. A simpliﬁed

metamodel deﬁnition of Xperimenter is given in Fig-

ure 1. The elements of the metamodel are brieﬂy de-

scribed below to provide a conceptual framework for

the components of a simulation experiment as well as

the relationships among them.

Experiment: The attributes of this class include

identifying information related to an experiment, such

as the experiment name, date and description. An

experiment is composed of following main compo-

nents: Simulation model, objective, simulation runs ,

design, design matrix, statistical analysis and visual-

ization methods.

SimulationModel: It is the core aspect of the sim-

ulation experiment. On the other hand, in simula-

tion experiments, the simulation model is the primary

source of information.

Objective: The class deﬁnes the purpose of the

experiment. This deﬁnition inﬂuences the experi-

ment type and the number of runs that are required

to achieve the experiment’s goals.

Run: The number of simulation runs required is

not necessarily known at the time of experiment de-

sign; it may depend on the actual progress of the ex-

periment. Each run has a start and end time.

Design and DesignMatrix: Design class captures

the structural aspect of the experiment. The experi-

mental structure is deﬁned by the responses, the fac-

tors and their levels, and user-provided value ranges.

Based on this design, a design matrix can be created,

which speciﬁes the actual experimental runs.

StatAnalysis: Statistical analyses on the experi-

mental data can provide a wealth of useful informa-

tion about the inﬂuence of factors on the responses.

Xperimenter enables the use of ANOVA analysis,

hypothesis testing, and conﬁdence intervals in its

present version.

Visualization: This part of the model denotes the

method of visual representation of the analysis.

Variable (Response and Factor): Each variable

is identiﬁed by its name and type. Currently, four

types of variables (Integer, Float, Boolean, String) are

supported in the metamodel. These variables can be

divided into two distinct classes, namely, responses

and factors. Responses, which correspond to de-

pendent variables, represent the output values of the

experiment. An experiment is conducted by vary-

ing these factor values and recording the outcomes.

Each factor can have multiple levels (also called treat-

ments). There is a one-to-one mapping between a fac-

tor level and a factor value. The factor values are the

values that are actually fed into the simulation model.

Response values are generated at each experimental

run. An experimental run is a run of the simulation

model with a set of input parameters. The input pa-

rameters are the factor values for that run.

SamplingInstance: A sampling instance is basi-

cally an aggregation of a variable and its actual value.

It can be an input to the model (factor variable) or out-

put of it (response variable). Sampling instances can

be used in a design matrix.

4 MEGAMODEL FOR

SIMULATION EXPERIMENTS

4.1 Conceptual Overview

The groundwork involves building a metamodel for

simulation experiment megamodels so that conform-

ing megamodels can be deﬁned by users for their ex-

periments. We call the megamodel GMM4SE, short

for Global Model Management for Simulation Ex-

periments. GMM4SE deﬁnes the supported types of

MODELSWARD 2018 - 6th International Conference on Model-Driven Engineering and Software Development

374

Figure 1: Simulation Experiment Domain Model.

modeling artifacts; presently these are metamodels,

transformations, and the relationships between meta-

models and model transformations. Figure 3 depicts

our simpliﬁed megamodel deﬁnition. The workspace

shown in the upper part of Figure 2 refers to the model

workspace. It contains a model-based solution com-

prised of three modeling artifacts: (i) a metamodel

for Xperimenter, which was introduced in Section 2,

(ii) Xperimenter models, and (iii) a model-to-model

transformation that produces models conforming to

the Xperimenter metamodel from models conform-

ing to the same metamodel. All of the modeling

artifacts in the workspace represent data for a par-

ticular megamodel. The megamodel keeps informa-

tion about their locations in the directory and the re-

lationships among them (e.g., dependency between

the source and target models of model transforma-

tion). The megamodel conforms to the GMM4SE

metamodel.

There are two fundamental mechanisms to specify

model relations in our megamodel. The ﬁrst mecha-

nism is used to deﬁne weaving relationships among

the models, and the second mechanism is used to de-

ﬁne constraints between them. Model weaving is an

operation for deﬁning ﬁne-grained relationships be-

tween models and metamodels and produces a weav-

ing model from the relationship. Also, operations are

executed on them based on the semantics of the weav-

ing relations (B

ezivin, 2005). For instance, when a

weaving relation occurs, a weaving model is produced

and it represents a mapping between the related mod-

els.

As for the constraints, they are provided by deﬁn-

ing rules among the models. However, rules speciﬁc

to simulation experiments are currently missing in our

megamodel. We are planning to add rule deﬁnition

functionality to the megamodel by using Xtend. We

will deﬁne a number of constraints to help megamodel

users analyze various properties of simulation exper-

Figure 2: Overview of Megamodel for Simulation Experi-

ments.

iments. For instance, when a source metamodel def-

inition of a model transformation is updated, associ-

ated source models must be checked for conformance.

If the associated models do not conform to the up-

dated metamodel, model transformation fails. A rule

for checking the conformance relation on updates can

be useful. Being an element of another model can be

given as another rule example. An experiment model

includes the information only related to the speciﬁed

experiment, its simulation, design etc. The graphical

user interface is given in another model. The graph-

ical user interface model becomes an element of the

experiment model. A rule between these models can

be utilized to check that if meaningful visualization of

the experiment results is feasible or not.

4.2 Construction of a Megamodel for

Simulation Experiments

Our GMM environment for Simulation Experiments

is implemented in the Eclipse environment. It is com-

prised of three main elements: (i) a workspace (model

repository) for modeling artifacts, (ii) GMM4SE

(metamodel deﬁnition for a megamodel), and (iii)

model interfaces in Xtend for model operations such

as model loading and model querying. By using the

Model Interfaces, which are speciﬁed and generated

by using Xtend, megamodel users are able to load,

edit and delete models, query available models, cre-

ate links among them and apply model transformation

from/to available models. Additionally, the Model In-

terfaces layer aims to separate the megamodel from

user interfaces. This separation leads to a ﬂexible and

reusable model management environment. The im-

plementation components and the available user op-

erations are shown in the Figure 3.

In addition, all metamodel deﬁnitions are speci-

ﬁed by using ECORE (a part of EMF) in the Eclipse

Modeling Framework (EMF) (Steinberg et al., 2009).

We choose to employ the Eclipse-based platform be-

cause of implementation concerns. Eclipse is at the

Supporting Simulation Experiments with Megamodeling

375

Figure 3: Megamodel Structure for Simulation Experiments

components and User Operations.

foundation of an ecosystem that supports free and

open software tools and languages like ECORE, EMF

and Xtend. Additionally, we intend to use Eclipse for

integration of the tools that we use for modeling, such

as Atlas Model Weaver (Didonet et al., 2006), to es-

tablish relationships between models.

5 CASE STUDY: QUERYING

XPERIMENTER MODELS

In this case study, an experiment involving a quad-

copter is modeled using Xperimenter. A quadcopter,

also known as a quadrotor helicopter or quadrotor, is

a multi-rotor helicopter that is lifted and propelled by

four rotors. Flight control of a quadcopter is a good

example of how a Proportional-Integral-Derivative

(PID) controller can be used to adjust some opera-

tional variables to hold an output variable at a set-

point. Validating the controller of the quadcopter by

using actual test ﬂights can be hazardous and costly.

Therefore, we need to ﬁnd a practical way to validate

a controller. As the name suggests, PID control in-

volves three basic coefﬁcients, namely, proportional,

integral and derivative (Kp, Ki, Kd). These coefﬁ-

cients can be varied to get an optimal response. We

want to experiment with the model to ﬁnd near opti-

mal PID gains.

The quality of a controller depends on the gain

values, and tuning these parameters require an experts

intuition and time. By using Xperimenter this tun-

ing is facilitated. First we need to deﬁne a research

question: ”Which gain parameter is most important

to determine the quality of the controller?”. Assume

that we have a differential equation model for quad-

copter ﬂight and its gain parameters are conﬁgurable

(preprocessed for this experiment). The Xperimenter

code snippet in Figure 4 articulates a full factorial de-

sign for this experiment.

Our Quadcopter Xperimenter model in Figure 4

Figure 4: Quadcopter Experiment model.

has a simulation element called QuadcopterSim and

there exist four variables: Ki, Kp, Kd and AV. The

model ﬁle and model type are speciﬁed in the sim-

ulation element. Additionally, the inports and out-

ports are identiﬁed. An inport is a link to pull data

from the outside of the simulation, and an outport is a

link to push data to outside. The experiment design is

called CompMachineIntExpDesign and the FullFac-

torial method is applied in the design. Finally, an

Anova Analysis takes place; the Anova service acces-

sible from the given URL is used.

Table 1: Quadcopter Models Input Variables.

name lowValue highValue

Quadcopter 1

Variables

Ki 3 6

Kd 5 9

Kp 6 8

Quadcopter 2

Variables

Ki 2 7

Kd 3 5

Kp 1 8

Querying on two different Xperimenter models

has been implemented by using Xtend. The example

Xperimenter models are shown in Figure 4 and Table

1. The implementation of the querying is shown as an

Xtend code snippet and the query result is shown in

Figure 5. The Xperimenter domain models are rather

simple for the purpose of illustration: Two models in

the repository are queried whether their input vari-

ables lowest and highest values are between the re-

quired value.

As for the Xtend implementation for the query-

ing in the code snippet, ﬁrst the Xperimenter meta-

model (deﬁned in Section 2), is registered to the EMF

registry, and then the two Xperimenter models are

loaded as resource sets. These resource sets manage a

collection of related resources that are received from

MODELSWARD 2018 - 6th International Conference on Model-Driven Engineering and Software Development

376

URIs and they can be loaded into a collection. In our

query example, Xperimenter models are loaded into

resource sets. From these resource sets, classes like

experiment, simulation, design are obtained. Then,

the query is executed. The query ﬁnds the input vari-

ables of the models which have the lowest value big-

ger than 2 and the highest value smaller than 8. The

Xperimenter models input variables are described in

Table 1. Finally, the query result is shown on the

Eclipse console.

class XperimenterQuery {

def static void main(String[] args) {

InputOutput.<String>println

("\nXperimenter 1")

new XperimenterQuery()

.queryModel("Quadcopter1.xml")

InputOutput.<String>println

("\nXperimenter 2")

new XperimenterQuery()

.queryModel("Quadcopter2.xml")

}

// Query the model

def queryModel(String file) {

// Register the EMF model

doEMFSetup

val resourceSet = new ResourceSetImpl

// Load the model and get the resources

val resource = resourceSet.getResource

(URI.createFileURI(file), true)

for (content : resource.contents)

validateModel(content)

}

// Validate the model

def validateModel(EObject o) {

val expImpl = o as ExperimentImpl

//find the variable which is between 2

and 8

for(v: expImpl.design.variables){

if (v.lowValue > 2 && v.highValue<8)

InputOutput.<String>println(v.name

+"["+v.lowValue+",

"+v.highValue+"] is between

2 and 8")

}

// Register Xperimenter packages to EMF

def doEMFSetup() {

EPackage.Registry.INSTANCE.put

(XperimenterPackage.eINSTANCE.nsURI,

XperimenterPackage.eINSTANCE);

Resource.Factory.Registry.INSTANCE.

extensionToFactoryMap.put("xml",

new XMIResourceFactoryImpl);

}

An important point is that the models are checked

whether they satisfy structural conformance to their

metamodels. At the beginning, Java class pack-

Figure 5: Xperimenter model validation result.

ages are generated from the Xperimenter Ecore meta-

model. doEMFSetup method registers these packages

to the EMF registry and checks metamodel confor-

mance. Then, the model is loaded as a ResourceSet.

If loading fails, this means the model conformance

control has failed.

In this case study, we managed to load and query

multiple Xperimenter models. This case study gives

a basic idea about utilizing a megamodel in terms of

models and metamodels, and it is an initial step for

building an environment for Simulation Experiments.

6 CONCLUSIONS AND FUTURE

WORK

In this paper, we report on our ongoing effort aimed

at creating a Global Model Management environment

for simulation experiments. We take advantage of

megamodeling techniques, which promote the reuse

of available simulation experiment models by inter-

relating the models and using the models for a vari-

ety of operations such as, loading, editing, deleting,

querying, applying model transformation. We pre-

sented a case study for Quadcopter experiment, im-

plemented using Xtend, for rudimentary querying of

Xperimenter models.

By using the GMM concept and megamodeling

techniques, we substantiate that the concept is effec-

tive in connecting different technologies that serve the

same purpose. we are planning to extend the environ-

ment for Simulation Experiments by integrating with

other scientiﬁc workﬂow systems such as Kepler (Al-

tintas et al., 2004) and Apache Taverna (Belhajjame

et al., 2008) to support model variety. Moreover, we

intend to base our simulation experiment environment

on SED-ML (Waltemath and Novre, 2014). SED-

ML is a standard language to encode simulation ex-

periments. Extending our proposed megamodel us-

ing SED-ML will be a complementary step toward

standardization of the model management environ-

ment. Additionally, with SED-ML, simulation ex-

periment descriptions becomes exchangeable among

Supporting Simulation Experiments with Megamodeling

377

simulation software, and the validation and reuse of

simulation experiments in different tools are enabled

(Waltemath et al., 2011). Therefore, SED-ML com-

pliance will promote the replicability of simulation

experiments among users and software tools.

REFERENCES

Altintas, I., Berkley, C., Jaeger, E., Jones, M., Ludascher,

B., and Mock, S. (2004). Kepler: an extensible sys-

tem for design and execution of scientiﬁc workﬂows.

In Proceedings. 16th International Conference on Sci-

entiﬁc and Statistical Database Management, 2004.,

pages 423–424.

Belhajjame, K., Wolstencroft, K., Corcho, O., Oinn, T.,

Tanoh, F., William, A., and Goble, C. (2008). Meta-

data management in the taverna workﬂow system. In

2008 Eighth IEEE International Symposium on Clus-

ter Computing and the Grid (CCGRID), pages 651–

656.

ezivin, J. (2005). On the uniﬁcation power of models.

Software and System Modeling, 4(2):171–188.

ezivin, J., Jouault, F., Rosenthal, P., and Valduriez, P.

(2005). Modeling in the Large and Modeling in the

Small. Springer Berlin Heidelberg, Berlin, Heidel-

berg.

uttner, F., Bartels, U., Hamann, L., Hofrichter, O.,

Kuhlmann, M., Gogolla, M., Rabe, L., Steimke, F.,

Rabenstein, Y., and Stosiek, A. (2014). Model-driven

standardization of public authority data interchange.

Sci. Comput. Program., 89:162–175.

Ceri, S., Palpanas, T., Valle, E. D., Pedreschi, D., Frey-

tag, J.-C., and Trasarti, R. (2013). Towards mega-

modeling: A walk through data analysis experiences.

SIGMOD Rec., 42(3):19–27.

Combemale, B., DeAntoni, J., Baudry, B., France, R. B.,

Jezequel, J.-M., and Gray, J. (2014). Globalizing mod-

eling languages. Computer, 47(6):68–71.

Denny Luan, C. W. (2017). Experiment.

https://experiment.com/. Accessed: 2017-06-12.

Didonet, M., Fabro, D., Bzivin, J., and Valduriez, P. (2006).

Weaving models with the eclipse amw plugin. In

In Eclipse Modeling Symposium, Eclipse Summit Eu-

rope.

Efftinge, S. (2017). Xtend. https://www.eclipse.org/xtend/.

Accessed: 2017-05-12.

Favre, J.-M. and NGuyen, T. (2005). Towards a megamodel

to model software evolution through transformations.

Electron. Notes Theor. Comput. Sci., 127(3):59–74.

Fritzsche, M., Bruneli

ere, H., Vanhooff, B., Berbers, Y.,

Jouault, F., and Gilani, W. (2009). Applying meg-

amodelling to model driven performance engineering.

In 16th Annual IEEE International Conference and

Workshop on the Engineering of Computer Based Sys-

tems, ECBS 2009, San Francisco, California, USA,

14-16 April 2009, pages 244–253.

Goble, C. A., Bhagat, J., Aleksejevs, S., Cruickshank, D.,

Michaelides, D. T., Newman, D. R., Borkum, M.,

Bechhofer, S., Roos, M., Li, P., and Roure, D. D.

(2010). myexperiment: a repository and social net-

work for the sharing of bioinformatics workﬂows. Nu-

cleic Acids Research, 38(Web-Server-Issue):677–682.

Hebig, R., Seibel, A., and Giese, H. (2011). On the Uni-

ﬁcation of Megamodels. In Amaral, V., Vangheluwe,

H., Hardebolle, C., Lengyel, L., Magaria, T., Padberg,

J., and Taentzer, G., editors, Proceedings of the 4th

International Workshop on Multi-Paradigm Modeling

(MPM 2010), volume 42 of Electronic Communica-

tions of the EASST.

Jouault, F., Vanhooff, B., Bruneliere, H., Doux, G., Berbers,

Y., and B

ezivin, J. (2010). Inter-dsl coordination sup-

port by combining megamodeling and model weav-

ing. In Proceedings of the 2010 ACM Symposium on

Applied Computing, SAC ’10, pages 2011–2018, New

York, NY, USA. ACM.

Koegel, M. and Helming, J. (2010). Emfstore: a model

repository for emf models. In 2010 ACM/IEEE 32nd

International Conference on Software Engineering,

volume 2, pages 307–308.

Montgomery, D. C. (2006). Design and Analysis of Exper-

iments. John Wiley & Sons.

Simmonds, J., Perovich, D., Bastarrica, M. C., and Sil-

vestre, L. (2015). A megamodel for software process

line modeling and evolution. In 2015 ACM/IEEE 18th

International Conference on Model Driven Engineer-

ing Languages and Systems (MODELS), pages 406–

415.

Steinberg, D., Budinsky, F., Paternostro, M., and Merks,

E. (2009). EMF: Eclipse Modeling Framework 2.0.

Addison-Wesley Professional, 2nd edition.

Vierhauser, M., Grnbacher, P., Heider, W., Holl, G., and

Lettner, D. (2012). Applying a consistency checking

framework for heterogeneous models and artifacts in

industrial product lines. In Proceedings of the 15th In-

ternational ACM/IEEE Conference on Model Driven

Engineering Languages & Systems (MODELS), Inns-

bruck, Austria.

Waltemath, D., Adams, R., Bergmann, F. T., Hucka, M.,

Kolpakov, F., Miller, A. K., Moraru, I. I., Nicker-

son, D., Sahle, S., Snoep, J. L., and Le Nov

ere, N.

(2011). Reproducible computational biology exper-

iments with sed-ml - the simulation experiment de-

scription markup language. BMC Systems Biology,

5(1):198.

Waltemath, D. and Novre, N. L. (2014). Simulation ex-

periment description markup language (sed-ml). In

Jaeger, D. and Jung, R., editors, Encyclopedia of Com-

putational Neuroscience. Springer.

MODELSWARD 2018 - 6th International Conference on Model-Driven Engineering and Software Development

378