Hron-Turek Benchmark in OpenFOAM and Foam-Extend

Table of Contents

Disclaimer:

While this document is given as an aid to my students it should not serve as a template for the technical report they need to provide. The descriptions in this document may be rudimentary and are given as a guide for further study, rather than a complete treatise on the subject.

Please follow the links in this document and use the references.

1 Background

Fluid Structure Interaction (FSI) is a complex phenomenon that poses unique challenges to the numerical methods used to simulate them. Validation and verification is particularly difficult for FSI problems due to the scarcity of dedicated validation experiments. In many cases benchmarking is done where validation data is unavailable. 

The Hron-Turek benchmark [Turek2006] is used as a standard case to test the capability of FSI implementations. It is a simple case which nonetheless poses a significant challenge to coupling algorithms due to the following characteristics:

  • low Re vortex shedding - needs low diffusion fluid code, otherwise numerical diffusion will dampen or prevent the oscillation
  • soft material and large (non-linear) deformation - realistic challenge for structural code aimed at application to biomechanical problems (soft-tissue)
  • density ratio of unity - high demands on stabilisation of coupling algorithms

This case is available as a test or tutorial case for many Fluid-Structure-Interaction codes.

The Hron-Turek benchmark case is a numerical benchmark only, there is no experiment to accompany it. It is also important to note that the H-T benchmark does not include gravity. So while mass in accounted for in the inertia of both fluid and solids, there is no gravitational acceleration1.

An experimental test case, that is based on the same idea, has been proposed and performed by Kalmbach et al. [Kalmbach2013] and included in the ERCOFTAC validation database as cases UFR 2-13 and UFR 2-14. These cases, while based on the same idea, are different in some respects:

  • high Re, so turbulent flow where Hron-Turek is laminar - these cases are also used as test cases for Large Eddy Simulation (LES)
  • different oscillatory modes in the structure

Both, the Hron-Turek and the Kalmbach cases are useful tools to study the capability of an FSI code.

This document presents preliminary results and observations on the suitability of the solids4Foam framework [Cardiff2018],[Tukovic2018] to accurately represent the case as given in the Hron-Turek benchmark.

2 Foam-Extend or OpenFOAM?

There are a few different versions of OpenFOAM, which are related, but have separated along the way. All of them are similar, and many of the principles will be the same, but they differ in detail, so a solver or case set up for one variant may not work in the other (but it is usually possible to convert them).

  • OpenFOAM.org - released by the OpenFOAM foundation. Version numbers are of the form N. Current release is OpenFOAM 8. The release cycle is irregular.
  • OpenFOAM.com - released by ESI. Version numbers are of the form vYYMM, where YY is the year and MM the month of the release. Current version is v2012, released in December 2020. The release cycle is 6 months. This variant is popular with commercial users, since the copyright of derived code does not need to be transferred to ESI. This variant also has - in my opinion - the most extensive documentation.

These two variants are quite close and most settings are the same. Adaptations of cases from one to the other is usually straightforward. But the feature set is different and more current models may be available in one, but not the other.

  • foam-extend, released by a loose-knit group of developers, led by Hrvoje Jasak. This is a variant that has been forked from the original codebase and has a quicker way for new models to be integrated. On the other hand it is more fluid and chaotic. This is the most difficult to get used to.

    There are a few differences between OpenFOAM (both ESI and Foundation) and foam-extend. These are mostly related to available boundary condition types and physical models, and in some cases naming conventions and locations of files. The most important ones for our application are:

      OpenFOAM foam-extend
    name of symmetry BC symmetry symmetryPlane
    location of blockMeshDict ./system/polyMesh ./constant/polyMesh

3 Hron-Turek benchmark

For detailed description on the geometry, parameters and boundary conditions see [Turek2006]. In the proposal the complex FSI problem is broken down into Computational Fluid Dynamics (CFD) and Computational Solid Dynamics (CSM) problems which are treated separately (figure 1)

HTbreakdown.png

Figure 1: Structure of Benchmark Cases in [Turek2006]

This approach is common in validation studies, in order to allow validation of the individual codes or models. In this case it allows for validation of the flow and structural model separately, before - once it has been established that both flow and structural model work as expected - simulation of the fully coupled case (FSI) allows to assess the performance of the coupling algorithms.

FSI 1-3, CFD 1-3, and CSM 1-3 vary in the parameters and in consequence in the relevant dimensionless numbers, e.g. Re, density ratio, and another dimensionless ratio describing the relation of elasticity and viscosity/inertia (see [Turek2006] for a description of the cases). Be aware that the numbering is not always consistent and aligned, i.e. CFD 2, CSM 2, and FSI 2 may differ in their dimensionless numbers2!

Make sure that you understand the model and the results as they are presented in [Turek2006], since you are asked to reproduce and possibly extend on them.

4 solids4Foam

