천문학

Python을 사용하여 천문 데이터 플로팅

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.

별과 지구 사이의 거리를 보여주는 그래프를 만들려고했지만 아래에 표시된대로 원하는 그래프를 얻을 수 없었습니다 (확대하려면 클릭). 내 그래프 :

@uhoh가 제안했듯이 하나의 그래프를 다른 그래프 위에 오버레이했습니다. 이 혼란스러운 그래프를 게시 한 것에 대해 사과드립니다

결합 된 그래프는 내 그래프의 곡선 위치가 예상 그래프의 위치와 완전히 다르다는 것을 나타냅니다.

이 가이드를 따라 별의 위치 함수를 계산했습니다.

내 질문: 이상을 초래 한 실수를 저질렀습니까?

미리 감사드립니다.

코드에 대한 주석 :

  • 이름-별의 이름

  • RA-적경도, ICRS 조정. (J2000)

  • Dec-각도 단위의 적위, ICRS 조정. (J2000)

  • pm_mRA-적경의 적절한 운동, 연간 miliarcseconds

  • pm_mdec-연간 miliarcseconds 단위의 적절한 적위 운동

  • vr-초당 킬로미터의 반경 속도, 양수 값은 별이 우리에게서 멀어지고 있음을 의미합니다.

  • mparallax-miliarcseconds 단위의 별 시차

  • d-별과 지구 사이의 거리

내 코드 :

def parseTextFile (file_name, delimiter = ",", header = 0) : "" "텍스트 파일을 목록으로 구문 분석합니다. 파일 내용은 구분되며 헤더가 있습니다." ""with open (file_name) as f : # 건너 뛰기 the header in range (header) : next (f) data = [] # parse file contents for line in f : # 줄 바꿈 제거 char line = line.replace ( ' n', "). replace ( ' r ', ") # 구분 기호로 행 분할 line = line.split (delimiter) # i에 대한 행의 개별 항목에서 공백을 제거하고 enumerate (line) 항목 : line [i] = entry.strip () # 라인의 내용을 데이터 목록에 추가 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 = {} #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) #Transverse velocities vta = pm_RA * d * 4.740 vtd = pm_Dec * d * 4.740 #Linear velocities 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) # km / s에서 pc / 년으로 단위 변환 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 * 시간 y = yi + vy_pcyr * 시간 z = zi + vz_pcyr * 시간 거리 = 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 ()

거리 단위를 파섹에서 광년으로 변경하는 것을 잊었습니다. 이것은 피해야 할 간단한 단위 변환 오류입니다.

궁극적 인 그래프 :

사용 된 데이터 :

이름, RA (deg), Dec (deg), pm_RA (mas / yr), pm_Dec (mas / yr), Vr (km / s), parallax (mas)
늑대 359,164.120271, + 07.014658, -3842.0, -2725.0,19.321,418.3
프록시마 센타 우리, 217.42895219, -62.67948975, -3775.75,765.54, -22.40,768.13
알파 센타 우리, 219.900850, -60.835619, -3608,686, -22.3,742
버나드 스타, 269.45207511, + 04.69339088, -798.58,10328.12, -110.51,548.31
글 리제 445,176.92240640, + 78.69116300,743.61,481.40, -111.65,186.86
루만 16A, 150.8218675, -53.319405556, -2754.77,358.72,23.1,500.51
시리우스, 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
로스 248,355.479122, + 44.177994,115.10, -1592.77, -77.715,316.7
글 리제 65,24.756054, -17.950569,3321,562,29,373.70

암호:

% matplotlib qt import numpy as np from mpl_toolkits.mplot3d import axes3d from matplotlib import pyplot as plt from matplotlib import patch def parseTextFile (file_name, delimiter = ",", header = 0) : "" "텍스트 파일을 목록으로 구문 분석합니다. 파일 내용은 구분되고 헤더가 있습니다. "" "with open (file_name) as f : # i에 대한 헤더를 범위 (header) : next (f) data = [] # f에서 줄에 대한 파일 내용을 구문 분석합니다. # 줄 바꿈 제거 char line = line.replace ( ' n', "). replace ( ' r',") # 구분 기호로 줄 분할 line = line.split (delimiter) # 개별 항목에서 공백 제거 i에 대한 줄, enumerate (line)의 항목 : line [i] = entry.strip () # 데이터 목록에 줄 내용 추가 data.append (line) return data if __name__ == "__main__": file_name = 'C :  Users  The Wings of Dream  Desktop  UWO-PA-Python-Course  Lecture 5  Homework 2  star_data.txt'# 프로그램 시작 : fig = plt.figure () ax1 = fig.add_subplot (211, projection = "3d") ax2 = fig.add_subplot (212) 시간 = np.arange (-600 00,100000,10) count = 1 xdic = {} ydic = {} zdic = {} for star in 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 (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 * 시간 y = yi + vy_pcyr * 시간 z = zi + vz_pcyr * 시간 xdic [ 'x'+ str (count)] = x ydic [ 'y'+ str (count)] = y zdic [ 'z'+ str (count)] = z 거리 = 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') # 플로팅 제약 ax2.set_ylim (0.0, 10.0) ax2.set_xlim (-60000, 100000) ax1.set_xlabel ( 'x axis') ax1.set_ylabel ( 'y 축') ax1.set_zlabel ( 'z 축') ax1.title.set_text ( '우주에서 별의 움직임') ax2.title.set_text ( 'Distance-Time') ax2.set_xlabel ( 'Time (Year) ') ax2.set_ylabel ('거리 (광년) ') ax2.legend () plt.show ()

