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).

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.

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

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.

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

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).

T4 - Improve wind farm modeling and simulation workflow

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

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

Anand: pressure controller

• 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.

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)

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)

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)

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.

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.

User Experience & Data - L. Korzeczek, GDTECH

U2 - Coupling PyTorch/YALES2, combustion cartesian look-up tables - J. Leparoux, N. Treleaven, S. Dillon (SAFRAN), K. Bioche, G. Lartigue (CORIA)

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.