ECFD workshop, 8th edition, 2025

Description

• Event from 27th of January to 7th of February 2025
• Location: Centre Sportif de Normandie, Houlgate, near Caen (14)
• Two types of sessions:
  • common technical presentations: roadmaps, specific points
  • mini-workshops. Potential workshops are listed below
• Free of charge
• Participants from academics, HPC center/experts and industry are welcome
• The number of participants is limited to 68.

• Objectives
  • Bring together experts in high-performance computing, applied mathematics and multi-physics CFDs
  • Identify the technological barriers of exaflopic CFD via numerical experiments
  • Identify industrial needs and challenges in high-performance computing
  • Propose action plans to add to the development roadmaps of the CFD codes
• Organizers
  • Guillaume Balarac (LEGI), Simon Mendez (IMAG), Pierre Bénard, Vincent Moureau, Léa Voivenel (CORIA).

News

• 23/10/2024: First announcement of the 8th Extreme CFD Workshop & Hackathon !
• 22/11/2024: Deadline to submit your project

Thematics / Mini-workshops

These mini-workshops may change and cover more or less topics. This page will be adapted according to your feedback.

To come...

Projects

Hackathon GENCI - P. Begou, LEGI

This ECFD8 GENCI Hackathon was a rich event, involving 4 differents CFD codes (AVBP, ParaDIGM, SONICS and YALES2) using various paradigms (C++/cuda/hip, Fortran/OpenMP/OpenACC) with several SDKs (AMD, Cray/HPE, Nvidia, Gnu) on a large range of GPU architectures (Nvidia A100, GH100, AMD instinct Mi210, Mi250, Mi300). This two-week event benefited from a high level support from three HPC mentors, two on-site from AMD (J. Noudohouenou and A. Tsetoglou) and one remote from CINES (M. Boudaoud).

H1 - ParaDIGM and SONICS on GPU, B. Maugars, G. Staffelbach, R.Cazalbou and B. Michel (ONERA)

In this edition of the ECFD, our team envisioned extending the CFD code SoNICS, developed by ONERA, to be able to run on multiple GPU accelerators. SoNICS' unique architecture is based on large tasks called "operators" that can be linked via a dependency graph according to their required inputs and outputs. To optimize performance on GPUs, this graph is translated into a CUDAGraph, a generic feature of NVIDIA GPUs, also available on AMD accelerators via HIP (then called HIPgraph). The use of CUDAGraph allows for optimal efficiency by reducing latency and optimizing redundant operations.

Initially, SoNICS could only work using one GPU. To add parallelism on the CPU, the code relies on MPI. Unfortunately, the use of MPI message passing inside the graph was not recommended. Therefore, the execution graphs were split to include intermediate MPI calls wherever needed. This implementation was successfully tested during the ECFD on simple test cases such as the NACA12 profile and a compressor SRV2 blade using A30 NVIDIA nodes on the JUNO cluster at ONERA.

The multi-GPU implementation was also ported and tested on the TOPAZE cluster at CCRT on A100 GPUs. Additionally, the code was ported to the Grace Hopper architecture, which uses Arm-based processors and H100 GPUs (on the Calypso cluster at CERFACS).

Profiling, optimization, and performance tests are ongoing to evaluate and improve the multi-GPU implementation.

H2 - AVBP GPU offloading based on OpenMP, M.Ghenai, L. Legaux and A. Dauptain (CERFACS)

This hackathon provided a valuable opportunity to work on GPU offloading for AVBP. In the past, significant efforts were made to offload the entire AVBP code to GPUs. OpenACC was the primary strategy chosen, mainly due to access to NVIDIA's support, along with the availability of both software and hardware. This approach achieved good scalability performance. Recently, with the deployment of new supercomputers like ADASTRA at CINES, some issues have emerged when running AVBP on AMD GPUs, including both MI250 and MI300. The closed-source nature of the Cray environment has also prevented CERFACS from deploying AVBP on local MI210 GPUs. This hackathon was a great opportunity to address these challenges by exploring a new approach using OpenMP. An automatic translation tool was used to convert approximately 2,700 OpenACC directives to OpenMP, with each directive manually verified and fine-tuned afterward. AVBP with OpenMP had already been tested on NVIDIA GPUs, and during this hackathon, the focus was on extending support to AMD GPUs. Two compilers were used: Cray and the newly released AFAR from AMD. With the support of AMD and CINES, a working environment for compiling AVBP was set up, and performance-related issues were identified. Additionally, two mini-apps were used for benchmarking. One of them achieved a 2.5× speedup when compiled with AFAR compared to Cray. The next steps involve adapting the code to address necessary modifications, such as fixing issues related to Fortran indirections, and continuing performance evaluations with mini-apps. Further comparisons will be conducted using both compilers against results obtained with NVIDIA’s NVHPC.

H3 - YALES2 GPU from OpenACC to OpenMP, P. Bégou (LEGI), V. Moureau, G. Lartigue (CORIA) and R. Dubois (IMAG)

This Hackathon focuses on running Yales2 code on AMD Instinct Mi250 and Mi300 GPUs of the Adastra supercomputer (CINES). Previously, a first solver in the Yales2 CFD code was successfully ported on the GPU accelerators of the Jean-Zay supercomputer (IDRIS) using Nvidia SDK but difficulties remain on Adastra AMD GPUs, mainly related to the available development tools. High compilation time and the impossibility to use debug flags at compile time as soon as OpenACC is enabled are a real challenge when tracking errors. The current project is to evaluate a freshly deployed version (at the begining of the workshop) of the AMD Fortran compiler. This requires moving to OpenMP paradigm, starting from scratch since the OpenACC branch has largely diverged from the master one while tracking spurious remaining bugs. If the AMD compiler is able to build the cpu version of Yales2 "out of the box" (wich is not the case for Cray Fortran), the compilation time for each file is significantly higher. However, setting up a 2 stages dynamic compilation process allows for high parallelism that is not possible with Cray Fortran 18 and the library build time drops from nearly 2 hours (Cray Fortran 18) to 17 minutes (Amd Fortran compiler). Large kernels have been ported from OpenACC to OpenMP, raising some difficulties when offloading intrinsics functions or using strutures attributes in kernels loops. These limitations were also known in the previous OpenACC work. The goal was mainly to check the correctness of the results. The offloading of the complex data structure of Yales2 code was then investigated. Here again some limitations of the "young" compiler were discovered and workarounds were implemented. Several reproducers were built during this ECFD8 and provided to developpers by the 2 on-site AMD engineers. Preliminary tests on micro-applications show good performances of the generated binaries proving that this compiler could be a serious alternative on AMD GPUs and the goal is now to focus on this SDK in an OpenMP strategy while checking the portablility of this new implementation in Nvidia, Cray/HPE (and Gnu ?) environments.

