Astronomi

Plotta astronomiska data med hjälp av Python

Plotta astronomiska data med hjälp av 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.

Jag har försökt skapa en graf som visar avstånden mellan stjärnorna och jorden, men ändå kunde jag inte få den önskade grafen som visas nedan (klicka för att zooma in): Min graf:

Som @uhoh föreslog överlagrade jag ett diagram ovanpå det andra. Jag ber om ursäkt för att ha lagt upp den här förvirrande grafen

Det kombinerade diagrammet anger att kurvornas positioner i min graf skiljer sig helt från de i det förväntade diagrammet.

Jag följde den här guiden för att beräkna stjärnornas positionsfunktioner.

Min fråga: Gjorde jag några misstag som resulterade i avvikelser?

Tack på förhand.

Kommentarer till koden:

  • Namn - stjärnans namn

  • RA - Höger uppstigning i grader, ICRS-koord. (J2000)

  • Dec - Nedgång i grader, ICRS-koord. (J2000)

  • pm_mRA - Korrekt rörelse i höger uppstigning, i miliersekunder per år

  • pm_mdec - Korrekt rörelse i deklination, i miliersekunder per år

  • vr - radiell hastighet i kilometer per sekund, ett positivt värde betyder att stjärnan rör sig bort från oss

  • mparallax - parallax av stjärnan i miliaresekunder

  • d - avståndet mellan stjärnan och jorden

Min kod:

def parseTextFile (filnamn, avgränsare = ",", header = 0): "" "Analysera en textfil till en lista. Filinnehållet avgränsas och har en rubrik." "" med öppen (filnamn) som f: # Hoppa över rubriken för i inom intervallet (rubrik): nästa (f) data = [] # Analysera filinnehåll för rad i f: # Ta bort den nya linjens char line = line.replace (' n', "). ersätt (' r ', ") # Dela upp raden med avgränsningsraden = line.split (avgränsare) # Ta bort vita mellanslag från enskilda poster i raden för i, post i enumerate (rad): rad [i] = entry.strip () # Lägg till innehållet på raden i datalistan data. Lägg till (rad) returnera data fig = plt.figure () ax = fig.add_subplot () # tidsintervall = np.område (-60000,100000,10) antal = 1 xdic = {} ydic = {} zdic = {} # flera rader med data för stjärna i parseTextFile (filnamn, rubrik = 1): namn = str (stjärna [0]) RA = float (stjärna [1]) Dec = flottör (stjärna [2]) pm_mRA = flottör (stjärna [3]) pm_mDec = flottör (stjärna [4]) vr = flottör (stjärna [5]) mparallax = flottör (stjärna [6]) pm_RA = pm_mRA * 0,001 pm_Dec = pm_mDec * 0,001 d = 1 / (mparallax * 0.001) # Tvärhastigheter vta = pm_RA * d * 4.740 vtd = pm_Dec * d * 4.740 # Linjära hastigheter vx = vr * np.cos (dec) * np.cos (RA) - vta * np.sin (RA) - vtd * np.sin (Dec) * np.cos (RA) vy = vr * np.cos (Dec) * np.sin (RA) + vta * np.cos (RA) - vtd * np. sin (Dec) * np.sin (RA) vz = vr * np.sin (Dec) + vtd * np.cos (Dec) # enhetsomvandling från km / s till pc / år vx_pcyr = vx / 977780 vy_pcyr = vy / 977780 vz_pcyr = vz / 977780 # initialpositioner xi = d * np.cos (dec) * np.cos (RA) yi = d * np.cos (dec) * np.sin (RA) zi = d * np.sin (Dec) #position funktioner x = xi + vx_pcyr * tid y = yi + vy_pcyr * tid z = zi + vz_pcyr * tidsavstånd = np.sqrt (x ** 2 + y ** 2 + z ** 2) ax. plot (tid, avstånd, etikett = namn) ax.set_xlabel ('Time (Year)') ax.set_ylabel ('Distance (pc)') ax.legend () plt.show ()

Jag glömde att ändra enheten för avståndet från parsec till ljusår. Detta är ett enkelt enhetsomvandlingsfel som borde ha undvikits.

Ultimate Graph:

Data som används:

