simulation-openfoam

Lancez une simulation CFD open-source OpenFOAM à partir d'une discussion en anglais : décrivez la géométrie, le fluide et les conditions opératoires en langage naturel, puis construisez et exécutez le cas en ligne de commande, et convertissez le couple sur la paroi en résultat physique (ex. courbe d'écoulement de Couette).

Qu'est-ce que simulation-openfoam ?

Cette compétence permet de réaliser une simulation CFD complète avec OpenFOAM (version ESI/OpenCFD, GPL) en partant d'une simple description en langage naturel. Elle suit un flux de travail structuré en 7 étapes : discussion, rédaction d'un fichier `case.yaml`, maillage avec `blockMesh`, construction du cas, exécution du solveur (`simpleFoam` ou `pimpleFoam`), post-traitement du couple en contrainte de cisaillement et courbe d'écoulement, puis génération d'un rapport. La compétence est conçue comme l'équivalent open-source des compétences `mstar-simulation` et `palabos-simulation` : elle utilise les mêmes conventions de discussion, de validation et de rapport, mais avec un solveur volumes finis Navier-Stokes sans licence. Elle est particulièrement adaptée aux rhéomètres de Couette, canaux et cuves agitées, et inclut des modèles de viscosité Newtonienne et non-Newtonienne (Herschel-Bulkley, Bird-Carreau, etc.). La validation Newtonienne est obligatoire avant toute simulation non-Newtonienne. La compétence est disponible dans Copilot CLI via `.github/skills/openfoam-simulation/SKILL.md`.

Compatible avec✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/marcocaggioni/openfoam-skill/tree/HEAD/.github/skills/openfoam-simulation

Installed? Explore more Développement et programmation skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Simulation OpenFOAM

OpenFOAM (openfoam.com, ESI/OpenCFD) est le standard open-source pour la CFD volumes finis, sous licence GPL, écrit en C++ avec MPI. Il n'est pas un code Boltzmann sur réseau comme M-Star ou Palabos : il résout les équations de Navier-Stokes sur un maillage, avec des modèles de viscosité intégrés (Newtonien, loi de puissance, Herschel-Bulkley, Bird-Carreau, Cross, Casson), une condition limite rotatingWallVelocity, et des solveurs stationnaire (simpleFoam) et transitoire (pimpleFoam). Le couple provient de la fonction-objet forces. Cette compétence est l'équivalent open-source de la compétence mstar-simulation du dépôt privé mstar-skill et de palabos-simulation : même flux de travail discussion → cas → exécution → rapport, même exemple de Couette, solveur différent — pas de licence, pas d'interface graphique, pas de fichier .msb. À la place, vous écrivez des fichiers dictionnaire et exécutez les solveurs en ligne de commande.

Le flux de travail, dans l'ordre

1. Discussion (anglais) -> quel fluide, quelle géométrie, que voulez-vous mesurer ?
2. Écrire case.yaml -> tous les nombres dans un seul fichier, avec unités. Montrez-le. Obtenez un accord.
3. Maillage -> blockMeshDict : secteur en coin pour Couette. Vérifier avec checkMesh.
4. Construire le cas -> copier le modèle, substituer Omega. Pas d'interface graphique.
5. Balayage / exécution -> une exécution simpleFoam par taux de cisaillement, CSV de couple par exécution.
6. Post-traitement -> couple -> contrainte, omega -> taux de cisaillement, courbe d'écoulement + validation.
7. Rapport -> graphique + CSV + ce qui a été supposé, vérifié et non vérifié.

Ne sautez jamais l'étape 2. Même règle que dans les compétences M-Star et Palabos : une simulation avec une plage de taux de cisaillement, un modèle de fluide ou une géométrie non confirmés est une exécution gaspillée. Si l'utilisateur n'a pas nommé un nombre, demandez — n'en inventez pas un pour l'enfouir dans un dictionnaire. Les valeurs par défaut dans les exemples sont étiquetées default: et doivent être confirmées.

Exécuter est gratuit ici (pas de licence), mais ce n'est pas non plus sans coût : une exécution 3D à résolution fine coûte du temps CPU réel. Par défaut, optez pour une première exécution bon marché (maillage grossier, un seul taux de cisaillement) et ne balayez qu'ensuite.

1. Discussion — ce qu'il faut obtenir

Même liste de contrôle que la compétence M-Star, avec des éléments spécifiques à OpenFOAM :