Mesh adaptation - A. Grenouilloux, ONERA & G. Balarac, LEGI

M1 - Simulation of core shifting during investment casting, Y. Mayi (Safran Tech), S. Meynet (GDTech), M. Cailler (Safran Tech), R. Mercier (Safran Tech)

Ceramic core displacement and deformation during the casting process is a major source of cooled blades manufacturing scrap. Simplified casting experiment on a test blade has already been led with the help of our academic partners. During this project, two topics have been addressed: compute the shifting and the deformation of the test blade with YALES2. Concerning the shifting, dynamic mesh adaptation is required. This is why a coupling has been done between spray (for the filling) and mesh movement (for the shifting) solvers within YALES2. Tests cases have shown promising results but forces on the blade by fluids will have to be integrated later. About the deformation, the chosen strategy is to run filling simulation with YALES2 and ABAQUS afterwards (FEM software). This implies a numerical chaining but mesh interpolation is needed as meshes are different. As ABAQUS requires input files, the work consisted in writing this kind of ABAQUS files during a YALES2 simulation. For this purpose, four steps are considered during a time step: 1) Parse ABAQUS mesh 2) Create particles at face centers of ABAQUS mesh 3) Interpolate pressure between particles and the YALES2 mesh at the considered blade 4) Write a ABAQUS input file. Finally, the chaining was a success and this paves the way for ABAQUS simulations from YALES2 runs in the future.

M2 - Enhancement of mesh adaptation algorithms, B. Maugars (ONERA), B. Andrieu (ONERA), C. Benazet (ONERA), N. Dellinger (ONERA), G. Janodet (ONERA), G. Staffelbach (ONERA)

Mesh adaptation has become a crucial tool in order to automate industrial numerical simulations. ECDF7 allowed us to investigate the refine and EGADS libraries as tools for parallel mesh generation and adaptation using CAD as a geometric support. Since then, we fortified the workflow but some of our targeted industrial applications such as turbomachinery involve periodic boundary conditions. To manage these cases, the mesh generation and adaptation procedures must maintain matching periodic boundaries. During ECFD8, we addressed multiple topics : periodic mesh generation from CAD model in EGADS, parallel and periodic metric gradation in ParaDiGM, making our parallel remeshing algorithm more generic to support non-manifold and periodic meshes. All these topics were covered, but there is still some work to be done to fully manage periodic mesh adaptation. Non-manifold mesh adaptation was applied to changing mesh topologies. Here, an internal surface was described by a level-set and deformed up to hole creation to mimic ablation.

M3 - Development and definition of a new Automatic Mesh Convergence (AMC) driver for automating static mesh convergence in YALES2 (C. Papagiannis (LEGI/INRIA), G. Balarac (LEGI), O. LeMaître (INRIA), P.M. Congedo (INRIA))

Static mesh adaptation requires re-adapting an existing (usually coarse) mesh, to conform to some quality metric that satisfies some optimality criterion. This involves statistics (Mean and RMS fields) that need to be adequately converged. We proposed and developed a novel AMC strategy that can converge an initial coarse mesh to an adequately refined one by taking into account the quality of the calculated statistics before each adaptation. Specifically, so far, the moment (in terms of integrating the LES equations) at which to launch the adaptation was unknown and had to be set apriori as a parameter of the AMC, dependent on the flow physics and therefore on the case at hand. Our method is automatically performing adaptations when the quality of the volume averaged mean field estimate (characterized by its RMSE) reaches the levels of the bias error that this field has, due to the mesh being far from the desired one (dictated by the quality criterion). This was achieved through drawing inspiration from a theoretical model that treats the AMC as a "conditionally" contractive mapping with a fixed point.

M4 - Anisotropic mesh adaptation of interfaces in YALES2 (R. Barbera (LEGI/Safran Tech), G. Balarac (LEGI), G. Ghigliotti (LPSC), M. Cailler (Safran Tech))

Mesh adaptation is now a key feature for simulations of complex industrial flows. For transient flows such as multiphase and/or reactive flows, where regions of interest are strongly moving in space, dynamic mesh adaptation appears as the most suitable strategy. This strategy is now widely used in YALES2 based on isotropic mesh definition. The purpose of this project is to adapt this strategy to an anisotropic framework to reduce the overall simulation costs (in terms of memory consumption, CPU cost and time to solution). In order to be able to handle multiphase flows, the main objective of the project is to study the conditions for accurately describing the dynamics of the level-set function with an anisotropic mesh. Based on the work conducted during ECFD7, in which we assessed several anisotropic remeshing strategy for simple flow (ie droplet advection and dam break test case), we worked on the more complex case of the jet-in-crossflow. We highlighted that our strategy is able to accurately describe the main features of the flow (hydrodynamic instabilities at the basis of the jet and ligaments atomization in the upper region). But that a particular focus needs to be made on the accurate resolution of turbulence in the gaseous phase in order to accurately catch the complex coupling between the liquid phase and turbulence in the gas phase. This strategy showed a significant reduction in terms of number of elements in the domain with respect to isotropic mesh adaptation. The issue of mass conservation still needs to be dealt with but encouraging results has been conducted on this matter in the N3 project.

M6 - Dynamic mesh adaptation of turbulent flows (G. Balarac, L. Bricteux, P. Bénard, S. Mendez)

This work focuses on developing dynamic mesh adaptation strategies for turbulent flows, particularly in cases where static (statistical-based) adaptation is inadequate. The objective is to design a dynamic mesh metric capable of computing the required physical metric directly, without the need for an explicitly prescribed mesh size. The method, based on QC6 and developed at LEGI, has been assessed with encouraging results. Validation was performed on hemisphere flow at Re=55k —a regime for which LDV experimental measurements are available—yielding promising results in terms of Drag coefficient. Additionally, the approach was tested on vortex ring collisions, a canonical case where static adaptation is ineffective. The results demonstrated that the adaptation strategy performs well in capturing vortical flow regions. Furthermore, the strategy was applied to an elliptic jet flow (aspect ratio 3) generating vortex rings at Re=30k. The dynamically generated meshes successfully tracked the regions of interest, confirming the method’s robustness and effectiveness in complex flow configurations.

