Astronomie

Tracer des données astronomiques à l'aide de Python

Tracer des données astronomiques à l'aide de Python


We are searching data for your request:

Forums and discussions:
Manuals and reference books:
Data from registers:
Wait the end of the search in all databases.
Upon completion, a link will appear to access the found materials.

J'ai essayé de créer un graphique qui montre les distances entre les étoiles et la terre, mais je n'ai pas pu obtenir le graphique souhaité comme indiqué ci-dessous (cliquez pour zoomer) : Mon graphique :

Comme @uhoh l'a suggéré, j'ai superposé un graphique sur l'autre. Je m'excuse d'avoir publié ce graphique confus

Le graphique combiné indique que les positions des courbes dans mon graphique diffèrent totalement de celles du graphique attendu.

J'ai suivi ce guide pour calculer les fonctions de position des étoiles.

Ma question: Ai-je commis des erreurs qui ont entraîné des anomalies ?

Merci d'avance.

Annotations pour le Code :

  • Nom - Nom de l'étoile

  • RA - Ascension Droite en degrés, coord ICRS. (J2000)

  • Déc - Déclinaison en degrés, coord. (J2000)

  • pm_mRA - Mouvement propre en ascension droite, en milliarcsecondes par an

  • pm_mdec - Mouvement correct en déclinaison, en milliarcsecondes par an

  • vr - vitesse radiale en kilomètres par seconde, une valeur positive signifie que l'étoile s'éloigne de nous

  • mparallax - parallaxe de l'étoile en milliarcsecondes

  • d - distance entre l'étoile et la terre

Mon code :

def parseTextFile(file_name, delimiter=",", header=0): """ Analyse un fichier texte dans une liste. Le contenu du fichier est délimité et a un en-tête. """ with open(file_name) as f: # Ignorer l'en-tête pour i dans range(header): next(f) data = [] # Analyser le contenu du fichier pour la ligne dans f: # Supprimer le caractère de nouvelle ligne line = line.replace('
',").replace(' r',") # Fractionner la ligne par le délimiteur line = line.split(delimiter) # Supprimer les espaces blancs des entrées individuelles dans la ligne pour i, entrée dans enumerate(line): line[i] = entry.strip() # Ajouter le contenu de la ligne à la liste de données data.append(line) return data fig = plt.figure() ax = fig.add_subplot() #time span time = np.arange(-60000,100000,10) count = 1 xdic = {} ydic = {} zdic = {} #plusieurs lignes de données pour star dans parseTextFile(file_name, header=1): name = str(star[0]) RA = float(star[1]) Dec = float(star[2]) pm_mRA = float(star[3]) pm_mDec = float(star[4]) vr = float(star[5]) mparallax = float(star[6]) pm_RA = pm_mRA * 0,001 pm_Dec = pm_mDéc * 0,001 d = 1 / (mparallax * 0.001) #Vitesses transversales vta = pm_RA * d * 4.740 vtd = pm_Dec * d * 4.740 #Vitesses linéaires vx = vr * np.cos(Dec) * np.cos(RA) - vta * np.sin (RA) - vtd * np.sin(Déc) * np.cos(RA) vy = vr * np.cos(Déc) * np.sin(RA) + vta * np.cos(RA) - vtd * np. sin(Dec) * np.sin(RA) vz = vr * np.sin(Dec) + vtd * np.cos(Dec) #conversion d'unités de km/s en pc/an vx_pcyr = vx / 977780 vy_pcyr = vy / 977780 vz_pcyr = vz / 977780 #positions initiales xi = d * np.cos(RA) * np.cos(RA) yi = d * np.cos(Dec) * np.sin(RA) zi = d * np.sin (Déc) #fonctions de position x = xi + vx_pcyr * temps y = yi + vy_pcyr * temps z = zi + vz_pcyr * temps distance = np.sqrt(x ** 2 + y ** 2 + z ** 2) ax. plot(time,distance,label=name) ax.set_xlabel('Time (Year)') ax.set_ylabel('Distance (pc)') ax.legend() plt.show()

J'ai oublié de changer l'unité de la distance du parsec à l'année-lumière. Il s'agit d'une simple erreur de conversion d'unité qui aurait dû être évitée.

Graphique ultime :

Données utilisées :

Nom,RA(deg),Dec(deg),pm_RA(mas/an),pm_Dec(mas/an),Vr(km/s),parallax(mas)
Loup 359 164,120271,+07,014658,-3842,0,-2725,0,19,321,418,3
Proxima Centauri,217.42895219,-62.67948975,-3775.75.765.54,-22.40.768.13
Alpha Centauri,219.900850,-60.835619,-3608.686,-22.3.742
Étoile de Barnard,269.45207511,+04.69339088,-798.58,10328.12,-110.51.548.31
Gliese 445,176,92240640,+78,69116300,743,61,481,40,-111,65,186,86
Luhman 16A,150.8218675,-53.319405556,-2754.77,358.72,23.1,500.51
Sirius,101.28715533,-16.71611586,-546.01,-1223.07,-5.50,379.21
Lalande 21185,165,83414166,+35,96988004,-580,27,-4765,85,-84,69,392,64
Ross 248.355.479122,+44.177994.115.10,-1592.77,-77.715.316.7
Gliese 65,24,756054,-17,950569,3321,562,29,373,70

Code:

%matplotlib qt import numpy as np depuis mpl_toolkits.mplot3d import axes3d depuis matplotlib import pyplot as plt depuis matplotlib import patches def parseTextFile(file_name, delimiter=",", header=0): """ Analyse un fichier texte dans une liste. Le contenu du fichier est délimité et a un en-tête. """ avec open(file_name) comme f : # Ignore l'en-tête pour i dans range(header) : next(f) data = [] # Analyse le contenu du fichier pour la ligne dans f : # Supprimer le caractère de nouvelle ligne line = line.replace('
',").replace('
',") # Diviser la ligne par le délimiteur line = line.split(delimiter) # Supprimer les espaces blancs des entrées individuelles dans la ligne pour i, entrée dans enumerate(line): line[i] = entry.strip() # Ajoute le contenu de la ligne à la liste de données data.append(line) renvoie les données if __name__ == "__main__": file_name = 'C:UsersThe Wings of DreamDesktopUWO-PA-Python-CourseLecture 5Homework 2star_data.txt' #Program Begin: fig = plt.figure() ax1 = fig.add_subplot(211, projection="3d") ax2 = fig.add_subplot(212) time = np.arange(-600 00,100000,10) count = 1 xdic = {} ydic = {} zdic = {} pour star dans parseTextFile(file_name, header=1): name = str(star[0]) RA = float(star[1]) ) Dec = float(star[2]) pm_mRA = float(star[3]) pm_mDec = float(star[4]) vr = float(star[5]) mparallax = float(star[6]) pm_RA = pm_mRA * 0,001 pm_Dec = pm_mDec * 0,001 d = 1 / (mparallax * 0,001) vta = pm_RA * d * 4,740 vtd = pm_Dec * d * 4,740 vx = vr * np.cos(Dec) * np.cos(RA) - vta * np .sin(RA) - vtd * np.sin(Déc) * np.cos(RA) vy = vr * np.cos(Déc) * np.sin(RA) + vta * np.cos(RA) - vtd * np.sin(Déc) * np.sin(RA) vz = vr * np.sin(Déc) + vtd * np.cos(Déc) vx_pcyr = vx / 977780 vy_pcyr = vy / 977780 vz_pcyr = vz / 977780 xi = d * np.cos(Déc) * np.cos(RA) yi = d * np.cos(Déc) * np.sin(RA) zi = d * np.sin(Déc) x = xi + vx_pcyr * temps y = yi + vy_pcyr * temps z = zi + vz_pcyr * temps xdic['x'+str(count)] = x ydic['y'+str(count)] = y zdic['z'+str(count)] = z distance = np.sqrt(x ** 2 + y ** 2 + z ** 2) * 3.26156 ax1.plot(xdic['x'+str(count)],ydic['y'+str( count)],zdic['z'+str(count)]) ax2.plot(time,distance,label=name) count = count + 1 w_oort, h_oort = 160000, 3.2 ax2.add_patch(patches.Rectangle((- 60000, 0.03), w_oort,h_oort,color='slateblue',alpha=0.2)) ax2.annotate('Oort Cloud', xy=(15000,1.6), size=12) plt.axvline(x=0,color ='gray',linestyle='--',linewidth='0.5') #contraintes de traçage ax2.set_ylim(0.0, 10.0) ax2.set_xlim(-60000, 100000) ax1.set_xlabel('axe x') ax1.set_ylabel ('axe y') ax1.set_zlabel('axe z') ax1.title.set_text('mouvement des étoiles dans l'espace') ax2.title.set_text('distance-temps') ax2.set_xlabel('temps (année) ') ax2.set_ylabel('Distance (année-lumière)') ax2.legend() plt.show()

