OpenFoam depuis MESO@LR

Vous trouverez sur MESO@LR des informations concernant le Cluster de calcul haute performance Muse.

Connexion au cluster Muse via le protocole SSH :

ssh -X nom_user@muse-login.hpc-lr.univ-montp2.fr

IMPORTANT : “nom_user” est à remplacer par le nom de l’utilisateur de Muse.

L’exemple choisi est celui ici de damBreak disponible dans OpenFOAM : $FOAM_TUTORIALS/multiphase/interFoam/laminar/damBreak/

Dans le shell de muse, au niveau du répertoire de l’utilisateur (par exemple : /home/nom_user/), on créé d’abord le répertoire où sera copié l’exemple d’OpenFoam. Puis on se place dedans :

[nom_user@muse-login01 ~]$mkdir DemoDamBreak
[nom_user@muse-login01 ~]$cd DemoDamBreak

On charge le module Singularity: sbatch DemoModelUW.slurm

[nom_user@muse-login01 DemoDamBreak]$module load singularity/3.6.3

On charge l’image d’openfoam disponible sur hpc@lr :

[nom_user@muse-login01 DemoDamBreak]$singularity shell /trinity/shared/apps/local/openfoam/2006/openfoam_2006.sif

Là on arrive dans le shell de singularity. On tape la commande suivante pour récupérer le bon fichier bashrc :

Singularity>source /opt/OpenFOAM/OpenFOAM-v2006/etc/bashrc

Puis on copie dans le répertoire DemoDamBreak/ l’exemple damBreak du tutoriel d’openfoam :

Singularity>cp -R $FOAM_TUTORIALS/multiphase/interFoam/laminar/damBreak/ /home/nom_user/DemoDamBreak/ Singularity>exit #on sort du shell singularity

On se place ensuite dans le répertoire DemoDamBreak/damBreak/damBreak. Et on copie le répertoire 0.orig en le répertoire 0 (attention ici 0 est le chiffre zéro et non la lettre O !) :

[nom_user@muse-login01 DemoDamBreak]$cd damBreak/damBreak
[nom_user@muse-login01 DemoDamBreak]$cp -R 0.orig 0

Comment exécuter OpenFOAM dans le conteneur Singularity, en utilisant 4 cœurs sur la partition gladys : on va d’abord créer un script slurm puis lancer le job slurm associé :

[nom_user@muse-login01 DemoDamBreak]$nano DemoDamBreak.slurm

A l’intérieur, on copie le script suivant, en prenant soin de remplacer “nom_user” par son nom d’utilisateur Muse :

#!/bin/bash
#
#SBATCH -n 4

#walltime (hh:mm:ss)
#SBATCH -t 00:10:00

#My job name (displayed by the queue)
#SBATCH -J DemoDamBreak

#Specify the partition
#SBATCH --partition=gladys

# --- END OF SLURM BATCH SCRIPT HEADER

#Loading the required modules
module purge
module load singularity/3.6.3

# Go to the directory of example damBreak, change the nom_user by your username !!
cd /home/nom_user/DemoDamBreak/damBreak

# Full path to Singularity image
FOAM_SINGULARITY_IMAGE=/trinity/shared/apps/local/openfoam/2006/openfoam_2006.sif

# Location of the bashrc file within the Singularity container
FOAM_BASHRC=/opt/OpenFOAM/OpenFOAM-v2006/etc/bashrc

# Execute blockMesh (serial)
singularity exec $FOAM_SINGULARITY_IMAGE bash -c "source $FOAM_BASHRC && blockMesh -case damBreak"

# Execute setFields (serial)
singularity exec $FOAM_SINGULARITY_IMAGE bash -c "source $FOAM_BASHRC && setFields -case damBreak"

# Execute decomposePar (serial)
singularity exec $FOAM_SINGULARITY_IMAGE bash -c "source $FOAM_BASHRC && decomposePar -case damBreak"

# Execute interFoam (serial)
singularity exec $FOAM_SINGULARITY_IMAGE bash -c "source $FOAM_BASHRC && interFoam -case damBreak"

