Coupling OpenFOAM and MBDyn with precice coupling tool

Transcription

1 Cite as: Folkersma, M.: Coupling OpenFOAM and MBDyn with precice coupling tool. In Proceedings of CFD with OpenSource Software, 2018, Edited by Nilsson. H., CFD with OpenSource software A course at Chalmers University of Technology Taught by Håkan Nilsson Coupling OpenFOAM and MBDyn with precice coupling tool Developed for foam-extend 3.2 Requires: FOAM-FSI, precice, MBDyn and GMSH Author: Mikko Folkersma Delft University of Technology m.a.m.folkersma@tudelft.nl Peer reviewed by: Anand Ramesh Babu Mohammad Arabnejad Licensed under CC-BY-NC-SA, Disclaimer: This is a student project work, done as part of a course where OpenFOAM and some other OpenSource software are introduced to the students. Any reader should be aware that it might not be free of errors. Still, it might be useful for someone who would like learn some details similar to the ones presented in the report and in the accompanying files. The material has gone through a review process. The role of the reviewer is to go through the tutorial and make sure that it works, that it is possible to follow, and to some extent correct the writing. The reviewer has no responsibility for the contents. January 21, 2019

2 Learning outcomes The reader will learn: How to use it: how to use precice coupling tool how to run multiphysics simulations with precice coupling tool The theory of it: what is a precice adapter and how to implement one How it is implemented: short introduction to the tools that are used for the coupling How to modify it: how to implement a MBDyn adapter to precice. 1

3 Prerequisites The reader is expected to know the following in order to get maximum benefit out of this report: Basic OpenFOAM usage Basic knowledge of Python programming language Basics of fluid-structure interaction (FSI) 2

4 Contents 1 Introduction MBDyn FOAM-FSI library precice precice adapter for MBDyn 6 3 Test problem MBDyn settings FOAM-FSI settings precice settings Results Conclusions 16 3

5 Chapter 1 Introduction In this work, we show how to couple OpenFOAM (foam-extend) and MBDyn [5] softwares with precice coupling tool [2] to form a strongly coupled fluid-structure interaction (FSI) framework for membrane structures. We use an already existing precice adapter for foam-extend and we develop an adapter for MBDyn in this work. The coupled FSI framework is verified by carrying out a simulation on a modified cavity test case which has a flexible membrane at the bottom of the domain. The results are compared with the results of other authors. The solvers and the coupling tool are introduced here briefly. 1.1 MBDyn MBDyn [5] is a multibody dynamics software which supports both rigid and flexible bodies. In this work, we use only the flexible membrane elements to model thin structures which have negligible bending stiffness. MBDyn supports 4-node quadrilateral membrane elements with large (non-linear) displacements which are based on formulation by Witkowski [8]. The supported material models are linear isotropic and orthotropic. The source code can be downloaded from MBDyn s website Download. The membrane elements require an additional UMFPACK package. On Ubuntu system, it is part of the libsuitesparse-dev package which can be installed by executing following command sudo apt install libsuitesparse-dev and by defining the path of the library when executing the configure script CPPFLAGS=-I/usr/include/suitesparse./configure make After the library has been compiled the location of the MBDyn Python interface should be added to $PYTHONPATH environmental variable. If MBDyn is installed to the default location then following path should be added to the environmental variable export PYTHONPATH=$PYTHONPATH:/usr/local/mbdyn/libexec/mbpy 1.2 FOAM-FSI library FOAM-FSI is an FSI extension to the foam-extend project (version 3.2) developed by Blom et al. [1]. In this work, we mainly use the radial-basis function (RBF) based mesh deformation and the precice adapter of the library. The library can be installed by downloading the GitHub repository from and by following the installation guide in it. 4