Géométrie

  • Rayon intérieur (rotatif) R_i, rayon extérieur (fixe) R_o, longueur immergée L. En mètres.
  • La première version est un secteur en coin, pas un anneau complet. OpenFOAM est en volumes finis 3D, donc une cellule de Couette est modélisée comme un coin mince (4°, axe X, tranche axiale de 1 mm, 1 cellule axiale) avec des patches wedge sur les deux faces du secteur et des patches empty sur les deux faces axiales. La condition limite wedge rend la solution axisymétrique : pas de tourbillons de Taylor, pas d'effets d'extrémité — la cellule de Couette de longueur infinie idéale, exactement ce que suppose le couple analytique. Dites laquelle vous exécutez. Un anneau 3D complet est la suite : il ajoute des effets d'extrémité et, au-dessus du nombre de Taylor critique Ta_c ≈ 41,3, des tourbillons de Taylor qui augmentent le couple au-dessus de la valeur laminaire analytique et cassent la porte de validation. Pour ce cas (η = 1 Pa·s, ρ = 1000 kg/m³) Re ≤ 1,8 et Ta ≤ 0,9 sur tout le balayage, donc un anneau complet resterait laminaire — mais le coin reste l'option la moins chère et la plus propre pour la validation.

Fluide — choisissez une rhéologie, avec des nombres

OpenFOAM a un menu déroulant rhéologie, dans constant/transportProperties : transportModel Newtonian; est le cas de validation, et HerschelBulkley, BirdCarreau, Casson, powerLaw, CrossPowerLaw sont des modèles generalisedNewtonian intégrés. Herschel-Bulkley et Bird-Carreau sont les suites documentées, pas le cas de validation. Deux pièges :

  • La viscosité dans transportProperties est la viscosité cinématique nu = η/ρ (m²/s), pas la viscosité dynamique η. Pour η = 1,0 Pa·s et ρ = 1000 kg/m³, nu = 1e-03 — pas 1e-06 (la valeur pour l'eau, η = 1e-3 Pa·s). Une première ébauche de ce dépôt utilisait 1e-06 et le couple était exactement 1000× trop petit alors que le profil de vitesse semblait correct — le profil de Couette Newtonien est indépendant de la viscosité, donc le profil ne rattrape pas cette erreur. Le couple, si.
  • Les coefficients non-Newtoniens sont également cinématiques (nu0 = η0/ρ, k = K/ρ) ; la contrainte seuil tau0 est en Pa. Vérifiez par rapport à la source du modèle avant de faire confiance à une exécution non-Newtonienne. Si l'utilisateur nomme un matériau réel, n'inventez pas ses paramètres : demandez une courbe d'écoulement mesurée, un ajustement rhéofit, ou une valeur de la littérature, ou commencez par un Newtonien.

Conditions opératoires — le balayage

  • Plage de taux de cisaillement et espacement, par ex. 0,1 → 100 s⁻¹, espacement logarithmique.
  • Résolution du maillage : nombre de cellules dans l'entrefer (par défaut 40, soit dx = 0,125 mm). Plus de cellules = cisaillement pariétal plus précis, mais coût bien plus élevé.
  • Durée d'exécution : simpleFoam s'exécute en itérations, pas en secondes. endTime 3000 avec residualControl 1e-8 — le solveur s'arrête tôt quand il a convergé (γ̇ = 10 converge en ~2050 itérations, ~2 s). La fenêtre stationnaire pour moyenner le couple correspond aux 20% derniers échantillons de moment.dat.

Ce qui est mesuré

  • Couette : couple sur le rotor → contrainte de cisaillement, vitesse de rotation → taux de cisaillement. La courbe d'écoulement. Nommez le fichier d'où il provient (postProcessing/forces/0/moment.dat, écrit par la fonction-objet forces) avant d'exécuter.

2. Écrire case.yaml

Un fichier par simulation, dans examples/<nom>/case.yaml. C'est le contrat : les scripts le lisent, ils ne redérivent pas les nombres à partir de la discussion. Modèle : examples/couette/case.yaml. Montrez-le à l'utilisateur et obtenez un accord avant de construire.

3. Maillage — l'étape que M-Star cache

OpenFOAM a besoin d'un maillage, construit ici avec blockMesh à partir de system/blockMeshDict. Le maillage de Couette est un seul bloc hexaédrique :

axe = X (axe du cylindre), radial = Y, le coin s'ouvre dans le plan Y-Z
angle du coin 4 degrés au total (OpenFOAM exige < 5 degrés), demi-angle 2 degrés
étendue axiale x = 0..0,001 m, UNE cellule (pas de variation axiale)
radial : 40 cellules sur un entrefer de 5 mm, simpleGrading (1 1 1)
patches : innerWall, outerWall, back/front (type wedge),
         left/right (type empty)

Vérifiez-le avec checkMesh avant de résoudre : il doit rapporter Mesh OK., angle de coin 2° par côté, non-orthogonalité 0. La combinaison empty + wedge dans un seul maillage est acceptée par v2412 (vérifié ici) ; si une version future la rejette, remplacez les faces axiales par symmetry.

Facteur d'échelle du couple : le secteur est une tranche de 4° d'une tranche de 1 mm du cylindre de 60 mm, donc

T_complet = M_x(secteur) * (360/4) * (0,060/0,001) = M_x * 5400

où M_x est le moment autour de l'axe X provenant de la fonction-objet forces sur innerWall (CofR à l'origine, sur l'axe). Le signe est négatif (la traînée du fluide s'oppose à la rotation) ; le couple moteur est la magnitude.