Namn, RA (deg), Dec (deg), pm_RA (mas / år), pm_Dec (mas / år), Vr (km / s), parallax (mas)
Wolf 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
Barnards stjärna, 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,1777994,115,10, -1592,77, -77,715,316,7
Gliese 65,24,756054, -17,950569,3321,562,29,373,70

Koda:

% matplotlib qt importera numpy som np från mpl_toolkits.mplot3d importera axlar3d från matplotlib importera pyplot som plt från matplotlib importlappar def parseTextFile (filnamn, avgränsare = ",", header = 0): "" "Parse en textfil till en lista. Filinnehållet är avgränsat och har en rubrik. "" "Med öppen (filnamn) som f: # Hoppa över rubriken för i inom intervallet (rubrik): nästa (f) data = [] # Analysera filinnehåll för rad i f: # Ta bort den nya raden char line = line.replace (' n', "). Ersätt (' r',") # Dela upp raden med avgränsningsraden = line.split (avgränsare) # Ta bort vita utrymmen från enskilda poster i raden för i, post i enumerate (line): line [i] = entry.strip () # Lägg till radens innehåll i datalistan data. lägg till (line) returnera data om __name__ == "__main__": filnamn = 'C:  Users  The Wings of Dream  Desktop  UWO-PA-Python-Course  Lecture 5  Homework 2  star_data.txt' #Program Börja: fig = plt.figure () ax1 = fig.add_subplot (211, projektion = "3d") ax2 = fig.add_subplot (212) time = np.arange (-600 00,100000,10) count = 1 xdic = {} ydic = {} zdic = {} för stjärna i parseTextFile (filnamn, rubrik = 1): namn = str (stjärna [0]) RA = float (stjärna [1] ) Dec = flottör (stjärna [2]) pm_mRA = flottör (stjärna [3]) pm_mDec = flottör (stjärna [4]) vr = flottör (stjärna [5]) mparallax = flottör (stjärna [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 (Dec) * np.cos (RA) vy = vr * np.cos (Dec) * np.sin (RA) + vta * np.cos (RA) - vtd * np.sin (Dec) * np.sin (RA) vz = vr * np.sin (Dec) + vtd * np.cos (Dec) vx_pcyr = vx / 977780 vy_pcyr = vy / 977780 vz_pcyr = vz / 977780 xi = d * np.cos (Dec) * np.cos (RA) yi = d * np.cos (Dec) * np.sin (RA) zi = d * np.sin (Dec) x = xi + vx_pcyr * tid y = yi + vy_pcyr * tid z = zi + vz_pcyr * tid xdic ['x' + str (antal)] = x ydic ['y' + str (antal)] = y zdic ['z' + str (antal)] = z avstånd = np.sqrt (x ** 2 + y ** 2 + z ** 2) * 3.26156 ax1.plot (xdic ['x' + str (antal)], ydic ['y' + str ( count)], zdic ['z' + str (count)]) ax2.plot (tid, avstånd, 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 = 'grå', linestyle = '-', linewidth = '0.5') # plottningsbegränsningar ax2.set_ylim (0.0, 10.0) ax2.set_xlim (-60000, 100000) ax1.set_xlabel ('x axel') ax1.set_ylabel ('y-axel') ax1.set_zlabel ('z-axel') ax1.title.set_text ('Motion of Stars in Space') ax2.title.set_text ('Distance-Time') ax2.set_xlabel ('Time (Year) ') ax2.set_ylabel (' Distance (Light Year) ') ax2.legend () plt.show ()

ax1-delplan ger dig en 3d-parametrisk plot som visar stjärnornas rörelse.


En introduktion till bildbehandling med Python

För att få en djupare förståelse för hur astronomiska bilder bearbetas kommer vi att skriva vår egen programvara för att göra behandlingen. För att minimera ansträngningen att göra detta kommer vi att använda datorspråket Python. Python är ett interaktivt och utdragbart programmeringsspråk. Den har tillägg för att ladda bilder från FITS-filer, bearbeta bilder med kompakt kod utan öglor och visa bilder på skärmen. Under den här veckans labb kommer du att bekanta dig med grunderna i python och några av uppgifterna om hantering av bilder i python.

