Attachment 0-7

Ref.
Ares(2019)5444128 - 28/08/2019
D1.7: INDIVIDUAL MATERIALS MODELS

INTERFACES WITH MUPIF
Work Package WP1 (D1.7)
Lead Authors (Org) B. Patzák (CTU), V. Šmilauer (CTU)

Contributing Author(s) (Org) All
Reviewers (Org) S. Belouettar (LIST), V.Regnier (e-Xstream)
Due Date 31-08-2019
Date 31-08-2019
Version V2.0
D1.7: INDIVIDUAL MATERIALS MODELS INTERFACES WITH MuPIF

Dissemination level
PU: Public X
PP: Restricted to other programme participants
RE: Restricted to a group specified by the consortium
CO: Confidential, only for members of the consortium
Versioning and contribution history
Version Date Author Notes
v1.0 06-05-2019 B. Patzák, V. Šmilauer Initial draft

v1.1 08-07-2019 V. Šmilauer Revised version
Incorporated partner
v1.2 10-08-2019 B. Patzák, V. Šmilauer
contributions
v1.3 16-08-2019 S. Belouettar, V.Regnier Internal Review
v2.0 25-08-2019 B. Patzák Final version
Disclaimer:
This document’s contents are not intended to replace consultation of any applicable legal
sources or the necessary advice of a legal expert, where appropriate. All information in
this document is provided “as is” and no guarantee or warranty is given that the information
is fit for any particular purpose. The user, therefore, uses the information at its
sole risk and liability. For the avoidance of all doubts, the European Commission has no
liability in respect of this document, which is merely representing the authors’ view.

TABLE OF CONTENTS
Versioning and contribution history .....................................................................................................................2

Disclaimer: ............................................................................................................................................................2
Task and Deliverable descriptions from the project proposal ..............................................................................5
Compliance with the work-programme NMBP-23-2016 ......................................................................................6
Executive Summary...............................................................................................................................................6
Introduction ..........................................................................................................................................................7
Interaction of individual models in simulation layer ............................................................................................8
Model API........................................................................................................................................................... 10
Models in Composelector .................................................................................................................................. 12
Models related to Airbus case........................................................................................................................ 12
Models related to GoodYear case .................................................................................................................. 21
Models related to DOW case ......................................................................................................................... 27
Summary ............................................................................................................................................................ 31
References ......................................................................................................................................................... 31

LIST of Figures
Figure 1: BDSS platform used in COMPOSELECTOR project and its components ....................................................8
Figure 2: From MODA to workflow implementation in MuPIF: (a) MODA workflow specification, (b) graphical
workflow editor generating executable workflow representation in python, (c) workflow execution using
remote resources (models, data sources).........................................................................................................9
Figure 3: Model and API progress overview. (Threshold levels: 30% (API Prototype), 75% (API complete and
tested), 90% (used in regular simulations)..................................................................................................... 12

Task and Deliverable descriptions from the project proposal
WP definition: The goal of WP 1 is to provide relevant data and information about material properties
to the BDSS platform. Micro-structured and macro-structured PMCs will be investigated. This will be
achieved by addressing the following objectives:
• Elaboration of materials modelling workflows.
• Integration of manufacturing process modelling within the materials modelling workflows
allowing to relate microstructures to properties and performance requirements.
• Implementation of materials modelling workflows in the ‘multiscale modelling’ framework
(MuPIF platform) as automated multi-scale and multi-field computational recipes for the
prediction of structural and thermo-physical properties of (nano)composite materials.
• Implementation of uncertainty quantification and sensitivity analysis into the framework.
Improvements to linking and coupling, as well as post-processing of materials models, with a
view to BDSS requirements regarding properties, speed and accuracy
• Development of model reduction methods approximating high-order analytical model by lower-
order models or fitting input/output data.
Task 1.7: Task 1.7 Interfacing of materials and process models into the platform using APIs (Leader: e-
Xstream). Involved partners: CTU, POLITO, UniTS, LIST, ESI.
Following task T1.1 and the rationalization of the models inputs and outputs, APIs will be set-up in order
to allow interfacing the different software with MuPIF. These APIs will be as generic as possible in order
to envisage later addition of complementary material and process modelling software tools. To
facilitate the implementation of APIs for material and process models, the templates (in form of Python
classes implementing the platform API) will be prepared.
This will cover the templates suitable for models that can be linked as a library or with the source code
(so called direct API implementation, where Python can directly communicate with the model) as well
as codes, which are available only in binary form (so called indirect, file based, API implementation).
The API will be such that different coupling modes and functionalities will be available, for example: i)
tightly coupling relying on file based data exchange and allowing sequential, asynchronous and non-
local distributed computations. ii) Iterative coupling relying on memory based data exchange and
requiring synchronous and local, distributed or not, computations. Referring to RoMM [1], the
considered process models are Fluid Mechanics, Heat Transfer and Mass Transfer. Duration: M12-M36.

D1.7: (T2.7) (T1.7) Individual materials models interfaces with MuPIF: This intermediate deliverable
presents the progress made on models’ API and interfaces.
Compliance with the work-programme NMBP-23-2016

The BDSS should enable the integration of materials modelling and business tools and databases into a
single work-flow, allowing for flexibility of application to different industrial sectors.
From the call text of NMBP 23-2016.
Executive Summary
In this intermediate deliverable, we documented the approach how existing models are integrated into
simulation platform and document individual model interfaces used in COMPOSELECTOR project for
material modeling.

Introduction
The mission of COMPOSELECTOR is to develop a Business Decision Support System (BDSS), which
integrates materials modelling, business tools and databases into the end-user’s workflow to support
the complex decision process involved in the selection and design of polymer-matrix composites.
Making the BDSS tool available to and usable by decision makers is one of the most important goals of
COMPOSELECTOR1. Models integration into a unique workflows is a stepping stone for moving BDSS
system into real life.
An overview of the Composelector BDSS platform is presented in Figure 1. The business layer (ESTECO
BeePMN tool) interacts with Material layer (Granta MI database and workflow manager system). The
interaction has been documented in D3.2. The simulation layer (MuPIF) provides an infrastructure for
defining and executing distributed simulation workflows, consisting of several linked/coupled models
designed for particular use case and KPIs. The individual models connect to the platform by
implementing standardized API, allowing for model steering, data/metadata exchange, distributed and
remote computation, monitoring, etc. as described in D2.5 and demonstrated in D2.6 on a prototypic
test. Each workflow is well documented using MODA[3], the basic workflows have been already
documented in D6.2.
In 2019, MuPIF has been substantially extended to support structured metadata on any component,
representing for example models, workflows or data. The metadata structure is defined by a schema,
metadata can be attached to any component and validated against the schema. In the MuPIF platform,
metadata are encapsulated in the individual components, so they are passed together with the data in
one consistent package.
1
https://doi.org/10.1016/j.compstruct.2018.06.121

