A differentiable software suite for accelerated simulation of turbulent flows

Dit artikel presenteert IncompressibleNavierStokes.jl, een open-source Julia-pakket dat differentieerbare, hardware-onafhankelijke kernels en geheugenoptimalisaties combineert om turbulente stromingen op hoge resolutie te simuleren en het trainen van neurale netwerkbegrenzingsmodellen binnen grote-eddy-simulaties mogelijk te maken.

De kern

Stel je voor dat je een gigantische, complexe stad wilt simuleren. Maar in plaats van auto's en mensen, zijn het deeltjes lucht die door straten (buizen) en pleinen (open ruimtes) bewegen. Dit is wat wetenschappers doen bij het simuleren van turbulente stromingen, zoals wind die om een gebouw waait of water dat door een rivier stroomt.

Dit artikel introduceert een nieuwe digitale tool genaamd IncompressibleNavierStokes.jl (we noemen het kortweg INS.jl). Het is een stuk software geschreven in de programmeertaal Julia, ontworpen om deze lucht- en waterbewegingen extreem snel en nauwkeurig te berekenen.

Hier is hoe het werkt, vertaald naar alledaagse taal:

1. De "Sneeuwschoen" voor de Computer (Efficiëntie)

Stel je voor dat je een enorme muur van legoblokjes moet bouwen. De oude software (zoals MATLAB) deed dit door voor elke stap een enorme lijst met instructies op te slaan. Dat was als een bibliotheek vol met papieren die je elke keer opnieuw moest lezen. Het kostte veel ruimte en tijd.

INS.jl doet het anders. Het gebruikt een slimme "sneeuwschoen"-techniek. In plaats van de hele lijst op te slaan, berekent het de instructies pas op het moment dat ze nodig zijn.

• Het resultaat: Je kunt nu veel grotere simulaties draaien op één enkele grafische kaart (zoals die in een gaming-computer), zelfs met een dubbele precisie (zeer nauwkeurig). Het is alsof je een hele stad in 3D kunt simuleren op je laptop, terwijl je daarvoor een supercomputer nodig had.

2. De "Spiegel" die Alles Kan (Differentieerbaarheid)

Dit is misschien wel het coolste deel. Stel je voor dat je een robot bouwt die moet leren hoe hij het beste door een storm kan vliegen. Normaal gesproken moet je de robot duizenden keren laten vallen, kijken wat er misgaat, en dan handmatig de instructies aanpassen. Dat is traag.

INS.jl heeft een ingebouwde "spiegel" of terugspoorfunctie.

• Hoe het werkt: Als de simulatie een fout maakt, kan de software niet alleen zeggen "dit ging mis", maar ook precies vertellen: "Als je dit ene knopje 0,001% anders had gedraaid, was het resultaat perfect geweest."
• De toepassing: Hierdoor kunnen kunstmatige intelligentie (AI) modellen direct in de simulatie worden getraind. De AI leert van zijn eigen fouten terwijl de simulatie draait, net als een speler die in een videogame direct leert van elke dood.

3. De "Meesterkoks" (Neurale Netwerken)

In de wereld van stromingssimulaties zijn er twee manieren om te koken:

1. Directe Numerieke Simulatie (DNS): Je kookt elk klein detail van het gerecht. Dit is extreem nauwkeurig, maar duurt eeuwen.
2. Large Eddy Simulation (LES): Je kookt alleen de grote stukken vlees en gebruikt een recept (een "sluitingsmodel") om te voorspellen hoe de kleine kruiden zich gedragen. Dit is sneller, maar je recept moet goed zijn.

INS.jl laat AI de recepten schrijven. In plaats van een statisch recept te gebruiken, leert de AI het recept direct uit de data. Omdat de software "differentieerbaar" is (zie punt 2), kan de AI het recept continu verbeteren terwijl het de simulatie draait.

4. De "Bouwpakket" (Software Ontwerp)

De makers van deze software hebben het ontworpen als een Lego-bouwpakket.

