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éeL. 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
wedgesur les deux faces du secteur et des patchesemptysur 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
transportPropertiesest la viscosité cinématiquenu= η/ρ (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 seuiltau0est 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 :
simpleFoams'exécute en itérations, pas en secondes.endTime 3000avecresidualControl1e-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 demoment.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-objetforces) 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 tutorielclimbingRodavecrotatingWallVelocity.outerWall:noSlip.back/front:wedge;left/right:empty.- Pression :
fixedFluxPressuresur les deux parois (cas toutes-parois). constant/transportProperties:transportModel Newtonian;nu 1e-03;(voir §1 — cinématique, pas dynamique).constant/turbulenceProperties:simulationType laminar;. v2412 litturbulenceProperties; 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 sonobjectinterne.system/fvSolution:SIMPLEavecpRefCell 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,residualControlp/U 1e-8.system/controlDict:simpleFoam,endTime 3000itérations, fonction-objetforces(patches (innerWall),rho rhoInf; rhoInf 1000;,CofR (0 0 0),writeInterval 5). v2412 écritforce.datetmoment.dat(fichiers séparés), pasforces.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
aptscriptée dansscripts/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)