ax1 subplot vous donnera un graphique paramétrique 3D montrant le mouvement des étoiles.


Une introduction au traitement d'images avec Python

Afin de mieux comprendre comment les images astronomiques sont traitées, nous allons écrire notre propre logiciel pour effectuer le traitement. Pour minimiser l'effort de faire cela, nous utiliserons le langage informatique Python. Python est un langage de programmation interactif et extensible. Il possède des extensions pour charger des images à partir de fichiers FITS, traiter des images à l'aide d'un code compact sans boucles et afficher des images à l'écran. Au cours de l'atelier de cette semaine, vous vous familiariserez avec les bases de python et certains détails sur la gestion des images en python.

Python est un logiciel libre. Ainsi, si vous souhaitez travailler sur l'apprentissage de Python en dehors du cours, vous pouvez l'obtenir via les liens sur la page Web du cours. Notez que nous utiliserons Python 2.7 et non Python 3 (c'est parce que matplotlib n'a ajouté que récemment le support de Python 3, en fait c'est parce que votre professeur est un fossile et n'aime pas changer). Nous utiliserons un certain nombre de packages python pour traiter les images (sous forme de tableaux numériques), lire les fichiers FITS et afficher les données. Anaconda inclut python et (presque tous) les autres packages nécessaires. Si vous utilisez directement python (par exemple sous Linux), vous devrez installer ces packages séparément (ce qui est très facile pour les distributions comme Ubuntu). Si vous avez un mac, vous êtes seul.

Vous utiliserez beaucoup python pendant le semestre, il serait donc bon de l'installer sur un ordinateur auquel vous avez accès en dehors des cours (comme un ordinateur portable si vous en possédez un).

Pour installer Anaconda, utilisez ce lien http://continuum.io/downloads. Les machines du laboratoire exécutent des fenêtres 32 bits. Une fois python installé, essayez d'exécuter ipython. Une fois arrivé à la ligne de commande ipython, vous devez taper
cd h :/
pour changer le répertoire actuel dans lequel vos fichiers sont stockés. La ligne de commande ipython utilise des commandes unix. Quelques commandes utiles sont : 'ls' - pour lister le contenu du répertoire courant, 'cd' - pour changer le répertoire courant, et 'pwd' - pour imprimer le répertoire courant.
Je préfère éditer les fichiers .py en utilisant gedit. Vous devrez peut-être installer gedit. La plupart des autres éditeurs de texte fonctionnent également très bien.

Premier exemple de programme - lire et tracer une image

Pour commencer avec python, regardons un programme simple pour lire une image au format FITS et la tracer à l'écran. Le programme est ici : showimage.py. Vous devez télécharger le programme, puis le charger dans un éditeur de texte de votre choix. Le bloc-notes gâche le formatage. Wordpad est ok. Gedit devrait être installé sur les machines et est plutôt sympa.

La première ligne est un commentaire sur ce que fait le programme. C'est une bonne pratique de commenter généreusement votre code.

Le deuxième ensemble de lignes (3-7) indique à python que nous utiliserons un tas d'extensions. Les extensions sont des modules pré-écrits pour effectuer diverses tâches. numpy, ou 'Numerical Python' est un package permettant de définir des constructions mathématiques telles que des matrices (ou des tableaux) et de faciliter leur gestion en python. matplotlib est un package de traçage scientifique. pyfits est un package pour lire et écrire des fichiers FITS.

La première chose que nous faisons réellement dans le programme est à la ligne 12, où nous lisons dans un fichier FITS. Le programme lit actuellement dans un fichier appelé 'testpattern1.fit'. Vous devez modifier cette ligne pour lire l'un des fichiers que vous avez créés dans le dernier laboratoire. Notez que si vous exécutez python dans le même répertoire que vos données, vous n'avez besoin que du nom du fichier. Sinon, vous devrez ajouter le répertoire du fichier.

À la ligne 15, nous copions les données d'image du fichier FITS dans une variable appelée img1. img1 est en fait un tableau numpy et plus tard, nous verrons comment effectuer des opérations mathématiques sur des tableaux numpy (c'est facile).

La prochaine série de lignes, 18-21, trace l'image. De retour dans l'import, nous avons importé le package de traçage "as plt". Cela nous permet d'utiliser le raccourci "plt" pour désigner le package de traçage. Les quatre lignes appellent des routines dans le package matplotlib.pyplot en utilisant plt comme raccourci. La première ligne définit le tracé en mode interactif, cela signifie simplement que le programme continue après avoir tracé le tracé plutôt que d'attendre que l'utilisateur regarde le tracé avant de continuer. La deuxième ligne définit la carte des couleurs. Étant donné que la caméra est en noir et blanc, nous utilisons une carte en niveaux de gris pour créer des images réalistes. La troisième ligne utilise la routine "imshow" pour tracer les données de l'image à l'aide de la palette de couleurs sélectionnée. La ligne quatre met en fait l'intrigue sur l'écran.

Une fois que vous avez modifié le programme à lire dans votre fichier (modifiez la ligne 12, voir ci-dessus), lancez le programme. Démarrez ipython. ipython est une interface shell interactive vers python qui utilise des commandes de type Unix. Pour configurer Anaconda python pour l'interface de traçage que nous utilisons, tapez '%pylab' sans les guillemets. Vous voudrez le faire chaque fois que vous démarrerez ipython ou le programme se bloquera lorsque vous créerez des tracés. Si vous n'exécutez pas Anaconda, cette commande n'est probablement pas nécessaire. Utilisez cd pour vous déplacer vers le répertoire où se trouve showimage.py et tapez « run showimage » sans les guillemets et appuyez sur Entrée. ipython devrait afficher l'image. Notez que la fenêtre est interactive : on peut zoomer, faire un panoramique ou enregistrer l'image dans une variété de formats. Si vous rencontrez des problèmes pour exécuter le programme, assurez-vous que vous êtes dans le bon répertoire et que vous avez modifié le programme pour rechercher le fichier FITS au bon endroit. Assurez-vous que le programme fonctionne avant de continuer. Enregistrez dans votre cahier de laboratoire les procédures que vous avez suivies pour afficher l'image, y compris les répertoires où showimage.py et votre image sont enregistrés. N'oubliez pas de commencer sur une nouvelle page et d'écrire la date d'aujourd'hui et une brève description des activités d'aujourd'hui (comme « Intro to Python ») en haut de la page.