The solids4Foam extension is developed by Philip Cardiff at the University of Dublin. It extends the FOAM framework to solid mechanics and fluid-structure interaction. Both the fluid and solids solvers use the Finite Volume Method (FVM), rather than the more common way of using FVM for the fluid solver and the Finite Element Method (FEM) for the solid solver.

A detailed description can be found in [Cardiff2018],[Tukovic2018]. This new framework is under current development, and the implementation may vary in detail as new features are implemented. The codebase is hosted on BitBucket.

The main development platform for solids4Foam is foam-extend version 4.0, but the development branch has been tested with foam-extend 4.1 and OpenFOAM 73. OpenFOAM v1912 works, but has a much lower performance (up to 10 times slower), so is not recommended.

solids4Foam uses the same case structure as (Open)FOAM with only one difference: the two cases for fluid and solid are in sub-directories fluid and solid within the 0, constant, and system directories. For details on the FOAM case structure see OpenFOAM Directories.


casename
├── 0
│   ├── fluid
│   └── solid
├── constant
│   ├── fluid
│   ├── fsiProperties
│   ├── physicsProperties
│   └── solid
└── system
    ├── controlDict
    ├── fluid
    └── solid

Note that the controlDict is not in the fluid or solid sub-directories, but in the system directory itself. Since it controls the whole case. There are also some files that are not in a standard case, but are specific to FSI cases

  • fsiProperties controls the coupling algorithm
  • physicsProperties decides if the case is run as fluid only, solid only, or fluid-solid interaction case.

4.1 FSI settings

The most important settings in fsiProperties is the choice of under-relaxation. solids4Foam does offer three options:

  • constant (fixed) under-relaxation: has a constant relaxation factor. Not recommended since it will take a long time to converge.
  • Aitken adaptive under-relaxation: a classical convergence acceleration for under-relaxation methods. Changes the relaxation factor after each FSI iteration.
  • IQN-ILS, a quasi-Newton technique which can improve convergence [Degroote2010].

Typicaly, the IQN-ILS method is the preferred method. Should this prove unstable, the Aitken method can be applied. The Aitken method will typically need roughly twice as many FSI iterations to converge, but can be more stable. See also [Vierendeels2010],[Degroote2008].

Important parameters:

  • relaxationFactor: for Aitken and IQN-ILS this is only used in the initial phase (first few iterations) of each time step, after that the convergence acceleration method takes over. However, if the coupling becomes unstable at the beginning of a time step, reducing this value can help.
  • nOuterCorr: number of outer (FSI) iterations for each time step. This should be sufficiently high to allow the FSI coupling to converge. Setting this too high usually does not have negative consequences4, while setting it too low may not allow time steps to converge and may lead to instability.
  • interfaceTransferMethod: the method used to interpolate and transfer loads and discplacements between the two codes. Available values are:
    • AMI: Arbitrary Meshing Interface. Used in OpenFOAM, currently not available in OpenFOAM v1912. Use this is OpenFOAM 7.
    • GGI: Generalised Grid Interface. Only available in foam-extend, where it has the same functionality as AMI in OpenFOAM.
    • RBF: Radial Basis Function Interpolation. Available in all codes, but very slow. I assume that this is the reason that OpenFOAM v1912 does not perform on the same level as OF7 and FE40, since the AMI implementation is not compatible with solids4Foam at the time of writing.

5 Results

5.1 FSI 3 - Mesh Sensitivity Analysis

Mesh sensitivity study with 3 meshes for the FSI3 case. Mesh sizes and settings in table 1

Table 1: Mesh sensitivity study FSI3 - simulated time 6s
  mesh F mesh S dt FSI alg NCpu wallClock h5
fe40 coarse 5336 630 1e-3 IQN-ILS 1 19
          2 14.5
          4 11.7
          8 11.4
fe40 medium 10655 630 7.5e-4 Aitken 1 25.4
fe40 fine 18397 630 5e-4 Aitken 1 66.7
of7 coarse 5336 630 1e-3 IQN-ILS 1 17
of7 medium 10655 630 7.5e-4 Aitken 1  
of7 fine 18397 630 5e-4 Aitken 1 47

HT3_frequency_fe40.png

Figure 2: Time signal and frequency for HT FSI3 benchmark case - Foam-Extend 4.0. Mesh sensitivity

Table 2: Amplitudes and frequencies HT FSI3 benchmark case - foam-extend 4.0. Mesh sensitivity. GCI divergent, GCI results are invalid!
Case Dx [mm+-mm (Hz)] Dy [mm+-mm (Hz)]
Benchmark -2.69+-2.53 (10.9) 1.48+-34.85 (5.3)
     
fe40 coarse -2.18+-2.1 (11.05) 1.72+-29.86 (5.52)
fe40 medium -2.47+-2.37 (11.1) 1.01+-32.24 (5.55)
fe40 fine -2.67+-2.57 (11.21) 1.64+-33.64 (5.6)
     
GCI ext -3.98+-11.99 (11.26) 7.08+-38.39 (5.63)
     