Figure 1: BDSS platform used in COMPOSELECTOR project and its components
Interaction of individual models in simulation layer

The simulation layer is implemented on top of MuPIF integration platform allowing to create complex,
distributed, multi physics simulation workflows across the scales and processing chains by combining
existing simulation tools. The MuPIF platform provides services for allocation and execution of
simulation workflows on distributed computing resources, transparent data access and exchange, and
platform state monitoring.
The approach followed in MuPIF is based on a system of distributed, interacting objects (components)
designed to solve given problem. The individual components represent entities in the modeling domain,
including individual simulation packages, high level data, but also the workflows. The abstract classes
are introduced for all entity types in the model space, defining common interfaces (defined in D2.5)
that need to be implemented by any derived class, representing implementation of specific component.
Such interface concept allows using any derived class on a very abstract level, using common services
defined by abstract class interface, without being concerned with the implementation details. This
essentially allows to manipulate all models, data, and workflows using standardized interfaces. As the
simulation data are represented as components, all the data of the same type can be manipulated using
same generic interface. This allows the platform to be independent on particular data format/structure,
as the data components of the same type can be manipulated using same interface. Therefore, the
focus is on services provided by objects (object interfaces) and not on underlying object's data. In
addition, the distributed design allows to treat local as well as remote objects using the same interface
making the platform naturally distributed.

The interoperability with external data formats and external data repositories would require
implementing corresponding data interface (API). In case that the structure and meaning of the external
data will be described with standardized metadata schema (ontology), it would be possible to
implement generic API supporting such resources. From this point of view, the activities in EMMC [2]
towards establishing the standardized ontology for material modeling data are essential.
Building simulation workflow stems from MODA diagram, defining coupling/linking of individual models
MuPIF executable
Workflow (Python)
(a) (b) (c)
Figure 2: From MODA to workflow implementation in MuPIF: (a) MODA workflow specification, (b)
graphical workflow editor generating executable workflow representation in python, (c) workflow
execution using remote resources (models, data sources).
and data into the unique workflow, see Figure 2. The translator can either use graphical workflow
editor, allowing to set up workflow using graphical editor and generate its executable representation
or develop directly the executable representation. The executable workflow representation is Python
script built on top of platform infrastructure. It allocates the individual models, steers their execution
and performs data exchange using standardized APIs of individual components. Thanks to distributed
component architecture, the workflows can transparently use local as well as remote components.
MuPIF platform handles execution of models locally or remotely. The models are registered on a
nameserver (yellow pages), supporting grid/cloud/parallel computing, remote data exchange,
encrypted communication and security via VPN.

Model API
The integration of external simulation tools requires implementation of corresponding API, described
in detail in D2.5. The API design allows to build workflows from linked and loosely coupled models. The
platform allows integration of commercial, closed source as well as open-source codes.
The Model API is defined by Model class, inherited from MuPIFObject class. The MuPIFObject defines
the generic data structure and interface to manage object metadata, see Table 1. The class metadata
structure is defined in a standardized hierarchical (nested) JSON format, representing a schema
describing structure, value types and whether the metadata are required or not. The metadata can be
validated against the schema, exported to other formats and graphically visualized. Many metadata,
especially related to execution and model versioning are automatically generated by the platform,
remaining must be provided by the models themselves. As already mentioned, metadata are integral
part of any component, thus they are passed along the simulation chain together with data or models
in one package.
Table 1: MuPIFObject class interface
Service Description
__init__(self) Constructor. Initializes the object with internal dictionary.
getMetadata (self, key) ARGS:

- key(str, param): unique metadataID
Returns: metadata associated to key
getAllMetadata (self) Returns: dictionary of metadata
setMetadata (self, key, val) ARGS:

- val(str, param): value of any type
updateMetadata (self,dictionary) ARGS:

- dictionary (dict): Dictionary of metadata
hasMetadata (self, key) ARGS:

Returns: true if key defined, false otherwise
validateMetadata(self, template) ARGS:

- template (dict): Schema for json template
Returns: Exception if required key not found
printMetadata(self) Print all metadata
toJSONFile(self,filename) JSON serialization method.

Returns: file with JSON structure

The metadata are primarily associated with three main MuPIF components: Models, Workflows and
Components representing simulation data. The metadata schemata have been summarized in D8.6
“Metadata and interoperability standardization report”, the corresponding schemata are part of
component definitions and can be found at MuPIF git repository [1].
The interface to each model and corresponding solver is represented by a class derived from Model
class, which declares the generic model interface. The derived class, representing an interface to
specific solver, must provide an implementation of the interface. The API definitions have been
described in detail in D2.5. The Table 2 summarizes the generic model API.
Table 2: Model class interface (simplified).

Model Interface (API) Description
__init__(self, metaData) Constructor. Initializes the application.
Initialize (file, workdir, metaData, **kwargs) Initialize model, e.g. set input file, set path
getMesh (self, tstep) Returns the computational mesh for given solution step.
getField(self, fieldID, time) Returns the requested field at given time. Field is identified by
fieldID.
setField(field) Registers the given (remote) field in application.
getProperty(self, propID, time, objectID=0) Returns property identified by its ID evaluated at given time.
setProperty(self, property, objectID=0) Register given property in the application
setFunction(self, func,objectID=0) Register given function in the application
solveStep(self, tstep) Solves the problem for given time step.
finishStep(self, tstep) Called after a global convergence within a time step.
getCriticalTimeStep() Returns the actual critical time step increment.
getAssemblyTime(tStep) Returns assembly time within a timestep
getApplicationSignature() Returns the application identification
terminate() Terminates the application.
The data exchange with the model is performed using generic get/set methods. The data in MuPIF are
represented by components. Thus data exchange consists of component exchange between models.
The data components have standardized interface declared by corresponding parent class allowing to
manipulate data of the same type via the same interface. MuPIF provides definition for properties,
domain discretizations, spatial fields and particle sets, for example. Additional data types can be easily
introduced. Data components are also derived from MupifObject class inheriting the capability to
manage attached metadata defined by a corresponding schema.
The error reporting in MuPIF uses exceptions. When an error occurs within a function, it creates an