Fichiers FITS

Après avoir exécuté le programme, il devrait vous laisser à l'invite de commande ipython. Tapez maintenant 'print h[0].header'. L'écran ipython sera rempli d'un tas d'informations encodées dans le fichier. FITS est un format de fichier "auto-documenté". En plus des données d'image, le fichier contient des « métadonnées » décrivant les paramètres de l'image et comment et quand l'image a été obtenue. Ceux-ci ont été écrits par CCDOps lorsque vous avez enregistré le fichier dans le dernier laboratoire. Les métadonnées se composent d'un nom de mot clé, d'une valeur et d'un commentaire facultatif.

Par exemple, le mot-clé NAXIS donne le nombre d'axes, il doit être 2. Les mots-clés NAXIS1 et NAXIS2 donnent le nombre de pixels le long des deux axes de l'image. Notez-les dans votre cahier de laboratoire. Si vous avez enregistré une image complète (comme indiqué dans le dernier laboratoire), celles-ci doivent correspondre au nombre de pixels dans le CCD. Vérifiez la documentation du CCD pour voir si cela est vrai et enregistrez-le dans votre ordinateur portable. Le mot-clé CCD-TEMP enregistre la température du CCD lorsque l'image a été obtenue. Notez cela dans votre cahier et notez les unités. Vérifiez le mot-clé TELESCOP, il doit contenir ce que vous avez écrit pour 'Description du télescope'. Ecrivez dans votre cahier si TELESCOP est d'accord avec FOCALLEN et ce que vous avez écrit dans votre cahier sur l'objectif utilisé pour l'image. Tant que vous faites attention lorsque vous prenez les données, les métadonnées dans les fichiers FITS offrent un bon moyen de vérifier que vous travaillez avec les bons fichiers de données.

Deuxième exemple de programme - image de différence

Téléchargez maintenant diffimage.py et chargez-le dans votre éditeur. Modifiez les lignes 12 et 13 pour lire les deux images du motif de test que vous avez prises dans le premier laboratoire. Ce programme lit deux images, extrait les données d'image, calcule un nouveau tableau qui correspond à la différence entre les deux images, puis trace les trois images. L'image de différence est calculée à la ligne 33. Notez à quel point le code est simple. L'autre nouvel élément du code est l'utilisation de plt.figure(#) pour tracer plusieurs fenêtres à l'écran. Notez qu'un seul plt.show() est nécessaire pour afficher les trois images.

Jetez un œil à vos trois images. Si les deux images que vous avez prises avec le CCD étaient dans des conditions exactement identiques, alors le motif de test devrait disparaître dans l'image de différence. Est-ce arrivé? Écrivez vos conclusions ainsi que vos réflexions sur la façon d'améliorer la soustraction dans votre cahier. Aussi, pouvez-vous penser à une application astronomique pour l'imagerie différentielle ?

Troisième exemple de programme - histogramme d'image

Nous allons maintenant utiliser python pour calculer des statistiques et tracer un histogramme des valeurs de pixels dans nos images. Obtenez histimage.py. Les premières parties devraient être familières. Modifiez la ligne qui lit le fichier FITS pour utiliser votre fichier image. Les nouveautés commencent à la ligne 26. Les routines numpy/matplotlib pour créer des histogrammes et calculer des statistiques doivent avoir des tableaux à une dimension en entrée. A la ligne 26, on trouve la taille du tableau 2D img. la routine img.shape renvoie deux valeurs dans un 'tuple'. Les tuples Python sont des ensembles de valeurs séparées par des virgules et parfois mises entre parenthèses. À la ligne 26, nx est défini sur la première valeur du tuple et ny est défini sur la deuxième valeur. A la ligne 27, nous créons un nouveau tableau (1-d) imgh. Il a les mêmes valeurs que le tableau d'images 2D img, mais arrangé comme des canards dans une rangée.

Voici quelques lignes pour calculer les statistiques des valeurs de l'image. min, max et moyenne devraient être explicites. std donne l'écart type d'un ensemble de données. L'écart type est une mesure des fluctuations des données autour de la valeur moyenne. C'est la racine carrée de la moyenne des écarts au carré par rapport à la moyenne, c'est-à-dire std = sqrt(mean((x-mean(x))**2)), où ** est l'opérateur de Python pour élever un nombre à un Puissance. Enregistrez les statistiques des valeurs de pixels de votre image.

Ensuite, nous traçons l'histogramme. Un histogramme est une représentation graphique de la distribution d'un ensemble de valeurs. Dans ce cas, les valeurs sont les lectures d'intensité du CCD pour chaque pixel. Si vous les organisez dans un tableau 2D, vous obtenez une image. Un histogramme rejette les informations spatiales et ne montre que la distribution des valeurs elles-mêmes, en particulier la fréquence à laquelle chaque valeur (ou plage de valeurs) se produit. La routine matplotlib hist trace des histogrammes. Le premier argument est un 1-d de valeurs, les autres arguments définissent les paramètres du tracé. Le plus crucial d'entre eux est « bins » qui définit le nombre de bacs dans l'histogramme. Par défaut, les bacs seront régulièrement espacés entre les valeurs d'entrée les plus basses et les plus élevées.

Lors du calcul des statistiques d'un ensemble de données, on préfère souvent éliminer les valeurs aberrantes, par ex. pixels qui ont des valeurs élevées parce qu'ils sont saturés ou « chauds » ou des pixels qui ont des valeurs faibles parce qu'ils sont endommagés. Examinez l'histogramme de vos valeurs de pixels. Y a-t-il des valeurs aberrantes ? Aux lignes 41-44, nous définissons une plage autorisée pour les "bonnes" valeurs de pixels (entre labour et phi), puis créons un nouveau tableau, imghcut, en ne conservant que les valeurs de cette plage. Ajustez les valeurs de charrue et de phi en fonction de votre histogramme et enregistrez-les. Notez que les coordonnées actuelles du curseur de la souris sont affichées dans la fenêtre de tracé lorsque vous déplacez la souris sur le tracé. Ensuite, exécutez à nouveau histimage.py et enregistrez les statistiques des valeurs de pixels de votre image en ne conservant que les "bons" pixels.

Maintenant, essayez Python par vous-même

Passez le reste du labo à apprendre Python. Nous utiliserons python tout au long du semestre, c'est donc un bon investissement de votre temps. Une bonne façon de le faire est de vous fixer un objectif, puis d'essayer d'écrire le code nécessaire. De plus, il serait utile de parcourir les didacticiels Code Academy et NumPy (les liens se trouvent sur la page Web principale de la classe).

Il n'y a pas de cours le jour de la fête du Travail, il serait donc bon de passer 12 heures au cours des deux prochaines semaines à apprendre le python. Il y a des exercices python dus le 14/09 pour encourager cela.

Exercices Python prévus lors du prochain labo :

1) Ajoutez du code au programme de traçage d'histogramme pour superposer la valeur moyenne sur l'histogramme. Après avoir fait fonctionner cela, ajoutez plus de code pour tracer la moyenne - l'écart type avec des lignes en pointillés. Ce graphique donne une belle illustration graphique de la façon dont l'écart type est une mesure des fluctuations des données autour de la valeur moyenne. Ajoutez ensuite du code pour calculer la médiane (la valeur telle que la moitié des données se trouve au-dessus et l'autre moitié en dessous). Tracez la médiane et voyez comment elle se compare à la moyenne. Imprimez votre code et une copie de votre tracé avec la moyenne, les écarts types et la médiane à remettre.

2) Dans le prochain atelier, vous devrez faire des tracés de valeurs. Écrivez du code pour créer un tableau des nombres entiers de 1 à 10, trouvez leurs carrés, puis tracez le carré en fonction de la valeur. Imprimez votre code et une copie de votre tracé à remettre.