Numerics - M. Bernard, LEGI & G. Lartigue, CORIA

N1 - Traction open boundary condition G. Balarac (LEGI), M. Bernard (LEGI) and J.-B. Lagaert (IMO)

In simulations, artificial boundaries need to be introduced due to the limited size of computational domains. At these boundaries, flow variables need to be calculated in a way that will not induce any perturbation of the interior solution. During previous ECFD, more generic outlet boundaries conditions has been implemented, allowing to prescribe for instance an arbitrary traction at the boundary. This year, the focus was on setting up a traction model to determine those values. This model extrapolates edge tension from upstream tension within the calculation domain. It has been validated on an initial series of test cases where the theoretical solution is known, enabling to compare the traction-model accuracy both with the imposition of exact theoretical traction and with other more conventional boundary conditions.

N2 - Treatment of Inlet conditions in High-Order solver. M. Bernard (LEGI), Ghislain Lartigue (CORIA), Guillaume Balarac (LEGI)

In the context of node-centered Finite Volumes Method, spacial accuracy of a numerical scheme depends on ability to evaluate accurately fluxes through interface of each control volume (CV). Such accurate evaluation is not straightforward, especially when dealing with distorted grids. This project follows the work of [1] where fluxes use pointwise quantities, which are reconstructed from integrated quantities advanced in time. During the previous edition of the ECFD, a new data structure has been developed to store data at location of the boundary conditions facelets, with application to wall boundary conditions. During this 8th edition of the ECFD, we used the same data structure, but dedicated to the treatment of inlet conditions. The inlet condition is then either imposed directly at facelets center, or at nodes position them extrapolated to facelets center by use of Taylor expansion. For this later solution, high-order treatment requires the successive derivatives to be computed in the plane of the boundary condition. This is not done yet, leading for the moment to low accuracy results but the framework is ready for upcoming implementation.

[1] A framework to perform high-order deconvolution for finite-volume method on simplicial meshes, , Bernard et. al., IJNMF 2020

N3 - Conservative mesh-to-mesh interpolation. M. Bernard (LEGI), Ghislain Lartigue (CORIA), Guillaume Balarac (LEGI)

Mesh to mesh interpolations occur quite often in CFD simulations : in the context of adaptative mesh convergence or in the case of dynamic mesh adaptation for for example. Quality of the solution on the destination grid will depend on the characteristics of the interpolation method. In this project, we did not focus on accuracy of the interpolation method but rather on conservativity characteristics. A conservative interpolation ensures that the integral of the data on the source grid is exactly retrieved on the destination grid. This property is highly interesting when dealing with scalar quantities or phase indicators, whose values should remained bounded. In the context of nodes centered Finite Volume schemes, the methodology we used consists in (i) reconstructing element quantity from average nodal quantities on source grid. Then, for a cell of the destination mesh, (ii) computing the geometrical intersection between cells of source and destination meshes to evaluate to evaluate the rate of quantities they. Eventually, (iii) redistributing the solution from elements to control volumes of the destination mesh. The overall process is fully conservative as it is based on geometrical intersection of locally integrated quantities. The methodology as been implemented and tested on a few basic configurations and the conservativity is retrieved.

N4 - Determination of timestep in semi-implicit solver. T. Berthelon (LEGI), G. Balarac (LEGI), H. Lam (LEGI), M. El Moatamid (CORIA)

In order to reduce the computation time associated with incompressible LES simulations, an implicit time integration, based on BDF schemes, has been developed within the ICS solver. This integration eliminates the stability constraints associated with explicit schemes, and therefore opens up the question of the appropriate choice of time step. In parallel, recent work has been carried out on meshing criteria in LES. The strategy in place consists of adapting the mesh by distinguishing two zones: - "DNS" zones, where the meshing criterion is based on an estimate of the adimensioned spatial error. - "LES" zones, where the meshing criterion is based on Kolmorogov theory. During this project, the spatial criteria were extended to include temporal criteria. In the "DNS" zones, the time step is chosen using an estimate of the temporal error of the BDF scheme judiciously scaled to match the spatial error. In the "LES" zones, the time step is chosen using a scaling law associated with fully developed turbulence. The new time step selection strategy has been tested on the case of a turbulent jet and leads to an accuracy equivalent to the explicit case while reducing the simulation return time by a factor of nearly 3.

Another aspect of this project was to integrate certain implicit temporal schemes (C-N and SDIRK) recently developed by Mr. El Moatamid into the incompressible solver.

N5 - Local timestep. T. Berthelon (LEGI), M. Bernard (LEGI), G. Balarac (LEGI)

RANS modelling has recently been developed within the YALES2 library. With this modeling strategy, the objective is to reach as quick as possible a steady state. During this project, we investigate the use of a local time step to reduce the time to solution of steady computation in the incompressible solver. This implies solving a variable-coefficient Poisson equation. Encouraging results were obtained in the simple case of "Couette plan" flow artificially constrained by a mesh variation. In fact, the use of local time-step reduce drastically the time to solution on this configuration. This method needs to be tested on real RANS case.

N6 - Distributed version of DOROTHY. M. Roperch, G. Pinon (LOMC)

Dorothy is a Lagrangian code using vortex particle method. This method is based on the discretisation of the fluid into vorticity carrying particles. Before ECFD7, all the processors knew all the particles. Since ECFD7, we have gradually moved to a fully distributed version. At ECFD8, the goal was to get a domain decomposition without knowing all the particles. This decomposition is done by dividing the domain by prime factors so that each subdomain has the same number of particles. Prior to this ECFD, a Python draft of this module was created. At ECFD8, this new algorithm was implemented and will soon be operational. The next step is to continue this work for the velocity calculation, as each particle affects the velocity at a given position, and calculating the velocity without knowing all the particles requires more MPI communication.

N7 - Implicit time advancement for low-Reynolds number flows with particles. S. Mendez, C. Raveleau (IMAG), M. El Moatamid, V. Moureau (CORIA)