object and hands it off to the runtime system. The object, called an exception object, contains
information about the error, including its type and the state of the program when the error occurred.
Creating an exception object and handling it to the runtime system is called throwing an exception.
Exceptions in general have some advantages over traditional error reporting and handling. They allow
separating the details of what to do when an error occurs from the main logic of a program. A second
advantage of exceptions is the ability to propagate an error reporting up the call stack of the methods.
Because all exceptions thrown within a program are objects, the grouping or categorizing of exceptions
is a natural outcome of the class hierarchy. The new class APIException, defined as a part of MuPIF API,
is designed to be a base class for all exceptions thrown by platform components. The MuPIF handles
the exceptions transparently over the network. The exceptions thrown by remote objects are raised in
the caller, as if they were local and one can extract detailed remote trace back information. The
individual workflow catches the potential exceptions thrown by individual models. The information on
workflow execution is available to the workflow manager at the materials layer.
Models in Composelector
Figure 3 contains an overview of individual models/solvers used in COMPOSELECTOR project, together
with their implementation and integration status, see also D6.2 (MODA Workflows, including Models
required, Input/output data required, Linking/coupling required) and D8.5 (Software quality
management report). The details of individual solver APIs are reported in subsequent paragraphs.
Figure 3: Model and API progress overview. (Threshold levels: 30% (API Prototype), 75% (API
complete and tested), 90% (used in regular simulations).
All the APIs are implemented and functional. Their integration into workflows and BDSS depends
on progress in individual use cases. The most developed use case is the Airbus case, where all
workflows are available and integration within BDSS has been performed and demonstrated.

Models related to Airbus case
Atomistic model (LAMMPS)
Model type and Atomistic model: Classical molecular dynamics (MD)

name
Description Model simulating epoxy resin and delivering Young’s modulus …

Geometry -
User Defined Resin type – description, representation
Inputs SMILE molecular structure of resin– description, representation
filler type– description, representation
filler functionalization– description, representation
filler volume/weight fraction– description, representation
filler dimensions– description, representation
filler aspect ratio– description, representation
filler/polymer compatibilizer– description, representation
Fixed Inputs Potentials of …
Outputs Elastic properties of the matrix (Young modulus and Poisson ratio)
Solver name, LAMMPS (http://lammps.sandia.gov), version 7 Aug 2019, LGPL
version, licence
MuPIF nameserver LAMMPS.JobManager@UseCase1
ID
Model metadata {
'Name': 'LAMMPS MD',
'ID': 'LAMMPS',
'Description': 'Molecular dynamic simulation to determine elastic and thermal properties
of composite',
'Inputs': [ {'Description': 'ResinType (SMILE molecular structure)', 'Name': 'ResinType',

'Origin': 'Simulated', 'Required': True, 'Type': 'mupif.Property', 'Type_ID':
'mupif.PropertyID.PID_SMILE_MOLECULAR_STRUCTURE, 'Units': ''},
{'Name': 'Resin molecular weight', 'Required': True, 'Type': 'mupif.Property',
'Type_ID': 'mupif.PropertyID.PID.PID_MOLECULAR_WEIGHT', 'Units': 'mol'},
{'Name': 'Polydispersity Index', 'Required': True, 'Type': 'mupif.Property',
'Type_ID': 'mupif.PropertyID.PID_PID_POLYDISPERSITY_INDEX', 'Units': ''},
{'Name': 'Crosslinker type', 'Required': True, 'Type': 'mupif.Property',
'Type_ID': 'mupif.PropertyID.PID_PID_CROSSLINKER_TYPE', 'Units': ''},
{'Name': 'Filler type', 'Required': True, 'Type': 'mupif.Property', 'Type_ID':
'mupif.PropertyID. PID_FILLER_DESIGNATION', 'Units': ''},
{'Name': 'Modifier molecular structure', 'Required': True, 'Type':
'mupif.Property', 'Type_ID':
'mupif.PropertyID.PID_PID_SMILE_FILLER_MOLECULAR_STRUCTURE', 'Units': ''},
{'Name': 'Crosslinking density’, 'Required': True, 'Type': 'mupif.Property',
'Type_ID': 'mupif.PropertyID. PID_CROSSLINKONG_DENSITY', 'Units': 'kg/m^3'}

{'Name': 'Filler concentration’, 'Required': True, 'Type': 'mupif.Property',
'Type_ID': 'mupif.PropertyID. PID_FILLER_CONCENTRATION', 'Units': '’}
{'Name': 'Functionalization density’, 'Required': True, 'Type': 'mupif.Property',
'Type_ID': 'mupif.PropertyID. PID_DENSITY_OF_FUNCTIONALIZATION', 'Units':
'kg/m^3'}
{'Name': 'Temperature’, 'Required': True, 'Type': 'mupif.Property', 'Type_ID':
'mupif.PropertyID.PID_TEMPERATURE', 'Units': 'K'}
{'Name': Pressure, 'Required': True, 'Type': 'mupif.Property', 'Type_ID':
'mupif.PropertyID.PID_PRESSURE', 'Units': 'Pa'}],
'Outputs': [ 'Name': 'Density', 'Origin': 'Simulated', 'Type': 'mupif.Property', 'Type_ID':

'mupif.PropertyID.PID_DENSITY', 'Units': 'g/cm^3'},
{'Name': 'Young modulus’, 'Type': 'mupif.Property', 'Type_ID':
'mupif.PropertyID.PID_EModulus', 'Units': ‘GPa'},
{'Name': 'Effective conductivity', 'Type': 'mupif.Property', 'Type_ID':
'mupif.PropertyID.PID_effective_conductivity', 'Units': 'W/m/K'},
{'Name': 'Poisson ratio', 'Type': 'mupif.Property', 'Type_ID':
'mupif.PropertyID.PID_PoissonRatio', 'Units': ''},
{'Name': 'Transistion temperature', 'Type': 'mupif.Property', 'Type_ID':
'mupif.PropertyID.PID_TRANSISTION_TEMPERATURE', 'Units': 'K'}],
'Physics': {'Entity': 'Atom', 'Type': 'Atomistic’},

'Solver': { 'Accuracy': 'High',
'Complexity': 'High',
'Creator': 'LAMMPS',
'Documentation': 'LAMMPS documentation',
'Estim_comp_time_s': 1E7,
'Estim_execution_cost_EUR': 30,
'Estim_personnel_cost_EUR': 100,
'Estim_time_step_s': ‘’,
'Language': 'C++',
'License': ‘GPL',
'Required_expertise': 'High',
'Robustness': 'High',
'Sensitivity': 'Low',
'Software': 'LAMMPS (7 Aug 2019)',
'Type': 'Classical molecular dynamics (MD) code',
'Version_date': '07/08//2019'}
Additional notes -
Continnum model (Digimat MF)

Model type and name Continuum model. Mean Field Homogenization.
Description The mechanical properties for the composite (Matrix + Fiber) are
computed using mean field homogenization.
Geometry No geometry
User Defined Inputs Matrix properties: Young modulus, poisson ratio
Fiber properties: Young modulus, poisson ratio

Volume fraction of Fiber
Aspect ratio of Fiber
Fixed Inputs
Outputs Composite properties: Axial Young modulus, In-plane Young modulus, In-
plane Poisson ratio, Transverse Poisson ratio, In-plane shear modulus,
Transverse shear modulus, density
Solver name, version, licence Digimat-MF-2018.1, commercial license
MuPIF nameserver ID eX_DigimatMF_JobManager
Model metadata { 'Date_time_start': '2019-08-14 08:44:52',
'Description': 'Mean Field Homogenization for Airbus case',
'Execution': {'ID': '1', 'Task_ID': '1', 'Use_case_ID': '1_1'},
'Hostname': 'centos7-dev.e-xstream.local',
'ID': 'N/A',
'Inputs': [ {'Description': 'Time step', 'Name': 'Time step', 'Origin':
'Simulated', 'Required': True, 'Type': 'mupif.Property', 'Type_ID':
'mupif.PropertyID.PID_Time_step', 'Units': 's'},
{'Name': 'Young matrix', 'Required': True, 'Type':
'mupif.Property', 'Type_ID': 'mupif.PropertyID.PID_MatrixYoung', 'Units':
'MPa'},
{'Name': 'Young inclusion', 'Required': True, 'Type':
'mupif.Property', 'Type_ID': 'mupif.PropertyID.PID_InclusionYoung',
'Units': 'MPa'},
{'Name': 'Poisson ratio matrix', 'Required': True, 'Type':
'mupif.Property', 'Type_ID': 'mupif.PropertyID.PID_MatrixPoisson', 'Units':
''},
{'Name': 'Poisson ratio inclusion', 'Required': True, 'Type':
'mupif.Property', 'Type_ID': 'mupif.PropertyID.PID_InclusionPoisson',
'Units': ''},
{'Name': 'Aspect ratio inclusion', 'Required': True, 'Type':
'mupif.Property', 'Type_ID': 'mupif.PropertyID.PID_InclusionAspectRatio',
'Units': ''},
{'Name': 'Volume fraction inclusion', 'Required': True, 'Type':
'mupif.PropertyID.PID_InclusionVolumeFraction', 'Units': ''}],
'Name': 'DigimatApplication',
'Outputs': [ {'Description': 'Cummulative time', 'Name': 'Cummulative
time', 'Origin': 'Simulated', 'Type': 'mupif.Property', 'Type_ID':
'mupif.PropertyID.PID_Time', 'Units': 's'},
{'Name': 'Composite Axial Young', 'Type': 'mupif.Property',
'Type_ID': 'mupif.PropertyID.PID_CompositeAxialYoung', 'Units': 'MPa'},
{'Name': 'Composite In-plane Young', 'Type': 'mupif.Property',
'Type_ID': 'mupif.PropertyID.PID_CompositeInPlaneYoung', 'Units':
'MPa'},
{'Name': 'Composite In-plane Shear', 'Type': 'mupif.Property',
'Type_ID': 'mupif.PropertyID.PID_CompositeInPlaneShear', 'Units':
'MPa'},
{'Name': 'Composite Transverse Shear', 'Type':
'mupif.PropertyID.PID_CompositeTransverseShear', 'Units': 'MPa'},

{'Name': 'Composite In-plane Poisson ratio', 'Type':
'mupif.PropertyID.PID_CompositeInPlanePoisson', 'Units': 'MPa'},
{'Name': 'Composite Transverse Poisson ratio', 'Type':
'mupif.PropertyID.PID_CompositeTransversePoisson', 'Units': 'MPa'}],
'Physics': {'Entity': 'Other', 'Type': 'Continuum'},
'Complexity': 'Low',
'Creator': 'Vincent Regnier',
'Documentation': 'See Digimat official documentation',
'Estim_comp_time_s': 1.0,
'Estim_execution_cost_EUR': 1.0,
'Estim_personnel_cost_EUR': 1.0,
'Estim_time_step_s': 1.0,
'Language': 'C++',
'License': 'Commercial',
'Required_expertise': 'None',
'Sensitivity': 'High',
'Software': 'Digimat-MF-2018.1',
'Type': 'Mean Field Homogenization',
'Version_date': '05/2019'},
'Status': 'Initialized',
'Username': 'root'}
Additional notes
Continuum model (MUL2)

Model type and name Continuum model: MUL2-FEM
Description Computation of the displacement, strain and stress fields, and buckling
load via linear static analysis.
Geometry Provided by Airbus
User Defined Inputs Orthotropic material properties
Fixed Inputs Geometry and boundary conditions
Outputs Buckling load and buckling shape
Solver name, version, licence MUL2
MuPIF nameserver ID MUL2.JobManager@UseCase1
Model metadata ClassName:'mul2code'
{ 'Date_time_start': '2019-06-12 14:15:07',
'Description': 'MUL2-FEM code for structural analysis',
'Hostname': 'srvcarreralinux',
'ID': 'MUL2-ID-1',

'Inputs': [ {'Description': 'Material Property', 'Name': 'YoungModulus1',
'mupif.PropertyID.PID_YoungModulus1', 'Units': 'MPa'},
{'Description': 'Material Property', 'Name': 'YoungModulus2',
{'Description': 'Material Property', 'Name': 'YoungModulus3',
{'Description': 'Material Property', 'Name': 'PoissonRatio12',
'mupif.PropertyID.PID_PoissonRatio12', 'Units': '-'},
{'Description': 'Material Property', 'Name': 'ShearModulus12',
'mupif.PropertyID.PID_ShearModulus12', 'Units': 'MPa'},
'mupif.PropertyID.PID_ShearModulus13', 'Units': 'MPa'},
'mupif.PropertyID.PID_ShearModulus23', 'Units': 'MPa'}],
'Name': 'MUL2_FEM',
'Outputs': [ {'Description': 'First buckling load of the analyzed structure',
'Name': 'Buckling load', 'Origin': 'Simulated', 'Type': 'mupif.Property',
'Type_ID': 'mupif.PropertyID.PID_CriticalLoadLevel', 'Units': 'Nm'},
{'Description': 'Three dimensional shape of first buckling load
of the analyzed structure', 'Name': 'Buckling shape', 'Origin': 'Simulated',
'Type': 'mupif.Field', 'Type_ID': 'mupif.FieldID.FID_BucklingShape',
'Units'$ 'Physics': { 'Entity': 'Finite volume',
'Equation': ['Linearized buckling'],
'Equation_quantities': ['Stiffness matrix', 'Buckling load',
'Geometric stress matrix', 'Buckling mode vector'],
'Relation_description': ['Linear elastic'],
'Relation_formulation': ['Carrera Unified Formulation (CUF)'],
'Representation': 'Finite volumes',
'Type': 'Continuum'},
'Creator': 'MUL2 Group - IK',
'Documentation': 'NA',
'Estim_time_step_s': 1,
'Language': 'Fortran',
'License': 'LGPL',

'Required_expertise': 'Expert',
'Software': 'MUL2 FEM',
'Type': 'Finite elements',
'Version_date': '1.0 May 2019'},
'Username': 'root'}
Additional notes
Continuum model (COMSOL)

Model type and name COMSOL
Description New advanced multi-scale methods and simulation tools for composite
materials. Include manufacturing and process in the modelling to achieve
enriched material design optimisation. Include microstructure related
properties of polymer-based materials
Geometry Full scale piece
User Defined Inputs

Fixed Inputs Material propertiers (Extensional In-Plane and out of plane Stiffness, Shear In-
Plane and out of plane stiffness, Local bending stiffness), Geometry, molding
process properties
Outputs Displacement and deformation field, fiber directions, stresses
Solver name, version, licence COMSOL, (https://www.comsol.com/) commercial licence
MuPIF nameserver ID INSAServer
Model metadata 'Name': 'Enriched continuum model',

'ID': 'N/A',
'Description': 'New advanced multi-scale methods and simulation
tools for composite materials. Include manufacturing and process in the modelling
to achieve enriched material design optimisation. Include microstructure related
properties of polymer-based materials',
'Physics': {
'Type': 'Other',
'Entity': 'Other'
},
'Solver': {
'Software': 'COMSOL',

'Language': 'English',
'Creator': 'Gabriele Barbagallo',
'Version_date': '05/2019',
'Type': 'COMSOL - FEM software',
'Documentation': 'See COMSOL s documentation',
'Required_expertise': 'High',
'Accuracy': 'High',
'Complexity': 'High',
'Robustness': 'Low'
},
'Inputs': [
{'Type': 'mupif.Property', 'Type_ID':
'mupif.PropertyID.PID_ExtensionalInPlaneStiffness', 'Name': 'Extensional In-
Plane Stiffness', 'Description': 'Extensional In-Plane Stiffness', 'Units': 'MPa',
'Origin': 'Simulated', 'Required': True},
'mupif.PropertyID.PID_ExtensionalOutOfPlaneStiffness', 'Name': 'Extensional
Out-Of-Plane Stiffness', 'Description': 'Extensional Out-Of-Plane Stiffness',
'Units': 'MPa', 'Origin': 'Simulated', 'Required': True},
'mupif.PropertyID.ShearInPlaneStiffness', 'Name': 'Shear In-Plane Stiffness',
'Description': 'Shear In-Plane Stiffness', 'Units': 'MPa', 'Origin': 'Simulated',
'Required': True},
'mupif.PropertyID.ShearOutOfPlaneStiffness', 'Name': 'Shear Out-Of-Plane
Stiffness', 'Description': 'Shear Out-Of-Plane Stiffness', 'Units': 'MPa', 'Origin':
'Simulated', 'Required': True},
'mupif.PropertyID.LocalBendingStiffness', 'Name': 'Local Bending Stiffness',
'Description': 'Local Bending Stiffness', 'Units': 'MPa', 'Origin': 'Simulated',
'Required': True}],
'Outputs': [
'mupif.PropertyID.PID_Time_step', 'Name': 'Time step',
'Description': 'Time step', 'Units': 's', 'Origin': 'Simulated'}]
Additional notes User modifications for change of geometry
Continuum model (VPS)

Model type and name Continuum model: VPS
Description Computation of the displacement, strain and stress fields, and buckling
load via linear static analysis.
Geometry Provided by Airbus

User Defined Inputs Orthotropic material properties
Fixed Inputs Geometry and boundary conditions
Outputs Buckling load and buckling shape
Solver name, version, licence VPS, 2.2
MuPIF nameserver ID ESI_VPS_Jobmanager_MUPIF_v2.2
Model metadata {
'Name': 'VPS buckling analysis',
'ID': 'N/A',
'Description': 'Calculate first buckling load of the AIRBUS fuselage
model',
'Model_refs_ID': ['ESI_VPS_BUCKL'],
'Inputs': [{'Type': 'mupif.Property', 'Type_ID':

'mupif.PropertyID.PID_ESI_VPS_PLY1_E0t1', 'Name': 'E0t1' ,
'Description': 'Tensile modulus 11', 'Units': 'kN/mm**2', 'Origin':
'Simulated', 'Required': True},
'mupif.PropertyID.PID_ESI_VPS_PLY1_E0t2', 'Name': 'E0t2'
, 'Description': 'Tensile modulus 22', 'Units':
'kN/mm**2', 'Origin': 'Simulated', 'Required': True},
'mupif.PropertyID.PID_ESI_VPS_PLY1_E0t3', 'Name': 'E0t3'
, 'Description': 'Tensile modulus 33', 'Units':
'mupif.PropertyID.PID_ESI_VPS_PLY1_G012', 'Name': 'G012'
, 'Description': 'Shear modulus 12' , 'Units':
'mupif.PropertyID.PID_ESI_VPS_PLY1_NU12', 'Name': 'NU12'
, 'Description': 'Poisson ratio 12' , 'Units': ' '
, 'Origin': 'Simulated', 'Required': True},
'mupif.PropertyID.PID_ESI_VPS_hPLY' , 'Name': 'Ply

thickness', 'Description': 'Ply thickness' , 'Units':
'mm' , 'Origin': 'Simulated', 'Required': True},
'mupif.PropertyID.PID_ESI_VPS_PLY1_RHO' , 'Name': 'Mass
density' , 'Description': 'Mass density' , 'Units': 'mm'
, 'Origin': 'Simulated', 'Required': True}],
'Outputs': [{'Type': 'mupif.Field' , 'Type_ID':
'mupif.FieldID.FID_ESI_VPS_Displacement' , 'Name': 'Displacement
field',
'Description': 'Displacement field', 'Units': 'mm'},
'mupif.PropertyID.PID_ESI_VPS_BUCKL_LOAD', 'Name': 'Buckling
load' , 'Description': 'Buckling load' , 'Units':
'kN/mm'}] }
Additional notes
Models related to GoodYear case