6 1.3. PRECICE CHAPTER 1. INTRODUCTION 1.3 precice Coupling tool precice [2] allows to couple arbitrary amount of solvers to form a partitioned multiphysics framework. FOAM-FSI library includes an old version of precice which is compiled in its installation script. However, a small change is required in the compile precice script (FOAM- FSI/src/thirdParty/compile precice) to compile the Python interface. The Python flags in the file should be changed from python=false to python=true. To carry out a multiphysics simulations with precice, an adapter for each participant solver is required. The adapter is a small piece of code which interfaces the participating solvers with precice. It can be written in any of the supported languages (C/C++, Fortran and Python) and usually requires only minimal changes to the solver s source code, if any at all. In the following Chapter 2, we show how to develop such an adapter for MBDyn. Additionally, a configuration file is required for precice. The configuration file is a simple XML-file which defines the participant solvers, interface meshes, mapping schemes for non-conforming meshes and coupling schemes. An example of a configuration file is given in Chapter 3. 5

7 Chapter 2 precice adapter for MBDyn Although MBDyn is written in C++ programming language, we use the Python interface to couple it with precice. The source code consists of two files, adapter.py and helper.py. Each file has one class declaration: MBDynAdapter and MBDynHelper. MBDynHelper class contains all the functionality to interact with MBDyn and MBDynAdapter is the actual precice adapter. The main member functions of MBDynHelper are following: readmsh (filename): Reads GMSH file (.msh) and creates a Mesh container which has the information about the mesh nodes, the connectivity and the named regions. initializembdyn(): Calls writembdynscript function, executes MBDyn and gives the path to the MBDyn script file as a parameter, creates the MBDyn Python interface, initializes the socket connection to MBDyn. writembdynscript(filename): Writes out the MBDyn script file. The script depends on the Mesh container and two dictionaries: controldict and materialdict. getcellcenters(): Splits each quadrangle element into two triangles and returns their face center coordinates. getnodes(): Returns the current node coordinates of the mesh. setloads(pressure, stresses): Sets the distributed loads. Either uniform loads or an array of loads can be given for each element s face center. Pressure acts always to the normal of each elements face. Stresses are vectors. calcloads(): MBDyn does not support distributed loads so the nodal forces are calculated in this function. solve(converged): Calls calcloads function and executes MBDyn. If converged parameter is set to True then move to the next time step, otherwise continues the current same time step. writevtk(): Writes out a VTK file. The MBDynAdapter class consists of two member functions. The constructor function ( init ) initializes MBDyn and precice. It is given by 1 def init (self, mbdhelper, configfilename = "precice.xml"): 2 self.mbd = mbdhelper 3 self.intf = precice.pysolverinterface("structure_solver", 0, 1) 4 self.intf.configure(configfilename) 5 self.dim = self.intf.getdimensions() 6 nodes = self.mbd.getnodes() 7 6

8 CHAPTER 2. PRECICE ADAPTER FOR MBDYN 8 if self.dim == 2: 9 self.nodesid = np.where(nodes[:,2] < 1e-6) 10 nodes = nodes[self.nodesid] 11 self.nnodes = len(nodes) nmeshid = self.intf.getmeshid("structure_nodes") 14 self.nodevertexids = self.nnodes*[0.0] 15 self.intf.setmeshvertices(nmeshid, self.nnodes,\ 16 np.ravel(nodes[:,:self.dim]), self.nodevertexids) ccs = self.mbd.getcellcenters() 19 self.ncells = len(ccs) 20 cmeshid = self.intf.getmeshid("structure_cellcenters") 21 self.cellvertexids = self.ncells*[0.0] 22 self.intf.setmeshvertices(cmeshid, self.ncells,\ 23 np.ravel(ccs[:,:self.dim]), self.cellvertexids) self.stressesid = self.intf.getdataid("stresses", cmeshid) 26 self.displacementsid = self.intf.getdataid("displacements", nmeshid) self.dt = self.intf.initialize() 29 self.mbd.controldict["timestep"] = self.dt 30 self.mbd.initializembdyn() self.displacements = np.array(self.dim*self.nnodes*[0.0]) if (self.intf.isactionrequired(precice.pyactionwriteinitialdata())): 35 self.intf.writeblockvectordata(self.displacementsid, self.nnodes,\ 36 self.nodevertexids, self.displacements) 37 self.intf.fulfilledaction(precice.pyactionwriteinitialdata()) self.intf.initializedata(); self.stresses = np.array(self.dim*self.ncells*[0.0]) if (self.intf.isreaddataavailable()): 44 self.intf.readblockvectordata(self.stressesid, self.ncells,\ 45 self.cellvertexids, self.stresses) The function takes two parameters mbdhelper and configfilename (line 1). mbdhelper is an instance of MBDynHelper class which initializes the MBDyn case and configfilename is the path to the precice configuration file. The precice interface is created in line 3. The PySolverInterface object takes as an argument the solver name which is defined in the configuration file. In this case it refers to MBDyn. This adapter works only in serial mode and therefore the other two parameters, rank and size are set to 0 and 1. Two meshes are used at the interface. MBDyn calculates the displacements at the nodes and the adapter calculates the nodal forces from the stresses that are acting at the face centers (CellCenters). In case of quasi two-dimensional problem such as the present test problem 3, the nodes outside z = 0 plane and the z-coordinates of the nodes are deleted (lines 8-10). The nodes and the face center coordinates are passed to the precice interface as one-dimensional arrays (lines 15-23). The displacements array is initialized with zero values and passed to the precice interface (lines 34-39). The initial stresses are read from the interface (lines 43-45). The runprecice member function begins the simulation. The function is given by 7