IMAG runs numerous simulations of red blood cells under flow. Those simulations are at low Reynolds number (0.001 to 1.0, typically). Splitting of the time advancement is used to treat the diffusion terms implicitly, albeit with an important numerical cost: implicit diffusion is 50 to 60% of the computational cost. Recently, M. El Moatamid implemented a genral framework to deal with implicit time advancement for scalars. In this project, the general method has been transposed to the advancement of the velocity field in the ICS and RBC solvers of YALES2/YALES2BIO. This enables testing various linear solvers (GMRES based). However, such solvers do not decrease the CPU time compared to the existing implementation. However, while working on this, it was identified that residual recycling was not activated in the current implementation of the implicit diffusion. This sped up the implicit diffusion cost by 35%, for a total gain of 20% for the computation. In addition to this achievement, moving to the framework coded by Moncef will have other beneficial side effects: we anticipate simplifying the implementation, with an easier merging between YALES2BIO and YALES2. The method will also be implemented in the electrosatic solver, for which the Poisson problem should benefit from the new GMRES-based solvers. In addition, this project highlights the importance of improving the treatment of stiff source terms in the red blood cells simulations, to be able to overcome the current limitation in time step due to those term and have a chance to benefit from higher-order time schemes, efficient at high Fourier numbers.

N8 - Boundary Element Method in YALES2. B. Thibaud, S. Mendez (IMAG), G. Lartigue, P. Benard (CORIA), F. Nicoud (IMAG)

In the context of microfluidic systems for diagnosis, the Boundary Element Method alows to solve linear PDE such as electrostatic or Stokes. With well chosen kernel functions and the divergence theorem, this method allows to write on the boundary condition only the initial volumic problem. This project aimed at exploring the feasibility of the BEM in the context of massively parallel unstructured solver like YALES2 by developping a Julia demonstrator. The first step have been to implement and validate the method on simple configurations for the Laplace's equation. Only Neumann problems were considered (Dirichlet boundary conditions imposed). In a second time, the multi-domain approach has been identified to be the most suited in the framework of YALES. The inner domain is partitioned on each processor, each having a part of the physical boundary and interfaces between them. Every processor solve its own boundary problem and a parallel Dirichlet-Dirichlet fixed-point is used to converge the interface problem on the all domain. Applied to the ring case, with one interface, we managed to reproduce the linear convergence of the P-DD method.

Turbulence - L. Voivenel, CORIA & P. Bénard, CORIA

T1 - FSI-1D strategy for internal flows - Pierre BENEZ (SAFRAN Aerosystem), Renaud MERCIER (SafranTech), Yacine BECHANE (CORIA)

Many applications developed at Safran Aerosystem are based on internal turbulent flows coupled to a moving body. 2 cases were studied during this ECFD:

Case 1 (Incompressible flow): Translation of a piston subjected to a pressure difference in a pipe.

The challenges of this case are twofold: the small gap between the piston and the pipe and the large pressure gradient across the piston (>100bar). During the 1st week of ECFD, the CLIB (Conservative Lagrangian Immersed Boundary) solver was tested on this case. The study showed that the solver was unable to ensure the impermeability of the solid under these pressure conditions. In the rest of the study, a porous medium following Darcy's law will be added to the penalty force of the immersed solid to fully satisfy the impermeability of the piston.

Case 2 (Compressible flow): Rotation of a butterfly in a discharge vane.

The coupling between the ECS (Explicit Compressible Solver) and ALE (Arbitrary Lagrangian Solver) solvers having recently been implemented, this strategy was tested to model the opening of the valve by rotation of the butterfly. The challenge here lies in the small gap between the bottom of the butterfly and the vane casing. To limit the simulation cost, the gap is meshed with 1 element. In this case, MMG succeeded in adapting the mesh up to a critical angle at which the gap becomes too small (Work In Progress).

T2 - Dynamic Smagorinsky in Dorothy - Maëlenn ROPERCH (LOMC), Grégory PINON (LOMC)

Dorothy is a Lagrangian code using vortex particle method (VPM). This method is based on the discretisation of the fluid into vorticity carrying particles. In some cases, there is a perturbation in the wake that needs to be diffused. Two LES model for a turbulent viscosity exist currently in the code: a standard Smagorinsky model and a Mansour model. Both model apply the same LES constant everywhere. The aim of this ECFD is to add and compare two dynamic and local Smagorinsky models. The first version is a classical dynamic Smagorinsky model in VPM, quantities are filtered with a sum over all particles. Since the values of the sum terms are lower for more distant particles, a second version reduces the sum to neighbouring particles. Preliminary results shows some differences between the two method. The next step will be to validate and compare the results with the case of two vortex ring colliding.

T3 - Turbulence injection strategy for compressible flows - Patrick TENE HEDJE (UMONS), Laurent Bricteur (UMONS), Yacine BECHANE (CORIA), Pierre BENARD (CORIA)

Taking realistic turbulence into account in turbomachinery simulations for aeronautical applications remains a major challenge, particularly as regards the management of non-reflexive boundary conditions. The implementation of the actuator line method (ALM) in the YALES2 Library has enabled us to set up wind tunnel test reproduction setups, such as the modeling of turbulence grids. During the ECFD8, this project aimed to (WP1) finalize the implementation of this method in the Explicit Compressible Solver (ECS) of YALES 2 and (WP2) use this same method to model the interaction of the upstream stator wake on the downstream rotor wheels. The setups implemented have been successfully tested on simple channel flow cases. The aim is to continue the validation process on real turbomachinery geometry cases.

T4 - Improve wind farm modeling and simulation workflow - Pierre BENARD (CORIA), Ulysse VIGNY (UMONS), Etienne MULLER (CORIA & SGRE), Hakim HAMDANI (GDTech), Félix HOUTIN-MONGROLLE (SGRE), Anand PARINAM (CORIA & TUDelft), Hari MULAKALOORI (CORIA), Léa VOIVENEL (CORIA)