Continuum model (ComPoSTe)
Model type and name Solid continuum mechanics using finite element method,
ComPoSTe
Description Model macromodel of use case application
Geometry Use case geometry
User Defined Inputs Uniaxial Stress-strain curve data (stress axial strain, transverse strain for
determining coefficients of hyperelastic law
Fixed Inputs none
Outputs Use case KPIs: footprint, braking force
Solver name, version, licence ComPoSTe, vx.y, proprietary software
MuPIF nameserver ID ComPoSTe@Mupif.LIST
Model metadata ClassName:'ComPoSTe'
{ 'Description': 'Cummulates time steps',
'Hostname': 'melusina01',
'Physics': {'Entity': 'Other', 'Type': 'Other'},
'Creator': 'Rauchs, Giunta, Koutsawa, Bouhala',
'Documentation': 'Nowhere',
'Language': 'FORTRAN',
'License': 'LGPL',
'Required_expertise': 'Medium',

'Software': 'Finite Element Solver',
'Type': 'Summator',
Additional notes
Postprocessing (COSSMAS)
Model type and name Statistical homogenization software,
COSSMAS
Description Calculate thermal conductivity and linear elastic material parameters of
composite material
Geometry None
User Defined Inputs Thermomechanical properties of constituent phases
Volume fraction
Inclusion geometry
Fixed Inputs None
Outputs Composite elastic properties
Composite conductivity
Solver name, version, licence COSSMAS, proprietary software
MuPIF nameserver ID Cosmass@Mupif.LIST
Model metadata ClassName:'Cosmass'
{ 'Description': 'homogeneization software',
'Hostname': 'MRT-GRA-30488',
'Name': 'COSMASS statistical homogeneization for
calculating composite mechanical porperties',
'Creator': 'David Fiorelli Ahmed Makradi',
'Estim_comp_time_s': 14400.,
'Language': 'Python',
'License': 'proprietary code',
'Robustness': 'High'
'Software': 'COSMASS',
'Version_date': '04/2019',
'Type': 'Summator'},
Additional notes User modifications for …

Continuum model (Digimat-MF)
Model type and name Continuum model. Mean Field Homogenization
Description The mechanical properties for the composite (Matrix + Inclusion) are
computed using mean field homogenization.
Geometry No geometry
User Defined Inputs Matrix properties: Ogden Hyper-Elastic parameters (3 Young modulus
and 3 exponents)
Inclusion properties: Young modulus, Poisson ratio
Volume fraction of Inclusion
Fixed Inputs
Outputs Strain-Stress responses for a tensile loading at composite level:
Nominal_Strain_11-Cauchy_Stress_11 curve
Nominal_Strain_11-Nominal_Strain_22 curve
Solver name, version, licence Digimat-MF-2018.1, commercial license
MuPIF nameserver ID eX_DigimatMF_GYR_JobManager
Screenshot

'Description': 'Mean Field Homogenization for GoodYear case (SBR
with Silica)',
'ID': 'Digimat-MF-g',
{'Name': 'Ogden Modulus law matrix', 'Required': True, 'Type':
'mupif.Property', 'Type_ID': 'mupif.PropertyID.PID_MatrixOgdenModulus',
'Units': 'MPa'},
{'Name': 'Ogden Exponent for matrix', 'Required': True, 'Type':
'mupif.PropertyID.PID_MatrixOgdenExponent', 'Units': ''},
'Units': 'MPa'},
'Units': ''},