9 CHAPTER 2. PRECICE ADAPTER FOR MBDYN 1 def runprecice(self): 2 iteration = 0 3 previousdisplacements = self.mbd.getdisplacements() 4 while (self.intf.iscouplingongoing()): 5 if (self.intf.isactionrequired(precice.pyactionwriteiterationcheckpoint())): 6 self.intf.fulfilledaction(precice.pyactionwriteiterationcheckpoint()) 7 8 if self.dim == 2: 9 s = np.zeros((self.ncells,3)) 10 s[:,:self.dim] = np.reshape(self.stresses,(-1,self.dim)) 11 else: 12 s = np.reshape(self.stresses,(-1,3)) 13 self.mbd.setloads(0,s) if self.mbd.solve(false): 16 break displacements = self.mbd.getdisplacements() 19 reldisplacements = displacements - previousdisplacements 20 if self.dim == 2: 21 reldisplacements = displacements[self.nodesid][:,:self.dim] 22 self.intf.writeblockvectordata(self.displacementsid, self.nnodes,\ 23 self.nodevertexids, np.ravel(reldisplacements)) self.intf.advance(self.dt) 26 self.intf.readblockvectordata(self.stressesid, self.ncells,\ 27 1self.cellVertexIDs, self.stresses) if (self.intf.isactionrequired(precice.pyactionreaditerationcheckpoint())): 30 self.intf.fulfilledaction(precice.pyactionreaditerationcheckpoint()) 31 else: 32 previousdisplacements = displacements.copy() 33 iteration += 1 34 if self.mbd.solve(true): 35 break 36 if iteration % self.mbd.controldict["output frequency"] == 0: 37 self.mbd.writevtk(iteration) 38 mbd.finalize() FOAM-FSI works with relative displacements to the previous time step and therefore the initial displacements are saved (Line 3). The main iteration loop of the simulation is a while loop with an end condition that asks from the precice interface if the simulation should still continue (line 4). In implicit coupling the initial state of the time step is saved (lines 5-6). MBDyn does not have save/recover solution functionality and therefore nothing is saved. The implicit coupling is handled by a simple boolean parameter which is passed with the solve function call (Line 15). MBDyn works only with three-dimensional space coordinates and therefore the stresses have to be also always given in three-dimension (lines 8-10). Also, the third-dimension is removed from the displacements array (lines 20-21). The stress loads are set with setloads function (line 13) and the solution is calculated with solve function (15-16) which takes one boolean parameter. The False parameter means that the solver did not converge in the previous iteration and the True parameter means that the solver has converged and MBDyn will start a new time step. If the return value of the solve function is True then the socket connection to MBDyn has been lost. The resulting displacements are read from the MBDyn solver and passed to the precice interface (lines 18-23). The advance function communicates the coupling data (line 25) and the new stresses are read 8