The YALES2 library includes an advanced modular implementation of the Actuator Line Method (ALM). This approach remains state-of-the-art when performing an LES-based analysis of a wind turbine wake. The method also provides an accurate assessment of the aerodynamic loads applied on the turbine. Still, applying this method to investigate a wind farm flow can be challenging, both in terms of computational cost and simulation setup. For instance, an inadequate management of the wind turbine individual modeling parts in a HPC context can end up being the main bottleneck of the simulation. From another perspective, a wind farm is usually composed of more than 50 wind turbines. For such a case, setting up all YALES2 required inputs manually can be very tedious and error-prone. This project thus mainly aimed to optimize the YALES2 ALM implementation and the user experience around it. Additionally, a cost-effective alternative to the ALM when modeling wind farm flows, namely the Rotating Actuator Disk Method (ADM-R), has been implemented for further investigations.

WP1: Improve Actuator set rotor modelling

• Parallel processing of the actuator sets used to model the wind turbines

The implementation of the Actuator Line Method (ALM) into the YALES2 library leads to poor performances when many wind turbine rotors are set. Indeed, each rotor object is a derived type treated sequentially by all the processors participating to the computation. With 30 turbines in a computation, the return time is increased by 70% while the arithmetic intensity appears to be low. The objective of this sub-project is to improve the computation performances of the ALM already identified during the 5th iteration of the ECFD: (i) Assign one MPI communicator by rotor object gathering the processors close to the turbine and set-up a master/slave processus by communicator. This will allow the simultaneous rotors computation and reduce the number of MPI exchanges. (ii) Work on the domain decomposition to limit the number of processors attributed to each turbine. This would reduce or even eliminate MPI communications. During this workshop edition, the work focused on the re-synchronisation of the algorithm steps by allowing some packing an unpacking of the object to allow the transfert of the object inbetween workers. This is of major importance to enable load balancing and mesh adaptation during the temporal loop. This work required the refactoring of the involved oject structures.

• Rotating Actuator Disk Method (ADM-R):

According to the usual guidelines, the mesh requirements of the ALM, to profit entirely from its reachable accuracy, can be difficult to achieve or even unaffordable when simulating a wind farm flow, especially from the industrial point of view. Alternatives are available in the literature for this kind of application. Likely, the methods from the Actuator Disk family are the most prominent ones. Several kinds of implementation exist, which mostly differ by their capability to include the wake rotation. During the workshop, a new method from the Rotating Actuator Disk kind has been implemented and underwent an early validation on a single turbine setup. Applications to wind farm flows will follow.

WP2: Improve tools User Experience

Three Python tools have been developed or improved :

• The first tool is the wind farm previsualisation tool, 'y2_wind_previsualization', which is used before the calculation run. This provides an interactive HTML interface for viewing global data for each turbine on the farm (position, hub height, yaw angle, etc.). The tool traces all of these via the parsing of the input file.
• The second tool is for duplicating rotor templates for a wind farm (`y2_wind_duplication`). This tool was developed in the previous ECFD, but this time it has been refactored and incorporated into the y2tools package.
• The third and final tool is a post-processing tool for the temporal processing of global wind turbine simulation metrics (Thrust, Power, etc.), `y2_post_wind`. This tool generates an interactive HTML plot of time-dependent global quantities.

T5 - Improve atmospheric inflow turbulence - Ulysse VIGNY (UMONS), Pierre BENARD (CORIA), Etienne MULLER (CORIA & SGRE), Hakim HAMDANI (GDTech), Félix HOUTIN-MONGROLLE (SGRE), Anand PARINAM (CORIA & TUDelft), Hari MULAKALOORI (CORIA), Léa VOIVENEL (CORIA)

Atmospheric inflow turbulence is generated using the precursor database method. A half-channel flow driven by a pressure gradient is used to obtain the inflow which is used as inlet boundary condition for the wind turbine simulation domain. This project aimed to improve the whole methodology, from generation to injection.

• WP1: Improve inflow generation

The inflow generation using a velocity controller implementation was initially unstructured and lacked robustness. This PID-based velocity controller allows users to impose a specified velocity and direction at a given height, primarily for atmospheric flow simulations in wind farms. During the workshop, the controller was integrated into the source code by applying velocity forcing as a source term in the flow field. The approach utilizes a target velocity, interior boundary and specification of the ground boundary. Additionally, when using the logarithmic law in atmospheric flows, inconsistencies between the computed and the intended wall shear stress for the target velocity sometimes led to diverging velocity profiles. This was due to mismatches in the source terms. To address this, the wall shear stress is now computed for the target velocity and imposed as a source term, ensuring consistency and stability.

• WP2: Improve injection methodology (method A)

The previous workflow used plane probes in the ASCII format to sample the flow. The COWIT2 toolbox was used to convert the file into turbulence box (.man format). While functioning, this methodology had two major flaws. First the probe files are heavy ~O(10Go). Second, the method requires a lot of human effort, allowing numerous sources of errors. During this workshop, a new methodology has been developed. First, the probes are generated using the HDF5 format (now available for all probe types), leading to lighter file ~O(1Go). Second, Y2_tools is used to read HDF5 format (working for probes and temporals). HDF5 file is then converted into a Look-up Table. Finally, the Look-up Table is read directly by YALES2 as a boundary conditions.

• WP3: Improve injection methodology (method B)

Even though improvements achieved in WP2 prove to be very handy while removing many potential human errors, injecting a turbulent inflow through wind boxes ('offline' precursor approach) can sometimes remain cumbersome for several reasons: (1) no periodicity is enforced in the streamwise direction of those boxes, (2) potential high memory consumption, and (3) the boxes need to be moved to other cores whenever a mesh adaptation occurs. An alternative consists in co-simulating the precursor flow and the flow of interest (refered as the 'successor' simulation) at the same time ('online' precursor approach). The inlet boundary condition for the successor flow is then obtained by mapping the outflow of the precursor domain. During the workshop, some work has been initiated to implement this kind of coupling using the CWIPI library, for which YALES2 provides already an interface.

T6 - FSI model in Dorothy - Enzo MASCRIER (LOMC), Grégory PINON (LOMC)

The objective of the project was to enhance the numerical code Dorothy (developed at LOMC laboratory) to perform fluid-structure interaction studies. To achieve this goal, wind turbine blades must be capable of deforming in response to the incoming flow. The prediction of the blade deformation is modeled by a Timoshenko beam approach.

The code is presently written in a way that keeps the blades always in the rotor plane. Additionally, particles are currently emitted based on a local frame at each blade section. In a near future, when the blade will deform, this will change the orientation of the particles. Therefore, the particle emission must be updated accordingly to reflect these deformations.