Python är fri programvara. Så om du vill arbeta med att lära dig python utanför klassen kan du få det via länkarna på klassens webbsida. Observera att vi kommer att använda Python 2.7 och inte Python 3 (detta beror på att matplotlib nyligen har lagt till Python 3-stöd, faktiskt beror det på att din professor är en fossil och inte gillar att förändras). Vi kommer att använda ett antal pythonpaket för att bearbeta bilder (som numeriska matriser), läsa FITS-filer och visa data. Anaconda innehåller python och (nästan alla) andra paket som behövs. Om du använder rak python (t.ex. under Linux) måste du installera dessa paket separat (vilket är väldigt enkelt för distributioner som Ubuntu). Om du har en Mac är du ensam.

Du kommer att använda python kraftigt under terminen, så det skulle vara bra att installera den på en dator som du har tillgång till utanför klassen (som en bärbar dator om du äger en).

För att installera Anaconda, använd den här länken http://continuum.io/downloads. Maskinerna i labbet kör 32-bitarsfönster. När du har installerat python, försök att köra ipython. När du kommer till ipython-kommandoraden bör du skriva
cd h: /
för att ändra den aktuella katalogen till där dina filer lagras. Kommandoraden ipython använder unix-kommandon. Några användbara kommandon är: 'ls' - för att lista innehållet i den aktuella katalogen, 'cd' - för att ändra den aktuella katalogen och 'pwd' - för att skriva ut den aktuella katalogen.
Jag föredrar att redigera .py-filer med gedit. Du kan behöva installera gedit. De flesta andra textredigerare fungerar också bra.

Första exempelprogrammet - läsa och plotta en bild

För att komma igång med python, låt oss titta på ett enkelt program att läsa i en bild i FITS-format och plotta den på skärmen. Programmet är här: showimage.py. Du bör ladda ner programmet och sedan ladda det i en textredigerare du väljer. Notepad förstör formateringen. Wordpad är ok. Gedit bör installeras på maskinerna och är ganska trevligt.

Den första raden är en kommentar om vad programmet gör. Det är bra att liberalt kommentera din kod.

Den andra uppsättningen rader (3-7) berättar för python att vi kommer att använda en massa tillägg. Tillägg är förskrivna moduler för att utföra olika uppgifter. numpy, eller 'Numerical Python' är ett paket för att definiera matematiska konstruktioner som matriser (eller matriser) och göra det enkelt att hantera dem i python. matplotlib är ett vetenskapligt planeringspaket. pyfits är ett paket för att läsa och skriva FITS-filer.

Det första vi faktiskt gör i programmet är på rad 12, där vi läser i en FITS-fil. Programmet läser för närvarande i en fil som heter 'testpattern1.fit'. Du bör redigera den här raden för att läsa i en av filerna som du skapade i det senaste labbet. Observera att om du kör python i samma katalog som dina data behöver du bara filnamnet. Annars måste du lägga till filens katalog.

På rad 15 kopierar vi bilddata från FITS-filen till en variabel som heter img1. img1 är faktiskt en bedövad matris och senare diskuterar vi hur man gör matematiska operationer på domna matriser (det är enkelt).

Nästa rad linjer, 18-21, plottar bilden. Tillbaka i importen importerade vi plottpaketet "som plt". Detta tillåter oss att använda stenografi "plt" för att hänvisa till plottningspaketet. Alla fyra linjer anropar rutiner i matplotlib.pyplot-paketet med plt som stenografi. Den första raden ställer in plottningen till interaktivt läge, det betyder bara att programmet fortsätter efter att ha gjort plot istället för att vänta på att användaren ska titta på plot innan det fortsätter. Den andra raden ställer in färgkartan. Eftersom kameran är svartvitt använder vi en gråskalakarta för att göra realistiska bilder. Den tredje raden använder "imshow" -rutinen för att göra en ritning av bilddata med den valda färgkartan. Fyra rader sätter faktiskt tomten upp på skärmen.

När du har redigerat programmet för att läsa i din fil (redigera rad 12, se ovan), fortsätt och kör programmet. Starta upp ipython. ipython är ett interaktivt skalgränssnitt till python som använder unix-liknande kommandon. För att ställa in Anaconda python för det plottningsgränssnitt som vi använder, skriv '% pylab' utan citat. Du kommer att vilja göra detta varje gång du startar ipython eller så fryser programmet när du gör tomter. Om du inte kör Anaconda är det här kommandot förmodligen inte nödvändigt. Använd cd för att flytta till katalogen där showimage.py är och skriv 'run showimage' utan citattecken och tryck på Enter. ipython ska dyka upp och visa bilden. Observera att fönstret är interaktivt: man kan zooma, panorera eller spara bilden i olika format. Om du har problem med att köra programmet, se till att du är i rätt katalog och att du har redigerat programmet för att leta efter FITS-filen på rätt plats. Se till att programmet fungerar innan du fortsätter. Spela in i din labanteckningsbok, de procedurer som du följde för att visa bilden inklusive kataloger där showimage.py och din bild sparas. Kom ihåg att börja på en ny sida och skriva dagens datum och en kort beskrivning av dagens aktiviteter (som 'Intro till Python') högst upp på sidan.