# Execute interFoam in parallel
singularity exec $FOAM_SINGULARITY_IMAGE bash -c "source $FOAM_BASHRC && mpirun interFoam -parallel -case damBreak &> result.out"

# Reconstruct to have the whole domain
singularity exec $FOAM_SINGULARITY_IMAGE bash -c "source $FOAM_BASHRC && reconstructPar -case damBreak"

# all done
echo "Job finished"

Puis après avoir sauvegarder le fichier DemoDamBreak.slurm, on lance toujours sur muse le job avec la commande :

[nom_user@muse-login01 DemoDamBreak]$sbatch DemoDamBreak.slurm

On peut utiliser la commande slurm squeue pour afficher la liste des jobs

[nom_user@muse-login01 DemoDamBreak]squeue
2226011 gladys DemoDamB nom_user R 0:05 1 muse[033]

Comment rapatrier l’exemple depuis Muse en local sur son ordinateur :

Sur Muse, les noeuds de calcul ne permettent pas de faire de la visualisation. Pour ce faire, nous devons d’abord rapatrier notre exemple sur notre ordinateur pour ensuite pouvoir faire du post-traitement.
Ainsi, quand le job est terminé sur Muse, il faut archiver le répertoire damBreak pour pouvoir le rapatrier en local :

[nom_user@muse-login01 DemoDamBreak]$tar -czvf damBreak.tar.gz damBreak/

On obtient l’archive : damBreak.tar.gz

Ensuite en local, on rapatrie depuis le serveur muse l’archive damBreak.tar.gz via la commande sécurisée scp directement dans son répertoire local où l’on souhaite disposer de l’exemple damBreak :

“nom_user_local” est le nom de l’utilisateur sur la machine en local.

[nom_user_local@localhost]$ scp nom_user@muse-login.hpc-lr.univ-montp2.fr:/home/nom_user/DemoDamBreak/damBreak.tar.gz /home/nom_user_local/DemoDamBreak/

On décompresse l’archive avec la commande linux tar -xzvf (ou avec WinRAR par exemple sous Windows) :

[nom_user_local@localhost DemoDamBreak]$ tar -xzvf damBreak.tar.gz

Comment visualiser les résultats des calculs pour faire du post-traitement en local :

On souhaite pouvoir visualiser en local avec paraview (utilisation du script paraFoam d’OpenFOAM) le résultat.

Avec paraFoam dans OpenFOAM :

On se place dans notre environnement habituel d’OpenFoam via Docker (après avoir lancer Docker et ./startOpenFOAM) et on visualise en local à partir de la commande paraFoam :

bash-4.2$ pwd
/home/nom_user_local/DemoDamBreak/damBreak/damBreak
bash-4.2$ paraFoam

Avec Paraview :

paraFoam crée un fichier avec l’extension .foam dans le répertoire damBreak au même niveau que les répertoires constant/ et system/ , qui indique que les données sont enregistrées au format OpenFOAM. Cela signifie que le fichier * .foam ne doit pas être placé dans le même répertoire que les fichiers de sortie individuels (par exemple les données pour U, p, …), mais un niveau au-dessus. Sinon, cela ne fonctionnera pas. Si l’on souhaite utiliser paraview, il faut créer manuellement ce fichier à l’aide de la commande suivante “touch” comme par exemple :

[nom_user_local@localhost damBreak]$touch test-damBreak.foam
[nom_user_local@localhost damBreak]$ls
0 0.15 0.3 0.45 0.6 0.75 0.9 1 constant processor1 system
0.05 0.2 0.35 0.5 0.65 0.8 0.95 Allclean postProcessing processor2 test-damBreak.foam
0.1 0.25 0.4 0.55 0.7 0.85 0.orig Allrun processor0 processor3

Cela crée un fichier vide nommé test-damBreak.foam mais cela suffit à Paraview pour détecter le format de données OpenFOAM.

