astropy
Package d'analyse de données astronomiques. Développé à l'origine en tant que package séparé, il a été intégré vers 2012. Impression que le traitement propre à l'analyse astronomique est principalement couvert de la manipulation des données au fonctionnement du système d'unité et du système de coordonnées (le paquet est trop volumineux et je ne sais pas tout).
astropy.io.fits
Un module qui lit et écrit les fichiers FITS. Migration complète depuis pyfits (aucune utilisation supplémentaire de pyfits n'est recommandée). Le fichier FITS est un format de fichier avec un haut degré de liberté, créé dans le but de stocker des données astronomiques. Normalement, les données d'image 2D ou 3D sont enregistrées avec des informations de coordonnées, mais toute structure de données peut être enregistrée sous forme de tableau. Pour plus de détails sur les fichiers FITS, reportez-vous au "Guide de l'utilisateur FITS".
ipython
import astropy.io.fits
fits = astropy.io.fits.open('http://www.astro.s.osakafu-u.ac.jp/~nishimura/Orion/data/Orion.CO1221.Osaka.beam204.mom0.fits.gz')
hdu = fits[0]
header = hdu.header
data = hdu.data
#Vérifiez les informations d'en-tête
print(repr(header))
naxis = header['NAXIS'] #Peut être traité comme un dictionnaire
naxis1 = header.get('NAXIS1')
#Vérifiez la structure des données
type(data)
>>> numpy.ndarray
data.ndim
>>> 2
data.shape
>>> (480, 720)
astropy.wcs
WCS (World Coordinate System) est une spécification qui décrit comment les données enregistrées dans FITS correspondent aux coordonnées sur la sphère céleste. Pour plus d'informations, voir http://fits.gsfc.nasa.gov/fits_wcs.html. La valeur d'index est calculée sur la base d'informations telles que l'indice de référence (CRPIX) des données, la valeur de coordonnées physiques (CRVAL) de l'index de référence, la valeur de correspondance des coordonnées physiques (CDELT) de la grille de données et la méthode de projection (CTYPE) sur le gratte-ciel. Conversion en valeurs de coordonnées physiques.
ipython
import astropy.wcs
import astropy.io.fits
fits = astropy.io.fits.open('http://www.astro.s.osakafu-u.ac.jp/~nishimura/Orion/data/Orion.CO1221.Osaka.beam204.mom0.fits.gz')
wcs = astropy.wcs.WCS(fits[0].header)
print(wcs)
>>> ... #L'information est sortie
wcs.wcs_world2pix([[210, -19]], 0) # (l=210, b=-19)Obtenir l'index de
>>> array([[ 359.00009815, 120.00221429]])
wcs.wcs_pix2world([[150, 60]], 0) # (x=150, y=60)Obtenez les coordonnées physiques de
>>> array([[ 213.48334194, -20.0000389 ]])
astropy.coordinates Un module capable de convertir et de calculer le système de coordonnées du ciel (méridien rouge et coordonnées de latitude rouge, coordonnées de la galaxie Tenkawa, etc.).
ipython
import numpy
import astropy.coordinates
import astropy.wcs
import astropy.io.fits
fits = astropy.io.fits.open('http://www.astro.s.osakafu-u.ac.jp/~nishimura/Orion/data/Orion.CO1221.Osaka.beam204.mom0.fits.gz')
header = fits[0].header
data = fits[0].data
maxind = numpy.unravel_index(numpy.nanargmax(data), data.shape)
wcs = astropy.wcs.WCS(fits[0].header)
maxworld = wcs.wcs_pix2world([maxind[::-1]], 0)
# wcs_L'ordre des axes d'index requis par pix2world est x, y(, z)
# fits[0].L'ordre des axes de données est(z,) y, x
#Les deux directions sont opposées, donc maxind[::-1]Inversé avec
galx, galy = maxworld[0]
# >>> (208.99999963578261, -19.383371004831144)
#Créé avec des coordonnées galactiques
coord = astropy.coordinates.SkyCoord(galx, galy, frame='galactic', unit='deg')
# >>> <SkyCoord (Galactic): (l, b) in deg
# (208.99999964, -19.383371)>
#Vérifiez la constellation
coord.get_constellation()
>>> u'Orion'
#Trame rouge sutra rouge(epoch=J2000)Sortie avec
coord.fk5
>>> <SkyCoord (FK5: equinox=J2000.000): (ra, dec) in deg
(83.81461251, -5.38035224)>
#Format et sortie trame rouge et rouge
coord.fk5.to_string('hmsdms')
>>> u'05h35m15.507s -05d22m49.268s'
astropy.units Un module qui gère les unités utilisées dans les domaines astronomiques.
ipython
import astropy.units
# 1: 5km/Calculons le temps qu'il faut au noyau du nuage moléculaire se déplaçant avec s pour se déplacer de 5 pc
v = 5 * astropy.units.kilometer / astropy.units.second
# >>> <Quantity 5.0 km / s>
d = 5 * astropy.units.pc
# >>> <Quantity 5.0 pc>
(d/v).to('megayear')
>>> <Quantity 0.9777922216731284 Myr>
# 2: 10^-6 Mo/Taux d'accrétion de masse par an, kg/Essayez de sec
(1e-6 * astropy.units.solMass / astropy.units.year).to('kg/second')
>>> <Quantity 6.303077547088497e+16 kg / s>
APLpy
Package de visualisation de données FITS. Il peut produire des images de qualité pouvant être utilisées pour publier des articles.
ipython
import matplotlib.pyplot
import astropy.io.fits
import aplpy
#Lors du téléchargement de fichiers FITS à partir du Web
fits = astropy.io.fits.open('http://www.astro.s.osakafu-u.ac.jp/~nishimura/Orion/data/Orion.CO1221.Osaka.beam204.mom0.fits.gz')
fig = aplpy.FITSFigure(fits)
#Si le fichier FITS est stocké localement
# fig = aplpy.FITSFigure('Orion.CO1221.Osaka.beam204.mom0.fits.gz')
fig.show_colorscale()
fig.add_colorbar()
# fig.save('Orion.CO1221.Osaka.beam204.mom0.png') #Lors de l'enregistrement d'une image
matplotlib.pyplot.show()
numpy
Un module qui fournit la structure de données et les opérations qui forment la base des calculs numériques.
numpy.sum, .nansum Calculez la valeur totale de numpy.ndarray ou list. En spécifiant l'argument axe, vous pouvez spécifier l'axe à intégrer.
ipython
import numpy
import astropy.io.fits
fits = astropy.io.fits.open('http://www.astro.s.osakafu-u.ac.jp/~nishimura/Orion/data/Orion.CO1221.Osaka.beam204.mom0.fits.gz')
#Zone non observée(voxel)Contient souvent nan, alors utilisez nansum
numpy.nansum(fits[0].data)
>>> 1630958.2 #L'unité est K km/s pix^2
#Données 3D(cube)À partir de données 2D(Force intégrée)Également utilisé lors de l'émission
# !!!!Télécharger la note de capacité(1.8GB) !!!!
# fits = astropy.io.fits.open('http://www.astro.s.osakafu-u.ac.jp/~nishimura/Orion/data/Orion.CO1221.Osaka.beam204.cube.fits.gz')
fits = astropy.io.fits.open('Orion.CO1221.Osaka.beam204.cube.fits.gz')
fits[0].data.shape
>>> (2521, 480, 720) #Axe z(la vitesse),axe y(côté),axe x(Verticale)
mom0 = numpy.nansum(fits[0].data, axis=0) #Additionner les 0 axes
mom0.shape
>>> (480, 720)
numpy.min, .max, .nanmin, .nanmax Obtenez le minimum et le maximum de numpy.ndarray ou list.
ipython
import numpy
import astropy.io.fits
fits = astropy.io.fits.open('http://www.astro.s.osakafu-u.ac.jp/~nishimura/Orion/data/Orion.CO1221.Osaka.beam204.mom0.fits.gz')
numpy.nanmin(fits[0].data)
>>> -0.61183316 # K km/s
numpy.nanmax(fits[0].data)
>>> 431.83881 # K km/s
numpy.argmin, .argmax, .nanargmin, .nanargmax Obtenez l'index contenant les valeurs minimum et maximum de numpy.ndarray ou list.
ipython
import numpy
import astropy.io.fits
fits = astropy.io.fits.open('http://www.astro.s.osakafu-u.ac.jp/~nishimura/Orion/data/Orion.CO1221.Osaka.beam204.mom0.fits.gz')
data = fits[0].data
maxind = numpy.nanargmax(data)
# >>> 70259
maxcoord = numpy.unravel_index(maxind, data.shape)
# >>> (97, 419)
data[maxcoord] == numpy.nanmax(data)
>>> True
numpy.meshgrid Créez un tableau à deux dimensions à l'aide de deux tableaux à une dimension. À utiliser lorsque vous souhaitez une carte d'informations de coordonnées.
ipython
import numpy
import astropy.io.fits
fits = astropy.io.fits.open('http://www.astro.s.osakafu-u.ac.jp/~nishimura/Orion/data/Orion.CO1221.Osaka.beam204.mom0.fits.gz')
def get_axis(header, axis=1):
crval = header.get('CRVAL%1d'%(axis))
crpix = header.get('CRPIX%1d'%(axis))
cdelt = header.get('CDELT%1d'%(axis))
num = header.get('NAXIS%1d'%(axis))
return crval + (numpy.arange(num) - crpix + 1) * cdelt
x1d = get_axis(fits[0].header, 1)
y1d = get_axis(fits[0].header, 2)
X2d, Y2d = numpy.meshgrid(x1d, y1d)
X2d.shape
>>> (480, 720)
#Pour les données 3D(Comme meshgrid ne peut pas être utilisé, procédez comme suit)
# !!!!Télécharger la note de capacité(1.8GB) !!!!
# fits_cube = astropy.io.fits.open('http://www.astro.s.osakafu-u.ac.jp/~nishimura/Orion/data/Orion.CO1221.Osaka.beam204.cube.fits.gz')
fits_cube = astropy.io.fits.open('Orion.CO1221.Osaka.beam204.cube.fits.gz')
x1d_ = get_axis(fits_cube[0].header, 1)
y1d_ = get_axis(fits_cube[0].header, 2)
v1d_ = get_axis(fits_cube[0].header, 3)
X3d = x1d_[None, None, :]*1 + y1d_[None, :, None]*0 + v1d_[:, None, None]*0
Y3d = x1d_[None, None, :]*0 + y1d_[None, :, None]*1 + v1d_[:, None, None]*0
V3d = x1d_[None, None, :]*0 + y1d_[None, :, None]*0 + v1d_[:, None, None]*1
X3d.shape
>>> (2521, 480, 720)
#Numpy au lieu de None.newaxis peut également être utilisé(Est-ce recommandé?)
numpy.polyfit, .polyval
Ajustement en polypoly et fonction qui restaure une courbe à partir des paramètres d'ajustement.
scipy
scipy.signal.convolve scipy.ndimage.map_coordinates scipy.interpolate.interp1d
matplotlib ... (ajout prévu) ...
http://www.astro.s.osakafu-u.ac.jp/~nishimura/Orion/