Projet informatique Master 2 Simulation d un diagramme d Hubble

Transcription

1 Projet informatique Master 2 Simulation d un diagramme d Hubble Florent Marmol sous la direction de dominique Fouchez

2 Sommaire I.Directives du projet... 3 II. Méthodologie Simulation du diagramme d Hubble théorique Introduction des dispersions Dispersion stretch Dispersion en couleur Dispersion totale Méthode de standardisation Diagramme d Hubble observé Diagramme d Hubble observé avec coupure... 5 III. Résultats Résultats avec toutes les corrections Résultats avec coupure à 24 et toutes les corrections Résultats sans aucunes corrections Résultats avec correction stretch Résultats avec correction couleur... 7 IV. Conclusion... 7 Annexes

3 I.Directives du projet Le projet informatique est composé de deux parties. La première consiste à reproduire un diagramme d Hubble théorique à partir des équations de Friedmann-Lemaître. Le diagramme d Hubble est l un des outils les plus importants de la cosmologie, grâce à celui-ci il est possible de déterminer les valeurs de la densité de matière de l univers ainsi que celle de l énergie noire. Ces paramètres sont fondamentaux pour comprendre l évolution de l univers et sa composition. Ce diagramme consiste à tracer les magnitudes relatives des supernovae de type Ia, véritables balises de l univers, en fonction de leur redshift. Les supernovae de type Ia permettent de déterminer les distances à partir de leur caractéristique commune ; la luminosité lors de leur explosion. La première partie du projet consistera aussi à introduire des dispersions physiques et observationnelles de ces magnitudes, et d en mesurer l effet sur la détermination des densités. Une méthode de standardisation sera alors utilisée afin de réduire ces dispersions. Cette deuxième partie du projet a pour objet de constater l impact de la coupure en magnitude sur l évaluation des densités. Cette coupure qui correspond à une réalité physique, est la conséquence des limites de l astronomie optique. Ainsi un certain nombre de supernovae de type Ia ne peuvent pas être observées, ce qui va modifier le diagramme d Hubble. Mais aussi de mesurer l effet des dispersions sur ces densités. Ce projet informatique s inscrit dans les travaux du Groupe RENOIR au Centre de Physique des Particules de Marseille sous la direction de dominique Fouchez. II. Méthodologie 2.1 Simulation du diagramme d Hubble théorique La simulation du diagramme d Hubble est réalisée par la combinaison de 2 outils. Le premier consiste à faire les différents calculs à partir d un programme C++ pour produire les valeurs simulées. Celles-ci sont alors utilisées sous Root pour tracer graphiquement le diagramme d Hubble. Pour calculer les magnitudes des supernovae il faut connaître leur redshift z. Ces redshifts seront générés aléatoirement sous C++. Les magnitudes sont alors calculées par les formules suivantes : m ( z) M 5log( dl( z)) 5 Avec z (1 z) c dz' dl( z) H 3 (1 z') (1 )(1 z' )² M M Où m(z) est la magnitude, M la magnitude absolue, dl(z) la distance lumineuse, H la constante d Hubble, Ω M la densité de matière, Ω Λ la densité de l énergie noire. Ainsi le programme contient 3 fonctions pour faire ce calcul ; la première calcule la partie sous l intégrale de la formule précédente. Les valeurs des densités connues aujourd hui sont entrées manuellement dans le programme. 3

4 La deuxième fonction fait une intégration numérique et retourne dl(z). Une formule composite de la méthode du rectangle à été utilisée pour calculer cette intégrale. La fonction sous l intégrale est quasi-linéaire sur des redshifts allant de à 1 (ce qui correspond aux valeurs observationnelles en astronomie optique) justifiant cette méthode. La troisième fonction calcule finalement la magnitude associée à son redshift. 2.2 Introduction des dispersions Les supernovae de type Ia sont considérés comme des chandelles standards, pourtant il existe une dispersion intrinsèque dans leur magnitude. Il existe des dispersions dans les mesures mais celle-ci sont négligeables par rapport aux précédentes Toutes ces dispersions sont implantées dans le programme sous forme de fonction gaussienne avec un écart-type σ typique. Pour créer ces dispersions, il faut d abord tirer une probabilité entre et 1 de manière «équitable». Cette probabilité est ensuite insérer dans la fonction gaussienne pour en tirer la valeur de la dispersion. 2.3 Dispersion stretch Le stretch est associé à la vitesse de décroissance des courbes de lumière des supernoae. La dispersion stretch est paramétrisée de la manière suivante : m observé m ( s 1)* Avec s qui est tiré aléatoirement de façon gaussienne avec un σ de.1 et α est une constante dont la valeur est de 1.4. Cette méthode sera utilisé pour toutes les dispersions afin de créer une population de supernovae telle que la verrai un observateur. 2.4 Dispersion en couleur La dispersion couleur vient du fait que l observateur voit sa population de supernovae selon un filtre optique. Le plus souvent dans le domaine du bleu. Cependant quand le redshift augmente on constate un décalage spectral vers le rouge du pic de luminosité. Il faut paramétriser ceci par la formule suivante : m observé m * c Avec c qui est tiré aléatoirement de façon gaussienne avec un σ de.2 et β est une constante dont la valeur est Dispersion totale On obtient ainsi le calcul des magnitudes des supernovae en fonction de leur redshift et des différentes dispersions par la formule suivante : m observé m * c ( s 1) * 4

5 Magnitude Magnitude 2.6 Méthode de standardisation La méthode de standardisation à pour objectif de supprimer toutes ces dispersions, on peut alors définir la magnitude corrigée par la formule suivante : m corrigée 2.7 Diagramme d Hubble observé m observé * c ( s 1) * La magnitude avec ses dispersions permet donc enfin d avoir un échantillon d une population de supernovae de typer Ia. Voici le résultat obtenu sur un diagramme d Hubble : Diagramme d'hubble,2,4,6,8 1 1,2 z Figure 1 : Diagramme d Hubble avec toutes les dispersions 2.8 Diagramme d Hubble observé avec coupure Diagramme d'hubble avec coupure,2,4,6,8 1 1,2 z Figure 2 : Diagramme d Hubble avec toutes les dispersions et coupure en magnitude à 24 5

6 Densité Densité La figure 2 montre le vrai diagramme d Hubble vu par un observateur car la coupure en magnitude est une réalité physique. Une fois le diagramme obtenu, il est possible de déterminer les densités et les erreurs associées à celles-ci grâce à un programme réalisé par dominique Fouchez pour faire correspondre au mieux la simulation à la théorie. Evidemment les valeurs trouvées sont celles implantés dans le programme. Mais ce qui est intéressant c est de voir l impact sur les valeurs centrales et surtout sur les erreurs en faisant varier les différents paramètres ; comme la coupure en magnitude à hauts redshifts et les différentes corrections. Pour pouvoir utiliser le programme de «fit» il faut utiliser l interface de Root (voir les lignes de commandes dans la section Annexes). III. Résultats 3.1 Résultats avec toutes les corrections,8,6,4, ΩM,29,284,23,272,351,283,326,323,264,288 ΩΛ,72,69,645,682,756,691,727,736,68,71 Moyennes : Ω M =.291 et Ω Λ =.71 σ ΩM =.732 et σ ΩΛ = Résultats avec coupure à 24 et toutes les corrections 1,8,6,4, ΩM,299,269,32,358,388,4,382,46,288,371 ΩΛ,712,675,711,744,782,776,765,834,692,757 Moyennes : Ω M =.354 et Ω Λ =.745 σ ΩM =.13 et σ ΩΛ =.82 6

7 Densité Densité Densité 3.3 Résultats sans aucunes corrections,8 1,6,4, ΩM,154,299,541,736 ΩΛ,61,648,949,546 Moyennes : Ω M =.267 et Ω Λ =.686 σ ΩM =.335 et σ ΩΛ = Résultats avec correction stretch 1,2,8 1,6,4, ΩM,237,666,633,69,49,228,272 ΩΛ,66,998,951,967,481,687,686 Moyennes : Ω M =.396 et Ω Λ =.775 σ ΩM =.37 et σ ΩΛ = Résultats avec correction couleur Moyennes : IV. Conclusion 1,8,6,4, ΩM,12,16,244,285,321,52,17,217,223,351 ΩΛ,527,622,646,68,718,878,66,634,621,743 Ω M =.261 et Ω Λ =.667 σ ΩM =.124 et σ ΩΛ =.16 Les résultats montrent clairement qu appliquer une méthode de standardisation améliore significativement la détermination de la valeur centrale et erreur des densités. L autre résultat important est celui de l influence de la coupure en magnitude. Celle-ci pourrait paraître tout d abord comme très néfaste aux résultats. Cependant si les corrections sont appliquées, son impact est très fortement minimisé, jusqu'à obtenir des valeurs très proches de la réalité. 7

8 Annexes Programme en C++ : /// ///Simulation d'une population de SN Ia pour tracer un diagramme d'hubble/// ///Auteur: Florent Marmol/////////////////////////////////////////////////////// /// #include <time.h> #include <stdio.h> #include <stdlib.h> #include <time.h> #include <iostream.h> #include <math.h> #include <iomanip.h> #include <fstream> float* tableauz; float* tableaudl; float* tableaum; float* tableaumerror; float* tableauzcut; float* tableaumcut; float* tableaumcuterror; float* tableaus; float* tableauc; float* tableauscut; float* tableauccut; int accumulateur; float* tableaudisp1; float nombrealeatoire(float min, float max) return (min + ((float) rand() / RAND_MAX * (max - min))); float h_z(float z) float OM,OL; OL=.7; OM=.3; return (1/sqrt(OM*(1+z)*(1+z)*(1+z)+OL+(1-OM-OL)*(1+z)*(1+z))); //Je définie la function qui fait l intégration numérique float integration_h_z(float z) 8

9 float N=1; float accumulateur=.; for (int i=;i<n;i++) accumulateur = accumulateur + h_z(i*z/n); return z/n*accumulateur; // Je définie la fonction qui calcule la distance lumineuse en fonction de z float dl_z(float z) int H=7; double c= 3e5; return((c*(1+z)/h)*integration_h_z(z)); // Je définie la fonction qui calcule la magnitude en fonction de la // distance lumineuse float magnitude(float dl) //dl doit etre exprime en pc dans cette formule float M=-19.31; return (M+5*log1(dl*1)); /////////////////////////////////////////////////////////////////////////////// float gaussienne(float sigma) float p=.; float a=.; float x=.; float y=.; p=nombrealeatoire(.,1.); a=nombrealeatoire(-1.,1.); x= sqrt(-2*sigma*sigma*log(p)); if (a>=) y=x; if (a<) y=-x; return y; /////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// 9

10 void lecture_simu(float sigmadisp1, float sigmas, float sigmac, float coupure, int nb ) srand(time(null)); float max=1; int l=; tableauz= new float[nb]; tableaudl= new float[nb]; tableaum= new float[nb]; tableaumerror= new float[nb]; tableaus= new float[nb]; tableauc= new float[nb]; tableaudisp1= new float[nb]; for (int i=; i<nb;i++) float disp1=gaussienne(sigmadisp1); tableaudisp1[i]=disp1; float c=gaussienne(sigmac); tableauc[i]=c; float s=gaussienne(sigmas)+1; tableaus[i]=s; for (int i=; i<nb; i++) float z=nombrealeatoire(.,max); float dl = dl_z(z); float error=sqrt(sigmadisp1*sigmadisp1); tableaumerror[i]=error; tableauz[i]=z; tableaudl[i]=dl; float m = magnitude(dl); //on introduit une dispersion dans les valeurs des magnitudes m = m + tableaudisp1[i]/2 + (tableaus[i]-1)*1.4-2*tableauc[i]; tableaum[i]=m; accumulateur=; 1

11 for (int j=;j<nb;j++) if (tableaum[j]<coupure) accumulateur++; tableauzcut= new float[accumulateur]; tableaumcut= new float[accumulateur]; tableaumcuterror= new float[accumulateur]; tableauscut= new float[accumulateur]; tableauccut= new float[accumulateur]; for (int k=;k<nb;k++) if (tableaum[k]<coupure) tableaumcut[l]=tableaum[k]; tableauzcut[l]=tableauz[k]; tableaumcuterror[l]=tableaumerror[k]; tableauscut[l]=tableaus[k]; tableauccut[l]=tableauc[k]; l++; //Ici on fait la correction apres la coupure for (int n=;n<accumulateur;n++) tableaumcut[n]=tableaumcut[n]-(tableauscut[n]-1)*1.4+ 2*tableauccut[n]; //Ici on fait la correction sans la coupure for (int p=;p<nb;p++) tableaum[p]=tableaum[p]-(tableaus[p]-1)*1.4+ 2*tableauc[p]; 11

12 Commandes sous Root :.L fint.c+.l testhubble.c+ lecture_simu() TGraph *gsimu = new TGraphErrors(1,tableauz,tableaum,,tableaumerror) gsimu.draw("ap") ff = new TF1("ff",mobs,,2,5) ff->setparameters(.,.,.,.26,.74) ff->fixparameter(,.) ff->fixparameter(1,.) ff->fixparameter(2,.) ff->setparlimits(4,.,1.) ff->setparlimits(3,.,1.) gsimu->fit(ff,"r") TGraph *gsimu = new TGraphErrors(accumulateur,tableauzcut,tableaumcut,,tableaumcuterror) gsimu.draw("ap") ff = new TF1("ff",mobs,,2,5) ff->setparameters(.,.,.,.26,.74) ff->fixparameter(,.) ff->fixparameter(1,.) ff->fixparameter(2,.) ff->setparlimits(4,.,1.) ff->setparlimits(3,.,1.) gsimu->fit(ff,"r") 12