{'Name': 'Volume fraction inclusion', 'Required': True, 'Type':
'mupif.PropertyID.PID_InclusionVolumeFraction', 'Units': ''}],
'Name': 'DigimatApplicationGYR',
{'Name': 'Composite strain_11', 'Type': 'mupif.Property',
'Type_ID': 'mupif.PropertyID.PID_CompositeStrain11Tensor', 'Units': ''},
{'Name': 'Composite stress_11', 'Type': 'mupif.Property',
'Type_ID': 'mupif.PropertyID.PID_CompositeStress11Tensor', 'Units':
'MPa'}],
'Documentation': 'See Digimat official doc.',
'Estim_comp_time_s': 1,
'Language': 'C++',
'Software': 'Digimat-MF-2018.1',
'Type': 'Mean Field Homogenization',
'Username': 'root'}
Additional notes
Continuum model (Digimat-FE)

Model type and name Continuum model. Full Field
Homogenization
Description The mechanical properties for the composite (Matrix + Inclusion) are
computed using full field homogenization.
Geometry RVE with inclusion position given by MD
simulation

User Defined Inputs Matrix properties: Ogden Hyper-Elastic parameters (3 Young modulus
and 3 exponents)
Inclusion properties: Young modulus, Poisson ratio
Particle position (see class ParticleSet)
- particle x positions
- particle y positions
- particle z positions
- RVE size
- particle size
Fixed Inputs
Outputs Strain-Stress responses for a tensile loading at composite level:
Nominal_Strain_11-Cauchy_Stress_11 curve
Nominal_Strain_11-Nominal_Strain_22 curve
Solver name, version, licence Digimat-FE-2018.1, commercial license
MuPIF nameserver ID eX_DigimatFE_GYR_JobManager
Screenshot

