TP3 : créer sa propre géométrie avec la bibliothèque CAO star-cad

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 TP3
cd TP3

La variable d'environnement suivante simplifie l'accès aux exemples de
CAO :

export SCAD_EX=/home/lafrier/demonstrateur_2/libs/star-cad-examples

Dans les TPs précédents, on a vu que les géométries sont décrites par
des stl. En ouvrir un pour voir ce que cela signifie.
Ici le cube du premier TP.

cat /home/lafrier/Stardis-Starter-Pack-0.2.0/cube/solid.stl

On voit plusieurs facet ... endfacet, qui correspondent à des triangles
définis par 3 sommets et une normale sortante du triangle. Ces coordonnées
nous indiquent aussi la position de cet objet dans la scène et sa taille.
Il y a 12 triangles, qui correspondent bien à deux triangles pour chacune
des six faces du cube.

Pour une géométrie complexe, on n'aura pas envie d'écrire des maillages à
la main. On présente ici une façon d'obtenir des stl pour stardis, à
l'aide du logiciel starcad.

TP3 - Partie 1 : voir comment un simple cube est construit avec star-cad

ls "${SCAD_EX}"
mkdir star-cad-cube
cd star-cad-cube

On l'exécute :

"${SCAD_EX}"/cube

Observer tous les fichiers stl qui viennent d'être créés :

ls

Visualiser avec Paraview :

paraview

Open tous les fichiers stl du dossier star-cad-cube.
C'est la même scène que le starter pack sur laquelle on a travaillé dans
le TP1 :

Exécuter stardis :

cp -r "${SCAD_EX}"/models/cube.txt model.txt
stardis -V 3 -M model.txt -p 0.5,0.5,0.5,INF -n 10000

Ouvrir le fichier star-cad :

vim "${SCAD_EX}"/src/cube.c

On décrit ici tout le fichier. Pour vous, l'objectif est de cibler où le
modifier pour vos besoins.

On décrit tout de même l'ensemble des étapes :

TP3 - Partie 2 : maison cubique

cd ..
mkdir star-cad-house
cd star-cad-house

On exécute le script pour créer la géométrie :

"${SCAD_EX}"/cubic_house

Observer tous les fichiers stl qui viennent d'être créés :

ls

Visualiser avec Paraview :

paraview

Exécuter stardis :

cp -r "${SCAD_EX}"/models/cubic_house.txt model.txt
stardis -M model.txt -p 0,0,1.5 -n 10000 -V 3

Ouvrir le fichier pour observer sa structure :

vim "${SCAD_EX}"/src/cubic_house.c

On observe les mêmes étapes que dans le cas précédent.
Ici on voit de nouvelles fonctions pour définir les géométries qui sont plus
complexes. On fait appel à des opérateurs de CAD.
TODO : donner un pointeur vers un livre de CAO (voir avec Antoine).

Exercice :
Modifiez src/cube.c pour ajouter une boule au centre du cube,
cette boule sera un solide à température imposée.
Ici l'objectif est de créer avec starcad plusieurs fichiers stl :

Pour cela :
1/ Dupliquez src/cube.c (voir procédure ci-dessous) ;
2/ Après la création du cube, ajoutez une boule en consultant l'API de
starcad (fichier /home/lafrier/star-build/local/include/star/scad.h).
Vous devrez pour cela définir de nouvelles variables.
Attention, réglez les paramètres de la boule de sorte à ce qu'elle soit
inclue strictement dans le cube.
3/ Réalisez une opération de découpe (cut) entre le cube et la boule
pour obtenir un "cube troué". Vous pouvez vous aider de l'exemple
cubic_house.c qui fait aussi appel à cette fonction.
Lors de cette opération, la frontière commune (surface externe de la
boule et surface interne du cube troué) est dupliquée : elle existe de
façon distincte dans les deux représentations.
4/ Réalisez une partition de la scène afin d'identifier que cette
frontière est commune, c'est la seule manière d'assurer que le maillage
de cette frontière ensuite soit identique pour les deux objets (cube
troué et boule). Pour cela, vous devez créer une liste en entrée de la
fonction, qui contient les deux objets (cube troué et boule). Vous
pouvez choisir flags = 0.
Attention, la partition créé de nouveaux objets en sortie, il faut
utiliser ceux-ci uniquement (ne plus utiliser les objets d'entrée de
cette fonction).
5/ Exporter le maillage de la boule et du cube troué.
6/ Niveau avancé en C : pour aller plus loin, réalisez une libération
explicite de la mémoire, si vous ne le faites pas, la fonction
scad_finalize le fait déjà pour vous.

