Master première année. Mention : Statistiques et Traitement de Données «STD» Rapport de stage

Transcription

1 Université Blaise Pascal UFR Sciences et Technologie Département de Mathématique et Informatique AUBIERE CEDEXFrance Laboratoire de Météorologie Physique (LaMP) 24 avenue des Landais Aubière Master première année Mention : Statistiques et Traitement de Données «STD» Rapport de stage Simulation rapide du transfert radiatif en 3D dans les nuages atmosphériques à l'aide de processeur graphique «GPU» Validation du cas du nuage plan-parallèle homogène Réalisé par : Imane Hammouali Tuteurs de stage: Mr. Frédéric Szczap (LaMP) -Mr. Thierry Faure (LISC) Stage effectué à l'opgc (Observatoire de Physique du Globe de Clermont-Ferrand) LaMP (Laboratoire de Météorologie Physique) LISC (Laboratoire d'ingénierie pour les Systèmes Complexes) Du 06 Avril au 31 Juillet 2010 Année Scolaire 2009/2010 1

2 Remerciements Je tiens à remercier tout particulièrement et à témoigner ma reconnaissance aux personnes suivantes qui ont su m'accueillir chaleureusement au sein du laboratoire LaMP et dont l'aide m'a été précieuse tout au long du stage. Monsieur Fréderic Szczap et Monsieur Thierry Faure, pour la confiance qu'ils m'ont accordée dès mon arrivée au sein du laboratoire. Mes remerciements vont également à tout le personnel du laboratoire pour leur accueil, leur bonne humeur quotidienne et leur capacité de travail en équipe exemplaire. Année Scolaire 2009/2010 2

3 TABLES DE MATIERES INTRODUCTION...7 PARTIE I PRESENTATION DE L ORGANISME Observatoire de Physique du Globe de Clermont-Ferrand ''OPGC''.9 2 Laboratoire de Météorologie Physique ''LAMP''...10 PARTIE II - DESCRIPTION DES TECHNOLOGIES UTILISÉES Langage C Processeur graphique Définition Critères de choix en faveur du GPU Architecture Evolution de la puissance de calcul CUDA : une nouvelle architecture pour la programmation sur carte graphique Introduction à CUDA Les abstractions clés de CUDA La hiérarchie des Threads La mémoire partagée La barrière de synchronisation Programmation avec CUDA Runtime API Mode émulation Méthode de MC «Monte Carlo»...19 PARTIE III PRÉSENTATION DE L'EXISTANT Présentation générale de MCX Historique Objectif Description détaillée du code source de MCX Organisation du code MCX La structure de l algorithme MC 25 PARTIE IV L ETUDE Présentation du transfert radiatif dans un nuage plan-parallèle homogène Modèle du nuage plan- parallèle homogène Le rayonnement La Nature de l'interaction nuage/rayonnement Les modifications apportées au code MCX Propriétés optiques Direction initiale du photon Position initiale du photon Les conditions limites Les conditions cycliques Calcul des énergies La réflectance, la transmittance et l'absorptance...36 Année Scolaire 2009/2010 3

4 3 Résultats et analyse Erreur statistique sur les flux radiatifs Analyse des résultats du MCXRT(Monte Carlo extreme Radiatif Transfer Comparaison des résultats de MCXRT, MCLaMP et 3DMCPOL Réflectance Transmittance Absorptance Conclusion Temps d exécution Le code MCFortran Comparaison des propriétés radiatives de MCFortran2, MCLaMP et MCXRT Analyse des résultats de MCFortran Temps d exécution Le problème de la taille du nuage 55 CONCLUSION ET PERSPECTIVES...56 REFERENCES BIBLIOGRAPHIQUES...58 ANNEXE...59 A Rapport d'installation Installation de la bibliothèque CUDA Installation du logiciel MCX «Monte Carlo extreme»...60 B Le logiciel MCX L'exécution Le lancement de la simulation Les paramètres d'exécution La configuration Le fichier binaire...62 C Modifications apportées au code MCX 63 1 Programme MCXRT Le fichier MCXRT_utilis.c Le fichier MCXRT_utilis.h Le fichier logistic_rand.cu Le fichier MCXRT_core.cu.73 2 Exécution du programme MCXRT La démarche d exécution Le fichier d entrée Résultat d exécution 88 Année Scolaire 2009/2010 4

5 Liste des figures Figure 1: Architecture de CPU...12 Figure 2: Architecture de GPU...12 Figure 3: Évolution des puissances de calcul de CPU et de GPU...13 Figure 4: Exemple de la hiérarchie de groupe de threads...14 Figure 5: Hiérarchie de la mémoire dans le GPU...15 Figure 6: Les différentes composantes de CUDA...16 Figure 7 : Diagramme de l algorithme de Monte Carlo dans le code MCX.25 Figure 8 : Nuage plan-parallèle homogène Figure 9 : Exemple de l interaction nuage/rayonnement.30 Figure 10 : Présentation de l angle zénithal et azimuthal..32 Figure 11 : Exemple des photons réfléchis et transmis par le nuage..33 Figure 12.1 : La variation des flux radiatifs normalisés pour w0 = Figure 12.2 : La variation des flux radiatifs normalisés pour w0 = Figure 12.3 : La variation des flux radiatifs normalisés pour w0 = Figure 13.1 : Comparaison de la réflectance pour MCXRT, MCLaMP et 3DMCPOL.40 Figure 13.2 : Trois graphes représentant l erreur simple de R-MCXRT 41 Figure 14.1 : Comparaison de la transmittance pour MCXRT, MCLaMP et 3DMCPOL..42 Figure 14.2 : Trois graphes représentant l erreur simple de T-MCXRT.43 Figure 15.1 : Comparaison de l absorptance pour MCXRT, MCLaMP et 3DMCPOL 44 Figure 15.2 : Deux graphes représentant l erreur simple de A-MCXRT...45 Figure 16 : Illustration du temps d exécution de MCXRT et MCLaMP.47 Figure 17 : Evolution du gain de temps d exécution de MCXRT..47 Figure 18.1 : Comparaison de la réflectance pour MCFortran2, MCLaMP et MCXRT.48 Figure 18.2 : Trois graphes représentant l erreur simple de R-MCFortran2..48 Figure 19.1 :Comparaison de la transmittance pour MCFortran2,MCLaMP et MCXRT.50 Figure 19.2 : Trois graphes représentant l erreur simple de T-MCFortran2 51 Figure 20.1 :Comparaison de l absorptance pour MCFortran2,MCLaMP et MCXRT 52 Figure 20.2 : Deux graphes représentant l erreur simple de A-MCFortran2..52 Figure 21 : Illustration du temps d exécution de MCXRT et MCFortran2 54 Figure 22 : Evolution du gain de temps d exécution de MCFortran2.54 Figure 23 : comparaison de la réflectance d un nuage de taille 600*600*600 et un autre de taille 60*60* Liste des définitions Définition 1 : Thread...13 Définition 2 : DRAM...16 Définition 3 : API...16 Définition 4 : NVCC...17 Définition 5 : Chaîne de Markov...20 Définition 6 : Fluence 22 Définition 7 : Indice de réfraction..22 Définition 8 : Anisotropie...22 Définition 9 : Mesernne Twister.23 Année Scolaire 2009/2010 5

6 Liste des tableaux Tableau 1 : Récapitulatif des caractéristiques des mémoires..16 Tableau 2 : Les valeurs de l erreur statistique de MC sur la réflectance 41 Tableau 3 : L erreur statistique de MC sur la transmittance 43 Tableau 4 : L erreur statistique de MC sur l absorptance..45 Tableau 5 : L erreur statistique de MC sur la réflectance pour le code de MCFortran2 53 Tableau 6 : L erreur statistique de MC sur la transmittance pour le code de MCFortran Tableau 7 : L erreur statistique de MC sur l absorptance pour le code de MCFortran2 53 Année Scolaire 2009/2010 6

7 INTRODUCTION Dans le cadre de ma première année de Master Statistiques et Traitement de Données «STD», j'ai eu l'opportunité d'effectuer un stage de 4 mois «du 6 Avril au 31 Juillet» à l'observatoire de Physique du Globe de Clermont-Ferrand (OPGC), plus précisément au sein du Laboratoire de Météorologie Physique (LaMP). LaMP est une composante de l'opgc spécialisée dans la recherche atmosphérique. Ces principales études portent sur l'impact des aérosols et des nuages sur le climat. Les nuages recouvrent à peu prés 70% de la surface du globe. Ils jouent un rôle important dans la régulation du climat, c'est la raison pour laquelle l'évolution de la couverture nuageuse ainsi que ses propriétés radiatives sont très étudiées. Les nuages participent à l augmentation ou à la diminution du réchauffement climatique, à travers deux effets antagonistes: * l'effet de serre: les nuages piègent le rayonnement thermique émis par la terre et tendent ainsi à réchauffer l'atmosphère. * l'effet d'albédo: les nuages réfléchissent le rayonnement solaire vers l'espace et contribuent ainsi au refroidissement atmosphérique. Pour mieux comprendre le rôle des nuages dans le contexte du réchauffement climatique à l échelle globale. Il faut donc étudier les interactions entre les nuages et le rayonnement solaire et thermique, cela revient en particulier à calculer les propriétés radiatives des nuages. Afin de comprendre l'impact des nuages sur l'environnement, on a donc besoin de simuler le transfert radiatif dans les nuages atmosphériques. Les nuages présentent des formes géométriques complexes et des propriétés optiques spatiales différentes selon leur nature, c est la raison pour laquelle il est difficile de calculer leurs propriétés radiatives. Pour cela, on a recours à des méthodes statistiques de type Monte Carlo (MC) qui demandent beaucoup de ressources informatiques. Ces méthodes de calcul ne sont pas encore opérationnelles dans les applications nécessaires à l étude des nuages (analyse d image satellite, calcul du réchauffement dans les modèles climatiques). Pour contourner cette difficulté, les scientifiques idéalisent les nuages en utilisant le modèle du nuage plan-parallèle homogène. Le travail qui m a été demandé consiste à développer un programme informatique dont l'objectif est de simuler le transfert radiatif en trois dimensions dans les nuages atmosphériques à l'aide d'un processeur graphique ''GPU'', et de le valider dans le cas du nuage plan-parallèle homogène. Le code source de l'application s'appuiera sur celui du logiciel Monte Carlo extreme ''MCX'' [1]. Ce dernier est basé sur l'approche statistique des méthodes de simulation de Monte Carlo, ainsi que sur la technologie de programmation CUDA. Année Scolaire 2009/2010 7

8 Les différentes missions qui m ont été assignées sont d étudier les technologies proposées par mes tuteurs de stage, d analyser le code existant de MCX, de développer un programme qui simule le transfert radiatif en 3D dans un nuage atmosphérique planparallèle homogène, et enfin d analyser les résultats obtenus à partir de cette simulation. Dans la première partie de mon rapport, je vous présenterai les organismes OPGC et LaMP. La deuxième partie sera consacrée à la description des technologies et de la méthode de simulation, qui seront utilisées durant le stage. Ensuite, nous étudierons le logiciel MCX ainsi que son code source en troisième partie. Dans la dernière partie, je montrerai les différentes modifications effectuées sur le code source de MCX, puis les étapes de l'avancement des travaux de la simulation du transfert radiatif en 3D dans un nuage plan-parallèle homogène, et enfin l'analyse sur les résultats obtenus suite à cette simulation. Année Scolaire 2009/2010 8

9 PARTIE I DESCRIPTION DE L ORGANISME 1. Organisme Du 6 Avril au 31 juillet 2010, le laboratoire de météorologie physique «LaMP» de l observatoire de physique du globe de Clermont-Ferrand «OPGC» m'a accueilli sous la tutelle de Frédéric Szczap et Thierry Faure. 1.1 Observatoire de Physique du Globe de Clermont-Ferrand ''OPGC'' L'observatoire de Physique du Globe de Clermont-Ferrand (OPGC) est un Observatoire des Sciences de l Univers (OSU), et l héritier direct de l Observatoire Météorologique du Puy de Dôme, fondé en 1871 par le professeur Emile Alluard. La configuration actuelle de l OPGC date de Il s acquitte des quatre missions essentielles des OSU : * Il fournit à la communauté nationale et internationale des travaux liés à ses activités de recherche. * Il contribue au progrès de la connaissance de la Terre par l'acquisition et l'archivage de données d'observation et il contribue aux tâches de surveillance et de prévision des phénomènes naturels. * Il contribue dans le cadre de l Université Blaise Pascal de Clermont-Ferrand à la formation des étudiants et des personnels de recherche. * Il concourt à la diffusion des connaissances, en particulier auprès des personnels enseignants et des usagers du service public. L'OPGC est une fédération de deux laboratoires: * Le Laboratoire de Météorologie Physique «LaMP» * Le Laboratoire Magmas et Volcans «LMV» Année Scolaire 2009/2010 9

10 1.2 Laboratoire de Météorologie Physique ''LaMP'' LaMP est une composante de l'opgc spécialisée dans l'atmosphère. Sa problématique principale concerne l étude du rôle des aérosols et des nuages dans l évolution du climat et celle de la composition chimique stratosphérique. La recherche du Laboratoire de Météorologie Physique est fédérée autour de 4 thèmes principaux: * Observations et instrumentations * Pollution: Aérosols et nuages de la troposphère * Cycle de vie des nuages étendus et aérosols * Nuages précipitants Ces recherches dans le domaine atmosphérique nécessitent des moyens techniques importants, comme des avions et des satellites ainsi qu'un traitement informatique particulièrement développé. L'importance des moyens mis en jeu impose de nombreuses collaborations extérieures, aussi bien nationales qu internationales. La simulation fait partie des technologies clés éminemment transverses. Aussi, le laboratoire de météorologie physique développe des programmes de simulation pour étudier l'impact climatique de la couverture nuageuse et de l'interaction nuagesrayonnement, interaction troposphère-stratosphère et chimie humide de l'atmosphèreaérosols. Année Scolaire 2009/

11 PARTIE II DESCRIPTION DES TECHNOLOGIES ET MÉTHODES UTILISEES 1. Langage C Le langage C est un langage de programmation impératif conçu pour la programmation système, c'est à dire une programmation qui vise au développement des programmes qui font partie du système d'exploitation d un ordinateur ou qui en réalisent les fonctions. J'ai décidé de développer en C pour plusieurs raisons. La première raison est que ce langage permet au développeur de s'intéresser non pas au traitement des données, mais aux interfaces, aux protocoles et à la gestion des ressources, telles que le temps et l espace en mémoire. Puis la seconde raison est que le code existant étant programmé en C, il était donc préférable d'utiliser le même langage de programmation afin de faciliter l'adaptation de ce code à mes besoins. 2. Processeur graphique Cette partie consiste à présenter le GPU et à justifier le choix d exploiter la mémoire de ce dernier dans les calculs nécessaires à la simulation. 2.1 Définitions * CPU est une unité centrale de traitement, optimisée pour exécuter le plus rapidement possible des calculs très variés. Pour cela, le CPU nécessite des structures de contrôle sophistiquées. * GPU est destiné à effectuer des opérations d affichage et de manipulation de données graphiques. Dans le but d'exploiter pleinement les performances de ce dernier, la compagnie Nvidia a créé des GPU dédiés spécialement à des calculs de haut débit afin d'alléger le travail du CPU. Année Scolaire 2009/

12 2.2 Critères de choix en faveur du GPU Architecture Figure 1 : Architecture de CPU Le processeur CPU est composé d un ensemble d unités arithmétiques et logiques «ALU» dédiées pour effectuer des calculs arithmétiques et des tests, d une mémoire cache pour alléger l accès à la mémoire centrale et accélérer les calculs effectués par les ALUs. Il possède aussi une unité de contrôle pour gérer la synchronisation entre chaque composante du CPU. Figure 2 : Architecture de GPU Dans la figure ci-dessus, l'architecture du GPU est représentée sous la forme de 128 ALUs devisés en 8 partitions, chacune de ces partitions possède une mémoire cache et une unité de contrôle indépendante des autres partitions. Pour conclure, le GPU conserve une proportion énorme de son architecture pour les calculs, ce qui rend le GPU plus performant dans le cas de calculs massifs face au CPU. Année Scolaire 2009/

13 2.2.2 Évolution de la puissance de calcul A partir de 2003 la puissance de calcul des GPUs a commencé à surpasser celle des CPUs grâce à l'exploitation des processeurs graphiques dans les calculs intensifs de haut niveau, ce qui a déclenché une évolution exponentielle des GPU représentée par le graphe ci-dessous. 3 CUDA: Une nouvelle architecture pour la programmation sur carte graphique Dans cette partie, nous allons présenter l'architecture et la programmation CUDA, afin de prendre connaissance de ses fonctionnalités. 3.1 Introduction à CUDA En 2007 la compagnie NVIDIA a réalisé CUDA «Compute Unified Device Architecture», un modèle de programmation parallèle qui manipule de façon transparente la puissance d une carte graphique composée de plusieurs multiprocesseurs (à partir de GeForce 8800). Ce modèle de programmation supporte différents langages de programmation tels que C, fortran et C++. Cette technologie prend en charge trois abstractions clés qui sont : la hiérarchie de groupes de threads (1) les mémoires partagées la barrière de synchronisation (1)Thread : Un thread est une tâche similaire à un processus, ce dernier peut contenir un ou plusieurs threads. D'un point de vue de l'utilisateur, ces exécutions semblent se dérouler en parallèles. A la différence des processus, les threads partagent le même espace mémoire. Année Scolaire 2009/

14 Ces trois critères permettent de gérer le parallélisme offert par la carte graphique. Ils donnent la possibilité de découper le problème en sous problèmes qui peuvent être résolus de manière indépendante, parallèle et surtout la plus fine possible. Les trois abstractions sont accessibles à travers de nouvelles extensions ajoutées au langage de programmation C. L'exécution d'un programme CUDA peut alors se faire sur un certain nombre de processeurs différents, sans tenir compte de l architecture de la carte graphique. 3.2 Les abstractions clés de CUDA Dans ce chapitre je vais vous expliquer les abstractions clés de CUDA, évoquées précédemment La hiérarchie des groupes de threads Pour comprendre le parallélisme offert par CUDA, une présentation de la hiérarchie des groupes de threads s'impose. Le kernel est une fonction qui spécifie une portion de code à exécuter par tous les threads en parallèle sur le device (ici GPU). L host (ici le CPU) ordonne au GPU d effectuer les calculs. Année Scolaire 2009/

15 Comme illustré dans la figure précédente, chaque thread est contenu dans un bloc de threads par des coordonnées bidimensionnelles ou tridimensionnelles. Chaque bloc est caractérisé par un vecteur bidimensionnel et appartient à une grille. A partir de ces trois éléments «thread, bloc, grille», nous pouvons distinguer deux niveaux de regroupement de threads: * Niveau préemptif: l'ordre d'exécution des blocs est indéterminé, chaque bloc est exécuté indépendamment des autres blocs contenus dans la grille. * Niveau coopératif: tous les blocs ont le même nombre de threads (Ex: 512 blocs pour une carte Tesla C1060). Dans le cas de notre étude, nous avons choisi le niveau coopératif car il permet d'une part d'échanger des données entre les threads et d'autre part, de synchroniser les threads du même bloc. Après avoir étudié la hiérarchie des threads, je vais dorénavant vous présenter la deuxième abstraction clé de CUDA La mémoire partagée Après la hiérarchie des threads, une question se pose à propos de CUDA : Comment se partage la mémoire entre les threads? Pour répondre à cette question je vais vous présenter la deuxième abstraction clé de CUDA, ensuite je vous parlerai des différentes mémoires accessibles par les threads. Comme illustré dans la figure suivante, chaque bloc de threads contient sa propre zone mémoire appelée shared memory ''mémoire partagée''. Cette dernière est présente sur le chipset. Cette mémoire est accessible uniquement par les threads du même bloc en lecture et en écriture. Chaque thread possède en local une mémoire ''local memory'' qui est réservée automatiquement aux structures de grandes tailles ou de tailles inconnues. Figure 5 : Hiérarchie de la mémoire dans le GPU Année Scolaire 2009/

16 De plus, les threads ont accès également à la mémoire globale, la mémoire constante et à la mémoire texture. Mémoire Localisation Cachée Accès Portée Globale DRAM (2) NON Lecture/Écriture Les Threads+Hôte Constante DRAM OUI Écriture Les Threads+Hôte Texture DRAM OUI Écriture Les Threads+Hôte Tableau1: Récapitulatif des caractéristiques des mémoires La barrière de synchronisation Dans la librairie CUDA, il existe plusieurs fonctions permettant de mettre en place des barrières de synchronisation pour la gestion des threads. Le principe de la barrière de synchronisation est simple : chaque thread qui arrivera sur cette barrière devra attendre jusqu'à ce que tous les autres threads soient arrivés à cette barrière. La fonction CudaThreadsSynchronize () est l'une des fonctions de synchronisation qui permet de synchroniser l'ensemble des threads d'une grille. 3.3 Programmation avec CUDA Dans cette partie, nous nous intéressons à la programmation parallèle offerte par CUDA. Pour commencer, je vais vous présenter les composantes de CUDA, ensuite nous allons étudier les trois niveaux de programmation proposés par ce dernier et ses APIs (3). Le graphe ci-dessous représente les trois modules qui forment CUDA. (2) DRAM ''Dynamic Random Access Memory'': est la mémoire informatique dans laquelle un ordinateur place les données lors de leur traitement. (3) API ''Application Programming Interface'': est une interface de programmation qui possède un ensemble de fonctions, procédures ou classes mises à disposition des programmes par une bibliothèque ou un système d'exploitation. Année Scolaire 2009/

17 Après avoir pris connaissance des composantes de CUDA, nous allons maintenant nous intéresser aux trois niveaux de programmation de CUDA: * 1 er niveau: Utilisation d'une librairie externe : Ce niveau utilise des fonctions prédéfinies dans des librairies qui servent de liaison entre le programme et le GPU, comme CUBLAS et CUFFT. Ces librairies fournissent un ensemble d outils pour réaliser des calculs d algèbre linéaire sur le GPU ou calculer la transformée de Fourrier. A ce niveau, le programmeur ne peut utiliser que certaines fonctions prédéfinies, et il ne peut pas contrôler directement le GPU. * 2 ème niveau: Utilisation de l'api CUDA Driver bas niveau : L'API CUDA Driver offre un meilleur niveau de contrôle de GPU lors de la programmation. Elle offre l'avantage de pouvoir charger des portions de code en tant que fichiers assemblages -code ptx- ou binaires -fichier cubin- qui sont générés par le compilateur NVCC (3). En contrepartie, cette API rend la programmation plus contraignante puisque cette dernière est difficile à déboguer et nécessite beaucoup plus de ligne de code à écrire pour exprimer la même chose qu avec l API CUDA de 3 ème niveau. * 3 ème niveau: Utilisation de l'api CUDA Runtime haut niveau Cette interface a été créée après l API CUDA Driver. Chaque appel à une fonction du runtime est décomposé en instructions plus basiques gérées par l API Driver. L'API Runtime est considérée de haut niveau, car elle offre des fonctions plus pratiques pour l'initialisation et la gestion du contexte. Par la suite, seules les fonctions appartenant à l'api Runtime seront présentées. En effet, l algorithme choisi pour effectuer la simulation tout en optimisant le temps d'exécution s'appuie sur l API Runtime. Le choix s est porté naturellement vers cette API pour sa prise en main plus facile à partir du langage C. De plus, la compréhension de l algorithme par des personnes n ayant jamais manipulé CUDA sera plus aisée. (3)NVCC: le compilateur fournit par NVIDIA spécialement pour CUDA. Année Scolaire 2009/

18 3.4 Runtime API Le Runtime CUDA joue le rôle d'intermédiaire entre le développeur et le driver qui facilite le développement en masquant certains détails. Comme nous l'avons mentionné précédemment, cette API contient quelques extensions au langage C. Pour ne pas rentrer dans les détails concernant ces extensions, seules les principales fonctions vont être présentées. Certaines fonctions permettent d'accéder aux propriétés des cartes graphiques installées sur l'ordinateur. Le programme suivant permet de récupérer les caractéristiques telles que : la taille de la mémoire globale, la taille de la mémoire partagée, le nombre maximal de thread par bloc... et cela pour chaque carte graphique. int devicecount; cudagetdevicecount(&devicecount); int device; for (device = 0; device < devicecount; ++device) cudadeviceprop deviceprop; cudagetdeviceproperties(&deviceprop,device); A partir de ce code, on récupère le nombre total des GPUs existant sur la machine à l aide de la fonction cudagetdevicecount(). Ensuite, on affiche les propriétés avec la fonction cudagetdeviceproperties () pour chacunes des cartes graphiques sélectionnées. Cette API possède aussi la fonction cudasetdevice() qui permet de choisir le GPU à relier avec le CPU, et sur lequel nous allons exécuter les kernels. Concernant la mémoire du GPU, elle est manipulée et gérée à l'aide des fonctions suivantes: - cudamalloc (): alloue la mémoire - cudafree (): libère la mémoire - cudamemcpy (): copie la mémoire La fonction cudamemcpy () permet de copier la mémoire du CPU vers le GPU à l aide du paramètre cudamemcpyhosttodevice et réciproquement avec cudamemcpydevicetohost. Année Scolaire 2009/

19 3.5 Mode émulation L architecture CUDA ne possède pas de débogueur. Le mode émulation permet donc de déboguer un programme CUDA pour résoudre certains problèmes de programmation. En effet, l option de compilation -deviceemu force la compilation du code sur le CPU pour pouvoir déboguer le programme. L option deviceemu peut être utilisé directement lors de l exécution du programme, comme dans l exemple suivant : nvcc -deviceemu -o run prog.cu, ou en précisant l option dans un fichier makefile : CUUOPT=-deviceemu. L utilisation de ce mode permet d utiliser les moyens habituels pour déboguer un programme. De plus, toutes les variables sont stockées dans la mémoire du CPU. De ce fait, il est possible d afficher les résultats et les erreurs de calcul du programme. Pour lancer une application CUDA en mode émulation, il faut d abord vérifier les paramètres suivants : - Le CPU doit être capable de faire tourner jusqu au nombre maximum de threads par bloc défini dans un fichier de configuration. - Le CPU doit posséder suffisamment de ressources mémoires pour chaque thread, c'est-à-dire 256 KB par thread. 4 Méthode de Monte Carlo ''MC'' La méthode de MC est une approche statistique dédiée aux simulations des systèmes complexes dans différents domaines comme le domaine mathématique, statistique ou physique. Cette méthode est fondée sur la répétition aléatoire d'échantillonnage pour résoudre des problèmes basés sur des calculs comme des problèmes de type numérique (calcul des intégrales) ou de nature probabiliste (calcul des risques), selon les trois caractéristiques suivantes: 1. Générateur de nombre aléatoire uniformément distribué entre 0 et Simulation de valeurs aléatoires avec des fonctions de distribution plus complexes à partir de (1). 3. Calculs de quantités à partir de plusieurs réalisations indépendantes de (2) Année Scolaire 2009/

20 L étude du transfert radiatif dans un nuage consiste à étudier la propagation du photon tout au long de son trajet jusqu à ce qu il soit absorbé ou sorti du milieu. Pour cela, on considère cette propagation comme une chaîne de Markov (5) de collision d un photon dans un milieu. Le photon va être diffusé ou absorbé selon les propriétés du milieu. On a décidé de mettre en place la méthode Monte Carlo car d une part, le code existant MCX utilise cette méthode et d autre part, cette dernière permet donc de simuler cette chaîne de Markov en estimant statistiquement les propriétés désirées. (5) Chaîne de Markov: est un processus aléatoire (stochastique) [X(t),t>0] portant sur un nombre fini ou comptable d états, la distribution de X(t n) ne dépend que de X((t n-1), de manière simplifiée, la prédiction du futur, sachant le présent, n'est pas rendue plus précise par des éléments d'information supplémentaires concernant le passé. Année Scolaire 2009/

21 PARTIE III - PRÉSENTATION DE L'EXISTANT 1 Présentation générale de MCX MCX (Monte Carlo extreme) est un logiciel développé par le docteur Qianqian Fang au laboratoire PMI «The Photon Migration Imaging», spécialisé dans le domaine de l'imagerie biomédicale et plus particulièrement, dans l'exploration des nouvelles études du cerveau et de la poitrine de façon non invasive et sans utiliser des nuisibles. Le PMI travaille à développer la technologie d'imagerie optique, ainsi que de l'appliquer à un large éventail de la science fondamentale et les études cliniques. 1.1 Historique * 21 Octobre 2009 : sortie de la 1ère version de MCX appelée ''MCX 0.2 Beta'' sous Linux pour 32 et 64 bits, et sous Windows et Mac, accompagnée d un article décrivant le travail effectué. * 22 Décembre 2009: deux mois après la sortie de la 1ère version, la dernière version ''MCX 0.2 Final'' sort accompagnée des fichiers binaires ainsi que le code source du logiciel. 1.2 Objectif Le logiciel Monte Carlo extreme ''MCX'' est destiné à l'industrie de la santé, particulièrement à l'imagerie médicale dont l objectif principal est d'offrir une meilleure compréhension de la manière dont fonctionne le cerveau. De plus, il permet d'ouvrir de nouvelles perspectives de recherche et de servir de base à d éventuelles évolutions pour l'amélioration du dépistage et la détection d'une variété de pathologies. La vocation principale de MCX est la modélisation de la propagation des photons dans des milieux complexes en 3D (exemple: le cerveau). En profitant de la puissance de la carte graphique pour les calculs, ce logiciel permet donc d'exécuter un code de simulation basé sur la méthode de Monte Carlo(MC) d'une vitesse typiquement 300 fois plus rapide qu une exécution sur le CPU. Année Scolaire 2009/

22 L intérêt de ce logiciel est de pouvoir étudier les caractéristiques suivantes: * milieu complexe en 3D * la réflexion dans les bords du milieu * résolution de la propagation des photons en fonction du temps * optimisation des générateurs de nombre aléatoire * calcul de la fluence (6) 2 Description détaillée du MCX Le code MCX est une application écrite en C à l'aide d'une bibliothèque spécialisée dans la programmation parallèle appelée CUDA. Cette application offre la possibilité d étudier la diffusion d'un nombre inconnu de photons, dans un milieu en trois dimensions. Ce milieu est constitué de voxels contenant ses propriétés optiques. Un voxel est un pixel en trois dimensions. Chaque voxel du milieu contient le coefficient de diffusion σs, le coefficient d absorption σa, l indice de réfraction (7) n et l anisotropie (8) donné par le paramètre d asymétrie. 2.1 Organisation du code MCX (6) Fluence : intégrale d une densité de flux de particule sur un intervalle de temps donné. (7) Indice de réfraction: le facteur de réduction de la vitesse de la lumière dans le milieu. (8) Anisotropie: est la propriété d'être dépendant de la direction, dans cette étude il caractérise l effet de structure du milieu dans la façon de dévier les photons. Année Scolaire 2009/

23 Le code source du logiciel MCX est composé de différents types de fichiers : - fichiers.c : contiennent une partie du code source de MCX. Ces fichiers seront exécutés par le CPU. - fichiers.cu : contiennent les fonctions programmées en CUDA. Ces fichiers seront exécutés par le GPU. - fichiers.h : comprennent les prototypes des fonctions, les structures et les constantes utilisés par les fichiers.c et les fichiers.cu. - Makefile : facilite la compilation et l exécution des liens du programme MCX. Voici une description des différents fichiers sources du programme MCX: - Mcextreme.c: contient la fonction principale (fonction Main) du programme MCX. Ce fichier permet donc d'initialiser et de lancer l'exécution de la simulation. - Mcx_utilis.c: permet d initialiser le programme MCX à partir d un fichier de configuration. - Tictoc.c: indique le temps de transfert de données en mémoire CPU au GPU et réciproquement. - Logistic_rand_ring3.cu: génère des nombres aléatoires basés sur l algorithme Logistic Lattice «LL». - Logistic_rand.cu: génère des nombres aléatoires basés sur l algorithme Logistic Lattice «LL» - Mt_rand.cu: génère des nombres aléatoires basés sur l algorithme Mersenne Twister (9) «MT». (9)Mesernne Twister: générateur de nombres aléatoires uniformément distribués. Réputé pour sa qualité et sa vitesse, il est caractérisé par sa longue période avant que sa séquence de chiffre se répète «plus de ». Année Scolaire 2009/

24 - Mcx_core.cu: contient trois fonctions principales: - mcx_main_loop: constitue le cœur du programme qui effectue la simulation du Monte Carlo. - mcx_set_gpu: détermine le nombre de cartes graphiques existantes au sein de l ordinateur ainsi que leurs propriétés. Il permet de choisir sur quelle carte graphique le programme MCX va être exécuté. - mcx_run_simulation: exécute la fonction mcx_main_loop sur le GPU. Année Scolaire 2009/

25 2.2 La structure de l'algorithme MC Le processus de la simulation de la migration des photons dans le cerveau avec la méthode de Monte Carlo est représenté de la manière suivante: Figure 7 : Diagramme de l algorithme de Monte Carlo dans le code MCX : L accès en écriture // : L accès en lecture et écriture Année Scolaire 2009/

26 Comme nous pouvons déduire du diagramme de simulation, pour chaque thread nous étudions la diffusion du photon dans le milieu pour calculer la distribution de fluence. Détaillons les différentes étapes de la simulation : 1/ On lance un photon avec les caractéristiques suivantes : - la position initiale (vecteur [pos.x,pos.y,pos.z] initialisé par [30,30,1]) - la direction initiale (vecteur[dir.x,dir.y,dir.z] initialisé par[0,0,1]) - le poids initial du photon(pos.w=1) 2/ On calcule la distance de diffusion SL (Scattering Length) à partir de l épaisseur optique et du coefficient de diffusion. L épaisseur optique est déterminée en fonction d un nombre aléatoire ζ distribué uniformément entre 0 et 1. Epaisseur optique du photon (τ photon)= -ln(ζ) SL= τ photon / σs 3/ On compare l épaisseur optique du photon avec celle du voxel calculée à partir du coefficient de diffusion et de la distance minimale du voxel. Epaisseur optique du voxel (τ voxel)=minstep/ σs 1 er cas : si τ photon > τ voxel, le photon avance dans le milieu d un voxel. Ensuite, on calcule les nouvelles coordonnées du photon, puis on ajuste la distance de diffusion. pos.x_new=pos.x + dir.x pos.y_new=pos.y + dir.y pos.z_new=pos.z + dir.z τ photon_new= τ photon - τ voxel 2 éme cas : si τ photon < τ voxel alors cela implique une collision à l intérieur du voxel. On calcule les nouvelles coordonnées du photon de la manière suivante : pos.x_new=pos.x + (dir.x*sl) pos.y_new=pos.y + (dir.y*sl) pos.z_new=pos.z + (dir.z*sl) 4/ Si le milieu est absorbant, autrement dit si σa > ε, alors le poids du photon pos.w sera absorbé par le milieu suite à la diffusion. On calcule donc le nouveau poids et l énergie absorbée. Si le 1 er cas (τ photon > τ voxel) est vérifié alors on calcule l atténuation «atten» basée sur l absorption et le nouveau poids du photon. atten = e (-σa *minstep) pos.w_new=pos.w *atten Année Scolaire 2009/

27 Sinon si le 2 éme cas est vérifié alors on modifie directement le poids de la façon suivante : pos.w_new=pos.w * e (-σa *SL) Suite au déplacement du photon dans le milieu, on obtient l'énergie absorbée suivante : energyabsorbed=pos.w-pos.w_new 5/ On répète le 1 er cas de la 3 ème étape jusqu'à parcourir toute la distance de diffusion SL. 6/ A la fin de la diffusion, on calcule les deux angles de diffusion Azimuth φ et Zenith θ. Tout d'abord, l'angle φ est choisi aléatoirement entre [0,2π] à partir de rand_next_aangle qui génère un nombre aléatoire distribué uniformément entre 0 et 1. φ =2π *rand_next_aangle Le choix de l'angle zénith θ entre [0, π] dépend de l'anisotropie g: 1 er cas : si g>ε, on calcule la probabilité P HG à partir de la fonction de phase de Henyey-Greenstein. P HG=(1+g2-[(1-g 2 )/(1-g+2g*rand_next_zangle(t))] 2 )/2g -si P HG>1, on pose P HG à 1 et l'angle zénith est calculé à partir de la relation suivante : θ=acosf(p HG) 2 éme cas : sinon on calcule l'angle zénith directement selon le tirage alétoire entre 0 et 1 de rand_next_zangle. θ=π *rand_next_zangle 7/ On calcule la nouvelle direction basée sur les deux angles θ et φ calculés auparavant. - si le sens de la direction du photon selon l axe verticale «z» se dirige vers le haut ou vers le bas, la nouvelle direction est : new_direction=(tmp1*(dir.x*dir.z*cos(φ)-dir.y*sin(φ))+dir.x*cos(θ), Avec tmp1= sin(θ)* (1-dir.z 2 ) tmp1*(dir.y*dir.z*cos(φ)+dir.x*sin(φ))+dir.y cos(θ), -tmp1*(1-dir.z 2 )* cos(φ)+dir.z* cos(θ)); Année Scolaire 2009/

28 -sinon dir.x=sin(θ)*cos(φ) dir.y=sin(θ)*sin(φ) si l'ancienne valeur de dir.z>0 --> dir.z=cos(θ) sinon --> dir.z=-cos(θ) 8/ On répète le processus à partir de la 2ème étape jusqu'à que le photon sort du domaine ou jusqu'à ce que le temps dédié à la simulation arrive à expiration. 9/ On répète à partir de la première étape jusqu'à que le nombre de mouvement de photon soit épuisé. Année Scolaire 2009/

29 PARTIE IV L ETUDE 1 Présentation du transfert radiatif dans un nuage plan-parallèle homogène Le transfert radiatif décrit l'altération d'un flux lumineux à travers un nuage qui interagit avec celui-ci. Ce processus joue un rôle clé dans le bilan énergétique terrestre et met en jeu des radiations émises et absorbées par le système. Dans cette étude, nous allons traiter l'interaction entre le nuage et le rayonnement émis par le soleil. Nous allons présenter les deux acteurs qui interviennent dans le processus du transfert radiatif, ainsi que la nature de cette interaction. 1.1 Modèle du nuage plan-parallèle homogène Un nuage plan-parallèle homogène est un modèle de nuage caractérisé par : - Ses propriétés géométriques : ce nuage est infini selon l horizontale et fini selon la verticale, car il est limité par deux plans parallèles. - Ses propriétés optiques : l épaisseur optique, l albédo de diffusion et le paramètre d asymétrie sont constantes dans tout le nuage. - Figure 8 : Nuage plan-parallèle homogène Année Scolaire 2009/

30 1.2 Le rayonnement Le transfert radiatif dans les nuages atmosphériques est l'interaction entre les photons issus de notre source lumineuse (le soleil), et les gouttelettes d eau qui constituent le nuage. Pour simplifier l étude, nous n avons pas pris en compte l interaction entre le rayonnement solaire, les gaz atmosphériques et les aérosols. Après la présentation des acteurs dans l'interaction nuage/rayonnement, une description de cette dernière s'impose. 1.3 La nature de l'interaction nuage/rayonnement Les flux de photon émis par le soleil interagissent avec les particules du nuage; celles-ci peuvent être des gouttelettes d'eau nuageuses ou des cristaux de glace. Lorsque qu'un photon incident interagit avec une particule, celui-ci est soit absorbé ou diffusé. On parle de diffusion si les interactions entre la particule et le photon changent la direction initiale de ce dernier. L'absorption survient si la particule peut passer à un niveau d'énergie supérieur en absorbant l'énergie. Figure 9 : Exemple de l interaction nuage/rayonnement 2 Les modifications apportées au code MCX Pour développer un programme qui simule le processus de transfert radiatif dans un nuage plan-parallèle homogène, nous avons adapté le code source existant de MCX afin de répondre aux problématiques du sujet. Dans cette partie, nous allons expliquer les différentes modifications apportées au code source du Monte Carlo extreme. Année Scolaire 2009/

31 2.1 Les propriétés optiques Le milieu dans lequel les simulations sont effectuées à partir de MCX est un cerveau. Or, nous voulons que les simulations soient réalisées dans un nuage, il a donc fallu modifier le code de MCX. En effet, les propriétés optiques d un cerveau diffèrent en plusieurs points de celles d un nuage. Dans un premier temps, nous avons décidé de remplacer les propriétés de configuration du milieu (σs, σa, n, g) par les trois paramètres radiatifs du nuage suivants: - l'épaisseur optique τ Elle représente l'atténuation du rayonnement le long d'un trajet dans le nuage et traduit la capacité de ce dernier à absorber et à diffuser ce rayonnement. τ=( σs + σa ) * hauteur du nuage (1) - l'albédo de diffusion w0 Il traduit l'importance du processus de diffusion par rapport aux phénomènes d'absorption. Si l'albédo de diffusion vaut 1, l absorption est nulle, et il vaut 0 si il n'y pas de diffusion. w0= σs / ( σs + σa ) (2) - anisotropie g Le nuage est considéré comme un milieu anisotrope, car il ne diffuse pas la lumiére de manière isotrope, pour cela la valeur de g sera plus importante par rapport à celle du cerveau. Contrairement au code existant, les coefficients σa et σs seront calculés dans le programme. A partir de (1) et (2), nous déduisons les formules qui nous permettent d obtenir les valeurs de σa et σs. - coefficient de diffusion σs σs =(τ*w0)/hauteur du nuage - coefficient d'absorption σa σa=σs *(1-w0)/ w0 Année Scolaire 2009/

32 2.2 La direction initiale du photon Dans l'étude du transfert radiatif, la simulation commence par calculer la direction d'entrée des photons dans le nuage. Dans notre cas, cette direction est liée à la position du soleil ce qui signifie qu elle ne sera pas fixée par le fichier d'entrée contrairement au code existant. Elle sera donc calculée en fonction des deux angles (θ0, φ0). - l'angle azimuthal φ0 - L'angle zénithal θ0 solaire est l'angle entre la direction solaire incidente et la surface verticale du nuage représentée par l'axe x. Voici la représentation de θ0 et φ0 Soleil Zénith θ 0 S φ 0 N Figure 10 : Présentation de l angle zénithal et azimuthal Nous avons ajouté à la configuration de la simulation les deux angles θ0 et φ0, qui permettent de repérer le trajet de rayonnement solaire par rapport au nuage. Les deux angles seront lus à partir d un fichier d'entrée. La direction initiale du photon (srcdir.x, srcdir.y,srcdir.z) est initialisée dans notre code de la manière suivante : srcdir.x=sin(θ0)*cos(φ0) srcdir.y=sin(θ0)*sin(φ0) srcdir.z=cos(θ0) Année Scolaire 2009/

33 2.3 La position initiale du photon Dans le code MCX, la première collision du rayon avec le cerveau est fixée par le point d entrée (30,30,1). Pour étudier la propagation de l ensemble des rayons solaires dans le nuage, il a donc fallu calculer aléatoirement la position d entrée de chaque photon dans le milieu. Pour calculer la position initiale du photon, nous avons supprimé la configuration de cette dernière dans le code MCX. Ensuite, nous avons intégré une portion de code qui calcule la position initiale du photon par rapport à l axe x et y à l aide de la fonction rand(). La fonction rand génère un nombre aléatoire entre 0 et 1. Selon l'axe z, la position sera égale à 0, car le photon rentre par le haut du nuage. 2.4 Les conditions limites srcpos.x=rand ()*maxidx.x srcpos.y=rand()*maxidx.y srcpos.z=0 Lors de la propagation du photon, ce dernier peut sortir du nuage. Si le photon sort par le haut ou par le bas du nuage, cela signifie respectivement que la position du photon selon l axe z est inférieure à 0 ou supérieure à la hauteur du nuage. Figure 11 : Exemple des photons réfléchis et transmis par le nuage Pour traiter ce cas, nous avons intégré la partie condition limite dans le programme MCX. Les conditions limites permettent dès la sortie du photon, d'incrémenter le nombre de photons simulés, de considérer son poids actuel comme une énergie réfléchie ou transmise par le nuage et de lancer un nouveau photon. Ce photon possèdera la même direction initiale que ses prédécesseurs ainsi qu une nouvelle position initiale définie aléatoirement. Année Scolaire 2009/

34 Voici la partie du code source qui modélise les conditions limites: if (npos.z<0)//le photon est sortie par le haut du nuage energie_sortie_en_haut+=npos.w; //on lance un nouveau photon tmp0=rand_next_position_x(t);//génère un nombre aléatoire entre 0 et 1 tmp1=rand_next_position_y(t); npos=float4 (tmp0*maxidx.x,tmp1*maxidx.y, 0, 1);//position aléatoire d un photon ndir=ndir0;//ndir0 récupère la direction source du photon nlen=float2 (0.f,nlen.y+1); if(npos.z>=maxidx.z)//le photon est sortie par le bas du nuage energie_sortie_en_bas+=npos.w; tmp0=rand_next_position_x(t); tmp1=rand_next_position_y(t); npos=float4 (tmp0*maxidx.x, tmp1*maxidx.y, 0, 1); ndir=ndir0; nlen=float4 (0.f,nlen.y+1); 2.5 Les conditions cycliques Après l'étude de la position du photon selon l'axe z, nous nous sommes intéressés par la suite à la position du photon sur les axes x et y. Le nuage pris en compte dans notre étude est infini horizontalement, alors si le photon sort du nuage suivant les axes x ou y, nous appliquons les conditions cycliques, c'est-à-dire lors de la sortie du photon selon l un de ces deux axes, nous injectons de nouveau dans le nuage le photon qui vient d en sortir. Pour cela, nous calculons une nouvelle position d entrée du photon à l aide de la fonction «modulo» afin que le photon se retrouve dans le nuage. Les conditions cycliques : // Par rapport à l axe x if (npos.x<0 npos.x>=maxidx.x)//si le photon à l extérieur du milieu par rapport à x posx_old=npos.x; //on recalcule une nouvelle position if(posx_old<0) npos.x=fmod(-posx_old,maxidx.x); if(posx_old>=maxidx.x) npos.x=fmod(posx_old,maxidx.x); //par rapport à l'axe y if(npos.y<0 npos.y>=maxidx.y) posy_old=npos.y; Année Scolaire 2009/

35 //on recalcule la nouvelle position du photon par rapport à l'axe y if(posy_old<0) npos.y=fmod(-posy_old,maxidx.y); if(posy_old>=maxidx.y) npos.y=fmod(posy_old,maxidx.y); 2.6 Les énergies Pour analyser l'impact des nuages sur le climat, il faut étudier le bilan énergétique dû à l'interaction entre le rayonnement solaire et le nuage. Le but principal de l étude du transfert radiatif est d au moins de calculer l énergie réfléchie, transmise et absorbée par le système nuageux. Dans un premier temps, nous avons déclaré les trois variables qui représentent l'énergie absorbée, l'énergie sortie par le haut (énergie réfléchie) et par le bas du nuage (énergie transmise) sous la forme d'un tableau de dimension ''idx'', avec idx= blockdim.x * blockidx.x + threadidx.x. float energyabsorbed=genergy[idx]; float energie_sortie_en_haut=greflectance[idx]; float energie_sortie_en_bas=gtransmitance [idx]; - énergie absorbée : représente l énergie du photon absorbée par le nuage lors de sa propagation. La manière dont est calculée l énergie absorbée a déjà été expliquée dans le rapport (page 25-26). - énergie sortie par le haut du nuage : représente le poids actuel du photon lors de sa sortie par le haut du nuage (voir les conditions limites). energie_sortie_en_haut+=npos.w - énergie sortie par le bas du nuage: est le poids du photon sortant par le bas du nuage. energie_sortie_en_bas+=npos.w Après le calcul de ces trois énergies pour chaque thread, on effectue la somme totale pour chaque énergie de tous les threads. for(i=0; i<cfg->nthread; i++) photoncount+=(int)plen[i].y; //le nombre de photon simulé energyabsorbed+=energy[i]; //l'énergie absorbée energie_sortie_en_haut+=reflectance[i]; //énergie réfléchie energie_sortie_en_bas+=transmitance[i];//énergie transmise Année Scolaire 2009/

36 2.7 La réflectance, la transmittance et l'absorptance Comme nous l avons mentionné précédemment, l'énergie de ce dernier peut être absorbée, réfléchie ou transmise par le nuage. Nous avons calculé par la suite les propriétés, en particulier la réflectance, la transmittance et l absorptance. - la réflectance : représente le rapport entre l'énergie solaire réfléchie et l'énergie solaire incidente sur le nuage. Pour calculer ce rapport, nous divisons l'énergie réfléchie totale par la somme des poids initiaux de tous les photons simulés. Comme le poids initial est égal à 1, nous divisons directement l énergie réfléchie par le nombre total de photons simulés. Ce résultat est affiché dans le terminal lors de l exécution de la simulation. fprintf(cfg->flog,"réflectance=%f\n",energie_sortie_en_haut/photoncount); - la transmittance : est le rapport entre l'énergie solaire qui a traversé le nuage et l'énergie incidente sur la surface du nuage. Pour calculer la transmittance, nous divisons l'énergie totale sortie par le bas du nuage par le nombre total de photons simulés par le programme. fprintf(cfg->flog,"transmittance=%f\n",energie_sortie_en_bas/photoncount); - l'absorptance : est le rapport entre l'énergie absorbée et l'énergie incidente dans le nuage. fprintf(cfg->flog,"absorptance=%f\n",energyabsorbed/photoncount); N.B : La somme des trois rapports doit être égale à l'énergie initiale, c'est-à-dire que: 3. Résultat et analyse réflectance+transmittance+absorptance= poids initial 3.1 Erreur statistique sur les flux radiatifs L utilisation de la méthode de Monte Carlo produit une erreur statistique intrinsèque qui décroît avec le nombre de photons simulés par notre programme. Pour estimer l erreur statistique «E» de la méthode de MC sur les flux radiatifs de nuage planparallèle homogène, nous appliquons la formule suivante : E = Er* Pr avec Er : erreur relative et Pr : réflectance, transmittance ou absorbptance E r= (Np-Nfr)/( Np* Nfr) Avec Np et Nfr qui sont respectivement le nombre total de photon simulé et le nombre de photon contribuant au flux radiatif spécifique. Année Scolaire 2009/

37 3.2 Analyse des résultats de MCXRT (Monte Carlo extreme Radiatif Tranfer) Nous allons nous intéresser à l analyse des résultats obtenus après simulation du transfert radiatif par la méthode de Monte Carlo dans un nuage plan-parallèle homogène, à l aide de la carte graphique (Tesla C1060) pour effectuer les calculs. Dans un premier temps, nous avons calculé la réflectance, la transmittance et l'absorptance dans un nuage de taille 60*60*60 et de taille de voxel égale à 1*1*1 avec comme unité de mesure le mètre tout en variant l'albédo de diffusion simple (w0=0,9999;0,9000;0,5000). Nous avons réalisé plusieurs simulations indépendantes sur des épaisseurs optiques comprises dans l intervalle 0,5 τ 100 et avec l angle solaire θ0 =0. 1, , , albedo de diffusion simple=0,9999 0, , , , , , , , , , , Épaisseur optique Réf lectance Transmittance Absorptance Figure 12.1: La variation des flux radiatifs normalisés (réflectance, transmittance, absorptance) selon l'épaisseur optique, pour albédo de diffusion simple w 0=0,9999, et l'incidence solaire θ 0 =0. Si l'albédo de diffusion est égale à , cela signifie que le coefficient d absorption est presque nul, on est donc dans un milieu presque non absorbant. Alors, l effet d'absorption est négligeable comme nous pouvons le constater à partir de la courbe de l absorptance de la figure En augmentant l'épaisseur optique, le nuage devient de plus en plus épais ce qui a pour conséquence que les photons vont être réfléchis au lieu de traverser le nuage expliquant ainsi l'augmentation de la réflectance et la diminution de la transmittance. Année Scolaire 2009/

38 1, , , , , , , , , , albedo de diffusion simple=0,9000 Réflectance Transmittance Absorptance 0, , Épaisseur optique Figure 12.2: La variation des flux radiatifs normalisés (réflectance, transmittance, absorptance) selon l'épaisseur optique, pour albédo de diffusion simple w 0=0,9000, et l'incidence solaire θ 0 =0. Si l'albédo de diffusion simple vaut 0,9000, c'est-à-dire que le coefficient d absorption est plus important que dans le cas de w0=0,9999, alors le nuage est peu absorbant. En augmentant l épaisseur optique, les photons vont être réfléchis au lieu de traverser le nuage, car ce dernier devient de plus en plus épais. Comme le milieu est peu absorbant, une faible partie de l énergie des photons sera absorbée par le nuage expliquant ainsi la diminution de la valeur de la transmittance contrairement à celle de la réflectance et l absorptance. 1, , , , , , , , , , , albedo de diffusion simple=0,5000 0, , Réflectance Transmittance Absorptance Figure 12.3: La variation des flux radiatifs normalisés (réflectance, transmittance, absorptance) selon l'épaisseur optique, pour albédo de diffusion simple w 0=0,5000, et l'incidence solaire θ 0 =0. Année Scolaire 2009/

39 Quand l'albédo de diffusion est faible (w0=0,5000) alors l'effet d'absorption est plus important. A chaque collision du photon, ce dernier perdera une partie de son énergie en fonction du coefficient d absorption du nuage. Si le nuage devient trop épais, l énergie des photons émise sera absorbée totalement par le nuage. Comme nous pouvons le constater à partir de la courbe de l absorptance de la figure 12.3, en augmentant l épaisseur optique du nuage, c est-à-dire, lorsque le nuage s épaissit, l absorptance augmente également, car les coefficients d absorption et de diffusion augmentent (voir les formules page 30) ce qui implique que l énergie du photon sera de plus en plus vite absorbée. Ensuite, concernant la courbe de la transmittance, lorsque l épaisseur augmente, la transmittance diminue car les photons traversent moins facilement le nuage du fait que ce dernier s épaissit. Enfin, dans le cas absorbant, la réflectance est presque nulle quelque soit l épaisseur optique puisque dès la rentrée du photon, son énergie sera absorbée par le nuage. A partir des trois figures précédentes, on peut conclure que les flux radiatifs normalisés (réflectance, transmittance, absorptance) varient suivant l'albédo de diffusion et l'épaisseur optique, c est-à-dire en fonction de la nature du nuage. - Si le nuage est épais et l albédo de diffusion est élevé : l effet d albédo sera important et l effet de serre sera faible. - Si le nuage est épais et l albédo de diffusion est faible : toute l énergie émise sera absorbée. 3.3 Comparaison des résultats de MCXRT, MCLaMP et 3DMCPOL [2] Nous allons comparer dès à présent les résultats des flux radiatifs et de temps d exécution obtenus par le code MCXRT exécuté sur le GPU, avec ceux des deux programmes suivants : - MCLaMP ou Fortran : est une application en langage Fortran qui simule le transfert radiatif avec la méthode de Monte Carlo en trois dimensions sur le CPU. Ce code m a été fourni par le laboratoire. - 3DMCPOL «Three-dimensionnal Polarized Monte Carlo Atmospheric Radiatif Transfer Model» : est codé en Fortran, il simule le transfert radiatif en 3D dans un nuage sur le CPU, en tenant compte de la polarisation de la lumière. Dans le code de ce stage, nous n avons pas tenu compte la polarisation de la lumière. Année Scolaire 2009/

40 3.3.1 Réflectance 1, , , Albedo de diffusion=0,9999 0, , Albedo de diffusion=0,9000 R é fle c ta n c e 0, , , , , R-MCXRT R-Fortran R-3DMCPOL R é fl e c ta n c e 0, , , R-MCXRT R-fortran R-3DMCPOL 0, , , , , Epaisseur optique 0, , Epaisseur optique 0, , Albedo de diffusion=0,5000 Réflectance 0, , , R-MCXRT R-Fortran R-3DMCPOL 0, , , Epaisseur optique Figure 13.1: Comparaison de la réflectance des trois programmes «MCXRT, MCLaMP, 3DMCPOL», pour albédo de diffusion simple égale à , et Comme nous avons pu le constater précédemment, la réflectance varie en fonction de l albédo de diffusion et de l épaisseur optique. A partir des graphes cidessus, nous pouvons remarquer que les réflectances des trois programmes ne sont pas tout à fait identiques alors que théoriquement, elles devraient l être. La différence des résultats de la réflectance entre MCXRT et MCLaMP puis entre MCXRT et 3DMCPOL se calculent à partir des relations suivantes : Erreur1_R=réflectance du MCLaMP -réflectance du MCXRT Erreur2_R =réflectance du 3DMCPOL-réflectance du MCXRT Année Scolaire 2009/

41 Erreur simple 0,0200 0,0100 0,0000-0,0100-0,0200 Albédo de diffusion=0,9999 Erreur1_R Erreur2_R -0,0300 0, Epaisseur optique 0,0020 0,0000 Albédo de diffusion=0,9000 Erreur simple -0,0020-0,0040-0,0060 Erreur1_R Erreur2_R -0,0080 0, Epaisseur optique Erreur simple 0,0035 0,0030 0,0025 0,0020 0,0015 0,0010 0,0005 0,0000-0,0005 Albédo de diffusion=0,5000 0, Epaisseur optique Erreur1_R Erreur2_R Figure 13.2 : Trois graphes représentant l erreur simple de R-MCXRT par rapport à R-MCLaMP et R-3DMCPOL, en fonction de l albédo de diffusion et l épaisseur optique. On constate à partir de la figure 13.2 que le biais systématique sur la réflectance varie dans un intervalle [ ,0.0033]. Pour vérifier si ce biais est significatif statistiquement, nous allons calculer l erreur statistique de MC sur la réflectance de l application MCXRT à partir de la formule de l erreur statistique intrinsèque (voir page 35). w 0=0,9999 0,9000 0,5000 τ =0.5 0, , , , , , , ,00003 Tableau 2 : Les valeurs de l erreur statistique de MC sur la réflectance selon l albédo de diffusion et l épaisseur optique. Nous déduisons à partir des valeurs ci-dessus que l erreur statistique de MC sur la réflectance est inférieure au biais, donc ce dernier est significatif statistiquement. Année Scolaire 2009/

42 3.3.2 Transmittance Figure 14.1: Comparaison de la transmittance des trois programmes «MCXRT, MCLaMP, 3DMCPOL», pour albédo de diffusion simple égale à , et La figure 14.1 illustre le comportement de la transmittance obtenue à partir des trois programmes étudiés, pour une incidence solaire égale à 0. Ce comportement diffère considérablement selon la valeur de l albédo de diffusion et celle de l épaisseur optique. On constate une différence entre les transmittances obtenues à partir des programmes MCXRT, MCLaMP et 3DMCPOL, comme dans le cas de la réflectance. Cette différence est calculée à l aide des deux relations suivantes : Erreur1_T=transmittance du MCLaMP- transmittance du MCXRT Erreur2_ T=transmittance du 3DMCPOL-transmittance du MCXRT Année Scolaire 2009/

43 Erreur simple 0,0300 0,0250 0,0200 0,0150 0,0100 0,0050 0,0000 Albédo de diffusion=0,9999 0, Epaisseur optique Erreur1_T Erreur2_T 0,0150 0,0100 Albédo de diffusion=0,9000 Erreur 0,0050 0,0000 Erreur1_T Erreur2_T -0,0050 0, Epaisseur optique Erreur simple 0,0035 0,0030 0,0025 0,0020 0,0015 0,0010 0,0005 0,0000-0,0005-0,0010 Albédo de diffusion=0,5000 0, Epaisseur optique Erreur1_T Erreur2_T Figure 14.2 : Trois graphes représentant l erreur simple de T-MCXRT par rapport à T-MCLaMP et T-3DMCPOL, en fonction de l albédo de diffusion et l épaisseur optique. Nous remarquons que les valeurs du biais représentées par les trois graphes de la figure 14.2 sont comprises entre -0,0010 et 0,0030. Pour vérifier si le biais est significatif, il a fallu comparer l erreur statistique de MC sur la transmittance et le biais de cette dernière. Voici quelques valeurs de l erreur statistique: w 0=0,9999 0,9000 0,5000 τ= 0.5 0, , , , , ,00001 Tableau 3 : L erreur statistique de MC sur la transmittance Suite à cette comparaison, nous constatons que le biais est supérieur à l erreur statistique de MC sur la transmittance ce qui signifie que le biais est significatif statistiquement. Année Scolaire 2009/

44 3.3.3 Absorptance Pour étudier l absorptance, il faut d abord que le milieu soit absorbant. Pour cela, nous allons traiter l absorptance pour deux cas : albédo de diffusion égale à et , selon différents épaisseurs optiques, pour les trois programmes proposés dans notre étude. Figure 15.1 : Comparaison de l absorptance des trois programmes «MCXRT, MCLaMP, 3DMCPOL», pour albédo de diffusion simple égale à et De même que pour la réflectance et la transmittance, le comportement de l absorptance obtenu à partir des trois codes de la simulation du transfert radiatif dans le nuage atmosphérique, diffère selon deux facteurs : l albédo de diffusion et l épaisseur optique. A partir de la figure 15.1, on constate une faible différence entre les résultats de l absorptance obtenus de MCXRT, Fortran et 3DMCPOL. Comme nous pouvons le remarquer, cette différence est plus importante dans un milieu peu absorbant (w0=0.9000) que dans un milieu absorbant (w0=0,5000). Nous allons représenter graphiquement la différence de l absorptance entre MCXRT et MCLaMP puis entre MCXRT et 3DMCPOL, en calculant l erreur simple selon les relations suivantes : Erreur1_A=absorptance du MCLaMP- absorptance du MCXRT Erreur2_A= absorptance du 3DMCPOL- absorptance du MCXRT Année Scolaire 2009/

45 0,0100 0,0050 Albédo de diffussion=0,9000 Erreur simple 0,0000-0,0050-0,0100-0,0150-0,0200 Erreur1_A Erreur2_A -0,0250 0, Epaisseur optique Erreur simple 0,0010 0,0005 0,0000-0,0005-0,0010-0,0015-0,0020-0,0025-0,0030-0,0035 Albédo de diffusion=0,5000 0, Epaisseur optique Erreur1_A Erreur2_A Figure 15.2 : Deux graphes représentant l erreur simple d A-MCXRT par rapport à A-MCLaMP et A-3DMCPOL, en fonction de l albédo de diffusion et l épaisseur optique. A partir de la figure 15.2, on peut déduire des deux graphes que le biais de l absorptance varie entre et selon l albédo de diffusion et l épaisseur optique. Suite à la comparaison entre le biais et l erreur statistique intrinsèque de la méthode Monte Carlo sur l absorptance, nous déduisons que le biais est significatif car certaines valeurs de ce dernier sont supérieures à celles de l erreur statistique. w 0=0,9000 0,5000 τ= 0.5 0, , , , ,00003 Tableau 4 : L erreur statistique de MC sur l absorptance Dans la partie suivante, nous allons expliquer le biais entre les résultats de l application MCXRT et ceux des deux applications étudiés (MCLaMP, 3DMCPOL). Année Scolaire 2009/

46 3.3.4 Conclusion L étude menée sur les flux radiatifs normalisés (réflectance, transmittance, absorptance) dans un nuage plan-parallèle homogène avec la méthode de Monte Carlo, à partir des programmes MCXRT, MCLaMP et 3DMCPOL, montre qu il existe un biais entre les valeurs obtenues du code MCXRT et les deux autres codes, comme nous avons pu le constater à partir des résultats graphiques précédents concernant les erreurs simples. Le code MCLaMP utilise le polynôme de Legendre dans le calcul de la fonction de phase. Le polynôme de Legendre notés Pn, de degré n, vérifiant Pn(1) = 1 et défini sur l'intervalle [-1,1], est utilisé pour l'approximation en moyenne quadratique des fonctions dans un intervalle [a,b], que l'on ramène à [-1,1] par changement de variable. Avec mes tuteurs, nous avons supposé que l existence du biais dans les calculs doit être causée par le calcul de la direction du photon à partir de la fonction de phase. Cependant, nous n avons pas eu le temps de vérifier si cette première hypothèse est vraie ou pas. La seconde hypothèse qui peut expliquer ce biais est que chacun des trois programmes possèdent son propre algorithme. Les algorithmes de MCXRT et de 3DMCPOL simulent la propagation du photon pas à pas, et elles calculent l énergie absorbée à l aide de la fonction exponentielle (voir page 26). L application MCLaMP utilise la méthode de la section efficace maximale, cette méthode permet à chaque photon de sauter au prochain point de diffusion plutôt que de s accumuler le long de son chemin optique. L énergie absorbée dans le code MCLaMP est calculée de la façon suivante : new_poids=poids_avant*albédo de diffusion énergie absorbée=poids_avant - new_poids Temps d exécution Nous avons choisi le GPU, et non pas le CPU, car il permet d optimiser le temps d exécution du programme MCXRT. En effet, nous avons comparé le temps d exécution du MCXRT sur le GPU et de Fortran sur le CPU, en simulant un million de photon dans un nuage de taille 60*60*60 avec albédo de diffusion égal à et l angle solaire égale 0. Le graphique suivant représente les résultats du temps d exécution pour les deux applications MCXRT et MCLaMP. Année Scolaire 2009/

47 80,0000 Rédigé par Imane Hammouali Temps d'exécution en s 70, , , , , , ,0000 Temps_MCLaMP Temps_MCXRT 0,0000 0, Epaisseur optique Figure 16 : Illustration du temps d exécution pour les deux applications MCXRT et MCLaMP en fonction de l épaisseur optique du nuage. Le temps d exécution varie de 0.4 secondes à 71 secondes pour le code MCLaMP, et de à 0.39 secondes pour le programme MCXRT. On remarque donc un écart entre les performances de CPU et le GPU. Cet écart s explique par le fait que le GPU supporte beaucoup mieux la complexité des calculs que le CPU. La méthode du code MCXRT est très coûteuse en temps de calcul, cela est dû au fait qu elle suit le photon pas à pas. Contrairement à cette dernière, la méthode de la section efficace maximale utilisée dans le code MCLaMP ne suit pas le photon pas à pas ce qui permet d accélérer le temps d exécution du code Monte Carlo. N.B : l option «o 3» permet d accélérer le code fortran. Pour calculer le gain de temps, nous avons appliqué la formule suivante : Gain de Temps=Temps_MCLaMP/Temps_MCXRT. Les résultats obtenus sont représentés par le graphe suivant : 300, ,0000 Gain de temps 200, , ,0000 W0=0,9999 W0=0,9000 W0=0, ,0000 0,0000 0, Epaisseur optique Figure 17 : Evolution du gain de temps d exécution en utilisant le GPU pour MCXRT par rapport au CPU pour MCLaMP selon les différentes épaisseurs optiques et les albédos de diffusion. Année Scolaire 2009/

48 Les trois courbes illustrées par la figure 17 font apparaître un gain de temps important. En effet, il est possible de gagner jusqu à 250 fois en temps pour une épaisseur élevée et un albédo de diffusion faible par rapport au CPU. Pour conclure, le GPU montre ici tout son intérêt pour des calculs de haut niveau. 3.4 Le code MCFortran2 Avec l aide de mes deux tuteurs, nous avons développé une application semblable à celle du code MCLaMP appelée MCFortran2. Cette application utilise la méthode de la section efficace maximale et s exécute sur le GPU. La différence entre ces deux programmes réside dans le calcul de la fonction de phase de Henyey-Greenstein. Le programme MCFortran2 adopte la même méthode de calcul de la fonction de phase que le code MCXRT, c'est-à-dire sans l utilisation de polynôme de Legendre Comparaison des propriétés radiatives de MCFortran2, MCLaMP et MCXRT Dans cette partie, nous allons comparer les propriétés radiatives des codes suivants : MCFortran2, MCLaMP et MCXRT, ainsi que les biais entre les résultats de MCFortran2 et ceux des deux autres codes. La réflectance 0, , Albédo de diffusion=0,5000 Réflectance 0, , , R-MCFortran2 R-MCLaMP R-MCXRT 0, , , Epaisseur optique Figure 18.1: Comparaison de la réflectance des trois programmes «MCFortran2, MCLaMP, MCXRT», pour albédo de diffusion simple égale à , et Année Scolaire 2009/

49 -Biais de la réflectance : On calcule le biais entre les réflectances obtenues à partir du code MCFortran2 et celles obtenues à partir des codes MCLaMP et MCXRT. biais1_r=réflectance du MCLaMP- réflectance du MCFortran2 biais2_ R= réflectance du MCXRT- réflectance du MCFortran2 Voici la représentation graphique du biais : Biais 0,0200 0,0000-0,0200-0,0400 Albédo de diffusion=0,9999 0, Epaisseur optique biais1_r biais2_r Biais 0,0000-0,0050-0,0100-0,0150-0,0200-0,0250 Albédo de diffusion=0,9000 0, Epaisseur optique biais1_r biais2_r Biais 0,0000-0,0005-0,0010-0,0015-0,0020-0,0025-0,0030-0,0035-0,0040-0,0045 Albédo de diffusion=0,5000 0, Epaisseur optique biais1_r biais2_r Figure 18.2 : Trois graphes représentant le biais d R-MCFortran2 par rapport à R-MCLaMP et R-MCXRT, en fonction de l albédo de diffusion et l épaisseur optique. Année Scolaire 2009/

50 La transmittance Trans m ittance 0, , , , , , , , , , Albédo de diffusion=0,5000 0, Epaisseur optique T-MCFortran2 T-MCLaMP T-MCXRT Figure 19.1 : Comparaison de la transmittance des trois programmes «MCFortran2, MCLaMP, MCXRT», pour albédo de diffusion simple égale à , et Biais de la transmittance: Pour calculer le biais entre les résultats de la transmittance du code MCFortran2 et ceux des programmes MCLaMP et MCXRT. biais1_t=transmittance du MCLaMP- transmittance du MCFortran2 biais2_ T=transmittance du MCXRT- transmittance du MCFortran2 Année Scolaire 2009/

51 Nous représentons le biais calculé par les deux formules précédentes par les graphes ci-dessous. 0,0400 0,0300 Albédo de diffusion=0,9999 Biais 0,0200 0,0100 0,0000 biais1_t biais2_t -0,0100 0, Epaisseur optique 0,0250 0,0200 Albédo de diffusion=0,9000 0,0150 Biais 0,0100 0,0050 0,0000 biais1_t biais2_t -0,0050 0, Epaisseur Optique Biais 0,0160 0,0140 0,0120 0,0100 0,0080 0,0060 0,0040 0,0020 0,0000-0,0020 Albédo de diffusion=0,5000 0, Epaisseur optique biais1_t biais2_t Figure 19.2 : Trois graphes représentant le biais systématique de T-MCFortran2 par rapport à T-MCLaMP et T-MCXRT, en fonction de l albédo de diffusion et l épaisseur optique. Année Scolaire 2009/

52 L absorptance Absorptance 1, , , , , , , , , , , Albédo de diffusion=0,9000 0, Epaisseur optique A-MCFortran2 A-MCLaMP A-MCXRT 1, , Albédo de diffusion=0,5000 Absorptance 0, , , , A-MCFortran2 A-MCLaMP A-MCXRT 0, , Epaisseur optique Figure 20.1: Comparaison de l absorptance des trois programmes «MCFortran2, MCLaMP, MCXRT», pour albédo de diffusion simple égale à et Le biais de l absorptance Nous calculons la différence entre l absorptance de MCLaMP et l absorptance de MCFortran2, ensuite entre l absorptance de MCXRT et celle de MCFortran2. Biais 0,0300 0,0200 0,0100 0,0000-0,0100-0,0200-0,0300 Albédo de diffusion=0,9000 0, Epaisseur optique biais1_a biais2_a Biais 0,0100 0,0050 0,0000-0,0050-0,0100 Albédo de diffusion=0,5000 0, Epaisseur optique biais1_a biais2_a Figure 20.2 : Deux graphes représentant le biais d A-MCFortran2 par rapport à A-MCLaMP et A- MCXRT en fonction de l albédo de diffusion et l épaisseur optique. Année Scolaire 2009/

53 3.4.2 Analyse des résultats de MCFortran2 Pour vérifier la significativité du biais obtenu à partir des résultats du code MCFortran2, il a fallu calculer l erreur statistique intrinsèque de la méthode de Monte Carlo sur les flux radiatifs (voir page 35). Voici quelques valeurs de l erreur statistique de MC sur les flux radiatifs suivants : - la réflectance w 0=0,9999 0,9000 0,5000 τ =0.5 0, , , , , , , , ,00004 Tableau 5 : L erreur statistique de MC sur la réflectance pour le code MCFortran2. - la transmittance w 0=0,9999 0,9000 0,5000 τ =0.5 0,0000 0, , , , , , , ,00000 Tableau 6 : L erreur statistique de MC sur la transmittance pour le code MCFortran2. - l absorptance 0,9000 0,5000 τ =0.5 0, , , , , ,00005 Tableau 7 : L erreur statistique de MC sur l absorptance pour le code MCFortran2. D après les comparaisons entre les valeurs de l erreur statistique et celles du biais, nous avons constaté que certaines valeurs du biais sont supérieures à celles de l erreur statistique intrinsèque de MC. Le biais est donc statistiquement significatif, cela est dû au fait que dans le code MCFortran2, nous n avons pas utilisé le polynôme de Legendre pour calculer la fonction de phase. Année Scolaire 2009/

54 3.4.3 Temps d exécution Pour vérifier que la méthode de la section efficace maximale est moins coûteuse en temps de calcul par rapport à la méthode qui consiste à suivre le photon pas à pas, nous avons comparé le temps d exécution du MCFortran2 à celui du MCXRT sur le GPU. La simulation a été réalisée avec un million de photons dans un nuage de taille de taille 60*60*60 avec l albédo de diffusion égal à 0, Le graphique suivant représente les temps d exécution pour les applications MCXRT et MCFortran2. 0,4500 0,4000 Temps d'exécution en s 0,3500 0,3000 0,2500 0,2000 0,1500 0,1000 0,0500 0,0000 0, Epaisseur optique Temps_MCXRT Temps_MCFortran2 Figure 21 : Illustration du temps d exécution pour les applications MCXRT et MCFortran2 en fonction de l épaisseur optique du nuage. On remarque que le temps d exécution du code MCXRT varie de 0,052 secondes à 0,40 secondes, et que pour le code MCFortran2, il varie entre 0,0022 et 0,29. Nous pouvons donc en déduire que la méthode de la section efficace maximale optimise le temps de calcul. Par la suite, nous avons calculé le gain de temps obtenu pour une simulation avec un million de photon à partir des applications MCXRT ou MCFortran par rapport à la simulation du même nombre de photon à partir de l application MCLaMP. 300, ,0000 Gain de temps 200, , , ,0000 0,0000 0, Epaisseur optique Gain_MCXRT Gain_MCFortran2 Figure 22: Evolution du gain de temps d exécution en utilisant le GPU pour MCFortran2 et MCXRT par rapport à MCLaMP selon les différentes épaisseurs optiques. L application MCFortran2 donne un meilleur gain de temps, c est-à-dire l utilisation de la méthode de la section efficace maximale est plus avantageuse si on l exécute sur le GPU. Année Scolaire 2009/

55 3.5 Le problème de la taille du nuage Les applications MCXRT et MCFortran2 sont opérationnelles pour une taille de nuage 60x60x60 et une taille du voxel fixée à 1*1*1 en mètre. Pour simuler le transfert radiatif dans un nuage de taille quelconque, il a fallu modifier la représentation de la taille du nuage dans les deux programmes MCXRT et MCFortran2 de la manière suivante : Hauteur du nuage = maxidx.z*steps.z Profondeur du nuage =maxidx.y*steps.y Longueur du nuage = maxidx.x*steps.x Avec steps.x, steps.y et steps.z représentent respectivement la longueur, la largeur et la hauteur du voxel. Maxidx.x, maxidx.y et maxidx.z correspondent au nombre total de voxel suivant les trois axes (x,y et z). A l heure actuelle, nous avons pu résoudre le problème de la taille du nuage pour l application MCFortran2, ce code peut donc simuler le transfert radiatif dans un nuage plan-parallèle homogène de taille quelconque. Néanmoins, nous ne sommes pas arrivés à résoudre ce problème pour MCXRT. Voici une représentation graphique d un exemple de la réflectance d un nuage de taille égale à 600*600*600 mètres comparée à celle d un nuage de taille 60*60*60. 1, , Comparaison de la réflectance Pour albédo de diffusion=0,9999 Réflectance 0, , , nuage de 60*60*60 nuage de 600*600*600 0, , Epaisseur optique Figure 23 : Comparaison de la réflectance du code MCFortran2 pour un nuage de taille 60*60*60 et un autre de taille 600*600*600. Année Scolaire 2009/

56 CONCLUSION ET PERSPECTIVES Pour conclure, après avoir réalisé une étude sur l'existant ainsi que sur les différentes technologies proposées par mes tuteurs, j'ai pu modifier le code MCX, afin de mettre en place une application permettant de simuler le transfert radiatif en trois dimensions dans un nuage atmosphérique à géométrie plan parallèle et à propriétés optiques homogènes. Pendant ce stage nous avons comparé les résultats des flux radiatifs normalisés (réflectance, transmittance et absorptance) obtenus à partir du code MCXRT avec ceux obtenus à partir des codes MCLaMP et 3DMCPOL fournis par mes tuteurs. Suite à cette comparaison, nous avons pu en déduire l existence d un biais. Pour vérifier la significativité de ce dernier, nous avons calculé l erreur statistique intrinsèque de la méthode de MC pour MCXRT. Cette erreur nous a montré que le biais est significatif statistiquement. Ensuite, nous nous sommes intéressés au temps d exécution et au gain de temps de notre application par rapport aux autres applications, afin de monter l intérêt de l utilisation du GPU dans les calculs importants. Pour résoudre le problème du biais, nous avons développé un programme semblable à MCLaMP appelé MCFortran2. La seule différence entre ces deux codes se situe au niveau du calcul de la fonction de phase à l aide du polynôme de Legendre. A partir de l existence d un biais significatif entre les résultats de MCLaMP et MCFortran2, nous avons pu déduire que le biais est dû au fait que nous n avons pas utilisé le polynôme de Legendre dans le programme MCFortran2. Ensuite, nous avons comparé les temps d exécution de MCXRT et MCFortran2. Le résultat de la comparaison nous a permis de conclure que la méthode de la section efficace maximale utilisée dans l application MCFortran2 est moins coûteuse en temps par rapport à la méthode pas à pas de MCXRT. A ce jour, l'objectif du projet a été atteint pour le modèle nuage plan-parallèle homogène, car l application est opérationnelle pour un nuage de taille 60*60*60, et elle répond au travail demandé : simuler la propagation des rayons solaires dans un nuage en trois dimensions, calculer les différentes énergies «l énergie réfléchie, l énergie transmise et l énergie absorbée» ainsi que les flux radiatifs normalisés «réflectance, transmittance, absorptance». Les difficultés rencontrées sont à la fois d'ordre conceptuel et technique : mettre en place un algorithme qui simule le transfert radiatif en 3D dans un nuage en se basant sur l algorithme du code MCX. appréhender CUDA: comprendre l architecture et la programmation CUDA puis prendre connaissances de ces fonctionnalités, et apprendre à les appliquer. Année Scolaire 2009/

57 Ce stage m'a permis de développer des compétences tant sur le plan technique que sur le plan humain. En effet, sur le plan technique, j'ai pu mettre en application les connaissances acquises au cours de cette année universitaire, comme l implémentation de la méthode de Monte Carlo. J'ai également acquis un nouveau modèle de programmation, CUDA que j'ai mis en pratique lors de la réalisation de mon application. Sur le plan humain, le stage m'a permis d'apprendre à travailler de manière plus autonome, notamment sur l'étude de l'existant et des technologies qui m'ont permis de développer l application MCXRT (Monte Carlo extreme Radiatif Transfer). A l heure actuelle, l application MCXRT n est pas totalement terminée. Les points importants qui restent à traiter sont les suivants: - générer l application pour une taille du voxel différent d un mètre. Pour le programme MCFortran2 ce problème est résolu. - résoudre le problème du biais détecté lors des résultats. Auparavant, nous avons supposé que ce biais est dû à la manière dont est calculée la fonction de phase. Ensuite, vérifier si la tabulation des valeurs calculées de la fonction de phase permet d augmenter le gain de temps d exécution. - simuler du transfert radiatif en 3D dans un nuage hétérogène. Au final, ce stage m a permis de découvrir le travail de la recherche en modélisation et du développement en laboratoire. Année Scolaire 2009/

58 REFERENCES ET BIBLIOGRAPHIQUES SITES INTERNET CONSULTES o o o o o NVIDIA_CUDA_C_ProgrammingGuide_3.1.pdf Livres o Thèse de Monsieur Fréderic Szczap, étude des effets hétérogénéités des nuages sur leurs propriétés radiatives effectives et leurs paramétrisations Références o [1] : Fang Qianqian et David A. Boas, "Monte Carlo Simulation of Photon Migration in 3D Turbid Media Accelerated by Graphics Processing Units" Opt. Express, vol. Express, vol. 17, issue 22, pp (2009) 17, numéro 22, pp à (2009) o [2] : C. Cornet, L. C-Labonnote et F. Szczap " Three-dimensional Polarized Monte Carlo Atmospheric Radiative Transfer Model (3DMCPOL): 3D Effects en Polarized Visible Reflectances of a Cirrus Cloud" (2008). Année Scolaire 2009/

59 Annexe A. Rapport d'installation 1 Installation de la bibliothèque CUDA Dans cette partie, nous allons décrire la procédure d'installation de la bibliothèque CUDA. * Description de la machine : - Système d'exploitation: RedHat Enterprise Linux 5.4 (64bits) sur un noyau linux el5 - Carte graphique: Tesla C1060 «4 GB de mémoire» * Procédure d'installation : L installation du paquet CUDA Toolkit for RedHat Enterprise Linux 5.3 «64 bits». // en mode root (en mode administrateur) # localiser le paquet cudatoolkit_2.3_linux_64_rhel5.3.run: [root@xxxxxxx~] # locate cudatoolkit_2.3_linux_64_rhel5.3.run # se déplacer dans le répertoire où se trouve le paquet CUDA [root@xxxxxxx~] # cd /chemin ou se trouve le paquet # exécuter le paquet [root@xxxxxxx~] # sh cudatoolkit_2.3_linux_64_rhel5.3.run Verifying archive integrity... All good. Uncompressing NVIDIA CUDA Enter install path (default /usr/local/cuda, '/cuda' will be appended): /usr/local ======================================== * Please make sure your PATH includes /usr/local//cuda/bin * Please make sure your LD_LIBRARY_PATH * for 32-bit Linux distributions includes /usr/local//cuda/lib * for 64-bit Linux distributions includes /usr/local//cuda/lib64 * OR * for 32-bit Linux distributions add /usr/local//cuda/lib * for 64-bit Linux distributions add /usr/local//cuda/lib64 * to /etc/ld.so.conf and run ldconfig as root * Installation Complete Année Scolaire 2009/

60 Pour compléter l'installation de la bibliothèque CUDA, nous devons modifier les variables d'environnements. // en continue en mode root # dans /etc/profile, ajouter : PATH=$PATH:/usr/local/cuda/bin export PATH LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib64/ export LD_LIBRARY_PATH # dans /etc/ld.so.conf, ajouter: /usr/local/cuda/lib64 # dans /etc/ld.so.conf.d/ créer le fichier cuda.conf # dans /etc/ld.so.conf.d/cuda.conf, ajouter: /usr/local/cuda/lib64 # taper la commande ldconfig : # ldconfig # dans /home/szczap/.bash_profile, ajouter: LD_LIBRARY_PATH=/usr/local/cuda/cuda/lib64:$LD_LIBRARY_PATHexport PATH LD_LIBRARY_PATH 2 Installation du logiciel MCX "Monte Carlo extreme" Cette partie résume les étapes d'installation du logiciel MCX. Tout d'abord, nous téléchargeons la version MCX v0.2 (finale) compatible à notre OS «mcx x86_64-binary.tar.gz», puis nous extrayons l archive téléchargé. Voici les étapes de l installation du MCX. // Dans la console en mode root // 1er méthode : # dans /home/szczap/.bash_profile, ajouter : alias mcx=/home/szczap/desktop/mcx/bin/mcx # exécuter mcx : # mcx // 2éme méthode : # localiser le dossier mcx # locate mcx # se déplacer dans le répertoire où se trouve le dossier mcx # cd chemin # visualiser tous les dossiers et les fichiers du mcx # ls AUTHORS.txt ChangeLog.txt example README.txt svn utils bin doc LICENSE.txt src TODO.txt Année Scolaire 2009/

61 B. Le logiciel MCX 1 L exécution Après l installation, nous nous sommes intéressé à l exécution du code source de MCX. # On compile le code source # make --> la commande make crée dans le dossier «src» des fichiers objet et dans le dossier «bin» un exécutable «mcx». # On se déplace dans le dossier «bin» # cd bin # visualiser tous les dossiers et les fichiers du dossier bin # ls mcx # exécuter l'exécutable mcx #./mcx 2 Le logiciel MCX Pour lancer la simulation à partir du logiciel MCX, il faut avoir deux fichiers : - Le fichier de configuration (.inp) : contient l initialisation des variables d entrées. - Le fichier binaire : contient le volume du milieu. 2.1 Les paramètres d'exécution Le logiciel MCX offre à l'utilisateur l ensemble des options qui peuvent être utilisées à partir d'une ligne de commande. Voici la liste des options, ainsi que leurs modes d'utilisation: usage:./mcx <param1> <param2>... where possible parameters include (the first item in [ ] is the default value) -i (--interactive) interactive mode -f config (--input) read config from a file -t [128 int] (--thread) total thread number -T [128 int] (--blocksize) thread number per block -m[0 int] (--move) total photon moves -n [0 int] (--photon) total photon number (not supported yet, use -m only) -r [1 int] (--repeat) number of repeations -a [1 0] (--array) 1 for C array, 0 for Matlab array -g [1 int] (--gategroup) number of time gates per run -b [1 0] (--reflect) 1 to reflect the photons at the boundary, 0 to exit -B [1 0] (--reflect3) 1 to consider maximum 3 reflections, 0 consider only 2 Année Scolaire 2009/

62 -e [0. float] (--minenergy) minimum energy level to propagate a photon -R [0. float] (--skipradius) minimum distance to source to start accumulation -U[1 0] (--normalize) 1 to normailze the fluence to unitary, 0 to save raw fluence -d [1 0] (--savedet) 1 to save photon info at detectors, 0 not to save -S [1 0] (--save2pt) 1 to save the fluence field, 0 do not save -s sessionid (--session) a string to identify this specific simulation (and output files) -p [0 int] (--printlen) number of threads to print (debug) -h (--help) print this message -l (--log) print messages to a log file instead -L (--listgpu) print GPU information only -I (--printgpu) print GPU information and run program example:./mcx -t T 256 -m f input.inp -s test -r 2 -a 0 -g 10 La commande précédente lance la simulation sur 1024 threads (-t), avec 256 threads dans chaque bloc (-T). Chaque thread va simuler mouvements de photon (-m) et la simulation sera répétée deux fois (-r). La configuration sera lue à partir du fichier d'entrée ''input.inp'' (-f) et le résultat de cette simulation sera sauvegardé dans le fichier ''test'' (-s). 2.2 La configuration Le Logiciel MCX offre deux méthodes pour configurer la simulation : un mode interactive à l aide du paramètre (-i), et un autre mode consiste à créer un fichier d entrée en format txt. Le fichier d entrée est construit de la manière suivante: # total photon (not used), use -m to specify photon moves # RNG seed, negative to generate # source position (mm) # initial directional vector 0.e+00 1.e-09 1.e-10 # time-gates(s): start, end, step semi60x60x60.bin # volume ('unsigned char' format) # x: voxel size, dim, start/end indices # y: voxel size, dim, start/end indices # z: voxel size, dim, start/end indices 1 # num of media # scat. mus (1/mm), g, mua (1/mm), n 4 1 # detector number and radius (mm) # detector 1 position (mm) # Le fichier binaire Chaque octet du fichier binaire représente l indice du milieu (Ex : semi60x60x60.bin). Ce fichier peut être lu de deux façons par MCX : en ligne ou en colonne, selon la valeur du paramètre «-a». Si le fichier binaire est sauvegardé à partir de matlab ou de fortran, il sera donc lu en colonne. S il est sauvegardé à partir dec, la lecture se fera en ligne. Année Scolaire 2009/

63 ANNEXE C: Modifications apportées au code MCX 1 Programme MCXRT «Monte Carlo extreme Radiatif Transfert» 1.1 fichier : MCXRT_utilis.h #ifndef _MCEXTREME_UTILITIES_H #define _MCEXTREME_UTILITIES_H #include <stdio.h> #include <vector_types.h> #define MAX_PROP 256 #define MAX_DETECTORS 256 #define MAX_PATH_LENGTH 1024 #define MAX_SESSION_LENGTH 256 typedef struct nuagemedium float albedo;//prop.x float epaisseur_optique;//prop.y float g;//prop.z Medium; /*this order shall match prop.xyz in mcxrt_main_loop*/ typedef struct nuageconfig Config; int nphoton; /*(total simulated photon number) we now use this to temporarily alias totalmove, as to specify photon number is causing some troubles*/ //int totalmove; /* [depreciated] total move per photon*/ int nblocksize; /*thread block size*/ int nthread; /*num of total threads, multiple of 128*/ int seed; /*random number generator seed*/ float3 srcpos; /*src position in m*/ /* ON ajoute les deux variables thetaa et phi initiales*/ float thetaa_init; float phi_init; float3 srcdir; /*src normal direction*/ float3 steps; /*voxel sizes along x/y/z in mm*/ uint3 dim; /*domain size*/ int medianum; /*total types of media*/ Medium *prop; /*optical property mapping table*/ int respin; /*number of repeatitions*/ int printnum; /*number of printed threads (for debugging)*/ unsigned char *vol; /*pointer to the volume*/ char session[max_session_length]; /*session id, a string*/ char isrowmajor; /*1 for C-styled array in vol, 0 for matlab-styled array*/ char isgpuinfo; /*1 to print gpu info when attach, 0 do not print*/ FILE *flog; /*stream handle to print log information*/ char rootpath[max_path_length]; Année Scolaire 2009/

64 1.2 Fichier: MCXRT_utilis.c /******************************************************************************** * mcxrt_utils.c: configuration and command line option processing unit ********************************************************************************/ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> #include " mcxrt_utils.h" char shortopt[]='h','i','f','n','m','t','t','s','a','r','p','l','l','i','o','\0'; char *fullopt[]="--help","--interactive","--input","--photon","--move","--thread", "--blocksize","--session","--array","--repeat","--printlen",,"--log","--listgpu", "--printgpu","--root",""; /*******************Initialisation des variables de configuration*********************/ void mcxrt_initcfg(config *cfg) cfg->medianum=0; cfg->dim.x=0; cfg->dim.y=0; cfg->dim.z=0; cfg->nblocksize=128; cfg->nphoton=0; cfg->nthread=0; cfg->seed=0; cfg->isrowmajor=1; /* default is C array*/ cfg->respin=1; cfg->isgpuinfo=0; cfg->prop=null; cfg->vol=null; cfg->session[0]='\0'; cfg->printnum=0; cfg->minenergy=0.f; cfg->flog=stdout; cfg->rootpath[0]='\0'; /*on initiale thetaa_init et phi_init ajoutées auparavant dans la structure de données MCXconfig(voir mcx_utilis.h)*/ cfg->thetaa_init=0.f; cfg->phi_init=0.f; /********************************************************************************/ void mcxrt_loadconfig(file *in, Config *cfg) int i; char filename[max_path_length]=0, comment[max_path_length]; Année Scolaire 2009/

65 /*nombre de mouvement de photon*/ if(in==stdin) fprintf(stdout,"please specify the total number of photons: [ ]\n\t"); fscanf(in,"%d", &(i) ); if(cfg->nphoton==0) cfg->nphoton=i; fgets(comment,max_path_length,in); /*RNG: Random Number Generator*/ if(in==stdin) fprintf(stdout,"%d\nplease specify the random number generator seed: [ ]\n\t",cfg->nphoton); fscanf(in,"%d", &(cfg->seed) ); fgets(comment,max_path_length,in); /****************voir mcxrt_run_simulation() dans "TR _core.cu"************** *changement de position : la position source de chaque photon devient aléatoire * * changement de direction: le vecteur de direction sera calculée à partir de l'angle * *thetaa_init et phi_init * *****************************************************************************/ /*les angles initials thetaa et phi*/ if(in==stdin) fprintf(stdout,"\nplease specify the initial thetaa and phi: [0-->90 0-->180]\n\t"); fscanf(in,"%f %f ", &(cfg->thetaa_init),&(cfg->phi_init) ); fgets(comment,max_path_length,in); /* le chemin du fichier binaire*/ if(in==stdin) fprintf(stdout,"\nplease specify the path to the volume binary file:\n\t"); fscanf(in,"%s", filename); if(cfg->rootpath[0]) #ifdef WIN32 sprintf(comment,"%s\\%s",cfg->rootpath,filename);/*pour windows*/ #else sprintf(comment,"%s/%s",cfg->rootpath,filename);/*pour linux*/ #endif strncpy(filename,comment,max_path_length); fgets(comment,max_path_length,in); /*les dimensions(du voxel et milieu) par rapport à l axe x*/ if(in==stdin) fprintf(stdout,"%s\nplease specify the x voxel size (in m), x dimension [ ]:\n\t", filename); fscanf(in,"%f %d", &(cfg->steps.x),&(cfg->dim.x)); fgets(comment,max_path_length,in); Année Scolaire 2009/

66 /*les dimensions(du voxel et milieu) par rapport à l axe y*/ if(in==stdin) fprintf(stdout,"%f %d\nplease specify the y voxel size (in m), y dimension [ ]: \n\t",cfg->steps.x,cfg->dim.x); fscanf(in,"%f %d", &(cfg->steps.y),&(cfg->dim.y)); fgets(comment,max_path_length,in); /*les dimensions(du voxel et milieu) par rapport à l axe z*/ if(in==stdin) fprintf(stdout,"%f %d\nplease specify the z voxel size (in m), z dimension [ ]: \n\t",cfg->steps.y,cfg->dim.y); fscanf(in,"%f %d", &(cfg->steps.z),&(cfg->dim.z)); fgets(comment,max_path_length,in); /*le nombre total des différents types du milieu*/ if(in==stdin) fprintf(stdout,"%f %d\nplease specify the total types of media:\n\t",cfg->steps.z, cfg->dim.z); fscanf(in,"%d", &(cfg->medianum)); cfg->medianum++; fgets(comment,max_path_length,in); if(in==stdin) fprintf(stdout,"%d\n",cfg->medianum); cfg->prop=(medium*)malloc(sizeof(medium)*cfg->medianum); /*initialisation des propriétés optiques de l'air*/ cfg->prop[0].albedo=0.f; cfg->prop[0].epaisseur_optique=0.f; cfg->prop[0].g=0.f; /*Dans le cas de différent types on spécifie les propriétés optiques pour chaque type*/ for(i=1;i<cfg->medianum;i++) if(in==stdin) fprintf(stdout,"please define medium #%d: epaisseur-optique(1/m), anisotropy, albedo (1/m): [ ]\n\t",i); fscanf(in, "%f %f %f ", &(cfg->prop[i].epaisseur_optique),&(cfg->prop[i].g),&(cfg-> prop[i].albedo)); fgets(comment,max_path_length,in); if(in==stdin)fprintf(stdout,"%f %f %f \n",cfg->prop[i].epaisseur_optique,cfg-> prop[i].g,cfg->prop[i].albedo); if(filename[0]) mcxrt_loadvolume(filename,cfg); else Année Scolaire 2009/

67 mcxrt_error(-4,"one must specify a binary volume file in order to run the simulation"); /******************sauvegarder la configuration dans un fichier*********************/ void mcxrt_saveconfig(file *out, Config *cfg) int i; fprintf(out,"%d\n", (cfg->nphoton) ); fprintf(out,"%d\n", (cfg->seed) ); fprintf(out,"%f %f\n",(cfg->thetaa_init),(cfg->phi_init)); fprintf(out,"%f %d \n", (cfg->steps.x),(cfg->dim.x)); fprintf(out,"%f %d \n", (cfg->steps.y),(cfg->dim.y)); fprintf(out,"%f %d \n", (cfg->steps.z),(cfg->dim.z)); fprintf(out,"%d", (cfg->medianum)); for(i=0;i<cfg->medianum;i++) fprintf(out, "%f %f %f\n", (cfg->prop[i].epaisseur_optique),(cfg->prop[i].g),(cfg-> prop[i].albedo)); /***********************Les options de ligne de commande***********************/ int mcxrt_readarg(int argc, char *argv[], int id, void *output,char *type) /*when a binary option is given without a following number (0~1), we assume it is 1*/ if(strcmp(type,"char")==0 && (id>=argc-1 (argv[id+1][0]<'0' argv[id+1][0]>'9'))) *((char*)output)=1; return id; if(id<argc-1) if(strcmp(type,"char")==0) *((char*)output)=atoi(argv[id+1]); else if(strcmp(type,"int")==0) *((int*)output)=atoi(argv[id+1]); else if(strcmp(type,"float")==0) *((float*)output)=atof(argv[id+1]); else if(strcmp(type,"string")==0) strcpy((char *)output,argv[id+1]); else mcxrt_error(-1,"incomplete input"); return id+1; int mcxrt_remap(char *opt) int i=0; while(shortopt[i]!='\0') Année Scolaire 2009/

68 if(strcmp(opt,fullopt[i])==0) opt[1]=shortopt[i]; opt[2]='\0'; return 0; i++; return 1; Rédigé par Imane Hammouali void mcxrt_parsecmd(int argc, char* argv[], Config *cfg) int i=1,isinteractive=1,issavelog=0; char filename[max_path_length]=0; char logfile[max_path_length]=0; if(argc<=1) mcxrt_usage(argv[0]); exit(0); while(i<argc) if(argv[i][0]=='-') if(argv[i][1]=='-') if(mcxrt_remap(argv[i])) mcxrt_error(-2,"unknown verbose option"); switch(argv[i][1]) case 'h': mcxrt_usage(argv[0]); exit(0); case 'i': if(filename[0]) mcxrt_error(-2,"you can not specify both interactive mode and config file"); isinteractive=1; break; case 'f': isinteractive=0; i= mcxrt_readarg(argc,argv,i,filename,"string"); break; /* ideally we may support -n option to specify photon numbers, however, we found using while-loop for -n will cause some troubles for MT RNG, and timed-out error for some other cases. right now, -n is only an alias for -m and both are specifying the photon moves per thread. Here, variable cfg->nphoton is indeed the photon moves per thread*/ case 'n': mcxrt_error(-2,"specifying photon number is not supported, please use -m"); i= mcxrt_readarg(argc,argv,i,&(cfg->nphoton),"int"); break; case 'm': i= mcxrt_readarg(argc,argv,i,&(cfg->nphoton),"int"); Année Scolaire 2009/

69 case 't': case 'T': break; i= mcxrt_readarg(argc,argv,i,&(cfg->nthread),"int"); break; Rédigé par Imane Hammouali i= mcxrt_readarg(argc,argv,i,&(cfg->nblocksize),"int"); break; case 's': i= mcxrt_readarg(argc,argv,i,cfg->session,"string"); break; case 'a': i= mcxrt_readarg(argc,argv,i,&(cfg->isrowmajor),"char"); break; case 'r': case 'p': i= mcxrt_readarg(argc,argv,i,&(cfg->respin),"int"); break; i= mcxrt_readarg(argc,argv,i,&(cfg->printnum),"int"); break; case 'l': issavelog=1; break; case 'L': cfg->isgpuinfo=2; break; case 'I': cfg->isgpuinfo=1; break; case 'o': i= mcxrt_readarg(argc,argv,i,cfg->rootpath,"string"); break; i++; if(issavelog && cfg->session) sprintf(logfile,"%s.log",cfg->session); cfg->flog=fopen(logfile,"wt"); if(cfg->flog==null) cfg->flog=stdout; fprintf(cfg->flog,"unable to save to log file, will print from stdout\n"); if(cfg->isgpuinfo!=2) /*print gpu info only*/ if(isinteractive) mcxrt_readconfig("",cfg); else Année Scolaire 2009/

70 mcxrt_readconfig(filename,cfg); Rédigé par Imane Hammouali void mcxrt_usage(char *exename) printf("\################################################ ####\n\ # SIMULATION DU TRANSFERT RADIATIF EN 3D DANS UN NUAGE-- CUDA #\n\ # #\n\ ########################################################\n\\n\ usage: %s <param1> <param2>...\n\ where possible parameters include (the first item in [] is the default value)\n\ -i (--interactive) interactive mode\n\ -f config (--input) read config from a file\n\ -t [1024 int] (--thread) total thread number\n\ -T [128 int] (--blocksize) thread number per block\n\ -m [0 int] (--move) total photon moves\n\ -n [0 int] (--photon) total photon number (not supported yet, use -m only)\n\ -r [1 int] (--repeat) number of repeations\n\ -a [1 0] (--array) 1 for C array, 0 for Matlab array\n\ -s sessionid (--session) a string to identify this specific simulation (and output files)\n\ -p [0 int] (--printlen) number of threads to print (debug)\n\ -h (--help) print this message\n\ -l (--log) print messages to a log file instead\n\ -L (--listgpu) print GPU information only\n\ -I (--printgpu) print GPU information and run program\n\ example:\n\ %s -t T 128 -m f input.inp -s test -r 2 -a 0 \n",exename,exename); Année Scolaire 2009/

71 1.3 Fichier :logistic_rand.cu /****************************************************************************** * A Random Number Generator based on coupled chaotic Logistic lattice * * (both double and single precision random numbers are supported) * *******************************************************************************/ #ifndef _MCEXTREME_LOGISTIC_RAND_H #define _MCEXTREME_LOGISTIC_RAND_H #include <stdio.h> #include <stdlib.h> #include <math.h> #define MCX_RNG_NAME "Logistic-Lattice" #define RAND_BUF_LEN 5 //register arrays #define RAND_SEED_LEN 5 //32bit seed length (32*5=160bits) #define R_PI f #define INIT_LOGISTIC 100 #ifndef DOUBLE_PREC_LOGISTIC typedef float RandType; #define FUN(x) (4.f*(x)*(1.f-(x))) #define NU 1e-8f #define NU2 (1.f-2.f*NU) #define MIN_INVERSE_LIMIT 1e-7f #define logistic_uniform(v) (acosf(1.f-2.f*(v))*r_pi) #define R_MAX_C_RAND (1.f/RAND_MAX) #define LOG_MT_MAX f #else typedef double RandType; #define FUN(x) (4.0*(x)*(1.0-(x))) #define NU 1e-14 #define NU2 ( *NU) #define MIN_INVERSE_LIMIT 1e-12 #define logistic_uniform(v) (acos( *(v))*r_pi) #define R_MAX_C_RAND (1./RAND_MAX) #define LOG_MT_MAX #endif #define RING_FUN(x,y,z) (NU2*(x)+NU*((y)+(z))) device void logistic_step(randtype *t, RandType *tnew, int len_1) /*int i; for(i=0;i<=len_1;i++) t[i]=fun(t[i]); tnew[0]=ring_fun(t[0],t[1],t[len_1]); for(i=1;i<len_1;i++) tnew[i]=ring_fun(t[i],t[i-1],t[i+1]); tnew[len_1]=ring_fun(t[len_1],t[0],t[len_1-1]); */ RandType tmp; t[0]=fun(t[0]); Année Scolaire 2009/

72 t[1]=fun(t[1]); t[2]=fun(t[2]); t[3]=fun(t[3]); t[4]=fun(t[4]); tnew[3]=ring_fun(t[0],t[4],t[1]); /* shuffle the results by separation of 2*/ tnew[4]=ring_fun(t[1],t[0],t[2]); tnew[0]=ring_fun(t[2],t[1],t[3]); tnew[1]=ring_fun(t[3],t[2],t[4]); tnew[2]=ring_fun(t[4],t[3],t[0]); tmp =t[0]; t[0]=t[2]; t[2]=t[4]; t[4]=t[1]; t[1]=t[3]; t[3]=tmp; /********************************************************************************/ // generate random number for the next zenith angle device void rand_need_more(randtype t[rand_buf_len],randtype tbuf[rand_buf_len]) logistic_step(t,tbuf,rand_buf_len-1); logistic_step(tbuf,t,rand_buf_len-1); device void logistic_init(randtype *t,randtype *tnew,uint seed[],uint idx) int i; for(i=0;i<rand_buf_len;i++) t[i]=(randtype)seed[idx*rand_buf_len+i]*r_max_c_rand; for(i=0;i<init_logistic;i++) /*initial randomization*/ rand_need_more(t,tnew); /********************************************************************************/ // transform into [0,1] random number device RandType rand_uniform01(randtype v) return logistic_uniform(v); device void gpu_rng_init(randtype t[rand_buf_len], RandType tnew[rand_buf_len],uint *n_seed,int idx) logistic_init(t,tnew,n_seed,idx); /********************************************************************************/ // generate [0,1] random number for the next scattering length device float rand_next_scatlen(randtype t[rand_buf_len]) RandType ran=rand_uniform01(t[0]); return ((ran==0.f)?log_mt_max:(-logf(ran))); /********************************************************************************/ // generate [0,1] random number for the next arimuthal angle device float rand_next_aangle(randtype t[rand_buf_len]) Année Scolaire 2009/

73 return rand_uniform01(t[2]); /********************************************************************************/ // generate random number for the next zenith angle device float rand_next_zangle(randtype t[rand_buf_len]) return rand_uniform01(t[4]); /********************************************************************************/ //generate [0,1] random number for the next position in x device float rand_next_position_x(randtype t[rand_buf_len]) return rand_uniform01(t[1]); //generate [0,1] random number for the next position in y device float rand_next_position_y(randtype t[rand_buf_len]) return rand_uniform01(t[3]); #endif 1.4 Fichier :MCXRT_core.cu //////////////////////////////////////////////////////////////////////// // Simulation du transfert radiatif 3D dans un nuage atmosphérique // MCXRT_core.cu : GPU kernels and CUDA host code //////////////////////////////////////////////////////////////////////// #include "br2cu.h" #include " MCXRT_core.h" #include "tictoc.h" #include " MCXRT_const.h" #include <time.h> #include <stdlib.h> #ifdef USE_MT_RAND #include "mt_rand_s.cu" // use Mersenne Twister RNG (MT) #else #include "logistic_rand.cu" // use Logistic Lattice ring 5 RNG (LL5) #endif #define MIN(a,b) ((a)<(b)?(a):(b)) #ifdef DEVICE_EMULATION #define GPUDEBUG(x) printf x // enable debugging in CPU mode #else #define GPUDEBUG(x) #endif typedef unsigned char uchar; Année Scolaire 2009/

74 struct align (16) KernelParams float3 vsize;//taille de voxel float minstep;//distance minimum dans un voxel uchar isrowmajor; float Rstep; float4 p0,c0;//position et direction initiales float3 maxidx;//taille du milieu(x,y,z->longueur, profondeur, hauteur) uint3 dimlen; ; // optical properties saved in the constant memory //x:albedo de diffusion,y:épaisseur optique,z:anisotropy (g) constant float3 gproperty[max_prop]; // kernel parameters constant KernelParams gparam; #ifdef USE_ATOMIC device inline void atomicfloatadd(float *address, float val) int i_val = float_as_int(val); int tmp0 = 0,tmp1; while( (tmp1 = atomiccas((int *)address, tmp0, i_val))!= tmp0) tmp0 = tmp1; i_val = float_as_int(val + int_as_float(tmp1)); #endif //need to move these arguments to the constant memory, as they use shared memory /****************************************************************************** * The core Monte Carlo simulation kernel ******************************************************************************* kernel void mcxrt_main_loop(int nphoton,int ophoton,uchar media[],float genergy[], float greflectance[],float gtransmitance[],float3 vsize,float minstep,uint3 dimlen, uchar isrowmajor,float4 p0, c0,float3 maxidx,uint n_seed[],float4 n_pos[], float4 n_dir[],float2 n_len[]) int idx= blockdim.x * blockidx.x + threadidx.x; float4 npos=n_pos[idx]; //x,y,z: x,y,z coordinates,w:packet weight float4 ndir=n_dir[idx]; //x,y,z: ix,iy,iz unitary direction vector, w:total scat event float2 nlen=n_len[idx]; //nlen.w can be dropped to save register float energyabsorbed=genergy[(idx<<1)+1];//energie absorpée par le milieu float energie_sortie_en_haut=greflectance[idx]; Année Scolaire 2009/

75 float energie_sortie_en_bas=gtransmitance [idx]; float4 ndir0=float4(ndir.x,ndir.y,ndir.z,0); /*déclaration des nouvelles variables */ float posx_old; float posy_old; float mua;//coeff d'absorption float mus;//coeff de diffusion réduit int i,idx1d,idx1dold,idxorig; //idx1dold is related to reflection,idx1d: indice du milieu #ifdef TEST_RACING int cc=0; #endif uchar mediaid, mediaidorig; char medid=-1; float atten; //atten:atténuation //for MT RNG, these will be zero-length arrays and be optimized out RandType t[rand_buf_len],tnew[rand_buf_len]; float3 prop; //propriétés optiques float len,cphi,sphi,theta,stheta,ctheta,tmp0,tmp1; gpu_rng_init(t,tnew,n_seed,idx); // assuming the initial position is within the domain (mcx_config is supposed to ensure) //on calcule l'indice initial du milieu idx1d=isrowmajor?int(floorf(npos.x)*dimlen.y+floorf(npos.y)*dimlen.x+floorf(npos.z)): \int(floorf(npos.z)*dimlen.y+floorf(npos.y)*dimlen.x+floorf(npos.x)); idxorig=idx1d; mediaid=media[idx1d]; mediaidorig=mediaid; if(mediaid==0) // on n'est à l'extérieur du milieu return; // the initial position is not within the medium prop=gproperty[mediaid];//prop:propriétés optiques de chaque type de milieu /**************************DÉBUT D'ALGORITHME FIGURE1********************/ for(i=0;i<nphoton;i++)// here nphoton actually means photon moves GPUDEBUG(("*i= (%d) L=%f w=%e\n",(int)nlen.y,nlen.x,npos.w)); /*********************1er cas: si la distance de diffusion est nulle*******************/ if(nlen.x<=0.f) rand_need_more(t,tnew); nlen.x=rand_next_scatlen(t);//tirage alétoire de l'épaisseur optique du photon GPUDEBUG(("next scat len=%20.16e \n",nlen.x)); Année Scolaire 2009/

76 if(npos.w<1.f) //si le poids est inférieur à1 -->le photon est déjà diffusé auparavant tmp0=two_pi*rand_next_aangle(t); //next arimuth angle(phi) sincosf(tmp0,&sphi,&cphi); GPUDEBUG(("next angle phi %20.16e\n",tmp0)); /********************************************************************************* * Henyey-Greenstein Phase Function * ********************************************************************************** if(prop.z>eps)// if prop.w is too small, the distribution of theta is bad //on calcule la probabilité de choix de direction (fonction de phase) tmp0=(1.f-prop.z*prop.z)/(1.f-prop.z+2.f*prop.z*rand_next_zangle(t)); tmp0*=tmp0; tmp0=(1.f+prop.z*prop.z-tmp0)/(2.f*prop.z); // when ran=1, CUDA will give me for tmp0 which produces nan later if(tmp0>1.f) tmp0=1.f; if(tmp0<-1.f) tmp0=-1.f; theta=acosf(tmp0);//theta:angle zenith stheta=sinf(theta); ctheta=tmp0; else //Wang1995 has acos(2*ran-1), rather than 2*pi*ran, need to check theta=one_pi*rand_next_zangle(t); sincosf(theta,&stheta,&ctheta); GPUDEBUG(("next scat angle theta %20.16e\n",theta)); if( ndir.z>-1.f+eps && ndir.z<1.f-eps )//1:direction vers le bas, -1:vers le haut tmp0=1.f-ndir.z*ndir.z; //reuse tmp to minimize registers tmp1=rsqrtf(tmp0); tmp1=stheta*tmp1; /*on calcule la nouvelle direction du photon*/ ndir=float4(tmp1*(ndir.x*ndir.z*cphi - ndir.y*sphi) + ndir.x*ctheta, tmp1*(ndir.y*ndir.z*cphi + ndir.x*sphi) + ndir.y*ctheta, -tmp1*tmp0*cphi+ ndir.z*ctheta, ndir.w); GPUDEBUG(("new dir: %10.5e %10.5e %10.5e\n",ndir.x,ndir.y,ndir.z)); else ndir=float4(stheta*cphi,stheta*sphi,(ndir.z>0.f)?ctheta:-ctheta,ndir.w); GPUDEBUG(("new dir-z: %10.5e %10.5e %10.5e\n",ndir.x,ndir.y,ndir.z)); Année Scolaire 2009/

77 ndir.w++;//on incrémente le nombre de diffusion /***********************************Fin du 1er cas******************************/ prop=gproperty[mediaid]; mus=(prop.y*prop.x)/maxidx.z; len=minstep*mus; //Wang1995: minstep*(prop.x+prop.y) mua=mus*(1-prop.x)/prop.x; /*2éme cas: l'épaisseur optique du photon est inférieur à l'épaisseur optique du voxel*/ if(len>nlen.x)//scattering ends in this voxel: mus*minstep > s tmp0=nlen.x/mus;//tmp0: distance de diffusion en m energyabsorbed+=npos.w; //on calcule la nouvelle position du photon après la diffusion npos=float4(npos.x+ndir.x*tmp0,npos.y+ndir.y*tmp0,npos.z+ndir.z*tmp0,npos.w* expf(-mua*tmp0)); energyabsorbed-=npos.w;//l'energie absorpée= poids_avant-poids_actuelle nlen.x=same_voxel; GPUDEBUG((">>ends in voxel %f<%f %f [%d]\n",nlen.x,prop.y,mus,idx1d)); /********************************Fin du 2éme cas********************************/ /*****3éme cas: l'épaisseur optique du photon est plus grande que celle du voxel*****/ else //on avance le photon par un voxel energyabsorbed+=npos.w; //on test si le photon se situe dans le même du milieu après 2 déplacements consécutifs if(mediaid!=medid)//si le milieu est différent de celui d avant atten=expf(-mua*minstep); npos=float4(npos.x+ndir.x,npos.y+ndir.y,npos.z+ndir.z,npos.w*atten); medid=mediaid;//changement du milieu energyabsorbed-=npos.w;//l'energie absorpée= poids_avant-poids_actuelle nlen.x-=len; GPUDEBUG((">>keep going %f<%f %f [%d]\n",nlen.x,len,prop.y,idx1d)); /*******************************Fin du 3éme cas**********************************/ idx1dold=idx1d; idx1d=isrowmajor?int(floorf(npos.x)*dimlen.y+floorf(npos.y)*dimlen.x+floorf(npos.z)): \ int(floorf(npos.z)*dimlen.y+floorf(npos.y)*dimlen.x+floorf(npos.x)); GPUDEBUG(("old and new voxel: %d<->%d\n",idx1dold,idx1d)); Année Scolaire 2009/

78 /****************************LES CONDITIONS LIMITES*************************/ if(npos.z<0) energie_sortie_en_haut+=npos.w; //lancer un nouveau photon tmp0=rand_next_position_x(t); tmp1=rand_next_position_y(t); npos=float4(tmp0*maxidx.x,tmp1*maxidx.y,0,1);//la position initiale aléatoire du nouveau photon ndir=ndir0;//dépend de thetaa et phi GPUDEBUG(("new dir-init: %10.5e %10.5e %10.5e\n",ndir.x,ndir.y,ndir.z)); nlen=float2(0.f,nlen.y+1); idx1d=idxorig; mediaid=mediaidorig; if(npos.z>=maxidx.x) energie_sortie_en_bas+=npos.w; //On lance un nouveau photon tmp0=rand_next_position_x(t); tmp1=rand_next_position_y(t); npos=float4(tmp0*maxidx.x,tmp1*maxidx.y,0,1); ndir=ndir0;//dépend de thetaa et phi GPUDEBUG(("new dir-init: %10.5e %10.5e %10.5e\n",ndir.x,ndir.y,ndir.z)); nlen=float2(0.f,nlen.y+1); idx1d=idxorig; mediaid=mediaidorig; /**************************LES CONDITIONS CYCLIQUES ***********************/ //par rapport à l'axe x idx1dold=idx1d; if(npos.x<0 npos.x>=maxidx.x) posx_old=npos.x; //on recalcule la nouvelle position du photon par rapport à l'axe x if(posx_old<0) npos.x=fmod(-posx_old,maxidx.x); if(posx_old>=maxidx.x) npos.x=fmod(posx_old,maxidx.x); GPUDEBUG(("old and new poisition-x: %f<->%f\n",posx_old,npos.x)); //on recalcule le nouveau indice du milieu if(isrowmajor) idx1d=int(floorf(npos.x)*dimlen.y+floorf(npos.y)*dimlen.x+floorf(npos.z)); else idx1d=int(floorf(npos.z)*dimlen.y+floorf(npos.y)*dimlen.x+floorf(npos.x)); Année Scolaire 2009/

79 GPUDEBUG(("old and new voxel: %d<->%d\n",idx1dold,idx1d)); mediaid=media[idx1d]; prop=gproperty[mediaid]; //par rapport à l'axe y if(npos.y<0 npos.y>=maxidx.y) posy_old=npos.y; //on recalcule la nouvelle position du photon par rapport à l'axe y if(posy_old<0) npos.y=fmod(-posy_old,maxidx.y); if(posy_old>=maxidx.y) npos.y=fmod(posy_old,maxidx.y); (("old and new poisition-y: %f<->%f\n",posy_old,npos.y)); //on reclacule le nouveau indice du milieu if(isrowmajor) idx1d=int(floorf(npos.x)*dimlen.y+floorf(npos.y)*dimlen.x+floorf(npos.z)); else idx1d=int(floorf(npos.z)*dimlen.y+floorf(npos.y)*dimlen.x+floorf(npos.x)); GPUDEBUG(("old and new voxel: %d<->%d\n",idx1dold,idx1d)); mediaid=media[idx1d]; prop=gproperty[mediaid]; /*******************************Fin de la boucle for*******************************/ genergy[(idx<<1)+1]=energyabsorbed; greflectance [idx]=energie_sortie_en_haut; gtransmitance [idx]=energie_sortie_en_bas; #ifdef TEST_RACING n_seed[idx]=cc; #endif n_pos[idx]=npos; n_dir[idx]=ndir; n_len[idx]=nlen; /*****************************fin de la fonction kernel****************************/ /********************************************************************************* * query GPU info and set active GPU * *********************************************************************************/ int mcxrt_set_gpu(int printinfo) #if DEVICE_EMULATION return 1; #else Année Scolaire 2009/

80 int dev; int devicecount; cudagetdevicecount(&devicecount); //printf ("le nombre des devices=%d\n",devicecount); if (devicecount == 0) printf("no CUDA-capable GPU device found\n"); return 0; // scan from the last device, hopefully it is more dedicated for (dev = devicecount-1; dev>=0; dev--) cudadeviceprop dp; cudagetdeviceproperties(&dp, dev); if(strncmp(dp.name, "Device Emulation", 16)) if(printinfo) printf("=============== GPU Infomation ============\n"); printf("device %d of %d:\t%s\n",dev+1,devicecount,dp.name); printf("global Memory:\t%u B\n",dp.totalGlobalMem);//mémoire globale disponible sur le périphérique en bytes printf("constant Memory:%u B\n",dp.totalConstMem);//mémoire constante disponible sur le périphérique en bytes printf("shared Memory:\t%u B\n",dp.sharedMemPerBlock);//mémoire partagée disponible pour un bloc en bytes printf("registers:\t%u\n",dp.regsperblock);//nombre de registres 32 bits disponibles à un bloc de threads printf("clock Speed:\t%.2f GHz\n",dp.clockRate*1e-6f);//fréquence de l'horloge en kilohertz printf("maxthreads:\t%d threads\n",dp.maxthreadsperblock);//nombre maximale de threads/bloc #if CUDART_VERSION >= 2000 printf("number of MPs:\t%u\n",dp.multiProcessorCount); printf("numb.er of Cores:%u\n",dp.multiProcessorCount<<3); #endif if(printinfo!=2) break; if(printinfo==2) //list GPU info only exit(0); Année Scolaire 2009/

81 if (dev == devicecount) return 0; else return 1; #endif /********************************************************************************* * master driver code to run MC simulations * *********************************************************************************/ void mcxrt_run_simulation(config *cfg) int i,iter; float minstep=min(min(cfg->steps.x,cfg->steps.y),cfg->steps.z); float3 maxidx=float3(cfg->dim.x,cfg->dim.y,cfg->dim.z);//taille du milieu float energyabsorbed=0.f; float energie_sortie_en_bas=0; float energie_sortie_en_haut=0; float4 p0; float4 c0; float *energy; float *reflectance; float *transmitance; /*threadphoton:nbr de mouvement de photon par thread*/ int threadphoton, oddphotons; int photoncount=0,printnum; /*photoncount: nombre de photons simulés */ int tic; uint3 dimlen; dim3 mcgrid, mcblock; dim3 clgrid, clblock; int dimxyz=cfg->dim.x*cfg->dim.y*cfg->dim.z;//volume du milieu uchar *media=(uchar *)(cfg->vol); threadphoton=cfg->nphoton/cfg->nthread/cfg->respin; oddphotons=cfg->nphoton-threadphoton*cfg->nthread*cfg->respin; float4 *Ppos; float4 *Pdir; float2 *Plen; uint *Pseed; if(cfg->nthread%cfg->nblocksize) cfg->nthread=(cfg->nthread/cfg->nblocksize)*cfg->nblocksize; mcgrid.x=cfg->nthread/cfg->nblocksize; mcblock.x=cfg->nblocksize; Année Scolaire 2009/

82 clgrid.x=cfg->dim.x; clgrid.y=cfg->dim.y; clblock.x=cfg->dim.z; Ppos=(float4*)malloc(sizeof(float4)*cfg->nthread); Pdir=(float4*)malloc(sizeof(float4)*cfg->nthread); Plen=(float2*)malloc(sizeof(float2)*cfg->nthread); Pseed=(uint*)malloc(sizeof(uint)*cfg->nthread*RAND_SEED_LEN); energy=(float*)calloc(sizeof(float),cfg->nthread*2); //variables ajoutées pour calculer l énergie sortir en haut et en bas du milieu reflectance=(float*)calloc(sizeof(float),cfg->nthread); transmitance=(float*)calloc(sizeof(float),cfg->nthread); uchar *gmedia; mcxrt _cu_assess(cudamalloc((void **) &gmedia, sizeof(uchar)*(dimxyz))); float4 *gppos; mcxrt _cu_assess(cudamalloc((void **) &gppos, sizeof(float4)*cfg->nthread)); float4 *gpdir; mcxrt _cu_assess(cudamalloc((void **) &gpdir, sizeof(float4)*cfg->nthread)); float2 *gplen; mcxrt _cu_assess(cudamalloc((void **) &gplen, sizeof(float2)*cfg->nthread)); uint *gpseed; mcxrt _cu_assess(cudamalloc((void **) &gpseed, sizeof(uint)*cfg->nthread* RAND_SEED_LEN)); float *genergy; cudamalloc((void **) &genergy, sizeof(float)*cfg->nthread*2); //ajouter float *greflectance; cudamalloc((void **) &greflectance, sizeof(float)*cfg->nthread); float *gtransmitance; cudamalloc((void **) &gtransmitance, sizeof(float)*cfg->nthread); if(cfg->isrowmajor) // if the volume is stored in C array order dimlen.x=cfg->dim.z; dimlen.y=cfg->dim.y*cfg->dim.z; else // if the volume is stored in matlab/fortran array order dimlen.x=cfg->dim.x; dimlen.y=cfg->dim.y*cfg->dim.x; dimlen.z=cfg->dim.x*cfg->dim.y*cfg->dim.z; if(cfg->seed>0) srand(cfg->seed); Année Scolaire 2009/

83 else srand(time(0)); for (i=0; i<cfg->nthread; i++) /*changement de la position: chaque photon a une position aléatoire d entrée*/ cfg->srcpos.x = rand()%cfg->dim.x; cfg->srcpos.y = rand()%cfg->dim.y; cfg->srcpos.z = 0; float4 p0 = float4(cfg->srcpos.x,cfg->srcpos.y,cfg->srcpos.z,1.f); Ppos[i]=float4(cfg->srcpos.x,cfg->srcpos.y,cfg->srcpos.z,1.f); // initial position //printf("position source [%d] : %f %f %f\n",i,ppos[i].x,ppos[i].y,ppos[i].z); /*changement de direction source : calculée à partir des angles thetaa et phi */ cfg->srcdir.x=sin(cfg->thetaa_init)*cos(cfg->phi_init); cfg->srcdir.y=sin(cfg->thetaa_init)*sin(cfg->phi_init); cfg->srcdir.z=cos(cfg->thetaa_init); float4 c0 = float4(cfg->srcdir.x,cfg->srcdir.y,cfg->srcdir.z,1.f); Pdir[i]=c0; //printf("direction source[%d] : %f %f %f\n",i,pdir[i].x,pdir[i].y,pdir[i].z); Plen[i]=float2(0.f,0.f); for (i=0; i<cfg->nthread*rand_seed_len; i++) Pseed[i]=rand(); fprintf(cfg->flog,"\#############################################\n\ # Simulation rapide du transfert radiatif 3D dans un nuage atmosphérique-- CUDA#\n\ #########################################################\n"); tic=starttimer(); fprintf(cfg->flog,"compiled with: [RNG] %s [Seed Length] %d\n", MCX_RNG_NAME, RAND_SEED_LEN); /* on affiche le nombre de mouvement de photon traité par chaque thread, les mouvements non utilisé, nombre de thread et le nombre de répétition de la simulation*/ fprintf(cfg->flog,"threadph=%d oddphotons=%d np=%d nthread=%d repetition=%d\n",threadphoton,oddphotons, cfg->nphoton,cfg->nthread,cfg->respin); fprintf(cfg->flog,"initializing streams...\t"); fflush(cfg->flog); //on copie les données du CPU au GPU cudamemcpy(gppos,ppos,sizeof(float4)*cfg->nthread,cudamemcpyhosttodevice); cudamemcpy(gpdir,pdir,sizeof(float4)*cfg->nthread,cudamemcpyhosttodevice); cudamemcpy(gplen,plen,sizeof(float2)*cfg->nthread,cudamemcpyhosttodevice); cudamemcpy(gpseed,pseed,sizeof(uint)*cfg>nthread*rand_seed_len,cudamemcpy HostToDevice); cudamemcpy(gmedia,media,sizeof(uchar)*dimxyz,cudamemcpyhosttodevice); cudamemcpy(genergy,energy,sizeof(float)*cfg->nthread*2,cudamemcpyhosttodevice); cudamemcpytosymbol(gproperty,cfg->prop,cfg->medianum*sizeof(medium),0, cudamemcpyhosttodevice); Année Scolaire 2009/

84 //ajouter cudamemcpy(greflectance,reflectance,sizeof(float)*cfg>nthread, cudamemcpyhosttodevice); cudamemcpy(gtransmitance,transmitance,sizeof(float)*cfg>nthread, cudamemcpyhosttodevice); //fin de transfert des données fprintf(cfg->flog,"init complete : %d ms\n",gettimemillis()-tic);//temps du transfert /****************************Lancement de la simulation*************************/ fprintf(cfg->flog,"lauching mcxrt_main_loop...\n"); for(iter=0;iter<cfg->respin;iter++) fprintf(cfg->flog,"simulation run#%2d... \t\n",iter+1); mcxrt _main_loop<<<mcgrid,mcblock>>>(cfg>nphoton,0,gmedia,genergy,greflectance,gtransmitance, cfg->steps,minstep,dimlen,cfg->isrowmajor,p0,c0,maxidx, gpseed,gppos,gpdir,gplen); cudathreadsynchronize();/*pour synchroniser les blocs à la sortie d un kernel*/ if(iter+1==cfg->respin) //on copie du GPU au CPU cudamemcpy(energy,genergy,sizeof(float)*cfg->nthread*2, cudamemcpydevicetohost); cudamemcpy(plen,gplen,sizeof(float2)*cfg->nthread,cudamemcpydevicetohost); //ajouter cudamemcpy(reflectance,greflectance,sizeof(float)*cfg>nthread, cudamemcpydevicetohost); cudamemcpy(transmitance,gtransmitance,sizeof(float)*cfg->nthread, cudamemcpydevicetohost); for(i=1;i<cfg->nthread;i++) energy[0]+=energy[i<<1]; energy[1]+=energy[(i<<1)+1]; fprintf(cfg->flog,"saving data complete : %d ms\n",gettimemillis()-tic); fflush(cfg->flog); //initialisation de la prochaine simulation if(iter+1<cfg->respin) cudamemcpy(gppos,ppos,sizeof(float4)*cfg->nthread,cudamemcpyhosttodevice); cudamemcpy(gpdir,pdir,sizeof(float4)*cfg->nthread,cudamemcpyhosttodevice); cudamemcpy(gplen,plen,sizeof(float2)*cfg->nthread,cudamemcpyhosttodevice); if(cfg->respin>1 && RAND_SEED_LEN>1) Année Scolaire 2009/

85 for(i=0;i<cfg->nthread*rand_seed_len; i++) Pseed[i]=rand(); cudamemcpy(gpseed,pseed,sizeof(uint)*cfg->nthread*rand_seed_len, cudamemcpyhosttodevice); cudamemcpy(ppos,gppos,sizeof(float4)*cfg->nthread,cudamemcpydevicetohost); cudamemcpy(pdir,gpdir,sizeof(float4)*cfg->nthread,cudamemcpydevicetohost); cudamemcpy(plen,gplen, sizeof(float2)*cfg->nthread,cudamemcpydevicetohost); cudamemcpy(pseed,gpseed,sizeof(uint)*cfg->nthread*rand_seed_len, cudamemcpydevicetohost); cudamemcpy(energy,genergy,sizeof(float)*cfg->nthread*2,cudamemcpydevicetohost); //ajouter cudamemcpy(reflectance,greflectance,sizeof(float)*cfg->nthread, cudamemcpyhosttodevice); cudamemcpy(transmitance,gtransmitance,sizeof(float)*cfg->nthread, cudamemcpyhosttodevice); for(i=0; i<cfg->nthread; i++) photoncount+=(int)plen[i].y; // Nombre des photons simulés energyabsorbed+=energy[(i<<1)+1]; // Energie absorbée energie_sortie_en_haut+=reflectance[i]; // Energie réfléchie energie_sortie_en_bas+=transmitance[i];// Energie transmise /* The above thread info is for debugging purposes. The total number of threads to be printed can be specified using the "-p" option*/ printnum=cfg->nthread<cfg->printnum?cfg->nthread:cfg->printnum; for(i=0; i<printnum; i++) fprintf(cfg->flog,"% 4d[D % f % f % f]c%3d J%5d W% 8f[P %6.3f %6.3f %6.3f]L% 5.3f S%.0f\n",i,Pdir[i].x,Pdir[i].y,Pdir[i].z,(int)Plen[i].y,(int)Pdir[i].w, Ppos[i].w, Ppos[i].x,Ppos[i].y,Ppos[i].z,Plen[i].x,(float)Pseed[i]); /*i : thread id [Direction ] : direction vector C : completed photons for this thread J : number of jumps (scattering events) W : poids actuel du photon [Position] : la position actuelle du photon T : accumulative propagation time L : remaining scattering length for the current jump S : the random number state*/ fprintf(cfg->flog,"simulated %d with %d threads (repeat x%d)\n",photoncount, Année Scolaire 2009/

86 cfg->nthread,cfg->respin); fflush(cfg->flog); fprintf(cfg->flog,"energie absorpée=%16.8e\n",energyabsorbed); fprintf(cfg->flog,"energie sortie en haut du nuage=%f\n",energie_sortie_en_haut); fprintf(cfg->flog,"energie sortie en bas du nuage=%f\n",energie_sortie_en_bas); fprintf(cfg->flog,"réflectance=%f\n",energie_sortie_en_haut/photoncount); fprintf(cfg->flog,"transmittance=%f\n",energie_sortie_en_bas/photoncount); fprintf(cfg->flog, "réflectance+transmittance=%f\n", (energie_sortie_en_haut+energie_sortie_en_bas)/photoncount); fprintf(cfg->flog,"absorptance=%f\n",energyabsorbed/photoncount); fprintf(cfg->flog,"réflectance+transmittance+absorptance=%f\n", (energie_sortie_en_haut+energie_sortie_en_bas+energyabsorbed)/photoncount); fflush(cfg->flog); fflush(cfg->flog); cudafree(gmedia); cudafree(gppos); cudafree(gpdir); cudafree(gplen); cudafree(gpseed); cudafree(genergy); cudafree(greflectance); cudafree(gtransmitance); free(ppos); free(pdir); free(plen); free(pseed); free(energy); free(reflectance); free(transmitance); Année Scolaire 2009/

87 2 Exécution Du programme MCXRT 2.1 La démarche d exécution Pour exécuter le programme MCXRT, il a fallu d abord compiler ce dernier à l aide de la commande make. Cette commande crée l exécutable simulation_tr dans le dossier «bin». Ensuite, on lance l exécutable./simulation_tr, cela affiche en console les options suivantes : ############################################################ # SIMULATION DU TRANSFERT RADIATIF EN 3D DANS NUAGE-- CUDA # ############################################################ usage:./simulation_tr<param1> <param2>... where possible parameters include (the first item in [ ] is the default value) -i (--interactive) interactive mode -f config (--input) read config from a file -t [128 int] (--thread) total thread number -T [128 int] (--blocksize) thread number per block -m[0 int] (--move) total photon moves -n [0 int] (--photon) total photon number (not supported yet, use -m only) -r [1 int] (--repeat) number of repeations -a [1 0] (--array) 1 for C array, 0 for Matlab array -s sessionid (--session) a string to identify this specific simulation (and output files) -p [0 int] (--printlen) number of threads to print (debug) -h (--help) print this message -l (--log) print messages to a log file instead -L (--listgpu) print GPU information only -I (--printgpu) print GPU information and run program 2.2 Le fichier d entrée Le fichier d entrée du programme MCXRT est construit de la manière suivante: # total photon (not used) # RNG seed, negative to generate 0 0 # thetaa_initial, phi_initial semi60x60x60.bin # volume ('uchar' format) # x: voxel size, dim (en m) # y: voxel size, dim (en m) # z: voxel size, dim (en m) 1 # num of media # epaisseur-optique, g, albedo (1/m) Année Scolaire 2009/

88 2.3 Résultat de l exécution Voici un exemple d une ligne de commande exécutant le code MCXRT en utilisant quelques options : time./simulation_rt -t T 128 -m f qtest.inp -r 1 -a 0 NB : l option time donne le temps d exécution. On obtient donc les résultats suivants : ############################################################ # Simulation rapide du transfert radiatif 3D dans un nuage atmosphérique CUDA # ############################################################ compiled with: [RNG] Logistic-Lattice [Seed Length] 5 threadph=6 oddphotons=1696 np= nthread=16384 repetition=1 initializing streams... init complete : 0 ms lauching nuage_main_loop... simulation run# 1... saving data complete : 2293 ms simulated with threads (repeat x1) energie absorpée= e+04 energie sortie en haut du nuage= energie sortie en bas du nuage= réflectance= transmittance= absorptance= réflectance+transmittance+absorptance= real 0m2.417s user 0m2.305s sys 0m0.111s Année Scolaire 2009/