TP1 : premier pas avec Stardis.

Conditions de réalisation

Nous supposerons que le TP est réalisé par un utilisateur
travaillant depuis le système d'exploitation EDIX.

TP1 - Partie 1 : les débuts dans EDIX

Se connecter en tant qu'etudiant :

login: etudiant
mot de passe: etudiant&1edix

Vous êtes maintenant dans le système d'exploitation EDIX.
Vous pouvez consulter la documentation en saisissant la commande
suivante :

etudiant:~ $ man edix

Avant de poursuivre le TP, vous êtes invité à lire cette page de
manuel ainsi que celles vers lesquelles elle renvoit, notamment

etudiant:~ $ man edix_man
etudiant:~ $ man edix_premiers_pas
etudiant:~ $ man edix_gestes_de_base
etudiant:~ $ man edix_interface_graphique
etudiant:~ $ man edix_shell
etudiant:~ $ man edix_vim

Au minimum, vous aurez besoin d'apprendre à lancer l'interface
graphique avec la commande

etudiant:~ $ startx

et à ouvrir un terminal graphique avec la combinaison de touches
Alt + Entrée.

Le démonstrateur et l'ensemble des logiciels ont été installés
chez l'utilisateur lafrier, comme vous pouvez le voir avec la commande

ls /home/lafrier/

Vous allez travailler dans le répertoire /home/etudiant.
Vous pouvez vérifier que vous êtes bien dans ce répertoire à l'aide de
la commande

pwd

qui affiche le chemin vers le répertoire courant.
La commande

ls

vous permet ensuite d'afficher les fichiers et dossiers du répertoire
courant.

Il vous faudra ensuite créer un répertoire à votre nom :

mkdir mon_nom

Avec

ls

vous observerez que le répertoire a été créé.

Remarques
Si on veut renommer le répertoire parce qu'on a fait une faute :

etudiant:~ $ mv mon_nom_raté nom_nom_correct

Si on veut supprimer le répertoire :

etudiant:~ $ rm -r mon_nom

On se rend dans le répertoire créé :

cd mon_nom

On crée un sous-répertoire dédié au TP1 et on se rend dans ce
sous-répertoire :

mkdir TP1
cd TP1

On recopie les données utiles au TP1 dans un nouveau répertoire appelé
cube :

cp -r "${DEMONSTRATEUR_2}"/data/cube cube
cd cube
cp "${DEMONSTRATEUR_2}"/TP1/src/model.txt .

TP1 - Partie 2 : exécuter stardis

Partie 2.1 : première exécution de stardis

Pour pouvoir exécuter stardis, il faut réaliser l'opération suivante à
chaque fois que vous ouvrirez un nouveau terminal :

. /home/lafrier/star-build/local/etc/stardis.profile

Elements techniques de compréhension
Afficher le fichier pour voir que des variables vont être modifiées.
Ces variables sont enrichies avec les chemins vers le dossier d'installation
de stardis :

etudiant:~/mon_nom/TP1/cube $ cat \
/home/lafrier/star-build/local/etc/stardis.profile

Vérifier que ces variables ont bien été mises à jour :

etudiant:~/mon_nom/TP1/cube $ echo ${CPATH}

Afficher les fichiers dans le répertoire de travail :

ls

On voit qu'on a différents types de fichiers, d'extensions :

On commence par ouvrir le fichier model.txt, c'est la description
informatique du système physique considéré.

cat model.txt

Il s'agit d'un cube solide, dont les parois de gauche et de droite sont à
température imposée. Les 4 autres parois sont adiabatiques, le flux est
imposé à 0 dans le fichier "model.txt". Le fichier commence par décrire
les milieux : ici le solide, associé à une géométrie "solid.stl".
Ensuite sont décrites les conditions limites, ici de deux types différents.
Ces conditions limites sont elles aussi associées à des géométries.
L'exercice 3.2 sera dédié à la compréhension de la syntaxe pour décrire
le système.

Avec paraview, on commence par visualiser les stl (à réaliser de
préférence dans un autre bureau) :

paraview

Commencer par ouvrir tous les fichiers en .stl en cliquant sur File > Open
Cliquer sur Appliquer / Apply pour voir tous les chemins tracés
Il est possible de cliquer sur l'oeil à côté de chaque fichier pour
montrer ou cacher chaque objet