La correction est donnée dans le fichier
${DEMONSTRATEUR_2}/TP3/src/2_starcad/mon_cube.c.
Le fichier cube_modification_diff.txt contient les lignes ajoutées au
fichier originel cube.c.

cd ..
mkdir star-cad-exo-cube
cd star-cad-exo-cube

Créez votre propre fichier :

cp "${SCAD_EX}"/src/cube.c ./mon_cube.c

Compilation :

gcc mon_cube.c -o mon_cube -lscad -lrsys

Voir l'exécutable mon_cube :

ls

Exécution :

mkdir scene
cd scene
../mon_cube
ls

Vous devez observer que les fichiers stl ont été générés.
Vous pouvez maintenant modifier mon_cube.c en implémentant les étapes
2 à 6, puis recompilez et exécutez.

Une fois l'exercice réalisé, visualisez le maillage du cube troué :

paraview

Vous devriez avoir un résultat semblable à l'image ci-dessous en chargeant
1 seul stl correspondant au cube troué :

feh "${DEMONSTRATEUR_2}"/Figures/tp3_boule_dans_cube.png

Afin de lancer un calcul stardis sur cette scène, copiez le fichier :

cp "${SCAD_EX}"/models/cube.txt model.txt

Ajoutez la ligne suivante après la description du cube et placer le point
sonde dans le volume du cube troué (hors de la boule) :

vim model.txt

SOLID BOULE 0.1 25 2 0.01 280 280 0 FRONT boule.stl
stardis -M model.txt -p 0.99,0.99,0.99 -V 3

Dans cet exercice, nous faisons le choix de mettre une boule solide afin
que le système soit le plus simple possible à décrire. Comme dans le TP1,
une boule fluide nécessite de décrire la connexion solide / fluide.

Explication du concept de partition :
La partition est un opérateur qui permet d'identifier différentes composantes
et de garantir des frontières communes entre elles quand elles existent.
On donne ici un exemple sur la scène suivante, composée d'un carré et d'un
cercle en intersection :
__________
| |
| / | \
| | | |
| \ | /
|__________|

Les deux géométries d'entrée sont :
__________ _ _
| | / \
| | | |
| | \ _ _ /
| |
|__________|

En interne, trois composantes seront identifiées, ainsi qu'une arête commune :
__________
|1 |
| / | \
| |2 | 3|
| \ | /
|__________|

En sortie, renvoie le même nombre de géométries, où chacune aggrège des
composantes pour former la même surface que la géométrie d'entrée.
__________ _ _
| | / | \
| / | | | |
| | | \ | /
| \ |
|________|

Pour aller plus loin :
Vous pouvez consulter la ferme de ROFFIAC :

cd ../..
mkdir star-cad-farm
cd star-cad-farm

On exécute le script pour créer la géométrie :

"${SCAD_EX}"/roffiac_farm

Observer tous les fichiers stl qui viennent d'être créés :

ls

Visualiser avec Paraview :

paraview

Exécuter stardis :

cp -r "${SCAD_EX}"/models/roffiac_farm.txt model.txt
stardis -M model.txt -p 0,0,1.5 -n 10000 -V 3

Ouvrir le fichier pour observer sa structure :

vim "${SCAD_EX}"/src/roffiac_farm.c

On observe les mêmes étapes que dans le cas précédent.

TP3 - Partie 3 : import d'un fichier step

cd ..

Présenter le cas d'application d'Antoine, juste être en capacité de
comprendre les instructions de CAO. Il a un canal dans lequel il y a un fluide
et des MOS FET sources de puissance volumique. Il a déjà des fichiers ".stp"
issus de logiciels de CAO standards. Il souhaite importer et "découper" le
fluide en différentes bandes sur lesquelles des températures moyennes seront
calculées. Côté géométrie, il défini donc un rectangle qui permet de faire
cette découpe, il supprime cet outil avant de faire l'étape de maillage.
Les étapes sont les suivantes :

Les fichiers suivants sont copiés dans le répertoire courant,
car le code scad_sliced-geometry en a besoin et qu'il n'y a pas de mécanisme
en place pour spécifier ce chemin de façon absolue.

cp "${DEMONSTRATEUR_2}"/libs/scad_sliced-geometry/starcad_learning.stp .
cp "${DEMONSTRATEUR_2}"/libs/scad_sliced-geometry/starcad_learning_fluid.stp .
"${DEMONSTRATEUR_2}"/libs/scad_sliced-geometry/fragments_n.exe
ls

Lire le code en observant les différentes étapes décrites ci-dessus

vim "${DEMONSTRATEUR_2}"/libs/scad_sliced-geometry/fragments_n.c