FITS-filer

När du har kört programmet ska det lämna dig vid ipython-kommandotolken. Skriv nu 'print h [0] .header'. Ipython-skärmen kommer att fyllas med en massa information kodad i filen. FITS är ett "självdokumenterande" filformat. Förutom bilddata innehåller filen 'metadata' som beskriver bildparametrarna och hur och när bilden erhölls. Dessa skrevs av CCDOps när du sparade filen i det senaste labbet. Metadata består av ett nyckelordsnamn, ett värde och en valfri kommentar.

Exempelvis anger NAXIS-nyckelordet antalet axlar, det ska vara 2. NAXIS1- och NAXIS2-nyckelorden ger antalet pixlar längs bildens två axlar. Spela in dessa i din labbanteckningsbok. Om du sparade en helbild (enligt instruktionerna i det sista labbet) bör dessa matcha antalet pixlar i CCD: n. Kontrollera CCD-dokumentationen för att se om det är sant och registrera i din anteckningsbok. Nyckelordet CCD-TEMP registrerar CCD-temperaturen när bilden erhölls. Registrera det i din anteckningsbok och notera enheterna. Kontrollera TELESCOP-nyckelordet, det ska innehålla vad du skrev för "Teleskopbeskrivning". Skriv i din anteckningsbok om TELESCOP håller med FOCALLEN och vad du skrev i din anteckningsbok om linsen som användes för bilden. Så länge du är uppmärksam när du tar data, ger metadata i FITS-filer ett bra sätt att kontrollera att du arbetar med rätt datafiler.

Andra exemplet program - skillnad bild