'Description': 'Full Field Homogenization for GoodYear case (SBR with
Silica)',
'ID': 'Digimat-FE-g',
{'Name': 'Ogden Modulus law matrix', 'Required': True, 'Type':
'mupif.Property', 'Type_ID': 'mupif.PropertyID.PID_MatrixOgdenModulus',
'Units': 'MPa'},
{'Name': 'Ogden Exponent for matrix', 'Required': True, 'Type':
'mupif.PropertyID.PID_MatrixOgdenExponent', 'Units': ''},
'Units': 'MPa'},
'Units': ''},
{'Name': 'Particles set', 'Required': True, 'Type':
'mupif.ParticleSet', 'Type_ID':
'mupif.ParticleSetID.PSID_ParticlePositions', 'Units': ''}],

'Name': 'DigimatApplicationGYRFE_vrr',
{'Name': 'Composite stress_11', 'Type': 'mupif.Property',
'Type_ID': 'mupif.PropertyID.PID_CompositeStress11Tensor', 'Units':
'MPa'}],
'Documentation': 'See official doc',
'Estim_comp_time_s': 10000,
'Language': 'C++',
'Robustness': 'Medium',
'Software': 'Digimat-FE-2018.1',
'Type': 'Full Field Homogenization',
'Username': 'root'}
Additional notes
Continuum model (ABAQUS)