Lancer le premier calcul stardis :

stardis -V 3 -M model.txt -p 0.5,0.5,0.5 -n 10000 -e

On observe et commente la sortie :

On fait une nouvelle estimation avec plus de réalisations :

stardis -V 3 -M model.txt -p 0.5,0.5,0.5 -n 40000 -e

On observe que la barre d'erreur a diminué : l'estimation est plus précise.

Partie 2.2 : visualiser des chemins

Partie 2.2.1 : chemins de diffusion uniquement avec condition limite de

                                     Dirichlet (température imposée)

Enregistrer des chemins :

stardis -V 3 -M model.txt -p 0.5,0.5,0.5  -n 10 -D all,path -e
ls

On observe que 10 fichiers path00000*.vtk ont été produits.

Pour ouvrir directement paraview avec les fichiers créés par la
commande précédente :

paraview --script="${DEMONSTRATEUR_2}"/TP1/src/script_paraview_cube.py

Mais si ce script échoue, on peut également refaire toutes les étapes
à la main, en ouvrant simplement paraview avec la commande :
paraview
Puis en suivant les étapes suivantes :
dans la fenêtre paraview : File > Open ;
cliquer sur la flèche à côté de path.vtk ;
sélectionner l'ensemble des fichiers (path000.vtk jusqu'à path009.vtk) ;
par défaut les chemins ne sont pas visibles, il faut cliquer sur Apply.

Pour visualiser les différentes parties du cube, ouvrir les fichiers
".stl".

Pour une meilleure visualisation :
dans le Pipeline Browser à gauche, cacher tous les fichiers en .stl
sauf "solid.stl" ;
faire un clic gauche sur "solid.stl" ;
dans l'onglet Properties passer la représentation de "Surface" à
"Wireframe" ;
dans Coloring, cliquer sur Edit pour sélectionner une couleur (ex : noir).

Le script charge 10 chemins en même temps.
Commencez par en visualiser un seul : en cliquant sur l'oeil devant chaque
élément "path" du Pipeline Browser, vous allez les masquer.

Ce que vous observez :
Les chemins partent du point d'observation, ici au centre du cube,
ils "ressemblent" à du mouvement brownien.
Les sommets sont construits en échantillonnant uniformément une position
sur la surface d'une petite sphère (de taille delta) centrée sur le sommet
précédent.

Dans cet exemple, les chemins terminent en paroi au niveau des conditions
limites de Dirichlet uniquement. Lorsqu'ils rencontrent une paroi adiabatique,
ils sont réfléchis et ne s'arrêtent pas. Le poids de Monte-Carlo retenu
par le chemin est la température imposée au niveau de la paroi.

Pour tout problème de visualisation avec paraview, regardez l'image
ci-dessous :

etudiant:~ $ feh ${DEMONSTRATEUR_2}/Figures/tp1_chemins_dans_cube_solide.png

Le chemin part du centre du cube, point sonde auquel on souhaite évaluer la
température. Il s'arrête lorsqu'il renconstre la paroi de gauche, dont la
température est connue et retenue comme poids de Monte-Carlo.

Partie 2.2.2 : chemins pour condition limite de type Robin

On change maintenant la condition limite du système.
La température n'est plus imposée aux parois latérales du cube.
Le cube est plongé dans un fluide dont la température est connue,
il y a un coefficient d'échange convectif entre le cube solide et le fluide.
De plus, la température radiative de l'environnement est connue.

On copie le fichier texte comportant nos nouvelles conditions :

cp "${DEMONSTRATEUR_2}"/TP1/src/modele_cube_dans_fluide.txt .

On réalise une estimation de la température à l'aide de 10000 chemins :

stardis -V 3 -M modele_cube_dans_fluide.txt -p 0.5,0.5,0.5 -n 10000 -e