GCI 61.15+-457.03 (0.57) 415.25+-17.62 (0.51)

fe40_GCI_Dyfreq.png

Figure 3: Grid convergence and GCI extrapolation, frequency in y-direction, fe40

fe40_GCI_Dymean.png

Figure 4: Grid convergence and GCI extrapolation, mean deflection in y-direction, fe40

fe40_GCI_Dyamp.png

Figure 5: Grid convergence and GCI extrapolation, deflection amplitude in y-direction, fe40

HT3_frequency_of7.png

Figure 6: Time signal and frequency for HT FSI3 benchmark case - OpenFOAM.org 7. Mesh sensitivity

Table 3: Amplitudes and frequencies HT FSI3 benchmark case - OpenFOAM.org 7. Mesh sensitivity
Case Dx [mm+-mm (Hz)] Dy [mm+-mm (Hz)]
Benchmark -2.69+-2.53 (10.9) 1.48+-34.85 (5.3)
     
of7 coarse -1.86+-1.79 (11.25) 2.0+-27.22 (5.65)
of7 medium -2.44+-2.35 (11.21) 1.27+-31.45 (5.6)
of7 fine -2.67+-2.6 (11.33) 1.49+-33.4 (5.67)
     
GCI ext -2.96+-2.95 (11.38) 1.62+-36.66 (5.79)
     
GCI 13.7+-17.31 (0.57) 10.83+-12.21 (2.75)

OF7_GCI_Dyfreq.png

Figure 7: Grid convergence and GCI extrapolation, frequency in y-direction, OF7

OF7_GCI_Dymean.png

Figure 8: Grid convergence and GCI extrapolation, mean deflection in y-direction, OF7

OF7_GCI_Dyamp.png

Figure 9: Grid convergence and GCI extrapolation, deflection amplitude in y-direction, OF7

5.2 FSI2

HT2_frequency_of7.png

Figure 10: Time signal and frequency for HT FSI2 benchmark case - OpenFOAM.org 7

Table 4: Amplitudes and frequencies HT FSI2 benchmark case - OpenFOAM.org 7
Case Dx [mm+-mm (Hz)] Dy [mm+-mm (Hz)]
Benchmark -14.58+-12.44 (3.8) 1.23+-80.6 (2)
     
of7 medium -30.08+-24.78 (3.87) 5.16+-105.71 (1.95)

6 Bibliography

  • [Cardiff2018] Cardiff, Kara\v c, De Jaeger, Jasak, Nagy, Ivankovi\'c & Tukovi\'c, An Open-Source Finite Volume Toolbox for Solid Mechanics and Fluid-Solid Interaction Simulations, arXiv preprint arXiv:1808.10736 (Journal Article), (2018).
  • [Degroote2008] Degroote, Bruggeman, Haelterman & Vierendeels, Stability of a Coupling Technique for Partitioned Solvers in FSI Applications, Computers & Structures 86(23), 2224-2234 (2008).
  • [Degroote2010] Degroote, Haelterman, Annerel, Bruggeman & Vierendeels, Performance of Partitioned Procedures in Fluid\textendash Structure Interaction, Computers & Structures 88(7), 446-457 (2010).
  • [Kalmbach2013] Kalmbach & Breuer, Experimental PIV/V3V Measurements of Vortex-Induced Fluid\textendash Structure Interaction in Turbulent Flow\textemdashA New Benchmark FSI-PfS-2a, Journal of Fluids and Structures 42, 369-387 (2013).
  • [Tukovic2018] Tukovi\'c, Kara\v c, Cardiff, Jasak & Ivankovi\'c, OpenFOAM Finite Volume Solver for Fluid-Solid Interaction, Transactions of FAMENA 42(3), 1-31 (2018).
  • [Turek2006] Turek & Hron, Proposal for Numerical Benchmarking of Fluid-Structure Interaction between an Elastic Object and Laminar Incompressible Flow, FluidStructure Interaction 53(1), 371-385 (2006).
  • [Vierendeels2010] Vierendeels, Degroote, Annerel & Haelterman, Stability Issues in Partitioned FSI Calculations, Lecture Notes in Computational Science and Engineering 73, 83-102 (2010).

Footnotes:

1

For the cases with a density ratio of unity, you can also argue that the solid is neutrally buoyant, so there will be no influence of gravity (this will also be true for most biological tissues). This argument does not hold for FSI2, though, where the solid density is an order of magnitude higher than the fluid density

2

E.g. Young’s modulus and solid density between CSM2/3 and FSI2/3

3

At the time of writing, solids4Foam has not been ported to OF8 or OFv2012

4

Aside from a longer run time, if the code struggles to converge. However this argument can often be discarded, since a non-converged solution will often be useless. So I’d rather have a good solution take some time then have a wrong result

5

As can be seen there is not a lot be to won by using parallel computing on such a small case. It is much better use of resources to run several cases in serial at the same time, than running them in parallel one after the other.