Ladda nu ner diffimage.py och ladda den i din redigerare. Ändra raderna 12 och 13 för att läsa i de två bilderna av testmönstret som du tog i det första labbet. Detta program läser in två bilder, extraherar bilddata, beräknar en ny matris som är skillnaden i de två bilderna och plottar sedan alla tre bilderna. Skillnadsbilden beräknas på rad 33. Observera hur enkelt koden är. Det andra nya elementet i koden är användningen av plt.figure (#) för att plotta flera fönster på skärmen. Observera att endast en plt.show () behövs för att visa alla tre bilderna.

Ta en titt på dina tre bilder. Om de två bilderna som du tog med CCD var under exakt samma förhållanden, skulle testmönstret försvinna i skillnadsbilden. Hänt detta? Skriv ner dina slutsatser och eventuella tankar om hur du kan förbättra subtraktionen i din anteckningsbok. Kan du också tänka på någon astronomisk applikation för skillnadsavbildning?

Tredje exempelprogrammet - bildhistogram

Nu använder vi python för att beräkna lite statistik och plotta ett histogram över pixelvärdena i våra bilder. Hämta histimage.py. De första delarna bör vara bekanta. Redigera raden som läser FITS-filen för att använda din bildfil. De nya sakerna börjar vid rad 26. De rutiga numpy / matplotlib-rutinerna för att göra histogram och beräkna statistik måste ha endimensionella matriser som inmatning. I rad 26 hittar vi storleken på 2-d array img. img.shape-rutinen returnerar två värden i en "tuple". Python-tuples är uppsättningar av värden åtskilda av kommatecken och någon gång i parentes. I rad 26 sätts nx till det första värdet i tupeln och ny sätts till det andra värdet. I rad 27 gör vi en ny (1-d) array imgh. Den har samma värden som 2-d bildarray img, men ordnad som ankor i rad.

Efter detta följer några rader för att beräkna statistik över bildvärdena. min, max och medel bör vara självförklarande. std ger standardavvikelsen för en uppsättning data. Standardavvikelsen är ett mått på datafluktuationerna runt medelvärdet. Det är kvadratroten av medelvärdet av kvadratavvikelserna från medelvärdet, dvs. std = sqrt (medelvärde ((x-medelvärde (x)) ** 2)), där ** är Pythons operatör för att höja ett tal till ett kraft. Spela in statistiken för pixelvärdena för din bild.

Sedan plottar vi histogrammet. Ett histogram är en grafisk representation av fördelningen av en uppsättning värden. I detta fall är värdena intensitetsavläsningarna från CCD för varje pixel. Om du ordnar dessa i en 2-d matris får du en bild. Ett histogram kasserar den rumsliga informationen och visar endast fördelningen av själva värdena, särskilt frekvensen med vilken varje värde (eller intervall av värden) inträffar. Matplotlib rutinhistor visar histogram. Det första argumentet är en 1-d av värden, de andra argumenten anger plotparametrar. Den mest avgörande av dessa är "soptunnor" som ställer in antalet soptunnor i histogrammet. Som standard fördelas facken jämnt mellan de lägsta och högsta inmatningsvärdena.

Vid beräkning av statistiken för en datamängd föredrar man ofta att kasta bort outlier, t.ex. pixlar som har höga värden eftersom de är mättade eller "heta" eller pixlar som har låga värden eftersom de är skadade. Undersök histogrammet för dina pixelvärden. Finns det avvikelser? I raderna 41-44 ställer vi in ​​ett tillåtet intervall för 'bra' pixelvärden (mellan plog och phi) och gör sedan en ny matris, imghcut, med bara värdena i det intervallet. Justera värdena för plog och phi enligt ditt histogram och registrera dem. Observera att musmarkörens nuvarande koordinater visas i plotfönstret när du flyttar musen över diagrammet. Kör sedan histimage.py igen och registrera statistiken för bildens pixelvärden när du bara behåller de "bra" pixlarna.

Försök nu Python själv

Tillbringa resten av labbet med att lära sig python. Vi kommer att använda python under hela terminen, så det är en bra investering för din tid. Ett bra sätt att göra detta är att sätta dig själv ett mål och sedan försöka skriva den kod som behövs. Att gå igenom Code Academy och NumPy-självstudierna skulle också vara användbart (länkarna finns på huvudklassens webbsida).

Det finns ingen klass på Labor Day, så det skulle vara bra att spendera 12 timmar under de närmaste två veckorna på att lära sig python. Det finns pythonövningar på grund den 9/14 för att uppmuntra detta.

Pythonövningar på grund av nästa nästa laboratorium:

1) Lägg till kod i histogramplottningsprogrammet för att överplotta medelvärdet på histogrammet. Efter att ha fått det att fungera, lägg till mer kod för att plotta medelvärdet - standardavvikelsen med streckade linjer. Diagrammet ger en fin grafisk illustration av hur standardavvikelsen är ett mått på datafluktuationerna runt medelvärdet. Lägg sedan till kod för att beräkna medianen (värdet så att hälften av data ligger ovanför och hälften ligger under). Plotta medianen och se hur den jämförs med medelvärdet. Skriv ut din kod och en kopia av din plot med medelvärde, standardavvikelser och median att lämna in.

2) I nästa laboratorium måste du göra värderingar. Skriv kod för att skapa en matris av heltal från 1 till 10, hitta deras rutor och plotta sedan kvadraten kontra värdet. Skriv ut din kod och en kopia av din tomt att lämna in.


Astronomiska moduler och bibliotek i Python

Det finns många speciella astronomiska bibliotek i Python-världen, främst utvecklade i samband med forskningsarbete på institut och gjort tillgängliga för samhället. Jag publicerar några webbadresser här. Programmen beskrivs på motsvarande webbsidor och kan laddas ner där och installeras i din egen Python-miljö enligt installationsinstruktionerna.

Det mest omfattande systemet är förmodligen astropi: https://www.astropy.org/

Astropipaketet innehåller viktiga funktioner och vanliga verktyg som behövs för att utföra astronomi och astrofysik med Python. Det är kärnan i Astropy-projektet, som syftar till att göra det möjligt för samhället att utveckla ett robust ekosystem av anslutna paket som täcker ett brett spektrum av behov för astronomisk forskning, databehandling och dataanalys.

PyAstronomy (PyA) är en samling astronomirelaterade paket.