On génère juste 10 chemins (pas besoin de plus pour l'analyse) :

stardis -V 3 -M modele_cube_dans_fluide.txt -p 0.5,0.5,0.5  -n 10 \
  -D all,path_conv_ -e

On visualise ces chemins :

paraview \
  --script="${DEMONSTRATEUR_2}"/TP1/src/script_paraview_cube_dans_fluide.py

Les chemins s'arrêtent donc en paroi soit lorsqu'ils basculent en convection
(et la température de fluide environnant est connue),
ou bien lorsqu'ils basculent en rayonnement
(et la température radiative de l'environnement est connue).

Pour tout problème de visualisation avec paraview, regardez l'image
ci-dessous :
etudiant:~ $ feh \
${DEMONSTRATEUR_2}/Figures/tp1_chemins_dans_cube_avec_env_radiatif.png

Le chemin part du centre du cube, atteint la paroi de gauche puis bascule en
rayonnement avant de s'arrêter. Le poids de Monte-Carlo retenu est la
température de l'environnement radiatif.

Partie 2.2.3 : chemins couplant 3 modes de transferts thermiques

Autre exemple, illustrant le couplage conduction / convection / rayonnement.
Le chemin alterne maintenant entre différents modes physiques.
Il s'agit d'un système avec deux parties : un cube solide dans lequel se
trouve une cavité fluide. Cette cavité fluide est sphérique, dans laquelle
deux modes de transfert thermiques ont lieu : de la convection et du
rayonnement entre ses parois. Le modèle de convection est de type cavité
parfaitement brassée : la température est uniforme et peut varier dans le
temps. Le point d'observation peut être placé en tout point du fluide
(ici au centre) : la température mesurée sera la même.

Pour construire et sauvegarder 10 chemins :

stardis -V 3 -M "${DEMONSTRATEUR_2}"/data/boule_dans_cube/model.txt \
  -p 0.5,0.5,0.5  -n 10 -D all,coupled_path_ -e

Afin de visualiser ces chemins :

paraview \
  --script="${DEMONSTRATEUR_2}"/TP1/src/script_paraview_boule_dans_cube.py

Les chemins partent du centre du fluide en rayonnement ou bien en convection.
Ils basculent d'un mode de transfert à l'autre, éventuellement en conduction
quand ils sont dans le solide. Ils finissent par basculer en conduction puis
s'arrêtent au niveau d'une paroi du cube où la température est connue.

Pour tout problème de visualisation avec paraview, visualiser l'image
ci-dessous :

etudiant:~ $ feh \
${DEMONSTRATEUR_2}/Figures/tp1_chemins_dans_cube_avec_boule.png

Le chemin part du centre de l'inclusion fluide, il alterne entre convection,
rayonnement et conduction jusqu'à rencontrer la paroi de droite dont la
température est connue et retenue comme poids de Monte-Carlo.

Partie 3 : découvrir les pages de manuel

Partie 3.1 : lire la documentation de stardis pour changer d'observable

Jusqu'ici on vous a donné les lignes de commande à taper,
pour comprendre les différents arguments et leur rôle, vous allez lire la
documentation :

man stardis

La documentation prendra toujours la forme "man mon_programme",
comme c'est le cas pour toutes les autres commandes unix comme ls ou cd.
Les pages de manuel ont toujours le même format :

Dans la documentation, cherchez ce que signifient les arguments :
a/ -M model.txt ---> cet argument est obligatoire, c'est la description
de la scène
b/ -n 1000 ---> le nombre de réalisations de Monte-Carlo
c/ -V 3 ---> est un niveau de verbosité / quantité de détails
donnés dans la console (vous pouvez tester différentes
valeurs)
d/ Exercice : que signifie -D ? Quelles informations supplémentaires
faut-il renseigner ?
e/ Exercice : que signifie -p ? Quelles informations supplémentaires
faut-il renseigner ?

Correction :
d/ l'argument -D nécessite de renseigner deux informations :
le mot clé error ou success ou all ainsi qu'un préfixe de nom de
fichier. Avec cet argument, des chemins seront produits au format "vtk",
il peut s'agir uniquement des chemins ayant produit des erreurs (pour
le debug), des succès, ou tous.
e/ L'argument -p controle la position du point sonde où est estimée la
température : il faut renseigner la position en 3D (x,y,z).
En option, on peut spécifier le temps d'observation (sinon ce sera INF
pour le stationnaire), ou bien la durée d'intégration temporelle.

Exercice :
Si vous avez bien compris, sur le premier système "model.txt" :