ABAQUS
Fixed Inputs Reference point and component for load retrieval
Outputs Use case KPIs
Solver name, version, licence ABAQUS, vx.y, comemrcial software
MuPIF nameserver ID Abaqus@Mupif.LIST
Model metadata AppName:'LIST_Abaqus_API':
ClassName:'AbaqusApp'
{ 'Description': 'multi-purpose finite element software',

'Creator': 'Dassault systemes',
'Documentation': 'extensive',
'Language': 'FORTRAN, C/C++',
'Required_expertise': 'User',
'Software': 'ABAQUS Solver using ABAQUS',
'Type': 'Summator',
'Inputs': [
{'Type': 'mupif.Property', 'Type_ID': 'MyPropertyID.PID_Hyper1',
'Name': 'E1', 'Units': 'MPa', 'Required': True}],
'Outputs': [
{'Type': 'mupif.Property', 'Type_ID': 'MyPropertyID.PID_Footprint',
'Name': 'Footprint', 'Units': 'mm**2', 'Required': True},
'MyPropertyID.PID_Braking_Force', 'Name': 'Braking Force', 'Units': 'N',
'Required': True}]
}
Additional notes No possibility to address increment computation from mupif, only results
extraction after full incremental loop computation finished
Models related to DOW case
Postprocessing (CMBSFE)
Model type and name Computational homogeneization software,
CMBSFE
Description Calculate linear elastic material parameters of composite material
Geometry RVE of composite
User Defined Inputs Linear elastic properties of constituent phases
Fixed Inputs None
Outputs Composite elastic properties
Solver name, version, licence CMBSFE, proprietary software
MuPIF nameserver ID CmbsFE@Mupif.LIST
Model metadata ClassName:'CmbsFEApp'
{ 'Description': 'homogeneization software',

'Name': 'LIST_CmbsFE_API',
'Creator': 'Koutsawa',
'Language': 'C/C++',
'Software': 'VAMUCH Solver using CMBSFE',
'Type': 'Summator',
'Inputs': [{'Type': 'mupif.Property', 'Type_ID':
'PropertyID.PID_EModulus', 'Name': 'matrixYoung', 'Units': 'MPa',
'Required': True},
'PropertyID.PID_PoissonRatio', 'Name': 'matrixPoisson', 'Units': 'none',
'Required': True},
'PropertyID.PID_YoungModulus1', 'Name': 'inclusionYoung1', 'Units':
'MPa', 'Required': True},
'PropertyID.PID_PoissonRatio12', 'Name': 'inclusionPoisson12', 'Units':
'none', 'Required': True},
'PropertyID.PID_ShearModulus12', 'Name': 'inclusionShear12', 'Units':
'MPa', 'Required': True}],

'Outputs' : [{'Type': 'mupif.Property', 'Type_ID':
'PropertyID.PID_YoungModulus1', 'Name': 'compositeYoungModulus1',
'Units': 'MPa', 'Required': True},
'PropertyID.PID_ShearModulus12', 'Name': 'compositeShearModulus12',
'PropertyID.PID_PoissonRatio12', 'Name': 'compositePoissonRatio12',
'Units': 'none', 'Required': True},
'Units': 'none', 'Required': True}]
}
Additional notes
Continuum model (ABAQUS)

