crÉation d’un module plateforme de simulation …

Luisa VANEGAS ARISTIZÁBAL 5èmme année Génie Civil Master 2 SIG

UNIVERSITÉ JEAN MONNET SAINT ETIENNE - ISTHME 6 rue Basse des Rives – 42023 Saint-Etienne Cedex 2

Rapport de stage de Mars 2012 à Juillet 2012

CRÉATION D’UN MODULE DE LIAISON ENTRE UN SIG ET UNE PLATEFORME DE SIMULATION LBM (LATTICE BOLTZMANN METHOD)

Luisa VANEGAS ARISTIZABAL 5eme année Génie Civil – Master 2 SIG et Gestion de l’Espace

Parcours Professionnel

LABORATOIRE CETHIL INSA DE LYON

9 Rue de la Physique – 69100 Villeurbanne – France

Septembre 2012


REMERCIEMEMENTS

Je remercie dans un premier temps toute l’équipe pédagogique de l’ISTHME,

spécialement Monsieur Eric FAVIER pour m’avoir proposé ce stage et Monsieur

Thierry JOLIVEAU pour être une grande partie de ma formation académique et pour

l’aide et les conseils concernant ce stage.

Je tiens à remercier également mes collègues Ivan CUBILLOS et Diego CACERES

pour m’aider avec la récursivité des algorithmes.

Egalement Monsieur Gilles RUSAOUEN, mon tuteur, pour la confiance qu’il m’a

accordé et pour me permettre d’avoir une expérience aussi enrichissante.


Table des matières

1. PRESENTATION LABORATOIRE CETHIL – INSA DE LYON ....................................................... 1

2. LATTICE BOLTZMANN METHOD ............................................................................................ 2

3. OBJECTIF ET MÉTHODOLOGIE ............................................................................................... 4

4. CHOIX DES LOGICIELS ............................................................................................................ 6

5. LES DONNÉES ET LEUR TRAITEMENT .................................................................................... 7

6. LE FORMAT MULTIPATCH...................................................................................................... 9

7. CONSTRUCTION DU MAILLAGE ........................................................................................... 17

a. Idées de base ................................................................................................................... 17

b. Algorithmie ...................................................................................................................... 18

c. Résultats sous Matlab ..................................................................................................... 22

d. Résultats sous Python ..................................................................................................... 24

e. Résultats sous C++ ........................................................................................................... 26

8. CONCLUSIONS ..................................................................................................................... 27

9. BIBLIOGRAPHIE .................................................................................................................... 28

10. ANNEXES ......................................................................................................................... 28

a. Script sous Matlab ........................................................................................................... 28

b. Script sous Python ........................................................................................................... 32

c. Script sous C++ ................................................................................................................ 33


1

1. PRESENTATION LABORATOIRE CETHIL – INSA DE LYON

Le CETHIL a été fondé en 1982 par la réunion de deux laboratoires (Laboratoire de

Physique Industrielle, Laboratoire de Mécanique des Fluides et Thermiques), et d'une équipe

