The MoDeNa multi-scale simulation software framework

Transcription

1 The MoDeNa multi-scale simulation software framework Henrik Rusche Wikki Ltd. Jyväskylä, 28/05/2015 p. 1

2 MoDeNa project MOdelling of morphology DEvelopment of micro- and NAnostructures Aim: Simulate production of polyurethane materials, eg. foaming p. 2

3 Forward Mapping Workflow File E File A Software A File C Software C File F File B Software B File D p. 3

4 Backward Mapping Workflow File A Software A File D File B File E Software B File D p. 4

5 'De-couple' using surrogate model File A Software A Software A File EE File File D File B File EE File File E Design of Experiments Parameter Estimation Software B Surrogate Model Y File D p. 5

6 Flow of data for backward mapping Re ci pe Parameter Estimation Fit model parameters Result of experiment Ad ap te Result of r Post-Process experiment Re ci p Model parameters e Ad Run higher scale code Model ap te Instantiate model and its r parameters Database Re ci pe Spec(s) of experiment(s) Design of Experiments (DOE) point Outside point Determine new experiment(s) Re ci p Do work r Use model iterate Ad Spec of Apply Input ap experiment te r Ad ap Outside te v Run lower scale code Catch return code & Trigger DOE e p. 7

7 Software Stack Computational Recipe Setting boundary conditions / parameters Computational Code Recipes/FireTasks Workflow state Experiment spec Simulation parameters Embedded model (MoDeNa interface library) Post-Processing Submit results for fitting C/Python bindings FireTask Design of Experiments Recipe Identify new experiments Function reference Parameters, Bounds function name/library Result of Experiment Outside Point Experiment spec Trigger execution of Computational Recipe Result of Experiment Parameter Fitting Recipe Embedded model (MoDeNa interface library) Database (MongoDB) Legend: Scripts or compiled code FireWorks Parameters Function reference p. 8

8 Software used: FireWorks Workflow: Fireworks used to define and execute recipes (FireTasks) FireTasks are Python Scripts with (dynamic) dependencies Fell out of the Materials Project (US) FireWorks is a small-ish Python Library Uses MongoDB for storage Features: Dynamic workflows Running on queueing systems Job packing Automated duplicate checking Fault tolerance and failure detection and recovery Automated job provenance Frontend interface and job reporting p. 9

9 Software used: MongoDB & R MongoDB is a Non-SQL database - Indexable BSON documents (no tables!) Used to store workflow, workflow state, surrogate models, experiments, metadata, simulation context Drivers for many languages (C, Python, ) MongoEngine is a Document-Object Mapper R is a software environment for statistical computing and graphics used as a basis for design of experiments and parameter estimation Rpy2 is a Python interface library to R p. 10

10 Low-level Interface Library Queries database to find and instantiate models in higher scale code Models are loaded from shared libraries onto function pointer Implementation in plain C for portability computational efficiency of model embedding Can be loaded as a Python extension (Dual-Use) to provide consistent access to models for design of experiments and parameter fitting Option to use library from Fortran (Fortran module) Option to use from other scripted languages through SWIG wrappers p. 11

11 High-level Interface Library Provides access to the database Stores C-code of surrogate model in database with automatic compilation Provides design of experiments and regression analysis capabilities Implementation as Python module based on MongoEngine & rpy2 Problem specific surrogate model libraries Problem specific recipes and adaptors Software runs on Linux (Ubuntu) and Mac OS X p. 12

12 MoDeNa software prototyp Prototype of software framework has been distributed to all partners Example: The discharge of air from one tank into another through a nozzle Two tanks macroscopic problem Nozzle microscopic problem Everything is kept to the bare minimum in order to reduce runtime and dependencies (e.g. no external codes) p. 13

13 Use a surrogate model in macroscopic code (1) // In macroscopic code #include "modena.h" // Instantiate a model modena_model_t *model = modena_model_new("flowrate"); if(modena_error_occurred()) { int ret = modena_error(); return ret; } // Allocate memory and fetch arg positions modena_inputs_t *inputs = modena_inputs_new(model); modena_outputs_t *outputs = modena_outputs_new(model); size_t size_t size_t size_t Dpos = modena_model_inputs_argpos(model, "D"); rho0pos = modena_model_inputs_argpos(model, "rho0"); p0pos = modena_model_inputs_argpos(model, "p0"); p1byp0pos = modena_model_inputs_argpos(model, "p1byp0"); modena_model_argpos_check(model); p. 14