ax1 서브 플롯은 별의 움직임을 보여주는 3D 파라 메트릭 플롯을 제공합니다.


Python을 사용한 이미지 처리 소개

천문학적 이미지가 처리되는 방식을 더 깊이 이해하기 위해 처리를 수행하는 자체 소프트웨어를 작성합니다. 이를 위해 노력을 최소화하기 위해 컴퓨터 언어 인 Python을 사용합니다. Python은 대화 형이며 확장 가능한 프로그래밍 언어입니다. FITS 파일에서 이미지를로드하고, 루프없이 압축 코드를 사용하여 이미지를 처리하고, 화면에 이미지를 표시하는 확장 기능이 있습니다. 이번 주 실습에서는 Python의 기본 사항과 Python에서 이미지 처리에 대한 몇 가지 세부 사항에 익숙해 질 것입니다.

Python은 자유 소프트웨어입니다. 따라서 수업 밖에서 파이썬을 배우고 싶다면 수업 웹 페이지의 링크를 통해 얻을 수 있습니다. Python 3이 아닌 Python 2.7을 사용할 것입니다 (이는 matplotlib가 최근에 Python 3 지원을 추가했기 때문이며 실제로 교수님이 화석이고 변경하는 것을 좋아하지 않기 때문입니다). 많은 파이썬 패키지를 사용하여 이미지를 처리하고 (숫자 배열로) FITS 파일을 읽고 데이터를 표시합니다. Anaconda에는 python 및 (거의 모든) 필요한 다른 패키지가 포함되어 있습니다. 직선 파이썬 (예 : Linux에서)을 사용하는 경우 이러한 패키지를 별도로 설치해야합니다 (Ubuntu와 같은 배포판에서는 매우 쉽습니다). Mac이 있다면 혼자서 할 수 있습니다.

학기 중에 파이썬을 많이 사용하게되므로 수업 밖에서 액세스 할 수있는 컴퓨터에 설치하는 것이 좋습니다 (예 : 노트북이있는 경우).

Anaconda를 설치하려면 http://continuum.io/downloads 링크를 사용하십시오. 실험실의 컴퓨터는 32 비트 창을 실행합니다. 파이썬이 설치되면 ipython을 실행 해보십시오. ipython 명령 줄로 이동 한 후 다음을 입력해야합니다.
cd h : /
현재 디렉토리를 파일이 저장되는 위치로 변경합니다. ipython 명령 줄은 유닉스 명령을 사용합니다. 몇 가지 유용한 명령은 다음과 같습니다. 'ls'-현재 디렉토리의 내용을 나열하고, 'cd'-현재 디렉토리를 변경하고, 'pwd'-현재 디렉토리를 인쇄합니다.
gedit를 사용하여 .py 파일을 편집하는 것을 선호합니다. gedit를 설치해야 할 수도 있습니다. 대부분의 다른 텍스트 편집기도 잘 작동합니다.

첫 번째 예제 프로그램-이미지 읽기 및 플로팅

Python을 시작하기 위해 FITS 형식의 이미지를 읽고 화면에 플로팅하는 간단한 프로그램을 살펴 보겠습니다. 프로그램은 여기에 있습니다 : showimage.py. 프로그램을 다운로드 한 다음 원하는 텍스트 편집기로로드해야합니다. 메모장이 서식을 엉망으로 만듭니다. 워드 패드는 괜찮습니다. Gedit는 시스템에 설치되어야하며 꽤 좋습니다.

첫 번째 줄은 프로그램이 수행하는 작업에 대한 주석입니다. 코드를 자유롭게 주석 처리하는 것이 좋습니다.

두 번째 줄 (3-7)은 우리가 확장을 사용할 것임을 파이썬에게 알려줍니다. 확장은 다양한 작업을 수행하기 위해 미리 작성된 모듈입니다. numpy 또는 'Numerical Python'은 행렬 (또는 배열)과 같은 수학적 구성을 정의하고 파이썬에서 쉽게 처리 할 수 ​​있도록하는 패키지입니다. matplotlib는 과학적인 플로팅 패키지입니다. pyfits는 FITS 파일을 읽고 쓰는 패키지입니다.