During ECFD8, a forced blade motion case was coded and tested, allowing us to verify particle’s emission. This work will be further developed to deform the blade dynamically using the structural solver code at each time step.

Two Phase Flow - J. Leparoux, SAFRAN & J. Carmona, CORIA

TP1 - Towards very small contact angles in Nucleate boiling

Participants: Henri Lam (LEGI), Mohammad Umair (LEGI), Manuel Bernard (LEGI), Robin Barbera (LEGI) and Giovanni Ghigliotti (LPSC)

The boiling solver (BOI) was not able to accurately impose a contact angle (angle formed by the two-phase interface on the wall) at values lower than 30°. This angle is needed when simulating nucleate boiling. A similar limitation in contact angle value was applying to the spray (SPS) solver. A modified version of the level set reinitialization has been implemented during ECFD8, based on a different normal vector in the blind spot region around the contact line, vector now chosen to be a zero-order extension from outside the blind spot. This modification, that implied other modifications to the level set reinitialization in the blind spot, has been tested successfully on the spray solver (where no phase change occurs). Then, this new reinitialisation has been tested in the boiling solver for nucleate boiling, with great improvements. Now simulations of nucleate boiling at very small contact angle (10°) can be accurately performed. In the meanwhile, the level set reinitialization algorithm has been streamlined and the computational cost greatly reduced, resolving a computational cost issue that appeared when using the contact angle imposition both in the spray and boiling solvers, and that hampered its use in industrial configurations.

TP2 - Modeling spray-film interactions

Participants: Nicolas Gasnier (EM2C-SafranTech), Julien Leparoux (SafranTech), Mehdi Helal (CORIA-SafranTech) and Julien Carmona (CORIA)

The numerical simulation of sheared liquid films over walls with conventional high-fidelity methods requires fine meshes to depict accurately the dynamics of the fluids, as well as the gas-liquid interactions at the phase interface. In the context of thin film flows (with a thickness h ~ 1.0E-4 m), the spatial resolution required to ensure the validity of the simulations can be computationally prohibitive. To tackle this issue, a reduced-order model of thin film dynamics based on the Saint Venant equations has been implemented in the YALES2 platform over the last months. This numerical model is able to reproduce accurately the dynamics of strongly sheared film flows over partially wetted surfaces, and to take into account capillary effects. The objective of the ECFD8 was to couple the thin film framework with the pre-existing multiphase methods of the YALES2 platform: the Eulerian multiphase solver - based on the ACLS -, and the Lagrangian solver. This coupling was performed in three steps: first, a numerical method was designed to convert impinging Lagrangian droplets into source terms for the thin film model. Then, a phenomenological model was implemented to depict the atomization of films at sharp edges under the action of a high speed gas flow. The liquid film is converted into Lagragian droplets, whose dimensions are computed based on the PAMELA model. Finally, a numerical method has been designed to convert Eulerian droplets into source terms for the film model. This method is based on a transfer of the liquid properties from the nodes to the boundaries by using a set of fictitious particles. It ensures conservation of the liquid mass, and it is more robust than the first attempts that had been made during ECFD7.

TP3 - High-fidelity two-phase flow simulations of the purge of a fuel feed line

Participants: Thomas LAROCHE (Safran HE), Romain JANODET (Safran AE), Julien Leparoux (Safran Tech) and Melody Cailler (Safran Tech)

During the second week of the ECFD8, the fuel feed line purge process has been numerically investigated. In the context of aeronautical engines, the fuel feed line—carrying the fuel from the fuel tank to the injectors within the combustion chamber—needs to be purged at engine shutdown. This is intended to prevent fuel stagnation near hot metal parts, which could lead to coke formation and therefore decrease engine performance. Since this complex phenomenon is mainly driven by two-phase flow physics, the spray solver (SPS) of the YALES2 library has been considered in order to understand the physics of such process. The numerical setup was first converged on a simplified test case: the possibility of driving the flow dynamics with inlet and outlet pressure conditions was tested beforehand on a single-phase, incompressible case, and then on a two-phase flow problem. The setup has then been successfully applied to an industrial configuration: a pressure-swirl injector connected to a reduced portion of the fuel feed line. Due to the large scale of the domain, the interface resolution was set to 50μm, which is intentionally coarse for such problem. This initial computation successfully ran up to 3ms of physical time during the workshop, proving YALES2's capability to model the fuel purge. The computation is to be continued and analyzed further even after the workshop.

TP4 - Volume of Fluid solver in YALES2

Participants: Léa Voivenel (CORIA), Julien Carmona (CORIA), Mehdi Helal (CORIA), Pierre Portais (CORIA), Julien Leparoux (Safran Tech), Mélody Cailler (Safran Tech) and Nicolas Gasnier (EM2C / Safran Tech)

The aim of this project was to develop an alternative strategy to the ACLS method already implemented in Yales2 to investigate incompressible two phase flows. The Volume of Fluid (VoF) methods were chosen as they show excellent performances, with interesting qualities such as inherent conservation of mass. Nevertheless, they remain challenging in an unstructured mesh framework. The work conducted during ECFD8 can be divided into two parts.

First of all, we aimed to robustify and improve the new Volume of Fluid Solver (VFS) where a liquid volume fraction is transported with an imposed velocity field. In this simplified framework several resharpening strategies to counteract the liquid volume fraction numerical diffusion were explored. On one hand, a compressive velocity only acting at the interface was implemented as a source term in the Volume Fraction transport equation, ${\frac {\partial \alpha }{\partial t}}+\nabla \cdot (\alpha {\boldsymbol {u}})=\nabla .\left({\begin{array}{l}\alpha (1-\alpha )^{\begin{array}{c}\end{array}}C_{\gamma }|{\boldsymbol {u}}|{\boldsymbol {n}}_{\Gamma }\end{array}}\right)$. While satisfactory results were obtained, several improvements were identified: compute the source term at pairs instead of nodes and to investigate the influence of $C_{\gamma }$ depending on the numerical scheme. On the other hand, a strategy based on the solving of a "resharpening equation" at each timestep $\partial _{\tau }\alpha +{\underline {\nabla }}\cdot (\alpha (1-\alpha ){\underline {n}}-D({\underline {\nabla \alpha }}\cdot {\underline {n}}){\underline {n}})=0$ was also explored. This second approach seemed more efficient but its cost must still be evaluated.