14 Use a surrogate model in macroscopic code (2) while(t + deltat < tend + 1e 10) { t += deltat; // Set input vector modena_inputs_set(inputs, modena_inputs_set(inputs, modena_inputs_set(inputs, modena_inputs_set(inputs, Dpos, D); rho0pos, rho0); p0pos, p0); p1byp0pos, p1/p0); // Call the model int ret = modena_model_call(model, inputs, outputs); // Terminate, if requested if(modena_error_occurred()) { // Clean Up return modena_error(); } // Continue with normal operation } p. 15

15 Read experiment spec from microscopic code recipe def run_task(self, fw_spec): D = self['point']['d'] rho0 = self['point']['rho0'] p0 = self['point']['p0'] p1byp0 = self['point']['p1byp0'] # Write input f = open('in.txt', 'w') f.write('%g\n%g\n%g\n%g\n' % (D, rho0, p0, p1byp0)) f.close() # Execute the application # In this simple example, this call stands for a complex # microscopic code such as full 3D CFD simulation. os.system('../src/flowrateexact') # Write result of experiment from microscopic code recipe # (see next slide) p. 16

16 Write result of experiment from microscopic code recipe def run_task(self, fw_spec): # Read experiment spec from microscopic code recipe # (see previous slide) # Execute the application # In this simple example, this call stands for a complex # microscopic code such as full 3D CFD simulation. os.system('../src/flowrateexact') # Analyse output f = open('out.txt', 'r') self['point']['flowrate'] = float(f.readline()) f.close() return FWAction(mod_spec=[{'_push': self['point']}]) p. 17

17 Surrogate function definition (1) surrogatefunction = CFunction( Ccode= ''' #include "math.h" void two_tank_flowrate ( const double* parameters, const double* inputs, double *outputs ) { const double D = inputs[0]; const double rho0 = inputs[1]; const double p0 = inputs[2]; const double p1 = p0*inputs[3]; const double P0 = parameters[0]; const double P1 = parameters[1]; outputs[0] = M_PI*pow(D, 2.0)*P1*sqrt(P0*rho0*p0); } ''', p. 18

18 Surrogate function definition (2) f = CFunction( Ccode= ''' # Some C code } ''', # These are global bounds for the function inputs={ 'D': { 'min': 0, 'max': 9e99, 'argpos': 0 }, 'rho0': { 'min': 0, 'max': 9e99, 'argpos': 1 }, 'p0': { 'min': 0, 'max': 9e99, 'argpos': 2 }, 'p1byp0': { 'min': 0, 'max': 1.0, 'argpos': 3}, }, outputs={ 'flowrate': { 'min': 9e99, 'max': 9e99, 'argpos': 0 }, }, parameters={ 'param0': { 'min': 0.0, 'max': 10.0, 'argpos': 0 }, 'param1': { 'min': 0.0, 'max': 10.0, 'argpos': 1 }, }, ) p. 19

19 Surrogate model definition surrogatemodel = BackwardMappingModel( _id= 'flowrate', surrogatefunction= surrogatefunction, exacttask= FlowRateExactSim(), substitutemodels= [ ], initialisationstrategy= Strategy.InitialPoints( initialpoints= { 'D': [0.01, 0.01, 0.01, 0.01], 'rho0': [3.4, 3.5, 3.4, 3.5], 'p0': [2.8e5, 3.2e5, 2.8e5, 3.2e5], 'p1byp0': [0.03, 0.03, 0.04, 0.04], }, ), outofboundsstrategy= Strategy.ExtendSpaceStochasticSampling( nnewpoints= 4 ), parameterfittingstrategy= Strategy.NonLinFitWithErrorContol( # Some controls ), ) p. 20

20 Current workflow p. 21

21 Representative link p. 22

22 Where to find the code? Where to find the code? Public project: github.com//modena-euproject/modena Tar-ball downloads: modenaproject.eu p. 23

23 Questions? p. 24