astropy
Paket zur Analyse astronomischer Daten. Ursprünglich als separates Paket entwickelt, wurde es um 2012 integriert. Eindruck, dass die der astronomischen Analyse eigentümliche Verarbeitung hauptsächlich vom Umgang mit Daten bis zum Betrieb des Einheitensystems und des Koordinatensystems reicht (das Paket ist zu groß und ich weiß nicht alles).
astropy.io.fits
Ein Modul, das FITS-Dateien liest und schreibt. Vollständige Migration von pyfits (keine weitere Verwendung von pyfits wird empfohlen). Die FITS-Datei ist ein Dateiformat mit einem hohen Freiheitsgrad, das zum Speichern astronomischer Daten erstellt wurde. Normalerweise werden 2D- oder 3D-Bilddaten mit Koordinateninformationen gespeichert, aber jede Datenstruktur kann als Tabelle gespeichert werden. Einzelheiten zu FITS-Dateien finden Sie im "FITS-Benutzerhandbuch".
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
#Überprüfen Sie die Header-Informationen
print(repr(header))
naxis = header['NAXIS'] #Kann wie ein Wörterbuch behandelt werden
naxis1 = header.get('NAXIS1')
#Überprüfen Sie die Datenstruktur
type(data)
>>> numpy.ndarray
data.ndim
>>> 2
data.shape
>>> (480, 720)
astropy.wcs
WCS (World Coordinate System) ist eine Spezifikation, die beschreibt, wie die in FITS aufgezeichneten Daten den Koordinaten auf der Himmelskugel entsprechen. Weitere Informationen finden Sie unter http://fits.gsfc.nasa.gov/fits_wcs.html. Der Indexwert wird basierend auf Informationen wie dem Referenzindex (CRPIX) der Daten, dem physischen Koordinatenwert (CRVAL) des Referenzindex, dem physischen Koordinatenkorrespondenzwert (CDELT) des Datengitters und der Projektionsmethode (CTYPE) auf dem Wolkenkratzer berechnet. In physikalische Koordinatenwerte konvertieren.
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)
>>> ... #Informationen werden ausgegeben
wcs.wcs_world2pix([[210, -19]], 0) # (l=210, b=-19)Index von abrufen
>>> array([[ 359.00009815, 120.00221429]])
wcs.wcs_pix2world([[150, 60]], 0) # (x=150, y=60)Holen Sie sich die physikalischen Koordinaten von
>>> array([[ 213.48334194, -20.0000389 ]])
astropy.coordinates Ein Modul, das das Koordinatensystem des Himmels konvertieren und berechnen kann (rote Meridian- und rote Breitengradkoordinaten, Tenkawa-Galaxienkoordinaten usw.).
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_Die Reihenfolge der von pix2world benötigten Indexachsen ist x, y(, z)
# fits[0].Die Reihenfolge der Datenachsen ist(z,) y, x
#Die beiden Richtungen sind entgegengesetzt, also maxind[::-1]Umgekehrt mit
galx, galy = maxworld[0]
# >>> (208.99999963578261, -19.383371004831144)
#Erstellt mit galaktischen Koordinaten
coord = astropy.coordinates.SkyCoord(galx, galy, frame='galactic', unit='deg')
# >>> <SkyCoord (Galactic): (l, b) in deg
# (208.99999964, -19.383371)>
#Überprüfen Sie die Konstellation
coord.get_constellation()
>>> u'Orion'
#Roter Sutra roter Schuss(epoch=J2000)Ausgabe mit
coord.fk5
>>> <SkyCoord (FK5: equinox=J2000.000): (ra, dec) in deg
(83.81461251, -5.38035224)>
#Formatieren und Ausgeben von rotem und rotem Schuss
coord.fk5.to_string('hmsdms')
>>> u'05h35m15.507s -05d22m49.268s'
astropy.units Ein Modul, das Einheiten behandelt, die in astronomischen Bereichen verwendet werden.
ipython
import astropy.units
# 1: 5km/Berechnen wir die Zeit, die der molekulare Wolkenkern benötigt, um sich mit s um 5pc zu bewegen
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/Massenakkretionsrate von Jahr, kg/Versuchen Sie zu sek
(1e-6 * astropy.units.solMass / astropy.units.year).to('kg/second')
>>> <Quantity 6.303077547088497e+16 kg / s>
APLpy
FITS-Datenvisualisierungspaket. Es können hochwertige Bilder ausgegeben werden, die zum Veröffentlichen von Papieren verwendet werden können.
ipython
import matplotlib.pyplot
import astropy.io.fits
import aplpy
#Beim Herunterladen von FITS-Dateien aus dem Internet
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)
#Wenn die FITS-Datei lokal gespeichert ist
# fig = aplpy.FITSFigure('Orion.CO1221.Osaka.beam204.mom0.fits.gz')
fig.show_colorscale()
fig.add_colorbar()
# fig.save('Orion.CO1221.Osaka.beam204.mom0.png') #Beim Speichern eines Bildes
matplotlib.pyplot.show()
numpy
Ein Modul, das die Datenstruktur und Operationen bereitstellt, die die Grundlage für numerische Berechnungen bilden.
numpy.sum, .nansum Berechnen Sie den Gesamtwert von numpy.ndarray oder list. Durch Angabe des Achsenarguments können Sie die zu integrierende Achse angeben.
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')
#Unbeobachteter Bereich(voxel)Enthält oft Nan, also benutze Nansum
numpy.nansum(fits[0].data)
>>> 1630958.2 #Die Einheit ist K km/s pix^2
#3D-Daten(cube)Aus 2D-Daten(Integrierte Stärke)Wird auch beim Ausstellen verwendet
# !!!!Kapazitätshinweis herunterladen(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) #Z-Achse(Geschwindigkeit),y-Achse(Seite),x-Achse(Vertikal)
mom0 = numpy.nansum(fits[0].data, axis=0) #Summiere die 0 Achsen
mom0.shape
>>> (480, 720)
numpy.min, .max, .nanmin, .nanmax Holen Sie sich das Minimum und Maximum von numpy.ndarray oder Liste.
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 Ruft den Index ab, der die minimalen und maximalen Werte von numpy.ndarray oder list enthält.
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 Erstellen Sie ein zweidimensionales Array mit zwei eindimensionalen Arrays. Verwenden Sie diese Option, wenn Sie eine Karte mit Koordinateninformationen wünschen.
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)
#Für 3D-Daten(Da meshgrid nicht verwendet werden kann, gehen Sie wie folgt vor)
# !!!!Kapazitätshinweis herunterladen(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 statt None.Newaxis kann ebenfalls verwendet werden(Wird das empfohlen?)
numpy.polyfit, .polyval
Anpassung in Polypolyse und eine Funktion, die eine Kurve aus Anpassungsparametern wiederherstellt.
scipy
scipy.signal.convolve scipy.ndimage.map_coordinates scipy.interpolate.interp1d
matplotlib ... (soll hinzugefügt werden) ...
http://www.astro.s.osakafu-u.ac.jp/~nishimura/Orion/
Recommended Posts