프로그램에서 우리가 실제로하는 첫 번째 일은 12 행에서 FITS 파일을 읽는 것입니다. 이 프로그램은 현재 'testpattern1.fit'이라는 파일을 읽습니다. 마지막 실습에서 만든 파일 중 하나를 읽으려면이 줄을 편집해야합니다. 데이터와 동일한 디렉토리에서 python을 실행하는 경우 파일 이름 만 필요합니다. 그렇지 않으면 파일의 디렉토리를 추가해야합니다.

15 행에서 FITS 파일의 이미지 데이터를 img1이라는 변수에 복사합니다. img1은 실제로 numpy 배열이며 나중에 numpy 배열에서 수학 연산을 수행하는 방법에 대해 논의 할 것입니다 (쉽습니다).

다음 선 세트 인 18-21은 이미지를 플로팅합니다. 다시 가져 오기 작업으로 돌아가서 "plt로"플로팅 패키지를 가져 왔습니다. 이렇게하면 플로팅 패키지를 참조하기 위해 속기 "plt"를 사용할 수 있습니다. 네 줄 모두 plt를 속기로 사용하여 matplotlib.pyplot 패키지의 루틴을 호출합니다. 첫 번째 줄은 플로팅을 대화 형 모드로 설정합니다. 이것은 사용자가 계속하기 전에 플롯을 볼 때까지 기다리지 않고 플롯을 만든 후에 프로그램이 계속된다는 것을 의미합니다. 두 번째 줄은 색상 맵을 설정합니다. 카메라가 흑백이기 때문에 그레이 스케일 맵을 사용하여 사실적인 이미지를 만듭니다. 세 번째 줄은 "imshow"루틴을 사용하여 선택한 색상 맵을 사용하여 이미지 데이터의 플롯을 만듭니다. 네 개의 선은 실제로 플롯을 화면에 표시합니다.

파일을 읽을 수 있도록 프로그램을 편집했으면 (12 행 편집, 위 참조) 계속해서 프로그램을 실행하십시오. ipython을 시작하십시오. ipython은 유닉스와 유사한 명령을 사용하는 파이썬에 대한 대화 형 쉘 인터페이스입니다. 우리가 사용하는 플로팅 인터페이스에 대해 Anaconda python을 설정하려면 따옴표없이 '% pylab'을 입력하십시오. ipython을 시작할 때마다이 작업을 수행하거나 플롯을 만들 때 프로그램이 멈 춥니 다. Anaconda를 실행하지 않는 경우이 명령이 필요하지 않을 수 있습니다. cd를 사용하여 showimage.py가있는 디렉토리로 이동하고 따옴표없이 'run showimage'를 입력하고 Enter 키를 누릅니다. ipython은 이미지를 표시하는 팝업을 표시해야합니다. 창은 대화 형입니다. 다양한 형식으로 이미지를 확대 / 축소, 이동 또는 저장할 수 있습니다. 프로그램을 실행하는 데 문제가있는 경우 올바른 디렉토리에 있고 올바른 위치에서 FITS 파일을 찾도록 프로그램을 편집했는지 확인하십시오. 계속하기 전에 프로그램이 작동하는지 확인하십시오. showimage.py 및 이미지가 저장된 디렉토리를 포함하여 이미지를 표시하기 위해 수행 한 절차를 실습 노트북에 기록합니다. 새 페이지에서 시작하고 페이지 상단에 오늘 날짜와 오늘의 활동에 대한 간단한 설명 (예 : 'Intro to Python')을 작성하는 것을 잊지 마십시오.

FITS 파일

프로그램을 실행 한 후에는 ipython 명령 프롬프트가 표시됩니다. 이제 'print h [0] .header'를 입력합니다. ipython 화면은 파일에 인코딩 된 정보로 채워집니다. FITS는 "자체 문서화"파일 형식입니다. 이미지 데이터 외에도 파일에는 이미지 매개 변수와 이미지를 획득 한 방법 및시기를 설명하는 '메타 데이터'가 포함되어 있습니다. 마지막 실습에서 파일을 저장할 때 CCDOps에 의해 작성되었습니다. 메타 데이터는 키워드 이름, 값 및 선택적 주석으로 구성됩니다.

예를 들어, NAXIS 키워드는 축 수를 제공하며 2 여야합니다. NAXIS1 및 NAXIS2 키워드는 이미지의 두 축을 따라 픽셀 수를 제공합니다. 이를 랩 노트에 기록하십시오. 마지막 실습에서 설명한대로 전체 이미지를 저장 한 경우 CCD의 픽셀 수와 일치해야합니다. CCD 문서를 확인하여 그것이 사실인지 확인하고 노트북에 기록하십시오. CCD-TEMP 키워드는 이미지를 가져올 때 CCD 온도를 기록합니다. 그것을 노트북에 기록하고 단위를 기록하십시오. TELESCOP 키워드를 확인하십시오. 'Telescope Description'에 대해 작성한 내용이 포함되어 있어야합니다. TELESCOP이 FOCALLEN에 동의하고 이미지에 사용 된 렌즈에 대해 노트북에 쓴 내용을 노트북에 기록합니다. 데이터를 가져 오는 동안주의를 기울이는 한, FITS 파일의 메타 데이터는 올바른 데이터 파일로 작업하고 있는지 확인하는 좋은 방법을 제공합니다.