10 CHAPTER 2. PRECICE ADAPTER FOR MBDYN from the interface (line 26-27). At the end of the loop, the convergence of the implicit coupling is checked (lines 29-37). If the solver has converged, the solve function is called with True parameter and the output is written to the disk (lines 31-37). The adapter can be used in any location by adding the mbdynadapter folder to $PYTHONPATH environmental variable. 9

11 Chapter 3 Test problem We verify the MBDyn adapter implementation by carrying out a modified cavity flow test problem. The problem is shown in Figure 3.1. In the conventional cavity test case, the top wall of the square has a constant velocity and the three other walls have zero velocity. In this modified version, the bottom wall is a flexible membrane which deforms. Additionally, the top part of the left wall has an inflow with linear velocity profile and the top part of the right wall has a small outflow. The velocity of the top wall and the inlet is changing sinusoidally which is given by ( ) 2πt v = 1 cos (3.1) 5 v=v x v=v, x v=0 y p= v=0 x v=0 y v=0 x v=0 y v= 0, v= 0 x y bottommembrane Figure 3.1: Modified cavity problem with membrane [7]. The directory tree of the problem is following 10

12 3.1. MBDYN SETTINGS CHAPTER 3. TEST PROBLEM Allclean Allrun fluid 0 p U constant couplingproperties dynamicmeshdict fsi.yaml polymesh blockmeshdict precice.xml transportproperties turbulenceproperties system controldict fvschemes fvsolution structure cavityfsi.py membrane.geo precice.xml ->../fluid/constant/precice.xml 3.1 MBDyn settings The structural mesh is generated with GMSH software [4]. Although the problem could be solved by using one-dimensional beam elements, we are using membrane elements and therefore the mesh is two-dimensional and expands in z-direction. The mesh is divided into 23 cells in x-direction. The boundary conditions for the structure are given in the GMSH script file by giving names for the physical entities. Following names are recognized: fixx, fixy, fixz, fixxy, fixxz, fixyz, fixall. The membrane.geo file located in the case directory is given as follows Point(1) = {0, 0, 0, 1}; Point(2) = {1, 0, 0, 1}; Point(3) = {1, 0, 1, 1}; Point(4) = {0, 0, 1, 1}; Line(1) = {1, 2}; Line(2) = {2, 3}; Line(3) = {3, 4}; Line(4) = {4, 1}; Line Loop(6) = {1, 2, 3, 4}; Plane Surface(6) = {6}; Transfinite Surface {6}; Transfinite Line {1,3} = 24 Using Progression 1; Transfinite Line {2,4} = 2 Using Progression 1; Recombine Surface {6}; Physical Line("fixAll") = {2,4}; Physical Surface("Membrane") = {6}; The Python script (cavityfsi.py) for the MBDyn adapter is following 1 from mbdynadapter import MBDynHelper, MBDynAdapter 2 mbd = MBDynHelper() 3 mbd.readmsh('membrane.msh') 4 mbd.controldict = {'initialtime':0,'finaltime':100,'output frequency':10} 11

13 3.2. FOAM-FSI SETTINGS CHAPTER 3. TEST PROBLEM 5 mbd.materialdict = {'E':250, 'nu':0, 't':0.002, 'rho':500, 'C': } 6 adapter = MBDynAdapter(mbd) 7 adapter.runprecice() where E is the Young s modulus, nu is the Poisson s ratio (ν), t is the thickness, rho is the density (ρ) of the membrane and C is the damping coefficient. 3.2 FOAM-FSI settings The CFD mesh for the fluid is generated with the blockmesh utility which is part of the foam-extend package. blockmesh generates structured multi-block hexahedron meshes and it is controlled by a dictionary file blockmeshdict which is located in fluid/constant/polymesh/ folder. The mesh for the cavity case is a simple cartesian mesh which is divided in two blocks for the two boundary conditions at the side walls. The sinusoidally changing velocity boundary condition is implemented by using groovybc library which is also part of the foam-extend package. The velocity boundary conditions for inlet, top wall and bottom wall are given in file fluid/0/u as follows inlet { type groovybc; valueexpression "vector((pos().y-0.875)/0.125*(1.0-cos(2.0*pi*time()/5.0)),0.0,0.0)"; value uniform (0 0 0); } movingwall { type groovybc; valueexpression "vector(1.0-cos(2.0*pi*time()/5.0),0.0,0.0)"; value uniform (0 0 0); } bottomwall { type mymovingwallvelocity; value uniform (0 0 0); } For moving walls, FOAM-FSI has a mymovingwallvelocity boundary condition. Radial basis function based mesh deformation algorithm with adaptive coarsening is used. The mesh deformation settings are defined in fluid/constant/dynamicmeshdict as follows dynamicfvmesh dynamicmotionsolverfvmesh; solver ElRBFMeshMotionSolver; movingpatches ( bottomwall ); staticpatches ( inlet outlet movingwall fixedwalls ); coarseningstrategy AdaptiveCoarsening; interpolation { function TPS; } AdaptiveCoarsening { tol 1e-3; reselectiontol 1e-2; minpoints 100; maxpoints 500; } 12

