fluidsim

Par mkurman · zorai

Framework de simulation en dynamique des fluides computationnelle avec Python. À utiliser pour les simulations de dynamique des fluides incluant les équations de Navier-Stokes (2D/3D), les équations en eaux peu profondes, les écoulements stratifiés, ou pour l'analyse de la turbulence, de la dynamique des vortex ou des écoulements géophysiques. Fournit des méthodes pseudospectrales avec FFT, un support HPC et une analyse complète des sorties.

npx skills add https://github.com/mkurman/zorai --skill fluidsim

FluidSim

Vue d'ensemble

FluidSim est un framework Python orienté objet pour les simulations haute performance en dynamique des fluides numérique (CFD). Il fournit des solveurs pour des équations en domaines périodiques utilisant des méthodes pseudospectrales avec FFT, offrant des performances comparables à Fortran/C++ tout en conservant la facilité d'utilisation de Python.

Points forts clés :

  • Multiples solveurs : Navier-Stokes 2D/3D, eaux peu profondes, écoulements stratifiés
  • Haute performance : compilation Pythran/Transonic, parallélisation MPI
  • Workflow complet : configuration des paramètres, exécution de la simulation, analyse des résultats
  • Analyse interactive : post-traitement et visualisation basés sur Python

Capacités principales

1. Installation et configuration

Installez fluidsim avec uv en utilisant les drapeaux de fonctionnalités appropriés :

# Installation basique
uv uv pip install fluidsim

# Avec support FFT (requis pour la plupart des solveurs)
uv uv pip install "fluidsim[fft]"

# Avec MPI pour le calcul parallèle
uv uv pip install "fluidsim[fft,mpi]"

Définissez les variables d'environnement pour les répertoires de sortie (optionnel) :

export FLUIDSIM_PATH=/path/to/simulation/outputs
export FLUIDDYN_PATH_SCRATCH=/path/to/working/directory

Aucune clé API ou authentification requise.

Voir references/installation.md pour les instructions d'installation complètes et la configuration de l'environnement.

2. Exécuter des simulations

Le workflow standard comprend cinq étapes :

Étape 1 : Importer le solveur

from fluidsim.solvers.ns2d.solver import Simul

Étape 2 : Créer et configurer les paramètres

params = Simul.create_default_params()
params.oper.nx = params.oper.ny = 256
params.oper.Lx = params.oper.Ly = 2 * 3.14159
params.nu_2 = 1e-3
params.time_stepping.t_end = 10.0
params.init_fields.type = "noise"

Étape 3 : Instancier la simulation

sim = Simul(params)

Étape 4 : Exécuter

sim.time_stepping.start()

Étape 5 : Analyser les résultats

sim.output.phys_fields.plot("vorticity")
sim.output.spatial_means.plot()

Voir references/simulation_workflow.md pour les exemples complets, le redémarrage des simulations et le déploiement sur cluster.

3. Solveurs disponibles

Choisissez le solveur en fonction du problème physique :

Navier-Stokes 2D (ns2d) : turbulence 2D, dynamique des vortex

from fluidsim.solvers.ns2d.solver import Simul

Navier-Stokes 3D (ns3d) : turbulence 3D, écoulements réalistes

from fluidsim.solvers.ns3d.solver import Simul

Écoulements stratifiés (ns2d.strat, ns3d.strat) : écoulements océaniques/atmosphériques

from fluidsim.solvers.ns2d.strat.solver import Simul
params.N = 1.0  # fréquence de Brunt-Väisälä

Eaux peu profondes (sw1l) : écoulements géophysiques, systèmes en rotation

from fluidsim.solvers.sw1l.solver import Simul
params.f = 1.0  # paramètre de Coriolis

Voir references/solvers.md pour la liste complète des solveurs et des conseils de sélection.

4. Configuration des paramètres

Les paramètres sont organisés hiérarchiquement et accessibles via la notation pointée :

Domaine et résolution :

params.oper.nx = 256  # points de grille
params.oper.Lx = 2 * pi  # taille du domaine

Paramètres physiques :

params.nu_2 = 1e-3  # viscosité
params.nu_4 = 0     # hyperviscosité (optionnel)

Avancement dans le temps :

params.time_stepping.t_end = 10.0
params.time_stepping.USE_CFL = True  # pas de temps adaptatif
params.time_stepping.CFL = 0.5

Conditions initiales :

params.init_fields.type = "noise"  # ou "dipole", "vortex", "from_file", "in_script"

Paramètres de sortie :

params.output.periods_save.phys_fields = 1.0  # enregistrer tous les 1.0 unités de temps
params.output.periods_save.spectra = 0.5
params.output.periods_save.spatial_means = 0.1

L'objet Parameters lève une AttributeError pour les fautes de frappe, prévenant les erreurs de configuration silencieuses.

Voir references/parameters.md pour la documentation exhaustive des paramètres.

5. Sortie et analyse

FluidSim produit plusieurs types de sortie automatiquement enregistrés pendant la simulation :

Champs physiques : Vitesse, vorticité au format HDF5

sim.output.phys_fields.plot("vorticity")
sim.output.phys_fields.plot("vx")

Moyennes spatiales : Série temporelle de quantités moyennées sur le volume

sim.output.spatial_means.plot()

Spectres : Spectres d'énergie et d'enstrophie

sim.output.spectra.plot1d()
sim.output.spectra.plot2d()

Charger des simulations précédentes :

from fluidsim import load_sim_for_plot
sim = load_sim_for_plot("simulation_dir")
sim.output.phys_fields.plot()

Visualisation avancée : Ouvrir les fichiers .h5 dans ParaView ou VisIt pour la visualisation 3D.