두 번째 예제 프로그램-차이 이미지

이제 diffimage.py를 다운로드하고 편집기에로드하십시오. 첫 번째 실습에서 찍은 테스트 패턴의 두 이미지를 읽도록 12 행과 13 행을 수정합니다. 이 프로그램은 두 개의 이미지를 읽고 이미지 데이터를 추출하고 두 이미지의 차이 인 새로운 배열을 계산 한 다음 세 이미지를 모두 플로팅합니다. 차이 이미지는 33 행에서 계산됩니다. 코드가 얼마나 단순한 지 주목하십시오. 코드의 다른 새로운 요소는 화면에 여러 창을 그리는 데 plt.figure (#)를 사용하는 것입니다. 세 개의 이미지를 모두 표시하려면 하나의 plt.show () 만 필요합니다.

세 개의 이미지를 살펴보십시오. CCD로 찍은 두 이미지가 정확히 동일한 조건에 있었다면 차이 이미지에서 테스트 패턴이 사라져야합니다. 이런 일이 있었나요? 결론과 공책에서 빼기를 개선하는 방법에 대한 생각을 적으십시오. 또한 차이 이미징에 대한 천문학적 응용 프로그램을 생각할 수 있습니까?

세 번째 예제 프로그램-이미지 히스토그램

이제 파이썬을 사용하여 통계를 계산하고 이미지의 픽셀 값에 대한 히스토그램을 플로팅합니다. histimage.py를 가져옵니다. 첫 번째 부분은 익숙해야합니다. 이미지 파일을 사용하기 위해 FITS 파일을 읽는 행을 편집하십시오. 새로운 내용은 26 행에서 시작됩니다. 히스토그램을 만들고 통계를 계산하기위한 numpy / matplotlib 루틴은 입력으로 1 차원 배열을 가져야합니다. 26 행에서 2 차원 배열 img의 크기를 찾습니다. img.shape 루틴은 '튜플'에 두 개의 값을 반환합니다. 파이썬 튜플은 쉼표로 구분되고 때때로 괄호로 묶인 값 집합입니다. 26 행에서 nx는 튜플의 첫 번째 값으로 설정되고 ny는 두 번째 값으로 설정됩니다. 27 행에서는 새로운 (1-d) 배열 imgh를 만듭니다. 2 차원 이미지 배열 img와 동일한 값을 갖지만 연속으로 오리처럼 배열됩니다.

다음은 이미지 값의 통계를 계산하는 몇 줄입니다. 최소, 최대 및 평균은 자명해야합니다. std는 데이터 세트의 표준 편차를 제공합니다. 표준 편차는 평균값 주변의 데이터 변동을 측정 한 것입니다. 평균으로부터의 제곱 편차 평균의 제곱근입니다. 즉, std = sqrt (mean ((x-mean (x)) ** 2)), 여기서 **는 숫자를 a로 올리는 Python의 연산자입니다. 힘. 이미지의 픽셀 값에 대한 통계를 기록합니다.

그런 다음 히스토그램을 플로팅합니다. 히스토그램은 값 집합의 분포를 그래픽으로 표현한 것입니다. 이 경우 값은 각 픽셀에 대한 CCD의 강도 판독 값입니다. 이것을 2 차원 배열로 배열하면 이미지를 얻을 수 있습니다. 히스토그램은 공간 정보를 버리고 값 자체의 분포, 특히 각 값 (또는 값 범위)이 발생하는 빈도 만 표시합니다. matplotlib 루틴 hist는 히스토그램을 표시합니다. 첫 번째 인수는 1d의 값이고 다른 인수는 플롯 매개 변수를 설정합니다. 이들 중 가장 중요한 것은 히스토그램의 빈 수를 설정하는 '빈'입니다. 기본적으로 빈은 최저 입력 값과 최고 입력 값 사이에 균등하게 배치됩니다.

데이터 세트의 통계를 계산할 때 종종 이상 값을 버리는 것을 선호합니다. 포화 또는 '핫'이기 때문에 값이 높은 픽셀 또는 손상되어 값이 낮은 픽셀. 픽셀 값의 히스토그램을 조사하십시오. 특이 치가 있습니까? 41-44 행에서 우리는 '좋은'픽셀 값 (쟁기와 파이 사이)에 허용되는 범위를 설정 한 다음 해당 범위의 값만 유지하는 새 배열 imghcut을 만듭니다. 히스토그램에 따라 쟁기와 파이 값을 조정하고 기록하십시오. 플롯 위로 마우스를 이동하면 마우스 커서의 현재 좌표가 플롯 창에 표시됩니다. 그런 다음 histimage.py를 다시 실행하고 '좋은'픽셀 만 유지할 때 이미지의 픽셀 값 통계를 기록합니다.

이제 직접 Python을 사용해보세요

나머지 실습 시간을 파이썬 학습에 사용하십시오. 학기 내내 파이썬을 사용할 것이므로 시간을 투자하는 것이 좋습니다. 이를위한 좋은 방법은 목표를 설정 한 다음 필요한 코드를 작성하는 것입니다. 또한 코드 아카데미 및 NumPy 자습서를 살펴 보는 것도 유용 할 것입니다 (링크는 기본 클래스 웹 페이지에 있음).

노동절에는 수업이 없으므로 다음 2 주 동안 파이썬을 배우는 데 12 시간을 보내는 것이 좋습니다. 이를 장려하기 위해 9/14에 파이썬 연습이 있습니다.

다음 실습에서 Python 실습 마감 :

1) 히스토그램 플로팅 프로그램에 코드를 추가하여 히스토그램의 평균 값을 오버 플로팅합니다. 그것이 작동하도록 한 후, 점선으로 표준 편차의 평균을 플로팅하는 데 더 많은 코드를 추가하십시오. 이 플롯은 표준 편차가 평균값 주변의 데이터 변동을 측정하는 방법에 대한 멋진 그래픽 그림을 제공합니다. 그런 다음 코드를 추가하여 중앙값을 계산합니다 (데이터의 절반은 위, 절반은 아래에있는 값). 중앙값을 플로팅하고 평균과 어떻게 비교되는지 확인합니다. 평균, 표준 편차 및 중앙값을 사용하여 코드와 플롯 사본을 인쇄하십시오.

