TP2 : insensibilité du temps de calcul aux rapports d'échelle.

Voir le TP1 pour la prise en main du système d'exploitation EDIX.
Les commandes suivantes sont identiques à celles du début du TP1.

. /home/lafrier/star-build/local/etc/stardis.profile
mkdir TP2
cd TP2

Dans ce TP on aura régulièrement besoin d'extraire des temps de calcul
/ temps de chargement / nombre de triangles dans la scène.
Ces informations sont données par stardis lorsque cet exécutable est
appelé avec l'option -V 3. Ces fonctions d'extractions sont données
par les scripts suivants :

ls "${DEMONSTRATEUR_2}"/TP2/src/*.sh

Afin de pouvoir appeler ces scripts par la suite sans avoir à spécifier
le chemin complet vers ces exécutables :

export PATH="${DEMONSTRATEUR_2}/TP2/src/:${PATH}"

TODO : est-ce que ces scripts généraux iraient dans libs ?

TP2 - Partie 1 : augmentation de la complexité géométrique de la scène

On commence par créer un répertoire dans lequel on va travailler :

mkdir poreux && cd poreux

Description de la scène :
Une mousse poreuse solide qui échange avec un autre solide, tous deux
placés dans une boîte solide. Les conditions aux limites sont appliquées
aux parois de la boïte, toutes adiabatiques sauf

On commence par visualiser les différentes géométries :

ls "${DEMONSTRATEUR_2}"/data/poreux/
cat "${DEMONSTRATEUR_2}"/data/poreux/model_2_0.txt
paraview

1/ pour visualiser la scène modélisée :
Open, sélectionner tous les fichiers 'stl' du dossier
'demonstrateur_2/data/poreux_faible_resolution' commençant par 'solid'
('solid_gyroid.stl', 'solid_sole01.stl', 'solid_sole02.stl', ...,
'solid_sole06.stl'). Cliquer sur 'Apply' pour les afficher.
Vous observez la boîte dans laquelle se trouve la mousse.
Cliquer sur le symbole de l'oeil dans le 'Pipeline Browser' (sur la gauche)
pour cacher les 'soles' et voir apparaître le maillage du poreux.

2/ On visualise ensuite les différents niveaux de détail de ce poreux.
Open, sélectionner le fichier 'solid_gyroid.stl' du dossier
'demonstrateur_2/data/poreux'. Cliquer sur 'Apply'.
Open, sélectionner le fichier 'solid_gyroid.stl' du dossier
'demonstrateur_2/data/poreux_forte_resolution'. Cliquer sur 'Apply'.

Observez la différence de résolution dans le maillage des pores, vous
pouvez sélectionner 'Surface With Edges' dans le menu déroulant en haut
au lieu de 'Surface', il vous faudra d'abord sélectionner le maillage
considéré dans le menu Pipeline Browser (à gauche). En cliquant sur
l'oeil du menu Pipeline Browser, vous pouvez cacher successivement les
maillages pur n'en visualiser qu'un seul à la fois.

On commence par créer un fichier qui contiendra les informations lues.

echo "triangle_count computation_time_in_msec loading_time_in_msec" \
  > computation_times.txt

Lancer un calcul stardis sur la scène :

stardis -V 3 -M "${DEMONSTRATEUR_2}"/data/poreux/model_2_0.txt -n 20 \
  -s "${DEMONSTRATEUR_2}"/data/poreux/interface_sole02_Xplus.stl \
  2> stardis_output.txt
cat stardis_output.txt

On observe que le nombre de triangles est donné dans ce fichier, ainsi que
le temps de calcul. On peut extraire cette information de façon automatique
grâce au scripṭ suivant :

echo "Nombre de triangles " \
  $(extract_stardis_triangle_count.sh stardis_output.txt)

On extrait du fichier temporaire puis on stocke ces informations :

echo \
  $(extract_stardis_triangle_count.sh stardis_output.txt) \
  $(extract_stardis_computation_time.sh stardis_output.txt) \
  $(extract_stardis_loading_time.sh stardis_output.txt) >> computation_times.txt

On vérifie que ces données sont écrites dans le fichier :

cat computation_times.txt

Idem sur une autre scène moins résolue :

stardis -V 3 \
-M "${DEMONSTRATEUR_2}"/data/poreux_faible_resolution/model_2_0.txt \
-n 20 -s \
"${DEMONSTRATEUR_2}"/data/poreux_faible_resolution/interface_sole02_Xplus.stl \
2> stardis_output_faible_resol.txt
echo \
$(extract_stardis_triangle_count.sh stardis_output_faible_resol.txt) \
$(extract_stardis_computation_time.sh stardis_output_faible_resol.txt) \
$(extract_stardis_loading_time.sh stardis_output_faible_resol.txt) \
>> computation_times.txt
cat computation_times.txt

Idem sur une autre scène plus résolue :
stardis -V 3
-M "${DEMONSTRATEUR_2}"/data/poreux_forte_resolution/model_2_0.txt
-n 20 -s
"${DEMONSTRATEUR_2}"/data/poreux_forte_resolution/interface_sole02_Xplus.stl
2> stardis_output_forte_resol.txt echo
$(extract_stardis_triangle_count.sh stardis_output_forte_resol.txt)
$(extract_stardis_computation_time.sh stardis_output_forte_resol.txt)
$(extract_stardis_loading_time.sh stardis_output_forte_resol.txt)
>> computation_times.txt cat computation_times.txt

Faire un plot des temps de chargement des données et du temps de calcul
en fonction du nombre de triangles :

{
  echo "set terminal pdfcairo size 15cm,10cm"
  echo "set output \"temps_de_calcul.pdf\""
  echo "set key noenhanced"
  echo "set key notitle"
  echo "set multiplot layout 2, 1"
  echo "set xlabel 'nombre de triangles'"
  echo "set ylabel 'temps de chargement (en msec)'"
  echo "plot 'computation_times.txt' using 1:3 title ''"
  echo "set ylabel 'temps de calcul (en msec)'"
  echo "plot 'computation_times.txt' using 1:2 title ''"
  echo "print \"Génération de : temps_de_calcul.pdf\""
} > plot_time.gp
gnuplot plot_time.gp
mupdf temps_de_calcul.pdf

Ici on fait une courbe avec peu de points pour éviter que ce soit trop long.
Commenter une courbe avec plus de points dans le TP : observer que le temps
de calcul reste du même ordre quand on double le nombre de triangles.

feh ${DEMONSTRATEUR_2}/Figures/tp2_graphique.png

Prendre comme point de comparaison les méthodes maillées, où ce ne serait
pas du tout le cas.
Bémol : ici on ne prend qu'un seul point de mesure, les temps devraient être
moyennés sur plusieurs réalisations, il se peut que vous ayez donc des temps
plus long pour faire tourner une simulation avec moins de triangles, auquel
cas relancez le calcul.

cd ..

TP2 - Partie 2 : augmentation du nombre d'objets

Note : Mégane n'a pas réussi à dupliquer la gyroïde dans deux directions
seulement, avec la boîte l'encadrant. La configuration Dx=1,Dy=2,Dz=2,
Nint=100 soles=T génère bien une géométrie mais ensuite stardis détecte
plusieurs enclosures. Tous les chemins sont alors rejetés.

Pour le moment, elle a donc opté pour la réutilisation de la scène
électronique du starter pack (en attendant).

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

Description de la scène :
une pièce d'électronique, puis cette pièce répliquée de nombreuses fois.

Visualisation des géométries :

paraview

Ouvrir les stl non préfixés de '_multiple'. Visualiser ce composant avec
ses ailettes.
Ouvrir les stl préfixés de '_multiple'.
Visualiser la plaque avec les 50 composants.

Temps de calcul sur 1 élément :

stardis -V 3 -M model.txt -m SIPw,INF -n 1000 -e

Lire "Computation time ="

Temps de calcul sur des répétitions de cet élément :

stardis -V 3 -M model_multiple.txt -m SIPw,INF -n 1000 -e

Lire "Computation time ="

Bien qu'il y ait une réplication x50 du motif, vous voyez que le temps de
calcul est du même ordre de grandeur.

cd ..

TP2 - Partie 3 : augmentation du raffinement temporel des données

mkdir meteo && cd meteo

Description de la scène :
Il s'agit de la ferme de Roffiac composée de deux étages avec une seule
pièce chacun. La température dans la pièce du bas est constante (par
exemple climatisée), et la température du grenier est inconnue.
La météo extérieure est fluctuante.
On estime la température moyenne de la façade de la maison.

Remarque :
Sur EDIX les propriétés programmables sont déjà installées. Si ce
n'est pas le cas sur un autre système, il faut les installer avec les
commandes suivantes :

cd demonstrateur_2/libs/lib_cosmo
mkdir build && cd build
cmake ../cmake -DCMAKE_INSTALL_PREFIX=../../local
make install
cd ../../

Créer la variable d'environnement suivante :

LD_LIBRARY_PATH="${DEMONSTRATEUR_2}"/libs/local/lib:"${LD_LIBRARY_PATH}"

Visualiser les données plus détaillées :
Ici, afin de permettre une visualisation rapide, l'abscisse représente la
position des données dans le fichier et non la date. Il est possible
d'afficher ces données en fonction de la date en affectant la variable
'NO_TIMESTAMP_COMPUTATION=1' dans le fichier 'run_visualization.sh'.

mkdir visualisation_donnees_meteo_30j && cd visualisation_donnees_meteo_30j
sh "${DEMONSTRATEUR_2}"/TP2/src/3_house/run_visualization.sh \
  "${DEMONSTRATEUR_2}"/data/donnees_meteo_basiques/2_meteo_sur_30j.txt
rm -f graphe_10.png
feh graphe_*.png

Utilisez les flèches pour passer d'un graphique au suivant.
Vous voyez des cycles journaliers dans les données.

Lancer stardis sur les données les plus détaillées :

cd ..
stardis -V 3 -M \
"${DEMONSTRATEUR_2}"/data/ferme_roffiac/meteo_30j_et_isolation_exterieure.txt \
-s "${DEMONSTRATEUR_2}"/data/ferme_roffiac/facade.stl,5000 -n 100000 -e \
2> stardis_meteo_30j_et_isolation_exterieure.txt

stardis -V 3 -M meteo_30j_et_isolation_exterieure.txt -s facade.stl,5000 \
-n 100000 -e 2> stardis_meteo_30j_et_isolation_exterieure.txt

Notez cette température estimée.

Visualiser les données moins détaillées :

mkdir visualisation_donnees_meteo_moyenne_30j
cd visualisation_donnees_meteo_moyenne_30j
sh "${DEMONSTRATEUR_2}"/TP2/src/3_house/run_visualization.sh \
  "${DEMONSTRATEUR_2}"/data/donnees_meteo_basiques/3_meteo_moyennee.txt
rm -f graphe_10.png
feh graphe_*.png

Vous voyez qu'il y a beaucoup moins de points que dans le graphique
précédent, ils couvrent la même plage temporelle.

Relancer stardis sur les données les moins détaillées :

cd ..
stardis -V 3 -M \
"${DEMONSTRATEUR_2}"/data/ferme_roffiac/meteo_moyenne_30j_et_isolation_exterieure.txt \
-s "${DEMONSTRATEUR_2}"/data/ferme_roffiac/facade.stl,5000 -n 100000 -e \
2> stardis_meteo_moyenne_30j_et_isolation_exterieure.txt

Notez cette température estimée. Elle est proche de la précédente.
Les barres d'erreur sont comparables.

Observer le temps de calcul obtenu dans les deux cas :

sed -n '/Computation time =/p' \
  stardis_meteo_moyenne_30j_et_isolation_exterieure.txt
sed -n '/Computation time =/p' \
  stardis_meteo_30j_et_isolation_exterieure.txt

Il est comparable !!

Comparaison des valeurs de température estimées dans les deux cas :

sh "${DEMONSTRATEUR_2}"/TP2/src/3_house/run_computation_time.sh

Comparaison des temps de calcul dans les deux cas :

gnuplot plot_computation_time.gp
mupdf graphe_temps_calcul.pdf

Appuyer sur q pour fermer le plot. Le second graphique montre la valeur de
la température estimée.

gnuplot plot_temperature.gp
mupdf graphe_temperature.pdf

cd ..

TP2 - Partie 4 : augmentation de la plage temporelle d'intégration

mkdir integration_temporelle && cd integration_temporelle

Intégrer sur 1 jour ou sur une semaine. Ici il faudrait la même barre d'erreur

echo "duree_integration temps_calcul" \
  > temps_calcul_en_fonction_duree_integration_temporelle.txt
stardis -V 3 -M \
"${DEMONSTRATEUR_2}"/data/ferme_roffiac/meteo_30j_et_isolation_exterieure.txt \
-s "${DEMONSTRATEUR_2}"/data/ferme_roffiac/facade.stl,5000,5500 -n 100000 -e \
2> stardis_integre_500.txt
echo "500 " $(extract_stardis_computation_time.sh stardis_integre_500.txt) \
>> temps_calcul_en_fonction_duree_integration_temporelle.txt
stardis -V 3 -M \
"${DEMONSTRATEUR_2}"/data/ferme_roffiac/meteo_30j_et_isolation_exterieure.txt \
-s "${DEMONSTRATEUR_2}"/data/ferme_roffiac/facade.stl,5000,6000 -n 100000 -e \
2> stardis_integre_1000.txt
echo "1000 " $(extract_stardis_computation_time.sh stardis_integre_1000.txt) \
>> temps_calcul_en_fonction_duree_integration_temporelle.txt
stardis -V 3 -M \
"${DEMONSTRATEUR_2}"/data/ferme_roffiac/meteo_30j_et_isolation_exterieure.txt \
-s "${DEMONSTRATEUR_2}"/data/ferme_roffiac/facade.stl,5000,6500 -n 100000 -e \
2> stardis_integre_1500.txt
echo "1500 " $(extract_stardis_computation_time.sh stardis_integre_1500.txt) \
>> temps_calcul_en_fonction_duree_integration_temporelle.txt
cat temps_calcul_en_fonction_duree_integration_temporelle.txt

Une fois de plus, les temps de calculs sont comparables.

cd ../..