(Equipe de l'Habitat), auxquels s'est joint en 1986 un autre laboratoire (Laboratoire

d'Energétique et d'Automatique). Initialement, le laboratoire ressemblait plutôt à une

structure fédérative, œuvrant dans un champ disciplinaire commun, utilisant des moyens

partagés, et dont les membres étaient en charge des enseignements de cette discipline dans

différents départements de l'Institut National des Sciences Appliquées (INSA) de Lyon et

à l'Université Claude Bernard-Lyon1 (UCBL).

Associé au Centre National de la Recherche Scientifique (CNRS) à partir de 1989, le

laboratoire s'est regroupé sur deux sites à partir de 1994 et son nombre d'équipes réduit à

trois en 1997. Depuis 1996, le CETHIL est également rattaché officiellement à l'UCBL. En

2000, il a obtenu son statut d'Unité Mixte de Recherche (UMR).

Le Centre de Thermique de Lyon, UMR 5008, organisé depuis 2004 en 6 thématiques scientifiques, est rattaché à trois établissements :

1. Le CNRS et en particulier le Département Ingénierie (ST2I) section 10 CN. Administrativement, il est également rattaché de la Délégation Régionale Rhône Auvergne,

2. l'INSA de Lyon, établissement principal de rattachement qui l'héberge, 3. l'Université Claude Bernard Lyon I.

Dans le cadre de l'INSA, le CETHIL est lié au Département du Premier Cycle et à trois Départements, Génie Energétique et Environnement (GEN), Génie Civil et Urbanisme (GCU), Génie Mécanique et Conception (GMC), par des conventions département-laboratoire. Il apparaît aussi comme laboratoire du Pôle de compétence « Energie - Environnement-» affiché par l'établissement.

Son rattachement à l'UCBL (Université Claude Bernard Lyon 1) se traduit par son implication

dans deux départements de l'Institut Universitaire et Technologique (IUT A), le Département

de Génie Civil et celui de Génie Thermique et Energie, et à un Institut Universitaire

Professionnel (IUP) de Génie Civil. Administrativement, il relève de l'Unité de Formation et

de Recherche (UFR) de Mécanique.

L'ensemble de ces établissements dépend d'une même tutelle : le Ministère de l'Education

Nationale, de l'Enseignement Supérieur et de la Recherche.

Le Centre de Thermique de Lyon dispose aujourd'hui d'une surface totale de l'ordre de

2500m2, répartie sur cinq sites.

http://www.insa-lyon.fr/

http://www.univ-lyon1.fr/

http://www.cnrs.fr/


2

Ses bureaux sont installés principalement sur deux sites, les 2ème et 3ème étages du

bâtiment Sadi Carnot et sur une partie du rez-de-chaussée et du 1er étage du bâtiment

Eugène Freyssinet.

Les dispositifs expérimentaux importants développés par le laboratoire occupent des

surfaces dans trois autres bâtiments, Claude Chappe, Gustave Eiffel et Blaise Pascal.

2. LATTICE BOLTZMANN METHOD La méthode Lattice Boltzmann, – nous l’appellerons désormais LBM –, est une méthode assez nouvelle qui est attirante pour les chercheurs du champ de la turbulence et des écoulements polyphasiques en milieu poreux. La LBM est une classe de la Mécanique des Fluides Numérique, une méthode de simulation d’écoulement de fluide. L’équation de Boltzmann décrit l’évolution d’un gaz peu dense hors d’équilibre. Au lieu de résoudre les équations de Navier-Stokes1, l’équation de Boltzmann discrète est résolue pour simuler l’écoulement d’un fluide newtonien avec des modèles de collision telles que Bhatnagar-Gross-Krook (BGK)2. En physique statique, un gaz est décrit par un nuage de particules obéissant à l’équation de Boltzmann, écrite sous la forme suivante :

(2.1)

Où représente la densité de la particule ayant la vitesse c au point x et au temps t. F désigne les forces extérieures et m la masse moléculaire du gaz. Pour le développement de l’équation ci-dessous nous ne considérons aucune force extérieure et les effets de la gravité seront négligés. On peut alors recalculer les paramètres macroscopiques comme la masse volumique ρ et la quantité de mouvement ou encore l’énergie de la façon suivante :

(2.2)

1 Les équations de Navier-Stokes sont des équations aux dérivées partielles qui décrivent un mouvement non

linéaire d’un fluide. Ces équations modélisent l’atmosphère terrestre, les courants océaniques et l’écoulement autour des véhicules ou des projectiles et, en général, tout phénomène dans lequel des fluides newtoniens sont impliqués. 2 L’opérateur Bhatnagar-Gross-Krook (BGK) s’agit d’un opérateur de collision utilisé dans l’équation de

Boltzmann et dans la LBM : où

est une valeur d’équilibre local pour la population de

particules dans la direction de liaison ei. Le terme est un temps de relaxation, et liée à la viscosité.


3

(2.3)

(2.4)

L’opérateur de collision

décrit l’effet des collisions entre particules. En ne

considérant que les collisions binaires, transformant les vitesses [c1, c2] (pré-collision) en [

] (post-collision) et en faisant l’hypothèse de chaos moléculaire3, cet opérateur peut

s’écrire sous la forme :

(2.5)

Où est la section différentielle de collision.

Dans la pratique l’équation de Boltzmann est résolue sous forme discrète. Pour cela on réalise un maillage de l’espace à simuler, régulier en x, y et z. On obtient donc des points de

calcul :

Figure 1. Exemple d’un maillage avec des points de calcul

La méthode utilise de plus une discrétisation de l’espace de la vitesse :

3 Les vitesses de deux particules avant collision sont décorrélées.


4

Figure 2. Discrétisation de la vitesse

Donc pour pouvoir réaliser la simulation il faut disposer d’un maillage de points de la zone à

calculer et, sur les bords de la zone de calcul (au niveau des conditions aux limites) il faut les

longueurs entre les points de calcul les plus proches des bords et les bords dans les

différentes directions de discrétisations de la vitesse. Il faut de plus disposer d’informations

thermiques et aéraulique concernant ce bord.

Cette méthode est utilisée dans des modèles aéraulique-thermiques pour les écoulements d’air par exemple autour des bâtiments de la ville de Lyon. Il est donc important d’établir une liaison entre la représentation SIG d’une ville et la simulation LBM pour avoir une approche générale de la simulation aéraulique-thermique des quartiers ou des villes.

3. OBJECTIF ET MÉTHODOLOGIE L’objectif de ce stage est donc de créer un module de liaison entre un Système d’Information Géographique (SIG) et une plateforme de simulation LBM, pour la visualisation des données aérauliques et thermiques dans l’espace. Ces données thermiques ne sont pas sur un format spécifique lisible par un SIG, non plus par un logiciel CAO (Conception Assistée par Ordinateur). Elles font parties des modèles LBM, c’est pourquoi nous sommes intéressés au développement d’un outil liaison. Pour cela nous avons pensé une méthodologie simple :


5

1. Nous commençons pour l’obtention des données (MNT4, bâtiments, routes5) ou leur fabrication pour une ville typique sur un format que l’on puisse visualiser sous un SIG (Shapefile, GML, XML, SLD, KML, EWC, GeoTIFF, ou d’autres).

2. Ensuite, nous voulons réaliser un maillage des points visible sous le SIG, dans les mêmes coordonnées géographiques du MNT – Soit par programmation, soit par création CAO et enregistrement en tant que couche (sur un des formats précédents) –.

3. D’après la visualisation du maillage sur la ville sous le SIG, nous cherchons les points du maillage à l’intérieur des bâtiments pour les extraire ou les supprimer ou les déplacer pour les mettre sur le bord du bâtiment.

Figure 3. Représentation de la manipulation souhaitée.

Maillage de points + polygone

Cette procédure doit pouvoir se réaliser de manière efficace pour un ilot typique.

4. Finalement les données aérauliques et thermiques seront ajoutées aux points du maillage pour une visualisation du climat.

4 MNT (Modèle Numérique de Terrain) : Représentation graphique du relief et de la topographie d’un terrain.

5 Des polygones et polylignes créés sous un CAO + l’insertion d’une table attributaire qui contient de

l’information sur l’élément dessiné.


6

4. CHOIX DES LOGICIELS Pour le SIG, nous sommes partis de l’idée d’un logiciel open source parce qu’il y en a beaucoup de très puissants avec autant fonctions que les logiciels payants comme MapInfo. Au départ, notre plus grand intérêt était pour :

les fonctions 3D

un module de codage y compris pour un éventuel besoin de programmation. Ci-dessous la liste des logiciels regardés avant de commencer l’étude :

QuantumGIS – GRASS 1.7.4

Virtual Terrain Project VTP 9

ArcGIS 10.0

MapInfo 10.0 En explorant les différents logiciels disponibles nous avons trouvé une fonction sous ArcGIS pour l’interpolation des données qui n’est pas présente sous d’autres logiciels – même payants – : Interpolation de Krigeage (Kriging Interpolation). Pourtant cette méthode peut être programmée au cas où nous ayons besoin plus tard ; mais celle-ci et d’autres fonctions du module 3D Spatial Analyst d’ArcGIS nous ont fait hésiter. Néanmoins, nous avons décidé de commencer avec un logiciel open source, avec un esprit ouvert au changement au cas où les fonctions ne soient pas satisfaisantes. QuantumGIS (QGIS) – GRASS a été le logiciel open source choisi car assez complet et pour lequel nous nous sentions à l’aise. Dû aux différentes contraintes dont nous parlerons par la suite, nous avons finalement gardé ArcGIS comme le seul SIG à utiliser tout au long du stage. Quant au langage de programmation, nous avons tout d’abord pensé à faire le maillage sous Matlab et à l’enregistrer en format kml pour le visualiser en tant que couche sous le SIG. Cette solution n’a pas été retenue car il semblait un peu compliqué pour une modification de la taille du maillage. En plus, il y a un module Python sous ArcGIS donc nous avons décidé de programmer le maillage directement avec ce langage. Sur la marche nous avons constaté que Python est un langage assez lourd et qui ne gère pas bien la 3D. Le langage C++ a été donc utilisé en essayant de trouver un temps d’exécution satisfaisant pour notre algorithme. En raison du confort dû à la visualisation, Matlab a été utilisé pour une première approche de la solution Enfin nous avons testé le programme sous les 3 langages : Matlab, Python et C++.


7

5. LES DONNÉES ET LEUR TRAITEMENT Des données d’un petit village près de Lyon, nommé Pélussin, sont à notre disposition pour le développement de cette étude. Sur le tableau suivant, nous donnons des détails des données :

NOM DE LA COUCHE

NB. DE DONNEES

SUR LA COUCHE

PARAMETRES ATTRIBUTAIRES DISPONIBLES

Chemins 225 Shape, Source, Nature, Nom, Position sol

Routes 407 Shape, Source, Nature, Classement, Département de gestion, Largueur, Nom, Nombre de voies, Numéro,

Position Sol

Bâtiments 768 Shape, Source, Catégorie, Nature, Hauteur

Corine Land Cover (CLC)

30 Shape, Surface, Périmètre, CLC00 FR, CLC00 FR I,

Code 00, e00 Centro, e00 Centro 1

MNT Image TIFF

Toutes les couches en format Shapefile. Les données 3D étant très dures à trouver, nous n’en utilisons que les 2D. Cela nous pose la première question : Comment convertir les données 2D en 3D ? La réponse est : Par extrusion 3D des polygones. Il existe certains logiciels qui en font mais non pas beaucoup. Nous avons regardé les options trouvées soit en passant par AutoCAD, soit par MapInfo avec un engagement 3D Pro, soit par ArcGIS avec le module 3D Analyst et ArcScene. Aucun logiciel open source n’offre cette fonction. A l’INSA, nous disposons de licences pour certains logiciels, entre autre AutoCAD et MapInfo, donc nous avons essayé ce traitement tout d’abord avec ces deux :

L’extrusion de polygones par AutoCAD est bien possible mais pas efficace. Du fait que c’est une CAO, ce logiciel ne reconnait pas l’information sauvegardée sur la table attributaire de la donnée, nous ne voyons que les polygones. L’extrusion doit se faire donc manuellement, donnant la valeur de l’altitude polygone par polygone. Cette manipulation est déjà longue pour un petit village de 768 bâtiments ; pour une grande ville ce n’est pas une possibilité. Nous n’avons pas gardé cette option.

Ensuite, nous avons demandé une licence MapInfo avec l’engagement 3D Pro. Celle-ci n’est pas disponible à l’INSA. Nous n’avons pas pu tester cette option.

Enfin, avant de penser à acheter une licence ArcGIS, nous avons essayé de faire cette manipulation à la faculté et ensuite enregistrer le projet sur un format lisible par d’autres logiciels – QGIS par exemple –. Malheureusement ce n’est pas possible. Un projet 3D créé


8

sous ArcScene est enregistré uniquement en format ESRI ArcScene Document (.sxd). Si nous voulons exporter le projet en 3D le seul format disponible est le VRML6 en extension .wrl qui ne permet pas des modifications et sa visualisation n’est possible que sur Internet Explorer. Enfin, nous avons constaté que QGIS ne contenait pas des fonctions qui correspondaient à nos besoins. En conséquence nous avons décidé d’acheter une licence ArcGIS complète pour le développement de cette étude. L’extrusion de bâtiments à été faite donc en utilisant ArcScene. Ci-dessous des images d’après cette procédure :

Figure 4. Extrusion des polygones – couche bâtiments – sous ArcScene

6 Virtual Reality Modeling Language ou Virtual Reality Markup Language ; Un format standard pour la

représentation des objets en 3D particulièrement pour le web.


9

Figure 5. Extrusion des polygones – couche bâtiments – sous ArcScene

Néanmoins, nous avons le besoin d’avoir accès indépendant à chaque face des polygones. Les données thermiques ne sont pas les mêmes d’un côté du bâtiment sous l’ombre que d’un côté du bâtiment avec du rayon solaire, par exemple. L’extrusion de polygones ne nous donne pas cette possibilité. Pour cela nous devions passer par un CAO et exploiter chacun des polygones en 2D et puis les extruder perdant toute l’information de la table attributaire. De plus, nous avions besoins de quelques informations sur les bâtiments extrudés, genre pente du toit des polygones, pourcentage de vitrage par façade, couleur du mur, occupation du sol, entre autres. Ces informations existent mais elles sont très limitées : que pour certaine villes ou certains bâtiments, les plus représentatifs. Enfin ces données ne nous sont pas satisfaisantes pour la réalisation de notre étude.

6. LE FORMAT MULTIPATCH Il existe un type de géométrie appelée « Multipatch », un format développé par ESRI en 1997. C’est une géométrie utilisée comme une représentation de limite pour les objets 3D. C’est une donnée créée à partir de quatre éléments : Triangle Strips, Triangle Fan, Triangles and Rings. Une donnée multipatch contient, au moins, une de ces géométries (explication ci-dessous).


10

Géométrie Description

esriGeometryRing Une région délimitée par un chemin fermé

esriGeometryTriangleStrip Un élément de surface de triangles définis par trois points consécutifs.

esriGeometryTriangleFan Un élément de surface de triangles définis par le premier point et deux points consécutifs

esriGeometryTriangles

Un élément de surface de triangles définis par des non-ensembles qui se chevauchent de trois points consécutifs chacun

Le multipatch est utilisé pour la construction des objets 3D, pour garder l’information existante et pour échanger de l’information avec des logiciels non-SIG. Le multipatch a été créé au début avec le but d’avoir accès aux informations des façades des polygones, comme l’orientation. Le multipatch enregistre information telle que la texture de l’image, la couleur, la transparence et le vecteur normal de l’éclairage. Ces géométries peuvent se faire manuellement utilisant la programmation en langage Python. L’enregistrement de l’information est un procès parallèle à la construction des géométries. Pourtant cette procédure nécessite beaucoup de dédicace et de connaissance. La guide « ESRI, The Multipatch Geometry Type » présent des exemples pour apprendre à construire des éléments multipatch pas compliqués. Ci-dessous, des images des géométries Multipatch :

Figure 6. Exemple de la géométrie Ring


11

Figure 7. Exemple de la géométrie Triangle Strip

Figure 8. Exemple de la géométrie Triangle Fan


12

Figure 9. Exemple de la géométrie Triangle

Ayant les informations requises (pente du toit des polygones, pourcentage de vitrage par façade, couleur des murs, orientation des façades, éclairage solaire), il est possible de construire les bâtiments en 3D exactement comme nous en avons besoin. Mais celui-ci serait un stage ou travail différent. Ci-dessous, un exemple d’un bâtiment réalisé en format multipatch :

Figure 10. Vue générale du bâtiment construit


13

Figure 11. Pas 1 : Définir la liste des matériaux

Figure 12. Pas 2 : Démarrage du « GeneralMultipatchCreator »

Figure 13. Pas 3 : Définir le type de patch


14

Figure 14. Pas 4 : Définir les indices du matériel

Figure 15. Pas 5 : Définir les indices et les textures de départ


15

Figure 16. Pas 6 : Définir les points


16

Figure 17. Pas 7 : Définir les points de texture


17

Figure 18. Bâtiment construit

7. CONSTRUCTION DU MAILLAGE

a. Idées de base Tout au début du projet, nous pensions mettre le maillage directement dans le SIG pour une visualisation dans le contexte (ici le village). Pour cela, nous avons décidé de faire le maillage sous Matlab, ajoutant une ligne de codage pour la transformation du fichier et son enregistrement en format kml : le format le plus simple à créer lisible par le SIG. Nous avons également pris les coordonnées des frontières du MNT aussi que le point d’élévation maximale. Cette information nous serait utile pour la délimitation des limites de notre maillage. L’importation du maillage est complètement faisable. Mais, pour ne pas commencer à trop mélanger les logiciels, nous avons choisi de réaliser le maillage en langage Python, le langage de QGIS et d’ArcGIS.


18

A ce moment là, nous avions déjà acheté la licence d’ArcGIS et nous voulions faire le maillage en programmant directement sous le module Python du logiciel. Ce module, en étant lié au SIG, a certaines contraintes : Il ne permet pas de créer de nouveaux éléments pour visualiser sur l’interface d’ArcGIS. Il ne permet que d’automatiser des processus à faire sur les données importées sur le SIG. Pour avoir une bonne base de programmation, il faut programmer en dehors du module du SIG. Nous pouvons utiliser le même langage mais là où toutes les fonctions nous sont disponibles. Après il existe un logiciel open source (celui-ci nous n’avons pas testé), AVPython, qui a été créé comme support d’ArcView et permet de passer les scripts les plus complexes sur le SIG. Ainsi nous avons abandonné l’idée de visualiser le maillage sur le SIG. De plus, il est apparu que les traitements sont lents avec les langages de script comme Pyhton ou Matlab. D’où l’idée de programmer un test de faisabilité : un petit îlot typique de 10 parallélépipèdes (bâtiments) situés de manière aléatoire dans un maillage de 1'000.000 de points (100 en x, 100 en y et 100 en z) juste pour tester le temps que nous mettions à savoir quels points du maillage étaient dans les parallélépipèdes. Et le même test pour différentes tailles du maillage permettra de définir les limites du traitement de base. Nous risquions en effet d’avoir un temps très grand qui pourrait empêcher l’évolution de notre étude. Dans un premier temps, nous avions décidé de faire ce programme en Python, pour continuer avec notre méthodologie d’utilisation de peu de logiciels. La fonction pour créer les parallélépipèdes était dure à trouver pourtant. Nous n’avancions pas beaucoup. Sur Matlab par contre nous avons deux avantages : la visualisation des résultats et la facilité du langage (le logiciel est assez complet et il comprend beaucoup de fonctions). Nous avons donc réalisé le test d’abord dans ce langage. Enfin, l’exécution du script en python étant assez longue, nous avons fait un troisième essai en C++.

b. Algorithmie La théorie de l’algorithme est la suivante : Nous voulons tout d’abord un maillage de 1'000.000 de points (100 en x, 100 en y et 100 en z). Les points du maillage seront des données thermiques plus tard.


19

Figure 19. Système coordonnées.

Ensuite, nous allons représenter les bâtiments par des parallélépipèdes. Pour un maillage aussi petit, 10 parallélépipèdes suffiront. La disposition des bâtiments dans le maillage est leur taille n’est pas fixée. Il nous suffit qu’ils soient à l’intérieur du maillage et d’une taille plus ou moins en accord d’échelle pour représenter un petit quartier. Les bases des parallélépipèdes sont créées de manière aléatoire. Nous partons d’un point : . Nous nous déplaçons une distance delta aléatoire qui nous amènera à un point

.

Figure 20. Exemple d’un « parallélépipède » typique et les coordonnées de ses sommets.


20

Ensuite nous voulons savoir si un point du maillage se trouve à l’intérieur d’un bâtiment ou pas. Ce test pour le million de points :

Enfin ce qui nous intéresse le plus est de connaître le temps que la machine met à tester tous les points du maillage pour différentes tailles ; différent nombre de points et de bâtiments.

Figure 21. Exemple du graphique cherché avec trois tailles de maillage

Ci-dessous, une image qui montre à peu près ce que nous voulons construire :


21

Figure 22. Image d’un maillage + un bâtiment (exemple)

Le script est très simple. Un diagramme de flux du code est montré sur la figure 23.

Figure 23. Diagramme de flux du script maillage + bâtiments


22

c. Résultats sous Matlab Nous avons testé ce programme pour 5 tailles de maillage. Nous sommes allés le plus loin possible en nombre de points. Le nombre de bâtiments a été augmenté proportionnellement au nombre de points. Le script se trouve dans les annexes. Pour le maillage de 100x100x100 (un million de points) nous avons ces images :

Figure 24. Localisation des bases


23

Figure 25. Bases situées

Figure 26. Image final pour 74996 points à l’intérieur des bâtiments


24

Des images comme celles-ci-dessus nous en avons pour tous les tests. Le tableau suivant montre les détails des essais.

Dimension maillage

Nb. De points Nb. De

bâtiments Nb. De points à

l'intérieur des bâtis

Temps d'exécution

(sec)

100x100x100 1,00E+06 10 74996 3,749

500x500x500 1,25E+08 50 149252 4,211

1000x1000x1000 1,00E+09 100 1236484 19,427

5000x5000x5000 1,25E+11 500 6716824 237,453

10000x10000x10000 1,00E+12 1000 32328068 1003,28

Enfin nous avons le graphique pour le temps de calcul :

Figure 27. Temps de calcul pour 5 essais sous Matlab

d. Résultats sous Python Python est un langage de très haut niveau, utilisé dans les domaines du web, des graphiques, de réseau, etc., open source et gratuit et le langage choisi pour les SIG. Cependant il ne gère pas bien les listes et la 3D, et c’est un langage assez lourd qui prend beaucoup de mémoire de l’ordinateur à exécuter un programme.

1,076

151,076

301,076

451,076

601,076

751,076

901,076

1051,076

1201,076

1,00E+06 2,00E+11 4,00E+11 6,00E+11 8,00E+11 1,00E+12

Tem

ps

d'e

xécu

tio

n

Nb. de points

Temps de calcul


25

En conséquence nous n’avons pas réussi à faire un programme 3D comme celui de Matlab ; en revanche nous avons fait le script en 2D, uniquement la construction du maillage plus les bâtiments, sans le test des points à l’intérieur des bâtiments. Pour ce cas nous avons testé 3 tailles de maillage et nous sommes arrivés le plus loin possible, après l’ordinateur plantait. Ci-dessous les détails des essais.

Dimension maillage Nb. De points

Nb. De bâtiments Temps

d'exécution (sec)

100x100 1,00E+04 10 0,6353

500x500 2,50E+05 50 70,4608

1000x1000 1,00E+06 100 1022,3647

Et le temps de calcul :

Figure 28. Temps de calcul pour 3 essais sous Python

0

200

400

600

800

1000

1200

1,00E+04 2,10E+05 4,10E+05 6,10E+05 8,10E+05 1,01E+06 1,21E+06

Tem

ps

d'e

xécu

tio

n

Nb. de points

Temps de calcul Python


26

e. Résultats sous C++ En raison de praticité nous avons fait le même script de Python sous C++. Ci-dessous les détails des essais :

Dimension maillage

Nb. De points Nb. De

bâtiments Temps d'exécution

(sec)

100x100 1,00E+04 10 0,197

500x500 2,50E+05 50 15,42

1000x1000 1,00E+06 100 70,18

5000x5000 2,50E+07 500 971,268

10000x10000 1,00E+08 1000 4002,457

Figure 29. Temps de calcul pour 5 essais sous C++

0

500

1000

1500

2000

2500

3000

3500

4000

4500

1,00E+04 2,00E+07 4,00E+07 6,00E+07 8,00E+07 1,00E+08

Tem

ps

d'e

xécu

tio

n

Nb. de points

Temps de calcul C++


27

8. CONCLUSIONS

Entre les logiciels open source nous n’en avons pas trouvé un d’assez puissant pour l’extrusion des données et ainsi pour la réalisation de notre étude.

L’extrusion des polygones ne nous permet pas d’avoir accès indépendant à chaque face du polygone. Pas qui est important pour introduire les données thermiques de chaque face d’un bâtiment.

Il existe un format de donnée appelé Multipatch qui permet de construire une couche avec toutes les informations nécessaires pour cette étude : pente du toit des polygones, pourcentage de vitrage par façade, couleur du mur, occupation du sol, matériaux du bâtiment, entre autres.

Le module Python sous ArcGIS présente des contraintes par rapport aux modules et aux fonctions disponibles car liée au SIG.

Python étant un langage assez complet et compliqué, nous avons décidé de tester le temps de calcul tout d’abord sous Matlab.

Le temps de calcul sous Matlab n’est pas très long. Nous sommes arrivés à un maillage de 10.000x10.000x10.000 avec 1000 bâtiments qui a pris près de 20 minutes à exécuter. Nous ne sommes pas allés plus loin car manque de mémoire de l’ordinateur.

Le script sous Python a été fait en 2D parce que ce langage ne gère pas bien la 3D et les listes.

Le script 2D sous Python a mis beaucoup plus de temps que le script sous Matlab en 3D. Des temps d’exécutions trop longs pour procéder avec cette solution. En conséquence nous n’avons pas gardé ce langage pour continuer.

Du coup nous avons fait un troisième essaie en langage C++. Il a mis moins du temps à exécuter mais Matlab est toujours le plus performant.

Nous essayons donc de trouver un moyen de passage depuis C++ vers un SIG. Cette procédure nécessite de beaucoup de connaissance en informatique et plus de temps de travail.


28

9. BIBLIOGRAPHIE [1] WAGNER Alexander. – “A practical introduction to the Lattice Boltzmann Method”. North Dakota State University. March 2008. [2] MARIE Simon. – « Etude de la méthode Boltzmann sur réseau pour les simulations en aéroacoustique ». Thèse de doctorat de l’Université Pierre et Marie Curie. Février 2008. [3] DUMOLARD Pierre ; DYRAS Izabela. – “Spatial Interpolation for Climate Data. The use of GIS in climatology and meteorology”. Geographical Information Systems Series. 2007. [4] OBRECHT Christian; KUZNIK Frédéric; TOURANCHEAU Beranrd; ROUX Jean-Jacques.- “Towards urban-scale flow simulations using the Lattice Boltzmann Method”. [5] LANGTANGEN Hans Petter. – “Python Scripting for Computational Science”. Texts in Computational Science Engineering. Third Edition. Springer, Germany 2004. [6] CASAMAYOU-BOUCAU Alexandre ; CHAUVIN Pascal ; CONNAN Guillaume. – « Programmation en Python pour les mathématiques ». Dunod, Paris 2012. [7] ESRI. – “The Multipatch Geometry Type”. An ESRI White Paper. December 2008.

10. ANNEXES

a. Script sous Matlab Le script suivant est celui qui construit un maillage de 1'000.000 de points et 10 bâtiments et fait le test des points (dedans ou dehors les bâtiments). t0=clock; m=100 n=100 o=100 [X Y]=meshgrid(1:1:m,1:1:n) Z=X*0+Y*0 C=zeros(10,4) P=zeros(10,5) k=1;


29

cont=9; hold on for i=1:10 C(i,1)=floor(m*rand()) C(i,2)=floor(n*rand()) C(i,3)=floor(10*rand()+1) C(i,4)=floor(10*rand()+1) if (C(i,1)-C(i,3)<=1 || C(i,1)+C(i,3)>=m ||C(i,2)-C(i,4)<=1 || C(i,2)+C(i,4)>=n) C(i,1)=floor(m*rand()) C(i,2)=floor(n*rand()) C(i,3)=floor(10*rand()+1) C(i,4)=floor(10*rand()+1) end P(i,1)=C(i,1)+C(i,3) P(i,2)=C(i,1)-C(i,3) P(i,3)=C(i,2)+C(i,4) P(i,4)=C(i,2)-C(i,4) P(i,5)=2*min(P(i,1)-P(i,2),P(i,3)-P(i,4)) for k=1:i-1 for s=P(i,2):P(i,1) for t=P(i,4):P(i,3) if(s<P(k,1) && s>P(k,2) && t>P(k,4) && t<P(k,3)) cont=9; while cont<10 cont=10 plot(C(i,1),C(i,2),'ro',[P(i,2) P(i,1)],[P(i,3) P(i,3)],[P(i,1) P(i,1)],[P(i,3) P(i,4)],[P(i,2) P(i,2)],[P(i,3) P(i,4)],[P(i,2) P(i,1)],[P(i,4) P(i,4)]) text(C(i,1),C(i,2),[sprintf('%d',i)],'HorizontalAlignment','center'); C(i,1)=floor(m*rand()) C(i,2)=floor(n*rand()) if (C(i,1)-C(i,3)<=1 || C(i,1)+C(i,3)>=m ||C(i,2)-C(i,4)<=1 || C(i,2)+C(i,4)>=n) C(i,1)=floor(m*rand()) C(i,2)=floor(n*rand()) end P(i,1)=C(i,1)+C(i,3) P(i,2)=C(i,1)-C(i,3) P(i,3)=C(i,2)+C(i,4) P(i,4)=C(i,2)-C(i,4) P(i,5)=2*min(P(i,1)-P(i,2),P(i,3)-P(i,4)) for p=1:i-1 for r=P(i,2):P(i,1) for u=P(i,4):P(i,3)


30

if(r<P(p,1) && r>P(p,2) && u>P(p,4) && u<P(p,3)) cont=cont-1 plot(C(i,1),C(i,2),'rx') end end end end hold on plot(C(i,1),C(i,2),[P(i,2) P(i,1)],[P(i,3) P(i,3)],[P(i,1) P(i,1)],[P(i,3) P(i,4)],[P(i,2) P(i,2)],[P(i,3) P(i,4)],[P(i,2) P(i,1)],[P(i,4) P(i,4)]) text(C(i,1),C(i,2),[sprintf('%d',i)],'HorizontalAlignment','center'); drawnow end end end end end hold on plot(C(i,1),C(i,2),[P(i,2) P(i,1)],[P(i,3) P(i,3)],[P(i,1) P(i,1)],[P(i,3) P(i,4)],[P(i,2) P(i,2)],[P(i,3) P(i,4)],[P(i,2) P(i,1)],[P(i,4) P(i,4)]) text(C(i,1),C(i,2),[sprintf('%d',i)],'HorizontalAlignment','center'); drawnow end figure for i=1:10 hold on plot(C(i,1),C(i,2),[P(i,2) P(i,1)],[P(i,3) P(i,3)],[P(i,1) P(i,1)],[P(i,3) P(i,4)],[P(i,2) P(i,2)],[P(i,3) P(i,4)],[P(i,2) P(i,1)],[P(i,4) P(i,4)]) text(C(i,1),C(i,2),[sprintf('%d',i)],'HorizontalAlignment','center'); drawnow end figure for i=1:10 plot3([P(i,2) P(i,1)],[P(i,3) P(i,3)],[P(i,5) P(i,5)],[P(i,1) P(i,1)],[P(i,3) P(i,4)],[P(i,5) P(i,5)],[P(i,2) P(i,2)],[P(i,3) P(i,4)],[P(i,5) P(i,5)],[P(i,2) P(i,1)],[P(i,4) P(i,4)],[P(i,5) P(i,5)]) plot3([P(i,2) P(i,1)],[P(i,3) P(i,3)],[0 0],[P(i,1) P(i,1)],[P(i,3) P(i,4)],[0 0],[P(i,2) P(i,2)],[P(i,3) P(i,4)],[0 0],[P(i,2) P(i,1)],[P(i,4) P(i,4)],[0 0]) hold on plot3([P(i,2) P(i,2)],[P(i,4) P(i,4)],[P(i,5) 0],[P(i,1) P(i,1)],[P(i,4) P(i,4)],[P(i,5) 0],[P(i,2) P(i,2)],[P(i,3) P(i,3)],[P(i,5) 0],[P(i,1) P(i,1)],[P(i,3) P(i,3)],[P(i,5) 0]) xlabel('Eje X'); ylabel('Eje Y'); zlabel('Eje Z'); grid('on') [X Y]=meshgrid(P(i,2):P(i,1),P(i,4):P(i,3)) Z=0*X+Y*0+P(i,5)


31

surf(X,Y,Z) end inside=0; for i=1:m for j=1:n for k=0:o-1 for s=1:10 if(i<=P(s,1) && i>=P(s,2) && j>=P(s,4) && j<=P(s,3) && k<=P(s,5) && k>=0) inside=inside+1; plot3(i,j,k,'MarkerFaceColor',[1 0 0],'MarkerSize',3,'Marker','o','LineStyle','none','Color',[1 0 0]); title(sprintf('Projet CETHIL - Para %d puntos dentro',inside)) drawnow end end end end end execution_time=etime(clock, t0); disp(sprintf(' ____________________________________________________________________________________________')); disp(sprintf(' Finalisation Simulation : ')); disp(sprintf(' Temps d''exécution (s) = %g \r',execution_time)); disp(sprintf(' ____________________________________________________________________________________________'));


32

b. Script sous Python Ce script fait un maillage en 2D plus la création de 10 bâtiments. Il ne fait pas le test des points. import time def GenerateMesh(tamx, tamy): matrix = [[0 for i in range(tamx)] for j in range(tamy)] return matrix def FindEmptyArea(matrix, tamx, tamy, x1, y1, x2, y2): if x1 >= tamx or y1 >=tamy or x2 >= tamx or y2 >=tamy: return x1, x2, y1, y2 for i in range(tamx): for j in range(tamy): if x1<=i and i < x2: if y1<=j and j < y2: if matrix[i][j] == 1: if x1+1 < tamx and x2+1 < tamx: x1, x2, y1, y2 = FindEmptyArea(matrix, tamx, tamy, x1+1, y1, x2+1, y2) elif y1+1 < tamy and y2+1 < tamy: x1, x2, y1, y2 = FindEmptyArea(matrix, tamx, tamy, x1, y1+1, x2, y2+1) return x1, x2, y1, y2 def AddPolygon(matrix, tamx, tamy, x1, y1, x2, y2): x1, x2, y1, y2 = FindEmptyArea(matrix, tamx, tamy, x1, y1, x2, y2) for i in range(tamx): for j in range(tamy): if x1<=i and i < x2: if y1<=j and j < y2: matrix[i][j] = 1 return matrix def Routine(): v = GenerateMesh(100, 100) AddPolygon(v, 100, 100, 0, 0, 3, 3) AddPolygon(v, 100, 100, 0, 0, 3, 3) AddPolygon(v, 100, 100, 0, 0, 3, 3) AddPolygon(v, 100, 100, 0, 0, 3, 3) AddPolygon(v, 100, 100, 0, 0, 3, 3) AddPolygon(v, 100, 100, 0, 0, 3, 3) AddPolygon(v, 100, 100, 0, 0, 3, 3) AddPolygon(v, 100, 100, 0, 0, 3, 3) AddPolygon(v, 100, 100, 0, 0, 3, 3) AddPolygon(v, 100, 100, 0, 0, 3, 3) for i in range(100): print v[i]


33

start_time = time.clock() Routine() print time.clock() - start_time, "seconds"

c. Script sous C++ #include <iostream> using namespace std; void FindEmptyArea(int** matrix, int tamx, int tamy, int& x1, int& y1, int& x2, int& y2); void AddPolygon(int** matrix, int tamx, int tamy, int& x1, int& y1, int& x2, int& y2); int main(void) { int x, y; cout<<"porfavor digite el tamanio en x"<<endl; cin>>x; cout<<"porfavor digite el tamanio en y"<<endl; cin>>y; int** matrix; matrix = new int *[x]; for(int i=0; i < x; i++) { matrix[i] = new int[y]; } for(int i=0; i < x; i++) { for(int j=0; j < y; j++) { matrix[i][j] = 0; } } int x1 = 0, y1 = 0; int x2 = 3, y2 = 3; AddPolygon(matrix, 1000, 1000, x1, y1, x2, y2); /*AddPolygon(matrix, 1000, 1000, 0, 0, 3, 3); AddPolygon(matrix, 1000, 1000, 0, 0, 3, 3); AddPolygon(matrix, 1000, 1000, 0, 0, 3, 3); AddPolygon(matrix, 1000, 1000, 0, 0, 3, 3); AddPolygon(matrix, 1000, 1000, 0, 0, 3, 3); AddPolygon(matrix, 1000, 1000, 0, 0, 3, 3); AddPolygon(matrix, 1000, 1000, 0, 0, 3, 3); AddPolygon(matrix, 1000, 1000, 0, 0, 3, 3); AddPolygon(matrix, 1000, 1000, 0, 0, 3, 3);


34

*/ for(int i=0; i < x; i++) { for(int j=0; j < y; j++) { cout<<matrix[i][j]; } cout<<endl; } return 0; } void FindEmptyArea(int** matrix, int tamx, int tamy, int& x1, int& y1, int& x2, int& y2) { if(x1>=tamx || y1 >= tamy || x2 >= tamx || y2 >=tamy) { return; } for( int i = 0; i < tamx; i++) { for( int j = 0; j < tamy; j++) { if (x1<=i && i < x2) { if (y1<=j && j < y2) { if (matrix[i][j] == 1) { if (x1+1 < tamx && x2+1 < tamx) { x1++, x2++; FindEmptyArea(matrix, tamx, tamy, x1, y1, x2, y2); } else if( y1+1 < tamy && y2+1 < tamy ) { y1++, y2++; FindEmptyArea(matrix, tamx, tamy, x1, y1, x2, y2); } } } } } } } void AddPolygon(int** matrix, int tamx, int tamy, int& x1, int& y1, int& x2, int& y2) { FindEmptyArea(matrix, tamx, tamy, x1, y1, x2, y2); for( int i = 0; i < tamx; i++ ) { for (int j = 0; j < tamy; j++ )


35

{ if (x1<=i && i < x2) { if (y1<=j && j < y2) { matrix[i][j] = 1; } } } } }

crÉation d’un module plateforme de simulation …

Documents