2) 다음 실습에서는 값의 플롯을 만들어야합니다. 1부터 10까지의 정수 배열을 만들고 제곱을 찾은 다음 값에 대한 제곱을 플로팅하는 코드를 작성합니다. 코드와 플롯 사본을 인쇄하여 제출하십시오.


Python의 천문 모듈 및 라이브러리

파이썬 세계에는 많은 특별한 천문학 라이브러리가 있으며, 대부분은 기관의 연구 작업 맥락에서 개발되어 커뮤니티에서 사용할 수 있습니다. 여기에 URL을 게시하고 있습니다. 프로그램은 해당 웹 페이지에 설명되어 있으며 여기에서 다운로드하여 설치 지침에 따라 자신의 Python 환경에 설치할 수 있습니다.

가장 광범위한 시스템은 아마도 천체: https://www.astropy.org/

astropy 패키지에는 Python으로 천문학 및 천체 물리학을 수행하는 데 필요한 주요 기능과 공통 도구가 포함되어 있습니다. 이는 천문학 연구, 데이터 처리 및 데이터 분석에 대한 광범위한 요구를 포괄하는 강력한 제휴 패키지 생태계를 커뮤니티가 개발할 수 있도록하는 Astropy Project의 핵심입니다.

PyAstronomy (PyA)는 천문학 관련 패키지 모음입니다.

PyAstronomy의 목표는 코드 및 문서 품질 모두에서 특정 표준을 충족하는 패키지 모음을 제공하는 것입니다. 이러한 방식으로, 우리 (PyA 그룹)는 PyA 패키지가 고통스러운 경험의 또 다른 소스가 아닌 우리 / 귀하의 업무 효율성을 향상시키는 즐거운 도구가되도록 보장하고자합니다.

PyA는 Hamburger Sternwarte의 일부 사람들의 작업에서 나왔습니다. 특정 분야를 다루기 위해 설계되지는 않았지만 작업 중에 유용한 도구를 통합했습니다. 다른 사람들은 다른 요구를 가지고 있으며 우리의 요구도 진화하고 있습니다. 따라서 PyA는 우리 자신의 기여와 다른 사람들의 기여로 성장할 것으로 기대합니다.

예를 들면 천체 계획 관찰 계획에 사용할 수 있습니다 : https://astroplan.readthedocs.io/en/latest/index.html

astroplan은 천문학 자들이 관측을 계획하는 데 도움이되는 오픈 소스 Python 패키지입니다.