14 3.3. PRECICE SETTINGS CHAPTER 3. TEST PROBLEM 3.3 precice settings In addition a precice configuration file is needed which is placed for to fluid/constant/precice.xml. The configuration file of the present problem is given by 1 <?xml version="1.0"?> 2 <precice-configuration> 3 4 <solver-interface dimensions="2"> 5 6 <data:vector name="stresses" /> 7 <data:vector name="displacements" /> 8 9 <mesh name="fluid_nodes"> 10 <use-data name="displacements" /> 11 </mesh> <mesh name="fluid_cellcenters"> 14 <use-data name="stresses" /> 15 </mesh> <mesh name="structure_nodes"> 18 <use-data name="displacements" /> 19 </mesh> 20 <mesh name="structure_cellcenters"> 21 <use-data name="stresses" /> 22 </mesh> <participant name="fluid_solver"> 25 <use-mesh name="fluid_nodes" provide="yes" /> 26 <use-mesh name="fluid_cellcenters" provide="yes" /> 27 <use-mesh name="structure_nodes" from="structure_solver" /> 28 <use-mesh name="structure_cellcenters" from="structure_solver" /> 29 <write-data mesh="fluid_cellcenters" name="stresses" /> 30 <read-data mesh="fluid_nodes" name="displacements" /> 31 <mapping:rbf-thin-plate-splines direction="read" from="structure_nodes" 32 to="fluid_nodes" constraint="consistent" timing="initial" y-dead="1" /> 33 <mapping:rbf-thin-plate-splines direction="write" from="fluid_cellcenters" 34 to="structure_cellcenters" constraint="consistent" timing="initial" y-dead="1"/> 35 </participant> <participant name="structure_solver"> 38 <use-mesh name="structure_nodes" provide="yes"/> 39 <use-mesh name="structure_cellcenters" provide="yes"/> 40 <write-data mesh="structure_nodes" name="displacements" /> 41 <read-data mesh="structure_cellcenters" name="stresses" /> 42 </participant> <m2n:sockets from="fluid_solver" to="structure_solver" distribution-type="gather-scatter" /> <coupling-scheme:serial-implicit> 47 <timestep-length value="0.05" /> 48 <max-timesteps value="20000" /> 49 <participants first="fluid_solver" second="structure_solver" /> 50 <exchange data="stresses" from="fluid_solver" mesh="structure_cellcenters" 13