Le fichier d'entrée de stardis "stardis_entry.txt" prévoit que les fichiers
stl soient placés dans des répertoires. (scad_sliced-geometry - tag 0.0.1)
On l'édite pour supprimer ces dossiers.

sed -e 's/MOS\///g; s/canal_frags_n\///g' -i stardis_entry.txt

Lancer stardis pour vérifier que la géométrie est bien conforme
On voit que le calcul va bien au bout, ici une température moyenne de la
surface indexée 0 du canal intérieur. Le calcul est long car les chemins
sont piégés. Dans la thèse d'Antoine, une autre méthode de Monte-Carlo est
développée (dite avec rebonds) mais n'est pas présentée ici.

stardis -M stardis_entry.txt -s canal_int_0.stl -n 1000 -V 3

TP3 - Partie 4 : city generator

Description de city generator :
C'est un outil de génération procédurale permettant la construction de la
géométrie d'une ville à partir d'un cadastre (empreinte au sol et hauteur
des batiments). Les modes constructifs contrôlent des propriétés des
batiments comme la présence d'isolations et de fenêtres par exemple.
Les catalogues décrivent eux les propriétés des batiments comme
l'épaisseur de chaque isolant, la proportion de fenêtres, l'épaisseur de
la dalle, etc.

Dans cet exercice, nous voyons comment paramétrer sa propre ville.

Partie 4.1 : un exemple concret, l'île du Ramier pour le projet ANR MC2

                                       (porté par C. Caliot du LMAP)  

cd ..

Voir la scène de l'île du Ramier :

paraview "${DEMONSTRATEUR_2}"/TP3/src/script_paraview_ile_ramier.py

Vous devez observer quelque chose de similaire à l'image suivante :

feh "${DEMONSTRATEUR_2}"/Figures/tp3_ile_du_ramier_geometrie.png

Vous pouvez jouer avec la caméra pour tester différents points de vue.
C'est cette description de la scène qui est utilisée ensuite pour le calcul
stardis. Si le script ne fonctionne pas, lancer paraview puis visualiser
B_BUILDING.stl du dossier '${DEMONSTRATEUR_2}/data/ile_du_ramier'

Lancer le calcul d'une image infrarouge :

stardis -V 3 -M "${DEMONSTRATEUR_2}"/data/ile_du_ramier/idr.txt \
-R file=idr2.ht:fov=30:pos=1730,70,50:tgt=900,800,-250:img=500x500:spp=2

Produire une image infrarouge à partir du fichier idr2.ht :

htpp -v -f -m default -o idr2.ppm idr2.ht

Visualiser l'image infrarouge :

feh idr2.ppm

La même image est disponible dans l'énoncé avec beaucoup plus de
réalisations par pixel :

feh "${DEMONSTRATEUR_2}"/Figures/ile_du_ramier_2048_spp.png

Dans cet exercice, la géométrie vous a été donnée, elle a été obtenue
grâce à city_generator. Dans la suite, afin de réduire le temps de
calcul de la géométrie, on prend une scène plus modeste (4 batiments
mitoyens).

Partie 4.2 : découverte de city_generator et du mode constructif 0

mkdir city_generator_mode_0
cd city_generator_mode_0

Obtention de la description géométrique de la scène :

Dans un shell à part (lancé par la commande sh), on commence par enrichir
les chemins avec les répertoires dans lesquels sont installées les librairies
et l'exécutable city_generator_2 (comme dans le TP1).
On le fait dans un shell à part pour éviter que cela n'interfère avec
l'environnement du démonstrateur 2.
sh . /home/lafrier/environnement_city_generator_2/etc/profile city_generator2
-m "${DEMONSTRATEUR_2}"/TP3/src/4_city_generator/4_buildings_mode_0/nc3.yaml
-c
"${DEMONSTRATEUR_2}"/TP3/src/4_city_generator/4_buildings_mode_0/catalog0.yaml
-V 3 exit On vient de quitter ce "sous-environnement".

Observer les stl créés :

ls

Produire le fichier model.txt de façon automatique, via le script suivant.
Pour éviter de décrire chaque batiment, on fusionne les murs ensemble, les
cavités ensemble et on donne à ces groupes les mêmes propriétés.
Le script propose des paramètres par défaut à ces propriétés physiques.

sh "${DEMONSTRATEUR_2}"/TP3/src/4_city_generator/make_stardis_model.sh \
  > model.txt 2> /dev/null

Editer le fichier model.txt, pour changer TRAD à 240 par exemple.
L'objectif est de voir que c'est le même type de fichiers que d'habitude :
vous auriez pu l'écrire à la main ... Sinon jetez un coup d'oeil au TP1 :-)

paraview

Chargez les fichiers STL préfixés par S_. Vous observez quelque chose
comme :