4. Construire le cas

OpenFOAM est un ensemble d'applications, pas une bibliothèque : vous écrivez des fichiers dictionnaire et les exécutez. L'organisation du dépôt :

bash scripts/install-openfoam.sh   # dépôt Debian officiel, v2412
source /usr/lib/openfoam/openfoam2412/etc/bashrc
bash scripts/check-setup.sh        # simpleFoam, blockMesh, checkMesh, uv
./run-couette.sh                   # essai à sec : construire le maillage + checkMesh seulement

couette_build.py copie le modèle (examples/couette/case/) dans un répertoire d'exécution et substitue __OMEGA__ dans 0/U par la vitesse angulaire correspondant au taux de cisaillement :

Omega = gamma * (Ro^2 - Ri^2) / (2 * Ro^2)

Conditions limites (vérifiées par rapport aux tutoriels v2412) :

  • innerWall : rotatingWallVelocity, axis (1 0 0), omega constant <Omega> (rad/s), origin (0 0 0). Modèle : le tutoriel climbingRod avec rotatingWallVelocity.
  • outerWall : noSlip.
  • back/front : wedge ; left/right : empty.
  • Pression : fixedFluxPressure sur les deux parois (cas toutes-parois).
  • constant/transportProperties : transportModel Newtonian; nu 1e-03; (voir §1 — cinématique, pas dynamique).
  • constant/turbulenceProperties : simulationType laminar;. v2412 lit turbulenceProperties ; les versions plus récentes l'ont renommé momentumTransport — si votre solveur se plaint de ne pas trouver l'autre nom, renommez le fichier et son object interne.
  • system/fvSolution : SIMPLE avec pRefCell 0; pRefValue 0; (obligatoire : chaque frontière est une paroi, donc la pression a besoin d'une cellule de référence — sans cela simpleFoam se termine avec « Unable to set reference cell for field p »), GAMG pour p, smoothSolver pour U, residualControl p/U 1e-8.
  • system/controlDict : simpleFoam, endTime 3000 itérations, fonction-objet forces (patches (innerWall), rho rhoInf; rhoInf 1000;, CofR (0 0 0), writeInterval 5). v2412 écrit force.dat et moment.dat (fichiers séparés), pas forces.dat.

Statut : le cas stationnaire a été exécuté pour de vrai dans cette VM (OpenFOAM v2412, 2026-11-17) et la validation Newtonienne au §6 réussit (0,03% d'erreur de couple analytique à γ̇ = 10 — voir examples/couette/RUN_REPORT.md). La variante transitoire pimpleFoam (case-transient/, pour la vidéo de mise en rotation) s'exécute aussi : 1000 pas en ~2 s, convergeant vers le même couple.

Non-Newtonien : changez transportModel dans transportProperties (Herschel-Bulkley en premier, Bird-Carreau en second). Gardez le chemin Newtonien comme valeur par défaut et comme porte de validation — ne déboguez jamais un modèle non-Newtonien sur une géométrie non validée.

5. Exécuter

./run-couette.sh --run           # une exécution par taux de cisaillement, dans examples/couette/runs/
# ou, par point :
python3 couette_build.py --gamma 10 --out runs/gamma_10
cd runs/gamma_10 && blockMesh && simpleFoam

Chaque exécution écrit torque.csv (itération, moment du secteur, couple du cylindre complet) et run_info.json (drapeau de convergence, itérations, temps mural). Si une exécution est lente, affinez d'abord le maillage ou le temps d'exécution — ne changez pas silencieusement la géométrie pour la rendre rapide. Une exécution qui atteint endTime sans que le résidu de Uz ne tombe en dessous de 1e-7 est marquée converged: false — diagnostiquez avant de faire confiance à son couple (maillage, conditions limites, relaxation).

6. Post-traitement — du couple à la courbe d'écoulement (Couette)

Même conversion que les compétences M-Star et Palabos :

taux de cisaillement à la paroi intérieure : gamma_i = 2*Omega*Ro^2 / (Ro^2 - Ri^2)
contrainte de cisaillement à la paroi intérieure : tau_i  = T / (2*pi*Ri^2*L)
viscosité apparente : eta_app = tau_i / gamma_i

Moyenne du couple sur la fenêtre stationnaire nommée dans case.yaml (20% derniers échantillons), rapportez son écart-type comme vérification de la stationnarité.

Porte de validation (obligatoire pour la première exécution d'une nouvelle géométrie). Exécutez d'abord un fluide Newtonien de η connu et comparez avec le couple de Couette analytique :

T_analytique = 4*pi*L*eta*Omega*Ri^2*Ro^2 / (Ro^2 - Ri^2)

Si le couple simulé diffère de plus de ~10%, ne procédez pas à une courbe d'écoulement non-Newtonienne. Arrêtez-vous et diagnostiquez : résolution du maillage dans l'entrefer, nu (cinématique vs dynamique — voir §1), temps d'exécution / convergence, condition limite de paroi tournante, facteur d'échelle du couple. Enregistrez le nombre de validation dans le rapport. couette_post.py applique cette porte et se termine avec un code de sortie non nul en cas d'échec.

Ensuite, chaque point de balayage donne un point (gamma_i, tau_i). Tracez tau vs gamma (log-log) et eta_app vs gamma, écrivez flow_curve.csv, et — si l'utilisateur le souhaite — ajustez la courbe avec rheofit (Herschel-Bulkley, Carreau, …) dans une étape séparée.

7. Rapport

Fournissez, par exécution : case.yaml (tel qu'exécuté), flow_curve.csv, flow_curve.png, et une courte note indiquant la géométrie (secteur en coin, angle, cellules dans l'entrefer), le fluide, le balayage, le résultat de la validation, le critère d'état stationnaire et tout ce qui n'est pas vérifié. Si une exécution a échoué, rapportez la fin du journal du solveur — ne supprimez pas silencieusement le point de la courbe.

Démarrer une session avec GitHub Copilot CLI

Même configuration que mstar-skill et palabos-skill : Copilot CLI découvre les compétences du projet dans .github/skills/, et cette compétence y est reflétée. Depuis la racine du dépôt :

git clone https://github.com/marcocaggioni/openfoam-skill.git
cd openfoam-skill
bash scripts/install-openfoam.sh
bash scripts/check-setup.sh
copilot

Ensuite, /skills list (vous devriez voir openfoam-simulation), et :

/openfoam-simulation exécute l'exemple Couette dans examples/couette/case.yaml

Cette compétence n'a délibérément pas de frontmatter allowed-tools : Copilot doit demander avant d'exécuter des commandes shell, et en particulier avant une longue exécution du solveur. Si la compétence a été ajoutée pendant une session, exécutez d'abord /skills reload.

Ce que cette compétence ne fait PAS

  • Elle n'installe pas OpenFOAM pour vous au-delà de la route apt scriptée dans scripts/install-openfoam.sh : vous avez besoin d'une machine Debian/Ubuntu et de sudo.
  • Elle ne prétend pas qu'un cas est vérifié tant qu'il n'a pas été exécuté sur un OpenFOAM installé et que la validation Newtonienne a réussi.
  • Elle ne remplace pas M-Star pour les cuves, les agitateurs, les écoulements multiphasiques ou chargés de particules — ceux-ci sont hors du périmètre de la v0.1. Ce dépôt est la courbe d'écoulement de Couette, réalisée ouvertement, comme première preuve que la voie des volumes finis ouverts fonctionne.

Fichiers dans ce dépôt

  • skills/openfoam-simulation/SKILL.md — ce fichier. Reflété octet par octet dans .github/skills/openfoam-simulation/SKILL.md (la copie que GitHub Copilot CLI découvre). Gardez les deux copies synchronisées — modifiez les deux dans le même commit.
  • docs/openfoam-guide.md — notes sur l'installation, le maillage, les conditions limites, les modèles non-Newtoniens, les limites.
  • examples/couette/ — l'exemple Couette développé : case.yaml, case/ (modèle stationnaire simpleFoam), case-transient/ (modèle transitoire pimpleFoam pour la mise en rotation), couette_build.py, couette_sweep.py, couette_post.py, make_video.py, README.md.
  • OpenFOAM lui-même : https://www.openfoam.com (GPL)

Skills associés