astroplan의 목표는 관측 계획 및 일정 수립을위한 유연한 도구 상자를 만드는 것입니다. 완료되면 목표는 Python 초보자와 새로운 관찰자가 쉽게 익힐 수 있지만 관찰자가 야간 및 장기 일정을 준비 할 수있을만큼 강력합니다.

    • 지구상의 모든 관측소에서 표적에 대한 상승 / 세트 / 자오선 이동 시간, alt / az 위치를 계산합니다.
    • 표준 관측 계획 플롯 (공기량, 평행 각도, 하늘지도)을위한 내장 플로팅 편의 기능.
    • 임의의 제약 조건 (예 : 고도, 기단, 달 분리 / 조명 등)이 주어지면 표적 집합의 관측 가능성 결정.

    에 대한 분광 목적 다음 URL이 중요합니다.

    specutils는 천문 분광 데이터를 표현,로드, 조작 및 분석하기위한 Python 패키지입니다. 일반 데이터 컨테이너와 함께 제공되는 모듈은 천문학 커뮤니티에서 더 많은 도메인 별 패키지를 빌드하는 데 사용할 수있는 도구 상자를 제공합니다.

    기준선 피팅은 기준선 및 연속체 피팅을 설명합니다.

    모델 피팅은 모델 피팅의 일반적인 프로세스를 설명합니다.

    Measurements는 EQW, 컬럼 및 기타 측정을 수행하기위한 툴킷입니다.

    단위에는 좌표 변환을 처리하는 데 사용되는 가장 중요한 SpectroscopicAxis 클래스가 포함됩니다.

    linetools는 1-D 스펙트럼 분석을위한 개발중인 패키지입니다. 핵심 개발자는 주로 UV / 광학 / IR 흡수 라인 연구를 수행하므로 대부분의 기능은 흡수 라인의 식별 및 분석을 목표로합니다. 최종 목표는 흡수선과 방출 선 모두에 유용한 도구 세트를 제공하는 것입니다.

    iSpec은 항성 스펙트럼의 처리 및 분석을위한 도구입니다. 스펙트럼 처리를위한 몇 가지 주요 기능은 다음과 같습니다.

      • 우주선 제거
      • 연속체 정규화
      • 해상도 저하
      • 방사형 속도 결정 및 수정
      • 텔루르 라인 식별
      • 재 샘플링

      Python 3 용 분광학 및 천체 물리학 라이브러리
      이 Python 패키지는 계산 천문학, 특히 분광학을 수행하기위한 확장 코드 기반입니다. 그것은 둘 다 포함합니다
      스펙트럼을 객체로 처리하기위한 스펙트럼 클래스 (+,-, *, / 등의 작업이 정의 됨) 및 증가하는 분석 도구 제품군.


      Python을 사용하여 천문 데이터 플로팅-천문학

      데이터 축소 및 분석 프로세스에는 원시 데이터 조작이 필요합니다. 디지털 검출기의 출현으로 이것은 컴퓨터와 소프트웨어에 매우 적합합니다.

      역사적으로 천문학적 이미지 처리를 위해 특별히 다양한 소프트웨어 패키지가 개발되었습니다.

      • IRAF. 특히 PYRAF Python 인터페이스에 유의하십시오.
      • XVISTA
      • 가이아
      • FIGARO : 칼텍
      • MIDAS : 유럽
      • AIPS : 라디오
      • 추가 패키지 : STSDAS (우주 망원경), PROS (X 선), DAOPHOT (항성 측광), SeXtractor (소스 감지).

      이들 모두는 가용성, 비용, GUI / 명령 줄, 데이터 처리 (디스크 대 메모리), 속도, 사용 용이성 (예 : 키워드 대 parm 파일), 언어 및 기존 코드에 대한 액세스 등 다양한 전문성과 장단점을 가지고 있습니다. 새로운 코드, 스크립트 / 프로 시저 (내부 제어 언어)를 추가하는 기능. 이러한 패키지의 대부분은 많은 이미지에 대한 스크립팅 및 반복 작업의 가치를 인식했으며 결과적으로 일부 기본 제공 스크립팅 기능이 포함되었습니다.

      IDL 및 Python과 같은 스크립팅 언어의 개발과 함께 천문학 관련 패키지에서 일반 스크립팅 언어로 작성되거나 적어도 호출 가능한 루틴으로 점차 변화하고 있습니다.

      일부 이미지 처리 작업은 간단하고 일부는 복잡합니다. 복잡한 작업의 경우 미리 만들어진 도구를 사용하는 것이 편리합니다. 그러나 일반적으로 주어진 도구가 수행하는 작업을 인식하는 것이 중요하며 제한이있을 수 있습니다. 익숙한 도구로 수행 할 작업에 제한을 두어서는 안되므로 항상 다른 도구의 가능성을 열어 두십시오. 또는 도구의 기능 향상!

      어떤 소프트웨어를 배워야합니까? 오늘날 많은 기기는 데이터를 줄이기 위해 다소 복잡한 작업을 필요로합니다. 종종 기기 팀 또는 관측소는 이러한 작업을 수행하기위한 루틴 (일부 패키지)을 제공합니다. 일반적으로 자주 사용하는 도구를 사용하여 다시 프로그래밍하는 것보다 이러한 루틴을 사용하는 것이 더 쉬울 수 있습니다! 따라서 아마도 여러 도구에 익숙해 져야하는 위치에있을 것입니다.

      사물을 보는 또 다른 방법은 최전선에 서서 새로운 도구 및 / 또는 새로운 기술로 작업하게되는 것입니다. 표준 분석을 사용하는 것은 새로운 데이터로 가장 큰 이점을 얻거나 전혀 작동하지 않을 수 있습니다. 따라서 도구를 직접 개발할 수있는 유연성을 갖기를 원합니다.

      천문 데이터로 작업하는 것을 매우 간단하게 만드는 몇 가지 프로그래밍 환경이 있습니다. 여기에서는 미국에서 가장 인기있는 두 가지 환경 인 Python (특히 PyRAF와 함께 사용할 때 유용함) 및 IDL을 소개합니다. 이러한 환경 중 하나에서 작업하면 기존 루틴의 사용을 스크립팅하고 고유 한 루틴을 개발할 수도 있습니다. 데이터를 탐색 할 수있는 도구를 갖는 것도 매우 중요합니다.

        기초
          다음을 사용하여 Python 시작 : ipython & ndashmatplotlib

        • type (var)은 변수 유형을 제공합니다.
        • var? 변수에 대한 정보 제공 (iPython 만 해당)
        • var. & lttab & gt는 변수 속성 및 메소드에 대한 정보를 제공합니다.
        • FITS : 헤더 / 데이터, 데이터 유형, HDUList 등
          • astropy.io 가져 오기 적합에서
          • hd = fits.open (filename)은 HDULIST를 반환합니다.
          • hd [0] .data는 numpy 배열의 초기 HDU 데이터입니다.
          • hd [0] .header는 numpy 구조화 된 배열에서 초기 HDU의 헤더입니다.
          • astropy.io import ascii에서
          • a = ascii.read (filename)은 열이있는 테이블을 반환합니다.
          • numpy 배열 방법 : 예 :
            • data.sum () : 합계
            • data.mean () : 평균
            • data.std () : 표준 편차
            • np.median (데이터) : 중앙값
            • imshow를 통한 원시 디스플레이
              • plt.imshow (hd [0] .data, vmin = min, vmax = max)
              • pyds9 가져 오기에서 *
              • d = DS9 () (DS9 창을 열고 개체 d와 연결)
              • d.set ( "fits filename") (파일에서 표시)
              • d.set_pyfits (hd) (HDULIST에서 표시)
              • d.set_np2arr (hd [0] .data) (numpy 배열에서 표시)
              • d.set ( "scale limits 400500") (디스플레이 범위 설정)
              • 명령 목록
              • 수입 OS
              • os.environ [ "PYTHONPATH"] = / home / holtz / python
              • holtz.pyvista.tv에서 가져 오기 *
              • t = tv.TV ()
              • t.tv (hd [0], 최소 = 400, 최대 = 500)
              • t.tv (hd [0] .data)
              • 확대 / 축소, 이동, 컬러 바
              • +/-로 깜박이는 이미지 버퍼
              • plt. 그림
              • plt.plot (hd [0] .data [:, 100] (100 열을 따르는 플롯의 경우)
              • plt.plot (hd [0] .data [500, :] (500 행을 따르는 플롯의 경우)

              / home / holtz / raw / apo / a535 / spicam / UT061215의 이미지로 계속 작업 해 보겠습니다.

                여러 이미지를 읽습니다 : SN17135_r.0103.fits, flat_r.0015.fits, bias.0001.fits. 소프트웨어 환경 (Python / pyds9 / tv / imshow 또는 IDL / atv) 내부에서 표시하고 사용에 익숙해집니다.


              Python을 사용하여 천문 데이터 플로팅-천문학

              APLpy (Python의 Astronomical Plotting Library)는 FITS 형식의 천문 영상 데이터의 출판 품질 플롯을 생성하기위한 Python 모듈입니다. 이 모듈은 강력한 대화 형 플로팅 패키지 인 Matplotlib를 사용합니다. EPS, PDF, PS, PNG 및 SVG를 포함한 여러 그래픽 형식으로 출력 파일을 생성 할 수 있습니다.

              주요 특징

              • 대화식으로 또는 스크립트를 사용하여 플롯 만들기
              • FITS 파일의 회색조, 색조 및 3 색 RGB 이미지 표시
              • 3 색 RGB 이미지를 만들기 위해 함께 정렬 된 FITS 큐브 생성
              • 임의의 WCS (예 : 위치 속도)를 사용하여 FITS 파일에서 플롯을 만듭니다.
              • 다차원 FITS 큐브 슬라이스
              • 원하는 수의 윤곽선 세트 오버레이
              • 완전히 사용자 정의 가능한 기호가있는 오버레이 마커
              • 원, 타원 및 직사각형과 같은 사용자 정의 가능한 모양 플로팅
              • DS9 영역 파일 오버레이
              • 오버레이 좌표 그리드
              • 컬러 바, 스케일 바 및 빔 표시
              • 레이블 및 눈금 모양 사용자 지정
              • 다양한 윤곽 및 마커 레이어 숨기기, 표시 및 제거
              • 모든보기를 전체 출판 품질 플롯으로 이동, 확대 / 축소 및 저장
              • 플롯을 EPS, PDF, PS, PNG 및 SVG로 저장

              기능을 요청하려면 여기에 요청을 남겨주세요.

              시작하기

              시작 하시겠습니까? 그런 다음 페이지의 지침을 따르고 훌륭하고 간단한 플롯을 만드는 방법에 대한 자습서 페이지를 확인하십시오.

              문제보고

              APLpy에 문제가 발생하면 여기에 버그 보고서를 남겨주세요.

              소스 코드

              배짱이 있고 Python으로 무엇을하는지 알고 있다면 Git으로 최첨단 소스 코드를 다운로드 할 수 있습니다.

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

              APLpy 사용 승인

              게시에 APLpy를 사용하는 경우 다음 승인을 사용할 수 있습니다.

              이 연구에서는 Python 용 오픈 소스 플로팅 패키지 인 APLpy를 사용했습니다 (Robitaille and Bressert, 2012).

              여기서 (Robitaille and Bressert, 2012)는이 ADS / ASCL 항목에 대한 인용입니다.


              이 사이트에는 Python 기술을 개발하고 소행성 식별, 천문학 이미지 작업, 천체력 데이터를 사용하여 소행성, 혜성 및 행성을 찾는 데 도움이되는 여러 천문 프로젝트에 적용 할 수있는 링크 및 리소스 개요가 있습니다. 하늘에. 여기에는 소행성의 주요 카탈로그, 태양계 물체의 궤도를 시뮬레이션하기위한 Python 노트북, 새로운 태양계 연구를 가능하게하는 NASA 천체력 데이터베이스가 포함 된 리소스가 있습니다.

              이를 섹션으로 나누고 시작하기위한 링크와 팁을 아래에 제공합니다.

              Python으로 시작하기

              이미 Python에 노출되어있을 수 있지만 그렇지 않은 경우 언어에 대한 유용한 소개와 학습에 도움이되는 많은 자료가 있습니다. Yale-NUS College는 Python에 대한 Marla Geha의 단기 과정을 가지고 있었기 때문에 천문학적 경사로 Python에 매우 좋은 진입 점을 제공하기 때문에 많은 자료를 포함 할 것입니다.

              대부분의 컴퓨터와 모든 MacOS 시스템에는 Python이 내장되어 있습니다. 그러나 모든 패키지에서 높은 평가를 받고 완전한 시스템을 Anaconda Python 설치라고합니다. 나는 매끄러운 경험을 제공하고 당신이하는 일을 시각화 할 수있는 매우 멋지고 고급스러운 노트북을 가지고 있기 때문에 이것을 강력히 추천합니다. Caltech에서 ZTF 부트 캠프도이 배포판을 사용합니다. https://store.continuum.io/cshop/anaconda/에서 다운로드 할 수 있습니다.

              설치가 완료되면 Yale의 Marla Geha 가이드를 사용하여 Python에 대해 자세히 알아볼 수 있습니다. 여기에는 Yale-NUS의 단기 과정과 HST 아카이브의 데이터를 사용하는 이미지 처리 연습이 포함됩니다. 이러한 리소스는 모두 Yale-NUS 8 월 단기 코스 사이트에서 사용할 수 있습니다. 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 평균 of a stack of FITS files. Each individual file may or may not have a detected a 펄서, 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 파일.

              The following figure shows the mean FITS file computed from thes above FITS files. Mean being an 대수 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. 중앙값, being a 전체 론적 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.

              그만큼 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 사용하여 쓰레기통. 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 백만 data points generated randomly. 자, binapprox algorithm will be used to compute the running median and the error in approximation will be computed with different number of bins .

              As can be seen from above, as the number of bins 증가, 오류
              approximation of the running 중앙값 감소합니다.

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

              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?

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


              비디오보기: sqlite3 მონაცემთა ბაზიდან მონაცემების წაკითხვა python-ზე დაწერილი სკრიპტის საშუალებით (할 수있다 2022).


코멘트:

  1. Cruadhlaoich

    미안하지만 제 생각에는 당신은 틀 렸습니다. 오후에 저에게 편지를 보내고 토론하십시오.

  2. Mu'tasim

    나는 당신에게 절대적으로 동의합니다. 좋은 생각이라고 생각합니다.

  3. Dahn

    방해해서 죄송합니다 ...이 상황에 익숙합니다. 논의 할 수 있습니다. 여기 또는 PM에 쓰십시오.

  4. Jeno

    오늘 편두통이 있습니까?

  5. Kippar

    interesting, and the analog is?



메시지 쓰기