feh "${DEMONSTRATEUR_2}"/Figures/tp3_city_generator_mode_0_geometrie.png

On génère maintenant une image infrarouge de cette scène :

stardis -V 3 -M model.txt \
  -R file=idr2.ht:fov=30:pos=22,-17,20:tgt=4,5,6.5:img=500x500:spp=16
htpp -v -f -m gnuplot:range=260,285 idr2.ht | gnuplot - > idr2.png
feh idr2.png

Observer l'impact du manque d'isolant sur l'image infrarouge des batiments.

Si vous n'avez pas pu générer l'image :

feh "${DEMONSTRATEUR_2}"/Figures/tp3_city_generator_mode_0_rendu_128_spp.png

Analyse de l'image :
Les recoins occultent le ciel, ce qui explique la couleur.
Deuxième effet, le mur est plus chaud ici parce que les deux pièces sont
chaudes. C'est un effet connu pour les batiments mitoyens.

cd ..

Partie 4.3 : mode constructif 1 avec fenêtre et isolants

mkdir city_generator_mode_1
cd city_generator_mode_1

Afin de lancer en mode 1 qui présente une isolation :

sh
. /home/lafrier/environnement_city_generator_2/etc/profile
city_generator2 -m \
"${DEMONSTRATEUR_2}"/TP3/src/4_city_generator/4_buildings_mode_1/nc3.yaml \
-c \
"${DEMONSTRATEUR_2}"/TP3/src/4_city_generator/4_buildings_mode_1/catalog1.yaml \
-V 3
exit

Observer les stl créés :

ls

Produire le fichier model.txt de façon automatique :

sh "${DEMONSTRATEUR_2}"/TP3/src/4_city_generator/make_stardis_model.sh \
  > model.txt 2> /dev/null

Aller éditer le fichier model.txt pour changer TRAD à 240 par exemple.

paraview

Chargez les fichiers STL préfixés par S_. Vous observez quelque chose
comme :

feh "${DEMONSTRATEUR_2}"/Figures/tp3_city_generator_mode_1_geometrie.png

Chargez l'ensemble des stl commençant par S_. Observer la présence de
fenêtres dans ce mode constructif, d'une dalle de fondation et d'isolants.
On vous demandera dans l'exercice suivant de modifier ces propriétés.

stardis -V 3 -M model.txt \
  -R file=idr2.ht:fov=30:pos=22,-17,20:tgt=4,5,6.5:img=500x500:spp=16
htpp -v -f -m gnuplot:range=260,285 idr2.ht | gnuplot - > idr2.png
feh idr2.png

Si vous n'avez pas pu générer l'image :

feh "${DEMONSTRATEUR_2}"/Figures/tp3_city_generator_mode_1_rendu_128_spp.png

Observer l'impact des isolants sur l'image infrarouge, noter que le batiment
le plus présente une forte perte par sa toiture.

cd ..

Partie 4.4 : Exercice, ajouter une isolation à la toiture du batiment

                                                      le plus haut  

cp -r "${DEMONSTRATEUR_2}"/TP3/src/4_city_generator/4_buildings_mode_1 \
  city_generator_exercice
cd city_generator_exercice

Démarche :
Identifier le batiment dans la scène :

cat nc3.yaml

Le batiment le plus haut (height = 13) correspond à l'identifiant "bat_1".
Il utilise les propriétés nommées "b1" dans le catalogue.
Il faut donc modifier les propriétés de "b1" dans le catalogue :

vim catalog1.yaml

catalog1.yaml

Ces modifications sont dans données dans le dossier de correction.

Générer la géométrie :

sh
. /home/lafrier/environnement_city_generator_2/etc/profile
city_generator2 -m nc3.yaml -c catalog1.yaml -V 3
exit

Générer la description du système pour stardis :

sh "${DEMONSTRATEUR_2}"/TP3/src/4_city_generator/make_stardis_model.sh \
  > model.txt 2> /dev/null

Lancer stardis :

stardis -V 3 -M model.txt -R file=idr2.ht:fov=30:pos=22,-17,20:tgt=4,5,6.5:img=500x500:spp=16

Convertir le résultat en image :

htpp -v -f -m gnuplot:range=260,285 idr2.ht | gnuplot - > idr2.png
feh idr2.png

Si vous n'avez pas pu générer l'image :

feh "${DEMONSTRATEUR_2}"/Figures/tp3_city_generator_exercice_rendu_128_spp.png

Comparer cette image avec la précédente.

feh ../city_generator_mode_1/idr2.png

Vous devez observer que l'isolant a bien été ajouté et qu'il y a donc moins
de perte par cette toiture.