15 3.4. RESULTS CHAPTER 3. TEST PROBLEM 51 to="structure_solver" /> 52 <exchange data="displacements" from="structure_solver" mesh="structure_nodes" 53 to="fluid_solver" /> 54 <relative-convergence-measure limit="1e-4" data="displacements" mesh="structure_nodes" /> 55 <max-iterations value="20" /> 56 <extrapolation-order value="2" /> <post-processing:iqn-ils> 59 <data mesh="structure_nodes" name="displacements" /> 60 <initial-relaxation value="0.001" /> 61 <max-used-iterations value="20" /> 62 <timesteps-reused value="2" /> 63 <filter type="qr1" limit="1e-8" /> 64 </post-processing:iqn-ils> 65 </coupling-scheme:serial-implicit> 66 </solver-interface> 67 </precice-configuration> The dimensions defines the dimension of the coordinates and the variables (line 4). Lines 6 and 7 define the exchanged variables and lines 9-22 define the meshes and which variables are used on them. Four meshes are defined. The displacements are calculated by MBDyn at the nodes and FOAM-FSI deforms the mesh based on the node locations. FOAM-FSI calculates the stresses at the cell centers and therefore the stresses are passed on the face centers. MBDyn adapter calculates the nodal forces from the total force that is acting on an element given by F e = σ e A e (3.2) where σ e is the stress at the center of the face and A e is the area of the face. The participating solvers are defined in the following blocks (Lines 24-43). Fluid Solver and Structure Solver refer to FOAM-FSI and MBDyn respectively. The solver names are given as an argument in the adapter when the interface to precice is generated. The fluid solver uses all the four meshes because the variables are mapped from one mesh to the other on its side. Both solvers provide the coordinates of their meshes. The mapping algorithm is calculated only at the beginning of the simulation and here thin-plate-splines type RBF mapping is used with consistent approach. The mapping is calculated only once at the beginning of the simulation and therefore only the x-direction is used (initially the interface is planar). The mapping in y-direction is neglected by setting y-dead = 1. The structure solver uses only its own two meshes (lines 37-42). The last block defines the coupling scheme (lines 46-65). Here we use an implicit coupling scheme which uses several sub-iterations at each time-step to ensure that the coupled solver has converged. The convergence criteria is the relative displacement with tolerance of The convergence is enhanced by using interface quasi-newton with inverse of the Jacobian from a least-squares model (IQN-ILS) [3] algorithm. 3.4 Results The vertical displacement of the middle node of the present simulation is shown in Figure 3.2. The results are in a good agreement with the simulation results of Valdes [7] and Mok [6]. 14

16 3.4. RESULTS CHAPTER 3. TEST PROBLEM Figure 3.2: Middle node vertical displacement. 15

17 Chapter 4 Conclusions In this work a precice adapter for MBDyn software has been developed. Currently, it only supports membrane elements but it can be rather easily extended for other element supported by MBDyn as well. The implementation was verified by carrying out FSI simulation on modified cavity test case where the bottom of the domain is a flexible membrane. For the fluid side an already existing precice adapter for foam-extend was used. The results showed good agreement. 16

18 Bibliography [1] D. Blom. https: // github. com/ davidsblom/ FOAM-FSI. Accessed: 27 November [2] H. Bungartz et al. precice A fully parallel library for multi-physics surface coupling. In: Computers and Fluids 141 (2016). Advances in Fluid-Structure Interaction, pp issn: doi: url: http: // [3] J. Degroote, K. Bathe, and J. Vierendeels. Performance of a new partitioned procedure versus a monolithic procedure in fluid structure interaction. In: Computers & Structures 87 (2009), pp [4] C. Geuzaine and J. Remacle. Gmsh: a three-dimensional finite element mesh generator with built-in pre- and post-processing facilities. In: International Journal for Numerical Methods in Engineering (2009). [5] P. Masarati, M. Morandini, and P. Mantegazza. An Efficient Formulation for General-Purpose Multibody/Multiphysics Analysis. In: ASME J. Comput. Nonlinear Dyn. 9.4 (2014). [6] D. Mok. Partitionierte Lösungsansätze in der Strukturdynamik und der Fluid-Struktur-Interaktion. PhD thesis. Universität Stuttgart, [7] G. Valdés. Nonlinear Analysis of Orthotropic Membrane and Shell Structures Including Fluid- Structure Interaction. PhD thesis. Universitat Politècnica de Catalunya, [8] W. Witkowski. 4-Node combined shell element with semi-eas-ans strain interpolations in 6-parameter shell theories with drilling degrees of freedom. In: Computational Mechanics 43.2 (2009), pp

19 Study questions and answers 1. Why is it beneficial to use precice for multiphysics coupling? 2. What are the requirements to carry out a multiphysics simulation with precice? 3. What is a precice adapter? 18