Modules et bibliothèques astronomiques en Python

Il existe de nombreuses bibliothèques astronomiques spéciales dans le monde Python, principalement développées dans le cadre de travaux de recherche dans des instituts et mises à disposition de la communauté. Je poste quelques URL ici. Les programmes sont décrits sur les pages Web correspondantes et peuvent y être téléchargés et installés dans votre propre environnement Python selon les instructions d'installation.

Le système le plus étendu est probablement astropie: https://www.astropy.org/

Le package astropy contient des fonctionnalités clés et des outils communs nécessaires pour effectuer l'astronomie et l'astrophysique avec Python. Il est au cœur du projet Astropy, qui vise à permettre à la communauté de développer un écosystème robuste de packages affiliés couvrant un large éventail de besoins en matière de recherche astronomique, de traitement de données et d'analyse de données.

PyAstronomy (PyA) est une collection de packages liés à l'astronomie.

L'objectif de PyAstronomy est de fournir une collection de packages, qui répondent à un certain standard à la fois en termes de qualité de code et de documentation. De cette façon, nous (le groupe PyA) voulons nous assurer que les packages PyA constituent un outil agréable pour améliorer l'efficacité de notre/votre travail et non une autre source d'expériences douloureuses.

PyA est né du travail de certaines personnes du Hamburger Sternwarte. Il n'a pas été conçu pour couvrir un domaine particulier, mais nous avons intégré des outils, que nous avons trouvés utiles au cours de notre travail. D'autres personnes ont des besoins différents et les nôtres aussi évoluent. Par conséquent, nous nous attendons à ce que PyA grandisse à la fois par nos propres contributions et, espérons-le, par les contributions des autres.

Par example, astroplan peut être utilisé pour planifier des observations : https://astroplan.readthedocs.io/en/latest/index.html

astroplan est un package Python open source pour aider les astronomes à planifier leurs observations.