Voir references/output_analysis.md pour les workflows d'analyse détaillés, l'analyse d'études paramétriques et l'export de données.

6. Fonctionnalités avancées

Forçage personnalisé : Maintenir la turbulence ou piloter une dynamique spécifique

params.forcing.enable = True
params.forcing.type = "tcrandom"  # forçage aléatoire corrélé en temps
params.forcing.forcing_rate = 1.0

Conditions initiales personnalisées : Définir les champs dans un script

params.init_fields.type = "in_script"
sim = Simul(params)
X, Y = sim.oper.get_XY_loc()
vx = sim.state.state_phys.get_var("vx")
vx[:] = sin(X) * cos(Y)
sim.time_stepping.start()

Parallélisation MPI : Exécuter sur plusieurs processeurs

mpirun -np 8 python simulation_script.py

Études paramétriques : Exécuter plusieurs simulations avec différents paramètres

for nu in [1e-3, 5e-4, 1e-4]:
    params = Simul.create_default_params()
    params.nu_2 = nu
    params.output.sub_directory = f"nu{nu}"
    sim = Simul(params)
    sim.time_stepping.start()

Voir references/advanced_features.md pour les types de forçage, les solveurs personnalisés, la soumission sur cluster et l'optimisation des performances.

Cas d'usage courants

Étude de turbulence 2D

from fluidsim.solvers.ns2d.solver import Simul
from math import pi

params = Simul.create_default_params()
params.oper.nx = params.oper.ny = 512
params.oper.Lx = params.oper.Ly = 2 * pi
params.nu_2 = 1e-4
params.time_stepping.t_end = 50.0
params.time_stepping.USE_CFL = True
params.init_fields.type = "noise"
params.output.periods_save.phys_fields = 5.0
params.output.periods_save.spectra = 1.0

sim = Simul(params)
sim.time_stepping.start()

# Analyser la cascade d'énergie
sim.output.spectra.plot1d(tmin=30.0, tmax=50.0)

Simulation d'écoulement stratifié

from fluidsim.solvers.ns2d.strat.solver import Simul

params = Simul.create_default_params()
params.oper.nx = params.oper.ny = 256
params.N = 2.0  # intensité de la stratification
params.nu_2 = 5e-4
params.time_stepping.t_end = 20.0

# Initialiser avec une couche dense
params.init_fields.type = "in_script"
sim = Simul(params)
X, Y = sim.oper.get_XY_loc()
b = sim.state.state_phys.get_var("b")
b[:] = exp(-((X - 3.14)**2 + (Y - 3.14)**2) / 0.5)
sim.state.statephys_from_statespect()

sim.time_stepping.start()
sim.output.phys_fields.plot("b")

Simulation 3D haute résolution avec MPI

from fluidsim.solvers.ns3d.solver import Simul

params = Simul.create_default_params()
params.oper.nx = params.oper.ny = params.oper.nz = 512
params.nu_2 = 1e-5
params.time_stepping.t_end = 10.0
params.init_fields.type = "noise"

sim = Simul(params)
sim.time_stepping.start()

Exécuter avec :

mpirun -np 64 python script.py

Validation du vortex de Taylor-Green

from fluidsim.solvers.ns2d.solver import Simul
import numpy as np
from math import pi

params = Simul.create_default_params()
params.oper.nx = params.oper.ny = 128
params.oper.Lx = params.oper.Ly = 2 * pi
params.nu_2 = 1e-3
params.time_stepping.t_end = 10.0
params.init_fields.type = "in_script"

sim = Simul(params)
X, Y = sim.oper.get_XY_loc()
vx = sim.state.state_phys.get_var("vx")
vy = sim.state.state_phys.get_var("vy")
vx[:] = np.sin(X) * np.cos(Y)
vy[:] = -np.cos(X) * np.sin(Y)
sim.state.statephys_from_statespect()

sim.time_stepping.start()

# Valider la décroissance d'énergie
df = sim.output.spatial_means.load()
# Comparer avec la solution analytique

Référence rapide

Importer le solveur : from fluidsim.solvers.ns2d.solver import Simul

Créer les paramètres : params = Simul.create_default_params()

Définir la résolution : params.oper.nx = params.oper.ny = 256

Définir la viscosité : params.nu_2 = 1e-3

Définir le temps final : params.time_stepping.t_end = 10.0

Exécuter la simulation : sim = Simul(params); sim.time_stepping.start()

Tracer les résultats : sim.output.phys_fields.plot("vorticity")

Charger une simulation : sim = load_sim_for_plot("path/to/sim")

Ressources

Documentation : https://fluidsim.readthedocs.io/

Fichiers de référence :

  • references/installation.md : Instructions d'installation complètes
  • references/solvers.md : Solveurs disponibles et guide de sélection
  • references/simulation_workflow.md : Exemples de workflow détaillés
  • references/parameters.md : Documentation exhaustive des paramètres
  • references/output_analysis.md : Types de sortie et méthodes d'analyse
  • references/advanced_features.md : Forçage, MPI, études paramétriques, solveurs personnalisés

Skills similaires

eval-bootstrap
datadog-labs / agent-skills

Générer du code d'évaluation Python à partir de traces de production LLM Datadog.

126
claude-api
anthropics / skills

Construire des applications LLM avec Claude via le SDK officiel adapté au langage.

146 952
ad-model-onboard
nvidia / skills

Automatiser l'intégration de modèles HuggingFace dans AutoDeploy avec tests et rapport.

1 033
trtllm-moe-develop
nvidia / skills

Auditer et aligner le code MoE TensorRT-LLM avec l'architecture de référence.

1 033
rowan
mkurman / zorai

Modéliser des molécules et orchestrer des workflows de chimie médicinale dans le cloud.

309