• Het is gemaakt om makkelijk aan te passen. Wil je temperatuur toevoegen (zoals bij een hete luchtballon)? Geen probleem, je plakt er gewoon een nieuw blokje bij.
• Het werkt op zowel gewone computers als op krachtige videokaarten (GPUs). De code is zo geschreven dat het automatisch weet of het op een CPU of GPU moet draaien, alsof je een auto hebt die zowel op benzine als elektriciteit kan rijden zonder dat je de motor hoeft te vervangen.

5. De "Testbaan" (Betrouwbaarheid)

Wetenschappers zijn vaak sceptisch over nieuwe software. Om te bewijzen dat dit werkt, hebben de auteurs de software laten racen tegen een bekende "kampioen" (referentiedata).

• Ze simuleerden een turbulente stroom in een kanaal (zoals water in een afvoerpijp) en vergeleken het met de beste bestaande metingen.
• Het resultaat: De software deed het bijna perfect. De snelheid en de draaikolken kwamen overeen met de echte wereld.

Samenvatting in één zin

INS.jl is een revolutionaire, open-source simulator die het mogelijk maakt om complexe lucht- en waterstromingen niet alleen super snel te berekenen, maar ook om er direct slimme AI-modellen in te laten leren, allemaal op één computer zonder ingewikkelde tussenstappen.

Het is alsof je van een simpele tekenpot bent gegaan naar een 3D-printer die zichzelf kan verbeteren terwijl hij print.

Technische samenvatting

Titel: Een differentieerbare software-suite voor versnelde simulatie van turbulente stromingen

Auteurs: Syver Døving Agdestein en Benjamin Sanderse (CWI & TU/e)

---

1. Het Probleem

De simulatie van turbulente stromingen, zoals Directe Numerieke Simulatie (DNS) en Large-Eddy Simulatie (LES), is computationeel zeer intensief. Traditionele CFD-solvers (Computational Fluid Dynamics) hebben vaak te kampen met de volgende beperkingen:

• Hoge geheugeneisen: Het opslaan van grote, dunbevolkte matrices voor discrete operatoren beperkt de haalbare resolutie, vooral op GPU's.
• Gebrek aan differentieerbaarheid: Het trainen van neurale netwerken als "closure models" (sluitingsmodellen) voor LES vereist vaak het differentiëren door de hele solver heen. Bestaande frameworks koppelen vaak Python-ML-bibliotheken aan externe CFD-codes, wat leidt tot overhead en complexiteit door inter-taal communicatie.
• Hardware-afhankelijkheid: Veel codes zijn geoptimaliseerd voor specifieke hardware (CPU of GPU), wat de portabiliteit beperkt.

2. Methodologie

De auteurs presenteren IncompressibleNavierStokes.jl (INS.jl), een open-source pakket geschreven in de programmeertaal Julia. De kern van de aanpak omvat:

• Numerieke Discretisatie:

  • Oplossing van de incompressibele Navier-Stokes-vergelijkingen op gestaggerde Cartesische roosters (staggered grids).
  • Tweede-orde eindige-volume discretisatie.
  • Ondersteuning voor zowel uniforme als niet-uniforme roosters (met rekfuncties zoals cosinus, tanh en geometrisch).
  • Tijdsintegratie via expliciete Runge-Kutta-methoden (o.a. SSP33, Wray3) met een projectiestap voor de druk (Poisson-vergelijking) om de divergentievrije voorwaarde te handhaven.

• Software-architectuur en Hardware-onafhankelijkheid:

  • Matrix-vrije kernels: In plaats van het opslaan van grote matrices, worden alle operatoren (divergentie, gradiënt, diffusie, convectie) geïmplementeerd als kernels.
  • Hardware-agnostisch: Danks KernelAbstractions.jl wordt dezelfde broncode gecompileerd voor multi-threaded CPU's en GPU's, afhankelijk van het type invoerarray.
  • Geheugenoptimalisatie: Gebruik van muterende (mutating) functies die vooraf toegewezen buffers herschrijven in plaats van nieuwe arrays te alloceren. Dit maakt DNS tot $840^3$ punten op één GPU (bijv. NVIDIA H100) mogelijk.