Correction :
déplacer le point sonde

stardis -V 3 -M model.txt -p 0.85,0.85,0.85 -n 10000 -e
stardis -V 3 -M model.txt -p 0.85,0.85,0.85 -n 10 -D all,path_probe_ -e

ajouter un temps d'observation

stardis -V 3 -M model.txt -p 0.5,0.5,0.5,10 -n 10000 -e
stardis -V 3 -M model.txt -p 0.5,0.5,0.5,10 -n 10 -D all,path_time_ -e

utiliser l'algorithme Walk-On-Sphere
stardis -V 3 -M model.txt -p 0.5,0.5,0.5 -n 10 -a wos -e -D all,path_wos_ stardis -V 3 -M model.txt -p 0.5,0.5,0.5 -n 100000 -a wos -e etudiant:~ $ feh \
"${DEMONSTRATEUR_2}"/Figures/tp1_chemins_dans_cube_solide_wos.png

Partie 3.2 : lire la documentation pour modifier des paramètres physiques

                                                            du système

Le système est décrit dans le fichier suivant :

cat model.txt

Comment identifier dans ce fichier le(s) paramètre(s) à modifier ?
On va lire le manuel pour comprendre le format de ce fichier.

man stardis-input

Alternative : la même documentation peut être visualisée en html :

etudiant:~ $ firefox-bin \
https://www.meso-star.com/projects/stardis/man/man5/stardis-input.5.html

Se rendre dans l'onglet 9 où firefox a été lancé.

La syntaxe du système est décrite sous la forme d'une "grammaire"
voir https://fr.wikipedia.org/wiki/Grammaire_formelle.
Elle est composée de règles, représentées par les parenthèses.
Ces règles sont ensuite remplacées par des valeurs ou bien d'autres règles.

On illustre sur un exemple du fichier model.txt : la ligne qui commence
par SOLID.
Que signifient les éléments de cette ligne ?
Dans la documentation, la règle première ⟨thermal-system⟩ est remplacée
par ⟨description-line⟩, puis ⟨medium⟩, ⟨solid⟩ et ⟨solid-const⟩.
On détaille le remplacement de la règle :
⟨solid-const⟩ ::= SOLID ⟨medium-name⟩ ⟨lambda⟩ ⟨rho⟩ ⟨cp⟩ \
⟨delta⟩ ⟨initial-temp⟩ ⟨imposed-temp⟩ \
⟨volumic-power⟩ ⟨triangle-sides⟩ ...

Dans le manuel, recherchez le mot clé SOLID.
Astuce : tapez '/' puis le mot cherché,
les touches 'n' ou 'N' permettent de déplacer le curseur à l'occurence
suivante ou précédente.

La première règle est remplacée par la règle
⟨medium-name⟩ ::= string
c'est-à-dire par une chaîne de caractère : le nom associé à ce solide.

La seconde règle est la suivante :
⟨lambda⟩ ::= real
Le troisième élément est donc un réel qui indique la conductivité
du solide.

Exercice : pour cette ligne commençant par "SOLID", identifiez ce que
signifie chacun des éléments. Faire le lien avec les paramètres physiques
et numériques du système présenté dans l'introduction.

Exercice : faire pareil avec la ligne commençant par T_BOUNDARY_FOR_SOLID
du fichier model.txt

Exercice : faire pareil avec la ligne commençant par H_BOUNDARY_FOR_SOLID
du fichier modele_cube_dans_fluide.txt

Vous allez maintenant éditer ces propriétés.

Dans EDIX, l'éditeur de texte privilégié est vim dont voici quelques
commandes "pour s'en sortir".
Il fonctionne avec 3 modes : "normal", "insertion" et "visuel".
Ici on aura besoin de taper :
i pour basculer en mode Insertion et éditer le texte
Echap pour basculer à nouveau en mode "normal" où on peut lancer les
commandes suivantes :
:w pour sauvegarder
:q pour quitter
Pour se former à cet outil : vimtutor est un tutoriel qui permet de voir
les commandes de base.
Un manuel moins détaillé sur vim est aussi disponible en tapant :
man edix_vim

vim model.txt