L'objectif d'astroplan est de créer une boîte à outils flexible pour la planification et la programmation d'observations. Une fois terminé, l'objectif est d'être facile à comprendre pour les débutants et les nouveaux observateurs Python, mais suffisamment puissant pour les observatoires qui préparent des horaires nocturnes et à long terme.

    • Calculez les temps de transit de montée/descente/méridien, les positions alt/az pour les cibles dans les observatoires n'importe où sur Terre
    • Fonctions de commodité de traçage intégrées pour les tracés de planification d'observation standard (masse d'air, angle parallactique, cartes du ciel).
    • Déterminer l'observabilité d'ensembles de cibles en fonction d'un ensemble arbitraire de contraintes (c.-à-d. altitude, masse d'air, séparation/illumination de la lune, etc.).

    Pour fins spectroscopiques les URL suivantes sont importantes :

    specutils est un package Python permettant de représenter, charger, manipuler et analyser des données spectroscopiques astronomiques. Les conteneurs de données génériques et les modules d'accompagnement fournissent une boîte à outils que la communauté astronomique peut utiliser pour créer des packages plus spécifiques à un domaine.

    L'ajustement de la ligne de base décrit l'ajustement de la ligne de base et du continuum.

    L'ajustement du modèle décrit le processus général d'ajustement du modèle.

    Measurements est une boîte à outils pour effectuer des mesures EQW, de colonne et autres…

    Units contient la très importante classe SpectroscopicAxis qui est utilisée pour traiter les transformations de coordonnées

    linetools est un package en cours de développement pour l'analyse des spectres 1-D. Ses principaux développeurs travaillent principalement sur la recherche de raies d'absorption UV/optique/IR, donc la plupart des fonctionnalités sont destinées à l'identification et à l'analyse des raies d'absorption. L'objectif final est de fournir un ensemble d'outils utiles à la fois pour les raies d'absorption et d'émission.

    iSpec est un outil de traitement et d'analyse des spectres stellaires. Certaines des fonctionnalités principales pour le traitement des spectres sont les suivantes :

      • Élimination des rayons cosmiques
      • Normalisation du continu
      • Dégradation de la résolution
      • Détermination et correction de la vitesse radiale
      • Identification des raies telluriques
      • Ré-échantillonnage

      Une bibliothèque de spectroscopie et d'astrophysique pour Python 3
      Ce package Python est une base de code en expansion pour faire de l'astronomie computationnelle, en particulier la spectroscopie. Il contient à la fois un
      Classe de spectre pour la gestion des spectres en tant qu'objets (avec des opérations +, -, *, /, etc.) et une suite croissante d'outils d'analyse.


      Tracer des données astronomiques à l'aide de Python - Astronomie

      Le processus de réduction et d'analyse des données nécessite la manipulation de données brutes. Avec l'avènement des détecteurs numériques, cela est bien adapté aux ordinateurs et aux logiciels.

      Historiquement, divers progiciels ont été développés spécifiquement pour le traitement d'images astronomiques, par ex.

      • IRAF. En particulier, notez l'interface Python PYRAF
      • XVISTA
      • GAIAA
      • FIGARO : Caltech
      • MIDAS : Européen
      • AIPS : radio
      • Packages complémentaires : STSDAS (télescope spatial), PROS (rayons X), DAOPHOT (photométrie stellaire), SeXtractor (détection de source).

      Ceux-ci avaient tous diverses spécialités et avantages et inconvénients : disponibilité, coût, interface graphique/ligne de commande, traitement des données (disque contre mémoire), vitesse, facilité d'utilisation (par exemple, mots-clés contre fichiers de paramètres), langue et accès au code existant, possibilité d'ajouter du nouveau code, des scripts/procédures (langage de contrôle interne). La plupart de ces packages reconnaissaient la valeur des scripts et des opérations répétitives pour de nombreuses images et, par conséquent, incluaient des fonctionnalités de script intégrées.

      Avec le développement de langages de script tels que IDL et Python, les choses se sont progressivement éloignées des packages spécifiques à l'astronomie vers des routines écrites dans le langage de script générique, ou du moins appelables à partir de celui-ci.

      Certaines tâches de traitement d'images sont simples et d'autres complexes. Pour les tâches complexes, il est pratique d'utiliser des outils prédéfinis. Mais il est généralement important de reconnaître ce que fait un outil donné, et s'il peut avoir des limites : vous ne devriez pas être limité dans ce que vous choisissez de faire par l'outil avec lequel vous êtes à l'aise, alors gardez toujours ouverte la possibilité d'autres outils, ou améliorer la capacité d'un outil !

      Quel logiciel faut-il apprendre ? De nos jours, de nombreux instruments nécessitent des tâches assez complexes pour réduire les données. Souvent, l'équipe d'instruments ou l'observatoire fournit des routines (dans certains packages) pour effectuer ces tâches. Généralement, il est peut-être plus facile d'utiliser ces routines plutôt que de les reprogrammer à l'aide de votre outil préféré ! Vous êtes donc probablement dans la position de devoir être à l'aise avec plusieurs outils.

      Une autre façon de voir les choses est que pour être à l'avant-garde, vous travaillerez probablement avec de nouveaux instruments et/ou de nouvelles techniques. L'utilisation d'une analyse standard peut être peu susceptible de tirer le meilleur parti, voire de fonctionner du tout, avec de nouvelles données. Vous voulez donc avoir la possibilité de développer vous-même des outils.

      Il existe plusieurs environnements de programmation qui facilitent le travail avec des données astronomiques. Ici, nous allons fournir une introduction à deux des environnements les plus populaires aux États-Unis : Python (particulièrement utile en conjonction avec PyRAF) et IDL. Travailler dans l'un de ces environnements vous permet de scripter l'utilisation de routines existantes, mais aussi de développer vos propres routines. Il est également extrêmement important d'avoir des outils pour pouvoir explorer les données.

        Notions de base
          Démarrez python en utilisant : ipython &ndashmatplotlib

        • type( var ) donne le type de variable
        • var? donne des informations sur la variable (iPython uniquement)
        • var.<tab> donne des informations sur les attributs et les méthodes des variables
        • FITS : en-tête/données, types de données, HDUList, etc.
          • d'astropy.io import correspond
          • hd=fits.open( filename ) renvoie HDULIST
          • hd[0].data sont les données du HDU initial dans un tableau numpy
          • hd[0].header est l'en-tête du HDU initial dans un tableau structuré numpy
          • depuis astropy.io importer ascii
          • a=ascii.read( filename ) renvoie une table avec des colonnes
          • méthodes de tableau numpy : par exemple :
            • data.sum() : total
            • data.mean() : moyenne
            • data.std() : écart type
            • np.median(data) : médiane
            • affichage primitif via imshow
              • plt.imshow(hd[0].data,vmin=min,vmax=max)
              • à partir de l'importation pyds9 *
              • d=DS9() (ouvre une fenêtre DS9, s'associe à l'objet d)
              • d.set("fits filename") (affichage à partir du fichier)
              • d.set_pyfits(hd) (affichage de HDULIST)
              • d.set_np2arr(hd[0].data) (affichage à partir du tableau numpy)
              • d.set("limites d'échelle 400 500") (définit la plage d'affichage)
              • liste de commandes
              • importer le système d'exploitation
              • os.environ["PYTHONPATH"] = /home/holtz/python
              • de holtz.pyvista.tv import *
              • t=tv.TV()
              • t.tv(hd[0],min=400,max=500)
              • t.tv(hd[0].données)
              • zoom, panoramique, barre de couleur
              • tampons d'image clignotants avec +/-
              • plt.figure
              • plt.plot(hd[0].data[:,100] (pour un tracé le long de la colonne 100)
              • plt.plot(hd[0].data[500,:] (pour un tracé le long de la ligne 500)

              Continuons à travailler avec les images dans /home/holtz/raw/apo/a535/spicam/UT061215.

                A lire en plusieurs images : SN17135_r.0103.fits, flat_r.0015.fits, bias.0001.fits. Affichez-les depuis un environnement logiciel ( Python/pyds9/tv/imshow ou IDL/atv) et familiarisez-vous avec son utilisation.


              Tracer des données astronomiques à l'aide de Python - Astronomie

              APLpy (la bibliothèque de tracés astronomiques en Python) est un module Python visant à produire des tracés de qualité publication de données d'imagerie astronomique au format FITS. Le module utilise Matplotlib, un package de traçage puissant et interactif. Il est capable de créer des fichiers de sortie dans plusieurs formats graphiques, notamment EPS, PDF, PS, PNG et SVG.

              Caractéristiques principales

              • Faire des tracés de manière interactive ou à l'aide de scripts
              • Afficher les images en niveaux de gris, en niveaux de couleurs et RVB 3 couleurs des fichiers FITS
              • Générez des cubes FITS co-alignés pour créer des images RVB 3 couleurs
              • Faire des tracés à partir de fichiers FITS avec WCS arbitraire (par exemple, position-vitesse)
              • Couper des cubes FITS multidimensionnels
              • Superposer un nombre quelconque d'ensembles de contours
              • Marqueurs de superposition avec des symboles entièrement personnalisables
              • Tracez des formes personnalisables comme des cercles, des ellipses et des rectangles
              • Superposer les fichiers de région ds9
              • Superposer les grilles de coordonnées
              • Afficher les barres de couleurs, les barres d'échelle et les faisceaux
              • Personnaliser l'apparence des étiquettes et des coches
              • Masquer, afficher et supprimer différents calques de contours et de marqueurs
              • Panoramique, zoom et enregistrement de n'importe quelle vue sous forme de tracé complet de qualité publication
              • Enregistrer les tracés au format EPS, PDF, PS, PNG et SVG

              Pour demander des fonctionnalités, veuillez laisser une demande ici.

              Commencer

              Vous voulez commencer ? Suivez ensuite les instructions sur la page, puis consultez la page Tutoriel sur la façon de créer de superbes et simples tracés.

              Signaler des problèmes

              Si vous rencontrez des problèmes avec APLpy, veuillez laisser un rapport de bogue ici.

              Code source

              Si vous êtes courageux et savez ce que vous faites avec Python, vous pouvez télécharger le code source de pointe avec Git.

              git clone git://github.com/aplpy/aplpy.git APLpy

              Reconnaître l'utilisation d'APLpy

              Si vous utilisez APLpy pour une publication, vous pouvez utiliser l'accusé de réception suivant :

              Cette recherche a utilisé APLpy, un logiciel de traçage open source pour Python (Robitaille et Bressert, 2012)

              où (Robitaille et Bressert, 2012) est une citation de cette entrée ADS/ASCL.


              Sur ce site, vous trouverez un recueil de liens et de ressources pour vous aider à développer vos compétences en Python et à les appliquer à plusieurs projets astronomiques : identifier des astéroïdes, travailler avec des images astronomiques et utiliser des données éphémérides pour localiser des astéroïdes, des comètes et des planètes. dans le ciel. Il existe des ressources ici qui incluent des catalogues majeurs d'astéroïdes, des cahiers Python pour simuler des orbites d'objets du système solaire et des bases de données d'éphémérides de la NASA pour permettre de nouvelles recherches sur le système solaire.

              J'ai divisé cela en sections et je fournis des liens et des conseils pour commencer ci-dessous.

              Premiers pas en Python

              Peut-être avez-vous déjà été exposé à Python, mais sinon, il existe de nombreuses introductions utiles au langage et de nombreux supports disponibles pour vous aider à apprendre. Étant donné que le Yale-NUS College a suivi le cours abrégé de Marla Geha sur Python, je vais inclure beaucoup de ses documents, car ils constituent un très bon point d'entrée dans Python avec une inclinaison astronomique.

              Python est intégré à la plupart des ordinateurs et à tous les systèmes MacOS. Cependant, un système très apprécié et complet dans tous ses packages est connu sous le nom d'installation Anaconda Python. Je le recommande vivement car cela permet une expérience fluide et des cahiers très agréables et avancés pour visualiser ce que vous faites. Chez Caltech, le camp d'entraînement ZTF utilise également cette distribution. Il est disponible sur https://store.continuum.io/cshop/anaconda/.

              Une fois que vous l'avez installé, vous pouvez utiliser le guide de Marla Geha de Yale pour vous aider à en savoir plus sur Python. Cela comprend des exercices de traitement d'images, en utilisant à la fois des données de son cours de courte durée à Yale-NUS et des archives HST. Ces ressources sont toutes disponibles sur le site Yale-NUS August Short Course. Her Pre-course Python guide – marla.geha.python.exercises.Precoursework_1 will help guide you through some of the introductory Python exercises. She also has a Research Methods site at Yale that has a number of very useful Python exercises – this is available at http://www.astro.yale.edu/mgeha/A255/problemsets.html.

              There are two ways to run Python – File Mode: by creating a .py file one can run it in a command line mode with a command like python file.py Notebook Mode: by creating a Python notebook, one can run the notebook using “ipython” or interactive python. These files will end in the prefix ipynb, can also be run with ipython file.ipynb. Within a notebook you will see input and output commands. A short example is below. These sections of a notebook are known as “cells” and can be run by highlighting the cell (here labelled In [4]) and punching the “Play button” on the top of the window (the triangle pointing right). The results will show up immediately below in the cell labelled Out (here Out [4] which prints out a table).

              Sometimes on the site github you will find python notebooks. These are a bit hard to figure out at first, but can be run by punching in the inputs into a new notebook, after visualizing the notebook using something called nbviewer. This program is available at http://nbviewer.ipython.org/ and can be used by pasting in the URL of the github python notebook nbviewer will render the file into a comprehensible format for you, and enable you a chance to experiment with it.

              Additional guides and links to Astronomy and Python are below:

              Marla Geha gave a wonderful short course at Yale-NUS on doing image processing in Astronomy with Python. Below are links to Marla’s Yale-NUS Python exercises: http://www.astro.yale.edu/mgeha/Singapore/problemsets.html

              Marla recommends this source for learning Python:
              http://learnpythonthehardway.org/book/

              Guide from ipython describing the “notebook” – a very useful tool for visualizing code in Python: http://ipython.org/ipython-doc/dev/notebook/index.html

              A basic bouncing ball program for Python – a good starting point: http://python4astronomers.github.com/contest/bounce.html

              You can learn about basic Python tables and plotting in this guide: http://www.astropy.org/astropy-tutorials/plot-catalog.html

              You can learn how to work with Astronomy fits images and make a ‘tricolor’ image in Python out of three monochrome images with this tutorial:http://www.astrobetter.com/making-rgb-images-from-fits-files-with-pythonmatplotlib/

              More Advanced Image Processing Notebooks – including SDSS and PTF data access

              For a more advanced user, we have several GREAT notebooks that work very well to demonstrate image display, photometric analysis, and integration with large databases such as SDSS and PTF. Within these routines are calls to routines in pyraf and to the image display program known as DS9. Below are links to the installation guides and software repositories.

              American Astronomical Society Python code from workshop entitled “Using Python for Astronomical Data Analysis” – This day-long workshop included a fantastic set of notebooks that led us through all aspects of finding sources in images, extracting photometry catalogs etc. The notebooks and installation instructions are below:

              Caltech ZTF/PTF Summer School (a.k.a “boot camp”) in Python and Astronomy notebooks include very detailed notebooks which document the techniques of time-domain astronomy and astrophysics. These notebooks include light curve generation, identification of variable sources within databases, and creation of color-color diagrams.

              Main Site for 2016 Summer School with notebooks and code – https://sites.google.com/site/pythonbootcamp/

              Additional Add-on Python Packages

              The standard Python distribution from Anaconda has numpy (the numerical package) but may lack some of the other packages you will need for working with astronomy data in Python. These packages include astropy – the astronomy python package pyfits – a package for handling FITS formatted astronomy images and ephem – an ephemeris package for Python. To install these packages, you will download a big file with an ending like .tar.gz, and move it to the part in your anaconda distribution where packages are stored. This is a directory just below your main directory “anaconda” called anaconda/pkgs. Store the .tar.gz file in this directory anaconda/pkgs, and then unpack it using the commands gunzip and tar. You can “gunzip” the files with a command like gunzip file.tar.gz, and unpack them using a command like tar -xvf file.tar. This will separate all the files you will need. Then change into the directory for the package (for pyfits, I have a directory called pkgs/pyfits-3.3), and once in that directory you can install the package with the command ipython setup.py install.

              Main package download sites are at these locations:

              Pyfits – http://www.stsci.edu/institute/software_hardware/pyfits – note: many features of this package are now in Astropy.

              Orbital Elements and Ephemeris Data

              For solar system work, one of the first steps is computing the ephemeris data for an object. This can be done using JPL’s Horizons Database, perhaps the best site for this with absolutely accurate data. You can access that database on the web at the site: http://ssd.jpl.nasa.gov/?horizons or http://ssd.jpl.nasa.gov/horizons.cgi. You can also see a very complete guides to orbits at the site http://www.braeunig.us/space/orbmech.htm and some interesting simulations at http://physics.info/orbital-mechanics-1/practice.shtml .

              Many planetarium programs enable asteroids, spacecraft and comets to be simulated in their orbits. A few of the most common ones are listed below:

              • Sky Safari: http://www.southernstars.com/products/skysafari/ – a good iOS system
              • Stellarium: http://www.stellarium.org – free open source planetarium program
              • TheSky: http://www.bisque.com/sc/pages/TheSkyX-Editions.aspx – industry-grade telescope control and planetarium simulator
              • Celestia: http://www.shatters.net/celestia/download.html – free open source with beautiful 3D renderings of planets

              An astronomical object is specified by its orbital elements. Those can be found at the JPL Horizons site at http://ssd.jpl.nasa.gov/?sb_elem. Each astronomical object can be completely specified by a set of orbital elements. Those are described below in brief. More details can be found on the web site linked above.

              VERY COOL Sites with a LOT of interesting stuff .

              For anyone who has read this far, and would like to really push the envelope, I have found a number of sites with what look like amazing resources for asteroid, and outer solar system work. I would be very excited to see students work with these sites and help get their various databases and Python notebooks working. They include vast databases of near earth asteroids, amazing solar system orbit simulators and much more!

              https://github.com/mwcraig – Matthew Craig’s github repository – highly recommended by experts at the AAS meeting!

              https://media.readthedocs.org/pdf/specviz/v0.1.2rc3/specviz.pdf – documentation for a spectral viewing package from STScI known as Specviz

              nolan/astorb.html – a cool database of asteroid orbital elements

              http://docs.astropy.org/en/v0.3/coordinates/ – nice document for working in astropy with coordinates.

              http://www.jzuhone.com/pages/scientific-education.html – an interesting site for an interactive Kepler’s Law demonstration. Again can be modified for some more advanced purposes.

              http://www.inference.phy.cam.ac.uk/mackay/python/ – a compendium of python programs including some simulations for astronomy.

              http://www.inference.eng.cam.ac.uk/teaching/comput/C++/python/index.shtml – a nice example of orbit simulation with a very simple program and the package vpython. Works!

              seb/celestia/transforming_ephemeris.html – guide for importing ephemeris data into the Celestia program.

              Orbital Elements Information — From the NASA horizons site:

              Orbital elements below are available as fixed-format ASCII tables. Asteroid elements are available as Keplerian elements while comet elements use perihelion distance and time of perihelion passage instead of semimajor axis and mean anomaly. See the table column headings description below. Magnitude parameters, H and G, are included in the asteroid tables. If you need other parameters, you should use the small-body search engine , mentioned above.

              (The files above were updated on 2015-Feb-11 02:32 -0800.)

              Sample Asteroid File Header for an Orbital Elements File

              Num Name Epoch a e i w Node M H G Ref

              1 Ceres 55400 2.7653485 0.07913825 10.58682 72.58981 80.39320 113.4104434 3.34 0.12 JPL 30

              2 Pallas 55400 2.7721532 0.23099956 34.84090 310.15094 173.12950 96.1482660 4.13 0.11 JPL 25

              3 Juno 55400 2.6700912 0.25498122 12.98211 248.10807 169.91138 32.0960832 5.33 0.32 JPL 86

              Sample Comet File Header for an Orbital Elements File

              Num Name Epoch q e i w Node Tp Ref

              1P/Halley 49400 0.58597811 0.96714291 162.26269 111.33249 58.42008 19860205.89532 JPL J863/77

              2P/Encke 55460 0.33586872 0.84833156 11.78308 186.54970 334.56582 20100806.50196 JPL K105/1

              3D/Biela -9480 0.87907300 0.75129900 13.21640 221.65880 250.66900 18321126.61520 IAUCAT03

              ASCII File Column Headings

              Number assigned to the asteroid or comet. Numbers are only assigned to secure short-period (<200 year) comets.

              Name given to the numbered asteroid or comet.

              Unnumbered asteroid’s preliminary designation.

              Epoch of the elements represented as the Modified Julian Date (MJD), which is defined as the Julian date – 2400000.5.


              1. Computig the Mean and Median Stacks from a set of noisy FITS files

              In this assignment, we shall focuss on calculating the moyenne of a stack of FITS files. Each individual file may or may not have a detected a pulsar, but in the final stack we should be able to see a clear detection.

              Computig the Mean FITS

              The following figure shows 5 noisy FITS files, which will be used to compute the mean FITS file.

              The following figure shows the mean FITS file computed from thes above FITS files. Mean being an algebraic measure, it’s possible to compute running mean by loadig each file at a time in the memory.

              Computing the Median FITS

              Now let’s look at a different statistical measure — the median, which in many cases is considered to be a better measure than the mean due to its robustness to outliers. The median can be a more robust measure of the average trend of datasets than the mean, as the latter is easily skewed by outliers.

              However, a naïve implementation of the median algorithm can be very inefficient when dealing with large datasets. Median, being a holistic measure, required all the datasets to be loaded in memory for exact computation, when implemeted i a naive manner.

              Calculating the median requires all the data to be in memory at once. This is an issue in typical astrophysics calculations, which may use hundreds of thousands of FITS files. Even with a machine with lots of RAM, it’s not going to be possible to find the median of more than a few tens of thousands of images.This isn’t an issue for calculating the mean, since the sum only requires one image to be added at a time.

              Computing the approximate runing median: the BinApprox Algorithm

              If there were a way to calculate a “running median” we could save space by only having one image loaded at a time. Unfortunately, there’s no way to do an exact running median, but there are ways to do it approximately.

              le binapprox algorithm does just this. The idea behind it is to find the median from the data’s histogram.

              First of all it ca be proved that media always lies within one standard deviation of the mean, as show below:

              The algorithm to find the running approximate median is show below:

              As soon as the relevant bin is updated the data point being binned can be removed from memory. So if we’re finding the median of a bunch of FITS files we only need to have one loaded at any time. (The mean and standard deviation can both be calculated from running sums so that still applies to the first step).

              The downside of using binapprox is that we only get an answer accurate to σ/ B by using B bins. Scientific data comes with its own uncertainties though, so as long as you keep large enough this isn’t necessarily a problem.

              The following figure shows the histogram of 1 million data points generated randomly. Now, the binapprox algorithm will be used to compute the running median and the error in approximation will be computed with different number of bins B.

              As can be seen from above, as the number of bins B increases, the error dans
              approximation of the running median decreases.

              Now we can use the binapprox algorithm to efficiently estimate the median of each pixel from a set of astronomy images in FITS files. The following figure shows 10 noisy FITS files, which will be used to compute the median FITS file.

              The following figure shows the median FITS file computed from the above FITS files using the binapprox algorithm.


              Astronomy 1221 - Astronomy Data Analysis

              Astronomy 1221, Astronomy Data Analysis, is a one-semester overview of data analysis in astronomy. The course will cover select topics in modern astronomy, combined with contemporary data analysis methods, illustrate how these data lead to scientific conclusions, and the limitations of data. The intended audience for the course is students with an interest in astronomy and the analysis of large datasets. The course will use the Python programming language. No prior knowledge of astronomy or Python is necessary.

              Course Objectives

              By the end of this course, students should successfully be able to:

              • Understand the basic facts, principles, theories, and methods of modern science.
              • Understand key events in the development of science and recognize that science is an evolving body of knowledge.
              • Describe the interdependence of scientific and technological developments.
              • Recognize the social and philosophical implications of scientific discoveries and understand the potential of science and technology to address problems of the contemporary world.

              Astronomy 1221 will meet these expected outcomes by combining an overview of modern astronomy with the data and analysis methods used to draw these conclusions. Example astronomy topics include the solar system, stars, exoplanets, the Milky Way, galaxies, dark matter, and cosmology. These will be taught alongside analysis topics such as basic statistical methods, time series analysis, databases, classification methods, and machine learning.

              Among the questions that you should be able to answer by the end of the course are the following:

              • What objects make up our solar system?
              • What are stars? How are they distributed in our Galaxy?
              • What do we know about planets around other stars?
              • How do we know that Dark Matter exists?
              • What methods do astronomers use to study celestial objects?
              • What are Dark Matter and Dark Energy?

              Course Organization

              This is a 3 credit hour course each week, there will be 3 hours of lecture with occasional take-home assignments designed to explore some of the course topics in greater depth. For Arts and Sciences students in a Bachelor of Arts or Bachelor of Science program, this course meets the Arts and Sciences GE requirement of a natural sciences course without a laboratory component.

              Course Catalog Description

              Overview of data analysis in astronomy. The course will combine select topics in modern astronomy with contemporary data analysis methods implemented in the Python programming language, illustrating how astronomical data lead to scientific conclusions. It is intended for students with interest in astronomy and analysis of large data sets prior astronomy experience not required.


              An Introduction to Image Processing with Python

              In order to gain a deeper understanding of how astronomical images are processed, we will be writing our own software to do the processing. To minimize the effort in doing this, we will use the computer language Python. Python is an interactive and extensible programming language. It has extensions to load images from FITS files, process images using compact code without loops, and display images on the screen. During this week's lab, you will become familiar with the basics of python and some of the particulars about handling images in python.

              Python is free software. So, if you want to work on learning python outside of class, you can obtain it via the links on the class web page. Note that we will use Python 2.7 and not Python 3 (this is because matplotlib only recently added Python 3 support). We will use a number of python packages to process images (as numerical arrays), read FITS files, and display data. Anaconda includes python and the other needed packages. If you use straight python (e.g. under Linux), you will need to install these packages separately (which is very easy for distributions like Ubuntu). As a reminder, when we start using telescopes on the roof and elsewhere for astronomical observations and measurements, each lab team will need to have the software installed on a laptop computer. It would be good to identify a (windows) laptop in the next few days, install the software, and try it out.

              First example program - reading and plotting an image

              To get started with python, let's look at a simple program to read in an image in FITS format and plot it on the screen. The program is here: showimage.py. You should download the program and then load it into a text editor of your choice.

              The first line is a comment about what the program does. It is good practice to liberally comment your code.

              The second set of lines (3-7) tells python that we will be using a bunch of extensions. Extensions are pre-written modules to do various tasks. numpy, or 'Numerical Python' is a package to define mathematical constructions like matrices (or arrays) and make it easy to handle them in python. matplotlib is a scientific plotting package. pyfits is a package to read and write FITS files.

              The first thing that we actually do in the program is on line 12, where we read in a FITS file. The program currently reads in a file called 'testpattern1.fit'. You should edit this line to read in one of the files that you made in the last lab. Note if you are running python in the same directory as your data, you need only the file name. Otherwise, you will need to add the file's directory.

              On line 15, we copy the image data from the FITS file to a variable called img1. img1 is actually a numpy array and later on we'll discuss how to do math operations on numpy arrays (it's easy).

              The next set of lines, 18-21, plot the image. Back in the import stuff, we imported the plotting package "as plt". This allows us to use the shorthand "plt" to refer to the plotting package. All four lines call routines in the matplotlib.pyplot package using plt as shorthand. The first line sets the plotting to interactive mode this just means that the program continues on after making the plot rather than waiting for the user to look at the plot before continuing. The second line sets up the color map. Since the camera is black and white, we use a gray scale map to make realistic looking images. The third line uses the "imshow" routine to make a plot of the image data using the selected color map. The four line actually puts the plot up on the screen.

              Once you have edited the program to read in your file (edit line 12, see above), go ahead and run the program. Start up ipython. ipython is an interactive, shell interface to python that uses unix-like commands. To setup Anaconda python for the plotting interface that we use, type '%pylab' without the quotes. You will want to do this every time you start ipython or the program will freeze when you make plots. If you are not running Anaconda, this command probably isn't necessary. Some useful commands are: 'ls' - to list the contents of the current directory, 'cd' - to change the current directory, and 'pwd' - to print the current directory. Use cd to move to the directory where showimage.py is and type 'run showimage' without the quotes and press Enter. ipython should pop up a displaying the image. Note that the window is interactive: one can zoom, pan, or save the image in a variety of formats. If you have problems running the program, make sure that you are in the right directory and that you have edited the program to look for the FITS file in the correct place. Make sure the program works before proceeding. Record in your lab notebook, the procedures that you followed to display the image including the directories where showimage.py and your image are saved. Remember to start on a new page and write today's date and a short description of today's activities (like 'Intro to Python') at the top of the page.

              FITS files

              After you have run the program, it should leave you at the ipython command prompt. Now type 'print h[0].header'. The ipython screen will be filled with a bunch of information encoded in the file. FITS is a "self-documenting" file format. In addition to the image data, the file contains 'meta-data' describing the image parameters and how and when the image was obtained. These were written by CCDOps when you saved the file in the last lab. The meta-data consists of a keyword name, a value, and an optional comment.

              For example, the NAXIS keyword gives the number of axes, it should be 2. The NAXIS1 and NAXIS2 keywords give the number of pixels along the two axes of the image. Record these in your lab notebook. If you saved a full image (as instructed in the last lab), these should match the number of pixels in the CCD. Check the CCD documentation to see if that is true and record in your notebook. The CCD-TEMP keyword records the CCD temperature when the image was obtained. Record that in your notebook and note the units. Check the TELESCOP keyword, it should contain what you wrote for 'Telescope Description'. Write in your notebook if TELESCOP agrees with FOCALLEN and what you wrote in your notebook about the lens used for the image. As long as you pay attention while taking the data, the meta-data in FITS files provides a nice way to check that you are working with the correct data files.

              Second example program - difference image

              Now download diffimage.py and load it into your editor. Modify lines 12 and 13 to read in the two images of the test pattern that you took in the first lab. This programs reads in two images, extracts the image data, calculates a new array which is the difference in the two images, and then plots all three images. The difference image is calculated on line 33. Note how simply the code is. The other new element in the code is the use of plt.figure(#) to pop-up multiple windows on the screen. Note that only one plt.show() is needed to display all three images.

              Take a look at your three images. If the two images that you took with the CCD were under exactly identical conditions, then the test pattern should disappear in the difference image. Did this happen? Write down your conclusions and also any thoughts about how to improve the subtraction in your notebook. Also, can you think of some astronomical application for difference imaging?

              Third example program - image histogram

              Now we'll use python to calculate some statistics and plot a histogram of the pixel values in our images. Get histimage.py. The first parts should be familiar. Edit the line that reads the FITS file to use your image file. The new stuff starts at line 26. The numpy/matplotlib routines to make histograms and calculate statistics need to have one-dimensional arrays as input. In line 26, we find the size of the 2-d array img. the img.shape routine returns two values in a 'tuple'. Python tuples are sets of values separated by commas and sometime enclosed in parenthesis. In line 26, nx gets set to the first value in the tuple and ny gets set to the second value. In line 27, we make a new (1-d) array imgh. It has the same values as the 2-d image array img, but arranged like ducks in a row.

              Following this are a few lines to calculate statistics of the image values. min, max, and mean should be self explanatory. std gives the standard deviation of a set of data. The standard deviation is a measure of the fluctuations of the data around the average value. It is the square root of the average of the squared deviations from the mean, i.e., std = sqrt(mean((x-mean(x))**2)), where ** is Python's operator for raising a number to a power. Record the statistics of the pixel values of your image.

              Then, we plot the histogram. A histogram is a graphical representation of the distribution of a set of values. In this case, the values are the intensity readings from the CCD for each pixel. If you arrange these in a 2-d array, you get an image. A histogram discards the spatial information and only shows the distribution of the values themselves, in particular the frequency with which each value (or range of values) occurs. The matplotlib routine hist plots histograms. The first argument is a 1-d of values, the other arguments set the plot parameters. The most crucial of these is 'bins' which sets the number of bins in the histogram. By default, the bins will evenly spaced between the lowest and highest input values.

              In calculating the statistics of a data set, one often prefers to discard outlier, e.g. pixels that have high values because they are saturated or 'hot' or pixels that have low values because they are damaged. Examine the histogram of your pixel values. Are there outliers? In lines 41-44, we set an allowed range for 'good' pixels values (between plow and phi) and then make a new array, imghcut, keeping only the values in that range. Adjust the values for plow and phi according to your histogram and record them. Note that the current coordinates of the mouse cursor are displayed in the plot window when you move the mouse over the plot. Then, run histimage.py again and record the statistics of the pixel values of your image when keeping only the 'good' pixels.

              Now try Python for yourself

              Spend the rest of the lab learning python. We will be using python throughout the semester, so it is a good investment of your time. A good way to do this is to set yourself a goal and then try to write the needed code. For example, you could add some lines to the histogram plotting program that overplot the mean value on the histogram. After getting that to work, you might try also plotting the mean the standard deviation (maybe with dashed lines). That will give you a nice graphical illustration of how the standard deviation is a measure of the fluctuations of the data around the average value. Later on, we will use the median (the value such that half the data lies above and half lies below) in addition to the mean. Try calculating the median and plotting it and see how it compares to the mean. In the next lab, you will need to make plots of values. You might try making an array of the integers from 1 to 10, finding their squares, and then plotting the square versus the value.


              GeoProjection for astronomical data - wrong ticks

              Here is an excellent answer to what I wanted to do, and it works like a charm. Unfortunately, when I want to change it a bit, it fails. For setting the stage, here is the datafile, and this is my initialization code:

              Then I use the following code to produce a projection of the points onto the sky:

              which produces the following image:

              Looks perfect. Next, I simply changed Sinusoidal to Mollweide in the above code, and got the following image:

              This, contrary to the previous case, places the ticks in wrong places: they do not correspond anymore to the dashed grid lines on the projection.

              So, my question is: how to fix this so the ticks are at the right places?

              ÉDITER: Inspired by this post I found out that the Hammer projection suffers the same issue as the Mollweide projection, but Aitoff (very similar to Hammer ) works as fine as the Sinusoidal projection.



Commentaires:

  1. Kagagrel

    pas de mots! juste wow! ..

  2. Darcy

    Je pense que rien de grave.

  3. Evin

    Je pense que vous vous trompez.

  4. Randkin

    Je considère que vous commettez une erreur. Discutons-en.

  5. Stearc

    Quels mots ... super, une magnifique phrase



Écrire un message