Puis après avoir lancer Paraview en local, on peut ouvrir le fichier test-damBreak.foam directement dans Paraview.

Cliquez ensuite sur “Apply”. Sélectionnez la variable à visionner (par exemple p_rgh). Cliquez sur play pour lancer la visualisation.

[nom_user_local@localhost damBreak]$ paraview

Ce modèle est constitué d’une colonne d’eau séparée du reste de la cuve par une membrane.
On retire la membrane à temps=0 s, et on observe la chute de la colonne d’eau.
On peut alors visualiser ce qui ce produit à l’aide de paraFoam ou de Paraview.

De manière générale, comment exécuter OpenFOAM dans un conteneur Singularity sur le cluster Muse :

Pour accéder de manière interactive au conteneur Singularity, il faut charger le module Singularity qui convient et créer un shell interactif dans le conteneur à partir de la commande suivante :

[nom_user@muse-login01]$module load singularity/3.6.3

A partir de là, pour accéder à OpenFOAM :

Ouvrir un shell interactif Singularity avec l’image Docker d’OpenFOAM disponible sur le cluster Muse et en récupérant le fichier bashrc avec source à l’intérieur du conteneur avec les commandes suivantes :

[nom_user@muse-login01]$singularity shell /trinity/shared/apps/local/openfoam/2006/openfoam_2006.sif
Singularity>source /opt/OpenFOAM/OpenFOAM-v2006/etc/bashrc
Singularity>

Comment exécuter des commandes directement dans le conteneur Singularity :

Vous êtes maintenant à l’intérieur du conteneur, car l’invite de ligne de commande deviendra : “Singularity> “. Pour quitter le conteneur, tapez simplement “exit”. Pour avoir par exemple les versions de gcc et mpirun utilisées dans OpenFOAM v2006, il suffit de taper les commandes suivantes :

Singularity>gcc -v # Output: gcc version 4.8.5 20150623 (Red Hat 4.8.5-11) (GCC)
Singularity>mpirun -version # Output: mpirun (Open MPI) 1.10.4

Comment exécuter en série une commande OpenFOAM depuis l’extérieur de Singularity (le module singularity/3.6.3 doit avoir été chargé auparavant) :

Toute commande dans le conteneur Singularity peut être exécutée depuis l’extérieur via la sous-commande Singularity “exec”.
Pour lancer une commande OpenFOAM depuis l’extérieur du conteneur, nous devons rechercher le fichier bashrc (pour définir les variables d’environnement) et appeler la commande OpenFOAM dans la même ligne de commande “exec” :

[nom_user@muse-login01]$singularity exec image_du_conteneur bash -c "source chemin_bashrc && commande_OpenFOAM"

Exemple avec damBreak d’openfoam_v2006 :

[nom_user@muse-login01 damBreak]$singularity exec /trinity/shared/apps/local/openfoam/2006/openfoam_2006.sif bash -c "source /opt/OpenFOAM/OpenFOAM-v2006/etc/bashrc && interFoam -case damBreak"

Dans l’exemple ci-dessus, image_du_conteneur est le chemin complet vers l’image openfoam_v2006, chemin_bashrc est le chemin complet du fichier bashrc dans le conteneur, commande_OpenFOAM est la commande OpenFOAM que vous souhaitez exécuter dans le conteneur.

Comment exécuter en parallèle une commande OpenFOAM depuis l’extérieur de Singularity (le module singularity/3.6.3 doit avoir été chargé auparavant) :

Une manière d’éxécuter une commande OpenFoam en utilisant la version openmpi de l’image openfoam_v2006.sif est :

[nom_user@muse-login01]$singularity exec image_du_conteneur bash -c "source chemin_bashrc && mpirun commande_OpenFOAM"

Ce qui donne sur l’exemple damBreak précédent :

$singularity exec /trinity/shared/apps/local/openfoam/2006/openfoam_2006.sif bash -c "source /opt/OpenFOAM/OpenFOAM-v2006/etc/bashrc && mpirun -n 4 interFoam -parallel -case damBreak"