Exercice :
Editez les paramètres suivants en vous aidant du manuel de stardis :
(vous pouvez choisir les valeurs que vous voulez) :
a/ température imposée à gauche
b/ température initiale (attention, pour observer son impact sur le calcul,
indiquer un temps d'observation)
c/ augmenter le coefficient d'échange convectif dans le fichier
"modele_cube_dans_fluide.txt" et commentez la température obtenue

Correction :
a/ température imposée à gauche
T_BOUNDARY_FOR_SOLID LTEMP 300 left_bc.stl
^^^

stardis -V 3 -M model.txt -p 0.5,0.5,0.5 -n 10000 -e

Observer une augmentation ou diminution de la température de la sonde.

b/ température initiale, regarder au stationnaire et à t = 10
SOLID CUBE 0.1 25 2 0.01 300 UNKNOWN 10 FRONT solid.stl
^^^

stardis -V 3 -M model.txt -p 0.5,0.5,0.5 -n 10000 -e

Si t=inf, aucun changement de la température du point sonde.

stardis -V 3 -M model.txt -p 0.5,0.5,0.5,10 -n 10000 -e

Si faible temps d'observation, alors cela a un impact sur la température
du point sonde.

c/ augmenter h du fichier modele_cube_dans_fluide.txt ; h = 1000

vim modele_cube_dans_fluide.txt

H_BOUNDARY_FOR_SOLID EXT 320 0.5 0.5 10 320 \
"${DEMONSTRATEUR_2}"/data/cube/right_bc.stl \
"${DEMONSTRATEUR_2}"/data/cube/center_bc.stl \
"${DEMONSTRATEUR_2}"/data/cube/left_bc.stl

stardis -V 3 -M modele_cube_dans_fluide.txt -p 0.5,0.5,0.5,10 -n 10000 -e

Le fluide dont la température est connue est bien plus souvent échantillonné
que la température radiative de l'environnement. Vous le voyez sur la valeur
de la température estimée.

Pour aller plus loin
La documentation existe aussi pour spécifier la sortie de stardis lorsque
l'option -e n'est pas utilisée :

man stardis-output

C'est utile notamment lorsqu'on stocke la sortie de stardis pour réaliser
des graphiques.

Partie 4 : explorations en autonomie - jouer avec le starter-pack

ls /home/lafrier/Stardis-Starter-Pack-0.2.0

Il n'y a pas que l'exemple du cube dans le starter-pack.
Dans chaque dossier il y a un exemple avec

Par exemple sur un milieu poreux :

cd ..
cp -r /home/lafrier/Stardis-Starter-Pack-0.2.0/porous .
cd porous

Lire le fichier décrivant la scène :

cat porous.txt

On a maintenant deux solides, et 4 conditions limites.
Les géométries sont définies dans de nouveaux stl.

On peut refaire exactement la même expérience que dans le premier exercice
sur une géométrie plus complexe que le cube.
Pour construire et sauvegarder 5 chemins :

stardis -V 3 -M "${DEMONSTRATEUR_2}"/TP1/src/model_poreux.txt \
  -p 0.0014,0.0014,0  -n 5 -D all,path_in_porous_ -e

Afin de visualiser ces chemins :

paraview \
  --script="${DEMONSTRATEUR_2}"/TP1/src/script_paraview_poreux.py

Commencez par n'en visualiser qu'un seul (en cliquant sur l'oeil).
Comme précédemment, les chemins partent du point sonde en noir. Il basculent
d'un mode physique à un autre, jusqu'à rencontrer une paroi où la température
est connue.

Pour tout problème de visualisation avec paraview, visualiser l'image
ci-dessous :

etudiant:~ $ feh \
${DEMONSTRATEUR_2}/Figures/tp1_chemins_poreux.png

Lire le fichier décrivant la scène :

cat porous.txt

Pour savoir ce que vous allez exécuter :

cat run_IR_rendering.sh

Vous voyez qu'il y aura des images en sortie.
Pour exécuter et pour voir qu'il y a bien de nouveaux fichiers (images) :

sh run_IR_rendering.sh
ls

Pour visualiser l'image sortie :

feh IR_rendering_320x320x32.ppm

Vous verrez dans le TP4 les différents types d'observables qu'on peut
estimer.