Finally, the second axis of this work aimed at coupling the liquid volume fraction transport with the momentum equation. A first working version of this new solver was proposed at the end of the 2 weeks. The next steps are the integration of the resharpening methods presented in the above section, the investigation of the problem of Poisson convergence for higher order schemes and the addition of the surface tension.

TP5 - Implement a local operator to distribute the solid volume of a particle over multiple cells

Participants: Théo Ndereyimana (Université de Sherbrooke), Stéphane Moreau (Université de Sherbrooke)

In the CFD-DEM, the cell size is required to be larger than the particle size for stability condition and keep feasible solid volume fraction. However, some applications require a cell size smaller than the particle. During this 8th edition of the ECFD, the use of operators to distribute the particle volume over multiple cells, ensuring a feasible solid volume particle has been tested on a fluidized bed configuration. The main operators tested (gather-scatter filter and gaussian filter) showed a tendency to blur the void structure interfaces. The equivalence of the gaussian filter of bandwidth $b$ and the resolution of a diffusion equation over a pseudo-time $T=b^{2}/4$ has been verified. One anisotropic diffusion constant has been tested and shows a possibility to adress the sharpness requirements.

Another objective was to develop a post-processing tool to detect and track the void structures (bubbles) in a fluidized bed. Based on previous work from J. Carmona, a tool to track the bubbles has been initiated.

TP6 - Complex thermodynamics in sloshing tanks

Participants: C. Merlin (AGS), D. Fouquet (CORIA), V. Moureau (CORIA), J. Carmona (CORIA) and G. Lartigue (CORIA)

During this ECFD, the phase change solver was improved. After introduction of conservative transport for enthalpy and energy, a new framework for multi fluid two phase flow was used that relies on a new reinitialization of the conservative level set, the transport of discontinuous scalars like temperature, energy or enthalpy and the transport of weight to ensure consistency. The pressure loop was improved to ensure mass and energy conservation while meeting the low Mach hypothesis. Many 1D test cases were performed with only the gas phase and two phase flow to validate the pressure loop. The new framework for the transport of discontinuous scalar was first derived for temperature with constant properties in each phase. A first step was to extend it to sensible enthalpy with ideal gas behavior for the gas phase. Then, the framework was extended to NIST tabulated gas & liquid with ideal or real gas behavior. After some 2D cases, a tank pressurization test was investigated as well as a sloshing test without phase change (just the pressure drop due to the increase of the thermal exchange between the liquid and the gas phase).

Combustion - Y. Bechane, CORIA & S. Dillon, SAFRAN & K. Bioche, CORIA

C1 - LES of the thermal degradation of a composite material

Participants: A. Grenouilloux (ONERA), K. Bioche (CORIA), N. Dellinger (ONERA) and R. Letournel (SafranTech)

The FIRE test bed is an experimental air-propane burner operated by ONERA. It is dedicated to the study of the thermal degradation of composite materials. This project concerned the implementation of a three-solver coupling methodology to simulate the dynamics of the impinging flame. The methodology considered is based on the coupling between the variable density solver (VDS) and the radiative solver (RDS) of the massively parallel library YALES2 and the solver dedicated to the degradation of composite materials, MoDeTheC, developed by ONERA. Given the typical test times of the order of tens of seconds, a methodology based on 2D axisymmetric calculations was considered. Various tests were performed to determine the optimal coupling frequency between solvers. Cases dedicated to the injection of pyrolysis gasses were set up, with the aim of simulating the auto-ignition phenomenon. Comparisons with experimental data are presented.

C2 - Hydrodynamic and compressibility effects induced by NRP plasma discharges in reactive mixtures

Participants: S. Wang (EM2C), Y. Bechane (CORIA), B. Fiorina (EM2C)

To reduce the expensive computational cost of Plasma-Assisted Combustion (PAC) full 3D simulations, the EM2C laboratory has developed phenomenological approaches to model Nanosecond Repetitively Pulsed (NRP) plasma discharges in reacting flows: Castela et al. (2016) and Blanchard et al. (2023). From previous ECFDs, the above-mentioned models were implemented and validated in the Low-Mach number (YALES2-VDS) and Compressible (YALES-ECS) frameworks. The main objective of ECFD8 was to assess the hydrodynamic and compressibility effects induced by the nanosecond plasma discharges with ECS solver. First, the hydrodynamic instabilities were successfully computed through 3D simulations of the pin-to-pin configuration. Then, the 3D flow tunnel configuration was successfully simulated with the plasma-assisted turbulent combustion modeling in compressible framework. In addition, during this workshop, HP-adaptation (hybrid schemes) was tested on the simulated configurations, and new features for the plasma discharge object were implemented.

C3 - Extending and validating a generalized formalism of virtual chemistry

Participants: M. Préteseille (EM2C), E. Espada (EM2C), N. Galand (EM2C), N. Darabiha (EM2C), B. Fiorina (EM2C)

Virtual chemistry presents a promising approach by creating optimized reduced mechanisms of chemical species and reactions to mimic specific flame characteristics. This method has successfully modeled the combustion of various fuels, including complex pollutants like NOx. However, its reliance on tabulated parameters has limited its adoption due to the need for modifications in traditional CFD solvers. This work aims to revise the formalism to eliminate parameter tabulation, creating highly reduced virtual mechanisms that emulate detailed schemes used in software like CHEMKIN and Cantera. The methodology is divided into three steps. A first optimization is achieved, focusing on mixture's thermodynamic properties to recover gas thermochemical equilibrium states across various equivalence ratios. The optimization of Arrhenius reaction rates on reference 0D reactors is then carried out to match temperature and heat release rate profiles. A final optimization is undertaken to find the optimal set of species' transport properties to capture complex diffusion phenomena on 1D laminar premixed flames. This methodology is applied to optimize a virtual scheme dedicated to Sustainable Aviation Fuel (SAF), illustrating the potential and versatility of the method to create highly reduced kinetic mechanisms for any desired fuel.

C6 - Flame stabilitity of flame-holders within reheat conditions

Participants : N. Detomaso (Safran AE), R. Janodet (Safran AE), L. Carbajal (Safran AE)