Syftet med PyAstronomy är att tillhandahålla en samling paket som uppfyller en viss standard både vad gäller kod och dokumentationskvalitet. På detta sätt vill vi (PyA-gruppen) se till att PyA-paket utgör ett roligt verktyg för att förbättra effektiviteten i vårt / ditt arbete och inte en annan källa till smärtsamma upplevelser.

PyA framkom från arbetet hos vissa människor på Hamburger Sternwarte. Det har inte utformats för att täcka något särskilt område, men vi integrerade verktyg som vi tyckte var användbara under vårt arbete. Andra människor har olika behov och även våra utvecklas. Därför förväntar vi oss att PyA växer både genom våra egna bidrag och förhoppningsvis genom bidrag från andra.

Till exempel, astroplan kan användas för att planera observationer: https://astroplan.readthedocs.io/sv/latest/index.html

astroplan är ett Python-paket med öppen källkod för att hjälpa astronomer att planera observationer.

Målet med astroplan är att skapa en flexibel verktygslåda för observationsplanering och schemaläggning. När det är klart är målet att vara lätt för nybörjare av Python och nya observatörer att plocka upp, men tillräckligt kraftfull för observatorier som förbereder nattliga och långsiktiga scheman.

    • Beräkna stigning / inställning / meridian-transittider, alt / az-positioner för mål vid observatorier var som helst på jorden
    • Inbyggda plottningsfunktioner för standard observationsplaneringsdiagram (luftmassa, parallaktisk vinkel, himmelkartor).
    • Bestämning av observerbarhet för uppsättningar av mål som ges en godtycklig uppsättning begränsningar (dvs. höjd, luftmassa, månseparation / belysning, etc.).

    För spektroskopiska ändamål följande webbadresser är viktiga:

    specutils är ett Python-paket för att representera, ladda, manipulera och analysera astronomiska spektroskopiska data. De generiska databehållarna och tillhörande moduler ger en verktygslåda som den astronomiska gemenskapen kan använda för att bygga mer domänspecifika paket.

    Baslinjeanpassning beskriver baslinje- & amp-kontinuumtillpassning.

    Model Fitting beskriver den allmänna processen för modellanpassning.

    Mätningar är en verktygslåda för att utföra EQW, kolumn och andra mätningar ...

    Enheter innehåller den viktiga SpectroscopicAxis-klassen som används för att hantera koordinatomvandlingar

    linetools är ett utvecklingspaket för analys av 1-D-spektra. Kärnutvecklarna arbetar främst med UV / optisk / IR-absorptionsledning, så det mesta av funktionaliteten är inriktad på identifiering och analys av absorptionslinjer. Det slutliga målet är att tillhandahålla en uppsättning verktyg som är användbara för både absorptions- och utsläppslinjer.

    iSpec är ett verktyg för behandling och analys av stjärnspektra. Några av de viktigaste funktionerna för spektrabehandling är följande:

      • Avlägsnande av kosmiska strålar
      • Kontinuerlig normalisering
      • Upplösning försämring
      • Radiell hastighetsbestämning och korrigering
      • Telluric linjer identifiering
      • Omprovtagning

      Ett spektroskopi och astrofysikbibliotek för Python 3
      Detta Python-paket är en växande kodbas för att göra beräkningsastronomi, särskilt spektroskopi. Den innehåller både a
      Spektrumsklass för hantering av spektra som objekt (med +, -, *, /, etc & # 8230 funktioner definierade) och en växande serie analysverktyg.


      Plotta astronomiska data med Python - Astronomi

      Processen för datareduktion och analys kräver manipulation av rådata. Med tillkomsten av digitala detektorer passar detta väl för datorer och programvara.

      Historiskt har olika mjukvarupaket utvecklats specifikt för astronomisk bildbehandling, t.ex.

      • IRAF. Notera särskilt PYRAF Python-gränssnittet
      • XVISTA
      • GAIA
      • FIGARO: Caltech
      • MIDAS: europeisk
      • AIPS: radio
      • Tilläggspaket: STSDAS (rymdteleskop), PROS (röntgen), DAOPHOT (stjärnfotometri), SeXtractor (källdetektering).

      Dessa hade alla olika specialiteter och nackdelar: tillgänglighet, kostnad, GUI / kommandorad, datahantering (disk vs minne), hastighet, användarvänlighet (t.ex. nyckelord vs. parmfiler), språk och tillgång till befintlig kod, förmåga att lägga till ny kod, skript / procedurer (internt kontrollspråk). De flesta av dessa paket kände igen värdet av skript- och upprepningsoperationer för många bilder, och som ett resultat inkluderade vissa inbyggda skriptfunktioner.

      Med utvecklingen av skriptspråk som IDL och Python har saker och ting gradvis flyttats bort från de astronomispecifika paketen mot rutiner skrivna på det generiska skriptspråket, eller åtminstone anropbara från det.

      Vissa bildbehandlingsuppgifter är enkla och andra är komplexa. För komplexa uppgifter är det bekvämt att använda förbyggda verktyg. Men det är i allmänhet viktigt att känna igen vad ett visst verktyg gör, och om det kan ha begränsningar: du bör inte vara begränsad av vad du väljer att göra av det verktyg du är bekväm med, så håll alltid möjligheten för andra verktyg öppna, eller förbättra förmågan hos ett verktyg!

      Vilken programvara ska du lära dig? Dessa dagar kräver många instrument ganska involverade uppgifter för att minska data. Ofta levererar instrumentteamet eller observatoriet rutiner (i något paket) för att utföra dessa uppgifter. I allmänhet kan det vara lättare att använda dessa rutiner snarare än att omprogrammera dem med ditt favoritverktyg! Så du är förmodligen i stånd att behöva vara bekväm med flera verktyg.

      Ett alternativt sätt att se på saker är att du kommer att arbeta med nya instrument och / eller nya tekniker för att vara i framkant. Att använda standardanalys kan vara osannolikt att dra största nytta eller till och med fungera alls med nya data. Så du vill ha möjlighet att själv utveckla verktyg.

      Det finns flera programmeringsmiljöer som gör det ganska enkelt att arbeta med astronomiska data. Här ger vi en introduktion till två av de mer populära miljöerna i USA: Python (särskilt användbart i samband med PyRAF) och IDL. Att arbeta i en av dessa miljöer gör att du kan använda användningen av befintliga rutiner och även utveckla dina egna rutiner. Också extremt viktigt att ha verktyg för att kunna utforska data.

        Grunderna
          Starta python med: ipython & ndashmatplotlib

        • typ (var) ger typ av variabel
        • var? ger information om variabel (endast iPython)
        • var. & lttab & gt ger information om variabla attribut och metoder
        • FITS: header / data, datatyper, HDUList, etc.
          • från astropy.io import passar
          • hd = fits.open (filnamn) returnerar HDULIST
          • hd [0] .data är data från ursprunglig HDU i en dum array
          • hd [0]. header är rubrik från ursprunglig HDU i en dum strukturerad matris
          • från astropy.io importera ascii
          • a = ascii.read (filnamn) returnerar tabell med kolumner
          • numpy array-metoder: t.ex.:
            • data.sum (): totalt
            • data.mean (): medelvärde
            • data.std (): standardavvikelse
            • np.median (data): median
            • primitiv visning via imshow
              • plt.imshow (hd [0] .data, vmin = min, vmax = max)
              • från pyds9 import *
              • d = DS9 () (öppnar ett DS9-fönster, associeras med objekt d)
              • d.set ("passar filnamn") (visning från fil)
              • d.set_pyfits (hd) (visning från HDULIST)
              • d.set_np2arr (hd [0] .data) (visning från numpy array)
              • d.set ("skalgränser 400 500") (ställer in visningsintervall)
              • kommandolista
              • importera os
              • os.environ ["PYTHONPATH"] = / home / holtz / python
              • från holtz.pyvista.tv import *
              • t = tv.TV ()
              • t.tv (hd [0], min = 400, max = 500)
              • t.tv (hd [0] .data)
              • zoom, panorera, färgfält
              • blinkande bildbuffertar med +/-
              • plt.figure
              • plt.plot (hd [0] .data [:, 100] (för en plot längs kolumn 100)
              • plt.plot (hd [0] .data [500 ,:] (för en tomt längs rad 500)

              Låt oss fortsätta arbeta med bilder i / home / holtz / raw / apo / a535 / spicam / UT061215.

                Läs på flera bilder: SN17135_r.0103.fits, flat_r.0015.fits, bias.0001.fits. Visa dem inifrån en mjukvarumiljö (Python / pyds9 / tv / imshow eller IDL / atv) och bekanta dig med att använda det.


              Plotta astronomiska data med Python - Astronomi

              APLpy (Astronomical Plotting Library in Python) är en Python-modul som syftar till att producera plott av astronomiska bilddata i publiceringskvalitet i FITS-format. Modulen använder Matplotlib, ett kraftfullt och interaktivt plottpaket. Den kan skapa utdatafiler i flera grafiska format, inklusive EPS, PDF, PS, PNG och SVG.

              Viktigaste egenskaper

              • Gör tomter interaktivt eller med skript
              • Visa gråskala-, färgskala- och trefärgade RGB-bilder av FITS-filer
              • Generera sampassade FITS-kuber för att skapa trefärgade RGB-bilder
              • Gör plottar från FITS-filer med godtycklig WCS (t.ex. positionshastighet)
              • Skär flerdimensionella FITS-kuber
              • Lägg över ett antal kontursatser
              • Överlagringsmarkörer med helt anpassningsbara symboler
              • Plotta anpassningsbara former som cirklar, ellipser och rektanglar
              • Överlägg ds9-regionfiler
              • Överlägg koordinatgaller
              • Visa färgfält, skalfält och balkar
              • Anpassa utseendet på etiketter och fästingar
              • Dölj, visa och ta bort olika kontur- och markörlager
              • Panorera, zooma och spara alla vyer som en fullständig publikationskvalitet
              • Spara diagram som EPS, PDF, PS, PNG och SVG

              För att begära funktioner, vänligen lämna en begäran här.

              Komma igång

              Vill du komma igång? Följ sedan instruktionerna på sidan och kolla sedan på sidan Tutorial om hur du gör några fantastiska och enkla diagram.

              Rapportera problem

              Om du stöter på problem med APLpy, vänligen lämna en felrapport här.

              Källkod

              Om du är modig och vet vad du gör med Python kan du ladda ner källkoden med blödande kant med Git.

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

              Erkänner användningen av APLpy

              Om du använder APLpy för en publikation kan du använda följande bekräftelse:

              Denna forskning använde APLpy, ett plottpaket med öppen källkod för Python (Robitaille och Bressert, 2012)

              där (Robitaille och Bressert, 2012) är en hänvisning till denna ADS / ASCL-post.


              På den här webbplatsen kommer ett kompendium med länkar och resurser för att hjälpa dig att utveckla dina färdigheter i Python, och för att tillämpa dem på flera astronomiska projekt & # 8211 identifiera asteroider, arbeta med astronomiska bilder och använda efemerdata för att lokalisera asteroider, kometer och planeter i skyn. Det finns resurser här som innehåller stora kataloger med asteroider, Python-anteckningsböcker för simulering av banor i solsystemsobjekt och NASA-efemerisdatabaser för att möjliggöra ny forskning om solsystemet.

              Jag har delat upp detta i avsnitt och ger länkar och tips för att komma igång nedan.

              Komma igång i Python

              Kanske har du redan utsatts för Python, men om inte finns det många användbara introduktioner till språket och massor av material tillgängliga för att hjälpa dig att lära dig. Eftersom Yale-NUS College hade den korta kursen av Marla Geha om Python, kommer jag att inkludera en hel del av hennes material, eftersom de ger en mycket trevlig ingång till Python med en astronomisk snedställning.

              De flesta datorer och alla MacOS-system har Python inbyggt. Men ett system som är högt ansedd och komplett i alla sina paket kallas Anaconda Python-installationen. Jag rekommenderar detta starkt eftersom det ger en smidig upplevelse och har mycket snygga och avancerade bärbara datorer för att visualisera vad du gör. På Caltech använder ZTF boot camp också den här distributionen. Den finns tillgänglig på https://store.continuum.io/cshop/anaconda/.

              När du har installerat det här kan du använda guiden från Marla Geha från Yale för att lära dig mer om Python. Detta inkluderar några övningar för bildbehandling, med hjälp av data både från hennes korta kurs på Yale-NUS och även från HST-arkivet. Dessa resurser är alla tillgängliga på Yale-NUS August Short Course-webbplatsen. 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 betyda 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.

              De 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 fel i
              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?

              REDIGERA: 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.


              Titta på videon: Data visualization with python. Create and customize plots using Matplotlib, seaborn and pandas (Maj 2022).