• Differentieerbaarheid (Differentiable Programming):

  • De solver is volledig differentieerbaar via reverse-mode automatic differentiation (AD) met Zygote.jl.
  • Omdat standaard AD-frameworks geen toegang hebben tot de pullback-regels van matrix-vrije kernels, hebben de auteurs handgeschreven adjoint-kernels voor alle discrete operatoren gedefinieerd via ChainRules.jl.
  • Dit stelt onderzoekers in staat om neurale netwerken als sluitingsmodellen te trainen terwijl ze ingebed zijn in de LES-solver (a-posteriori training), zonder externe koppelingen.

3. Belangrijkste Bijdragen

1. Eerste volledig differentieerbare CFD-solver in Julia: INS.jl combineert DNS/LES-simulatie direct met neurale netwerken in één omgeving, wat de noodzaak voor middleware tussen Python en C++/Fortran elimineert.
2. Handgeschreven adjoint-kernels: Een cruciale bijdrage die efficiënte reverse-mode differentiatie door de hele solver mogelijk maakt, zelfs voor niet-lineaire convectietermen en complexe randvoorwaarden.
3. Extreem geheugenefficiënte DNS: Door array-reuse, low-storage Runge-Kutta-methoden en trage berekening van tensorcomponenten, wordt dubbel-precisie DNS op hoge resolutie mogelijk op consumenten- en datacenter-GPU's.
4. Robuuste software-engineering: Het project volgt professionele praktijken zoals versiebeheer (Git), geautomatiseerde tests, continue integratie (GitHub Actions), literate programming voor voorbeelden, en archivering op Zenodo voor reproduceerbaarheid.

4. Resultaten

De software is gevalideerd aan de hand van twee hoofdtestcases:

• Analytische Validatie (2D Taylor-Green Vortex):

  • De solver toont een schone tweede-orde convergentie voor zowel uniforme als niet-uniforme roosters.
  • Precisie-onderzoek: Dubbel-precisie (Float64) levert betrouwbare resultaten. Enkel-precisie (Float32) is bruikbaar voor matige resoluties, maar vertoont convergentieverlies bij zeer fijne roosters door afrondingsfouten. Half-precisie (Float16) is momenteel niet levensvatbaar voor de ruimtelijke discretisatie in deze context.

• Turbulente Kanaalstroom (Re$\tau$ = 180):

  • DNS: De gemiddelde stroomsnelheidsprofielen en RMS-fluctuaties komen uitstekend overeen met referentiedata (Vreman & Kuerten). Kleine afwijkingen in hogere orde momenten worden toegeschreven aan het gebruik van een tweede-orde schema in plaats van een vierde-orde schema.
  • LES: Verschillende wervelviscositeitsmodellen (Smagorinsky, WALE, QR, Vreman) zijn getest.
    • Het Smagorinsky-model bleek te dissipatief bij wanden (niet-nul viscositeit).
    • Modellen zoals WALE, QR en Vreman presteerden beter en kwamen dichter bij de DNS-referentie, wat de correcte implementatie van de sluitingsmodellen bevestigt.

5. Betekenis en Toekomstperspectief

Deze paper markeert een belangrijke stap in de integratie van machine learning en CFD.

• Wetenschappelijke Impact: Het maakt het mogelijk om data-gedreven sluitingsmodellen te trainen die fysiek consistent zijn met de onderliggende vergelijkingen, wat de nauwkeurigheid van LES kan verbeteren.
• Technologische Impact: Het demonstreert dat Julia een krachtige taal is voor high-performance wetenschappelijk rekenen, waarbij het gemak van hoog-niveau programmering wordt gecombineerd met de snelheid van gecompileerde code en native GPU-ondersteuning.
• Toekomst: De auteurs zien uitbreiding naar multi-node simulaties (via MPI en domeindecompositie), hogere-orde discretisaties (vierde orde), en het gebruik van mixed-precision strategieën om de prestaties op moderne GPU-hardware verder te maximaliseren.

Kortom, INS.jl biedt een uniek, open-source platform dat de barrière tussen traditionele numerieke stromingsleer en moderne differentieerbare programmeertechnieken doorbreekt.