The mechanisms of flame stabilisation in a flame-holder are still not completely understood. This is particularly true for reheat conditions : the hot viciated gases at inlet, highly compressible flows, and a strong liquid/gas coupling make the flame stability hard to predict. During the ECFD8, simplified configurations of flame-holders within reheat conditions were analysed. After some try and error simulations due to simplifications of the flame-holders, cases leading to flame stability (or not) were identified. Post-processing tools were developped in order to recover criteria relevant to the flame stability. This step marks the beginning of a systematic mapping of dimensionless characteristic times ratios, and a comparison with integral quantities.

C8 - A first step toward hybrid CPU / GPU for reactive flow in YALES2

Participants: M. Laignel (CORIA), G. Lartigue (CORIA), K. Bioche (CORIA) and V. Moureau (CORIA)

In numerical simulations of reacting flows, one of the most computationally intensive tasks is the evaluation of source terms resulting from chemical reactions in the species transport equations. This step can account for up to 90% of the total simulation cost , depending on the complexity of the kinetic mechanism involved. To reduce this cost, various techniques such as mechanism reduction, virtual chemistry, etc. have been explored. However, the emergence of GPUs as powerful accelerators offers a promising alternative by providing massive parallelism. Despite their potential, GPUs often require significant adaptation of CPU-based codes. This project aims to address this challenge by taking a first step towards a hybrid CPU/GPU framework for reactive flow simulations. Specifically, the focus is on coupling Y2 with the updated version of the stiff time integration solver (CVODE), which is compatible with GPU (CUDA, HIP, OpenMP). The ultimate goal is to establish a foundation for hybrid computations by implementing and testing the updated solver on simplified test cases.

C12 - Dynamic sub-grid-scale modelling of multi-regime flame wrinkling

Large-eddy-simulation (LES) of reactive flows is widely used in both academic and industrial applications. Combustion phenomena occur at a scale often smaller than the LES mesh size, therefore, turbulent combustion models are required to account for unresolved turbulent flame interactions. The modeling of sub-grid-scale (SGS) flame turbulence interactions can be described with a flame surface wrinkling factor which measures the ratio of the total flame surface area to the resolved flame surface area. Flame surface wrinkling models are often expressed by assuming equilibrium between turbulent motions and flame surface wrinkling, however, in realistic burners non-equilibrium is present and dynamic models are needed to adapt model parameters. Current dynamic models identify flame surface areas from scalars such as the progress variable ${\widetilde {c}}$ or the mixture fraction ${\widetilde {z}}$, however, in multi-regime flames where filtered gradients ${\overline {|\nabla c|}}$ and ${\overline {|\nabla z|}}$ coexist, such approaches tend to fail. In this project we introduced a multi-regime dynamic formalism for determining flame wrinkling factors based on a mixed approach between premixed and diffusion flame surfaces. Model validation was performed using a DNS database of the HYLON configuration, a dual-swirl coaxial H2/air injector. The operating condition of interest was the lifted flame, HYLON L, which was studied in the framework of the turbulent flame workshop TNF. This flame has characteristic behavior of both non-premixed and partially-premixed flames, which allowed the model to be tested under conditions where iso-surfaces of ${\widetilde {c}}$ and ${\widetilde {z}}$ coexist.

User Experience & Data - L. Korzeczek, GDTECH

U1 - Low-fidelity (RANS) rotor/stator simulations, application to Kaplan Turbine -

Participants: Yayha Lakrifi, Guillaume Balarac (LEGI), Renaud Mercier (SAFRAN), Vincent Moureau (CORIA)

RANS rotor/stator coupling simulation has recently been developed within YALES2. This approach involves coupling the rotor, in the rotational frame, with the stator using a patch located at the domain interface. This patch allows interaction between the two regions and enables azimuthal averaging to account for azimuthal periodicity.

This year, the main objective was to improve the automatic mesh convergence (AMC) procedure for coupled RANS simulations by managing the AMC of coupled runs, integrating coupling runs into the workflow, which was not previously supported and, finally, implementing parallel remeshing of periodic boundaries.

U2 - Coupling PyTorch/YALES2, combustion cartesian look-up tables

Participants: Julien Leparoux (Safran Tech), Kévin Bioche (CORIA), Ghislain Lartigue (CORIA), Nicholas Treleaven (Safran Tech)

Neural Networks offer a promising alternative to Cartesian look-up tables for combustion simulations, reducing memory footprint. In this project, we investigated how to integrate an NN model for real-time inference in the YALES2 platform, exploring two approaches: a Python interface and a Fortran Torch binding (using FTorch[1]). We validated that the model remains accurate when embedded online and identified improvements for robustness. Inference costs were evaluated on a Mac M3 and the Austral cluster, revealing a strong dependency on data volume. To optimize efficiency, we propose grouping cells at the processor level.

U3 - Yales2 Trame Editor, toward a fully featured graphical user interface for YALES2

Participants: Laurent Korzeczek, Serge Meynet (GDTECH), Julien Leparoux, Melody Cailler (SAFRAN)

Currently, the YALES2 user experience relies mainly on scripted tools such as text editors and command-line interfaces for tasks ranging from setting up input files to monitoring calculations. Additionally, tools like ParaView are used for visualizing results. The goal of this project was to design and develop a graphical user interface (GUI) for YALES2, making it easier for a wider range of users to perform complex multiphysics calculations through an intuitive and well-structured interface. The initial version of this interface has been created using the Trame framework, an open-source platform developed by Kitware. This framework offers several benefits, such as access to various graphic libraries, ease of development with Python, and straightforward deployment. The interface can now locally set up, run, and monitor simple incompressible flow calculations. Throughout the development, a test-driven development (TDD) methodology was followed, ensuring the creation of high-quality, robust, and maintainable code.

U4 - Deep Refactoring of an excessive OOP structure in the SCHEMA-based Opentea3 GUI generator

Participants: Antoine Dauptain (CERFACS), Thibault Marzlin (CERFACS)

Opentea3 is an interface generator using the SCHEMA standard to create UIs with forms, visual cues, and 2D/3D feedback. Used at Safran for three years, it suffers from a visual cue changing unexpectedly due to an overly object-oriented design, making status management complex and fixes risky. A key code smell is the use of = for recursive updates. Refactoring focused on code metrics to clarify abstractions, reducing code size by 21% while maintaining lexical scope. Structural complexity was halved, improving readability, but cyclomatic complexity doubled, exposing business logic. This trade-off enhances maintainability with a more direct logic management.