ABAQUS
Fixed Inputs Reference point and component for displacement retrieval
Outputs Use case KPIs
Solver name, version, licence ABAQUS, vx.y, comemrcial software
MuPIF nameserver ID Abaqus@Mupif.LIST
Model metadata AppName:'LIST_Abaqus_API':
ClassName:'AbaqusApp'
{ 'Description': 'multi-purpose finite element software',

'Creator': 'Dassault systemes',
'Documentation': 'extensive',
'Language': 'FORTRAN, C/C++',
'Required_expertise': 'User',
'Software': 'ABAQUS Solver using ABAQUS',
'Type': 'Summator',
'Inputs' : [{'Type': 'mupif.Property', 'Type_ID':
'Units': 'none', 'Required': True}],
'Outputs' = [{'Type': 'mupif.Property', 'Type_ID':

'MyPropertyID.PID_Stiffness', 'Name': 'Footprint', 'Units': 'mm**2',
'Required': True},
'MyPropertyID.PID_maxDisplacement', 'Name': 'max. displacement',
'Units': 'mm', 'Required': True},
'MyPropertyID.PID_maxMisesStress', 'Name': 'max. von Mises Stress',
'MyPropertyID.PID_maxPrincipalStress', 'Name': 'max. principal Stress',
'Units': 'MPa', 'Required': True}]
}

Additional notes No possibility to address increment computation from mupif, only results
extraction after full incremental loop computation finished
Summary
In this deliverable, the developed and implemented APIs to material models in COMPOSELECTOR are
documented. The approach how existing models are integrated into simulation platform is described and
individual model interfaces are documented.
References
[1] What makes a material function? Let me compute the ways..., A. F. de Baas ed., Modelling in H2020 LEIT-
NMBP Programme Materials and Nanotechnology projects, Sixth version, 2017
[2] The European Material Modelling Council, https://emmc.info
[3] MODA Workflow Templates, https://emmc.info/moda-workflow-templates/
[4] B. Patzak, V. Šmilauer, S. Šulc and M. Horák, “MuPIF repository,” 2019. [Online, Available:
https://github.com/mupif/mupif].
[5] D3.2 Identification of requirements for the interaction between the business layer and the interoperability
layer and database tools, Composelector project, 2018
[6] D2.6 Integration test on prototypic simulation scenario, Composelector project, 2018.
[7] D2.5 Report on API definition for models, high-level data, and data storage platform, Composelector project,
2017

Attachment 0-7

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Attachment 0-7

Uploaded by

Copyright:

Available Formats

Ref.

D1.7: INDIVIDUAL MATERIALS MODELS

Work Package WP1 (D1.7)

Lead Authors (Org) B. Patzák (CTU), V. Šmilauer (CTU)

D1.7: INDIVIDUAL MATERIALS MODELS INTERFACES WITH MuPIF

Versioning and contribution history

Version Date Author Notes

v1.0 06-05-2019 B. Patzák, V. Šmilauer Initial draft

D1.7: INDIVIDUAL MATERIALS MODELS INTERFACES WITH MuPIF

Versioning and contribution history .....................................................................................................................2

D1.7: INDIVIDUAL MATERIALS MODELS INTERFACES WITH MuPIF

D1.7: INDIVIDUAL MATERIALS MODELS INTERFACES WITH MuPIF

D1.7: INDIVIDUAL MATERIALS MODELS INTERFACES WITH MuPIF

Compliance with the work-programme NMBP-23-2016

D1.7: INDIVIDUAL MATERIALS MODELS INTERFACES WITH MuPIF

D1.7: INDIVIDUAL MATERIALS MODELS INTERFACES WITH MuPIF

Interaction of individual models in simulation layer

D1.7: INDIVIDUAL MATERIALS MODELS INTERFACES WITH MuPIF

(a) (b) (c)

D1.7: INDIVIDUAL MATERIALS MODELS INTERFACES WITH MuPIF

Table 1: MuPIFObject class interface

__init__(self) Constructor. Initializes the object with internal dictionary.

getMetadata (self, key) ARGS:

getAllMetadata (self) Returns: dictionary of metadata

setMetadata (self, key, val) ARGS:

updateMetadata (self,dictionary) ARGS:

hasMetadata (self, key) ARGS:

validateMetadata(self, template) ARGS:

printMetadata(self) Print all metadata

toJSONFile(self,filename) JSON serialization method.

D1.7: INDIVIDUAL MATERIALS MODELS INTERFACES WITH MuPIF

Table 2: Model class interface (simplified).

__init__(self, metaData) Constructor. Initializes the application.

setField(field) Registers the given (remote) field in application.

setProperty(self, property, objectID=0) Register given property in the application

setFunction(self, func,objectID=0) Register given function in the application

solveStep(self, tstep) Solves the problem for given time step.

finishStep(self, tstep) Called after a global convergence within a time step.

getCriticalTimeStep() Returns the actual critical time step increment.

getAssemblyTime(tStep) Returns assembly time within a timestep

getApplicationSignature() Returns the application identification

terminate() Terminates the application.

D1.7: INDIVIDUAL MATERIALS MODELS INTERFACES WITH MuPIF

D1.7: INDIVIDUAL MATERIALS MODELS INTERFACES WITH MuPIF

Model type and Atomistic model: Classical molecular dynamics (MD)

Description Model simulating epoxy resin and delivering Young’s modulus …

'Inputs': [ {'Description': 'ResinType (SMILE molecular structure)', 'Name': 'ResinType',

D1.7: INDIVIDUAL MATERIALS MODELS INTERFACES WITH MuPIF

'Outputs': [ 'Name': 'Density', 'Origin': 'Simulated', 'Type': 'mupif.Property', 'Type_ID':

'Physics': {'Entity': 'Atom', 'Type': 'Atomistic’},

Continnum model (Digimat MF)

D1.7: INDIVIDUAL MATERIALS MODELS INTERFACES WITH MuPIF

D1.7: INDIVIDUAL MATERIALS MODELS INTERFACES WITH MuPIF

Continuum model (MUL2)

D1.7: INDIVIDUAL MATERIALS MODELS INTERFACES WITH MuPIF

D1.7: INDIVIDUAL MATERIALS MODELS INTERFACES WITH MuPIF

Continuum model (COMSOL)

User Defined Inputs

Outputs Displacement and deformation field, fiber directions, stresses

Solver name, version, licence COMSOL, (https://www.comsol.com/) commercial licence

MuPIF nameserver ID INSAServer

Model metadata 'Name': 'Enriched continuum model',

D1.7: INDIVIDUAL MATERIALS MODELS INTERFACES WITH MuPIF

init(self) Constructor. Initializes the object with internal dictionary.

init(self, metaData) Constructor. Initializes the application.