def sdss_fits(coo, filtro='r'):
try:
n_coo=len(coo)
except:
n_coo=1
coo=[coo]
n_col=np.min([n_coo,4])
n_row=np.ceil(n_coo*1./n_col)
fig, ax = plt.subplots(figsize=(5*n_col,5*n_row), sharex=True, sharey=True)
for i in range(len(coo)):
ax = plt.subplot(n_row, n_col, i+1)
print 'Procesando galaxia '+str(i)
xid = SDSS.query_region(coo[i], spectro=True)
image=SDSS.get_images(matches=xid, band=filtro)[0][0]
im_h=image.header
im_data=image.data
im_median=np.median(im_data)
im_std=np.std(im_data)
im_wcs = WCS(im_h)
im_data = Cutout2D(im_data, coo[i], u.Quantity((1., 1.), u.arcmin), wcs=im_wcs).data
# ax.imshow(im_data,vmin=im_median-1*im_std, vmax=im_median+5*im_std, cmap=plt.get_cmap('gray'), interpolation='nearest')
ax.imshow(imtoasinh(im_data.T), vmin=0.1, vmax=0.8, cmap=plt.get_cmap('gray'), interpolation='nearest', origin='lower')
ax.axis('off')
ax.text(0.05,0.05, str(i), transform=ax.transAxes, color='white', fontsize=16)
ax.text(0.95,0.05, 'Filtro '+filtro, transform=ax.transAxes, color='white', fontsize=16, horizontalalignment='right')
ax.invert_xaxis()
fig.subplots_adjust(hspace=0.1, wspace=0.1)
def save_data(index, ra, dec, req_par):
output_file = 'Result.dat'
#This function takes in coordinates and finds their SDSS objid and specobjid
#The objid and specobjid is needed to find the required parameters
#The required parameter is then extracted and saved on to a dat file
for i in range(len(index)):
c = SkyCoord(ra=ra[i], dec=dec[i], unit=(u.deg, u.deg), frame='icrs')
result_SDSS = None
try:
result_SDSS = SDSS.query_region(c, spectro=True, radius='3s')
except:
print('Failed to query SDSS - ', i)
if result_SDSS is None:
print(i)
if result_SDSS is not None:
objid = str(result_SDSS['objid'][0]) # Find SDSS objid
specobjid = str(result_SDSS['specobjid'][0]) # Find SDSS specobjid
par_value = get_value(
objid, specobjid, req_par
) # Calls the webscrapping function to extract the value of the required parameter
f = open(output_file, "a")
f.write('%d %f %f %f\n' % (index[i], ra[i], dec[i], par_value))
f.close()
print('%d %f %f %f' % (index[i], ra[i], dec[i], par_value))
return None
def rand_loop_through__sep(f, length):
sep_list = []
while len(sep_list) < length:
righta = np.random.uniform(-180, 180)
declin = np.random.uniform(-90, 90)
pos = coords.SkyCoord(ra=righta * u.degree, dec=declin * u.degree)
galatic_pos = pos.galactic
xid = SDSS.query_region(galatic_pos,
spectro=False,
radius=2.5 * u.arcmin,
photoobj_fields=['ra', 'dec'])
if xid is None:
continue
xid = unique(xid, keys=['ra', 'dec'])
righta_list = xid["ra"]
declin_list = xid["dec"]
sep = pos.separation(
coords.SkyCoord(ra=righta_list * u.degree,
dec=declin_list * u.degree))
sep_list = np.concatenate((sep_list, sep))
print(len(sep_list))
return sep_list
def query_region(self,
ra_hours: float,
dec_degs: float,
constraints: Optional[TDict[str, str]] = None,
limit: Optional[int] = None,
**region) -> TList[CatalogSource]:
"""
Return SDSS catalog objects within the specified rectangular region
:param ra_hours: right ascension of region center in hours
:param dec_degs: declination of region center in degrees
:param constraints: optional constraints on the column values
:param limit: maximum number of rows to return
:param region: keywords defining the query region
:return: list of catalog objects within the specified rectangular region
"""
sdss = SDSS()
return self.table_to_sources(
sdss.query_region(SkyCoord(ra=ra_hours,
dec=dec_degs,
unit=(hour, deg),
frame='icrs'),
data_release=15,
photoobj_fields=self._columns,
cache=False,
**region))
def querySDSS(ra, dec, radius):
''' using astroquery sdss system '''
pos = SkyCoord(ra*u.deg, dec*u.deg, frame='fk5')
table = SDSS.query_region(pos, radius=radius*u.deg,
photoobj_fields=['ra', 'dec', 'objid', 'type',
'u', 'g', 'r', 'i', 'z'])
return table[np.where(table['type'] == 6)[0]]
def cross_match_sdss(imageFile,
extension,
sources,
quality_detections,
extent,
search_radius=3):
data, image, hdulist, size, mid_point = load_image_data(
imageFile, extent, extension=extension)
# garbage collect data and image
data = None
image = None
# cross match quality detections with SDSS
filter = hdulist[extension].header["HIERARCH FPA.FILTERID"].split(".")[0]
# get WCS info from fits header
wcs = WCS(hdulist[extension].header)
reference_dict = {}
pos_output = open(imageFile + ".quality.coo", "w")
count = 0
for index in quality_detections:
if count == 30:
break
print
pixcrd = np.array([[sources['xcentroid'][index]+((size[0]/2.0)-extent), \
sources['ycentroid'][index]+((size[1]/2.0)-extent)]], np.float_)
world = wcs.wcs_pix2world(pixcrd, 1)
pos = coords.SkyCoord(ra=world[0][0] * u.degree,
dec=world[0][1] * u.degree,
frame='icrs')
# search ? arsec region in SDSS
xid = SDSS.query_region(pos,
radius=search_radius * (1 / 3600.0) * u.degree)
print xid
try:
for i in range(len(xid["objid"])):
id = xid["objid"][i]
mag, mag_err = get_reference_mags(id, filter)
if mag == "NULL":
continue
break
except TypeError:
continue
print
print "[*] %s, %s, %s, %s" % (
id, str(
(sources['xcentroid'][index], sources['ycentroid'][index])),
str(mag), str(mag_err))
if mag != "NULL" and mag_err != "NULL":
reference_dict[index] = {"mag":float(mag), "mag_err":float(mag_err), \
"id":id, "pos":(sources['xcentroid'][index], \
sources['ycentroid'][index])}
pos_output.write("%s %s\n" %
(str(pixcrd[0][0]), str(pixcrd[0][1])))
count += 1
pos_output.close()
return reference_dict
def download_sdss_data(self):
sdss = SDSS()
self.info_table = sdss.query_region(self.loc, radius=self.r * u.arcsec)
self.photo_data_table = sdss.query_region(
self.loc,
radius=self.r * u.arcsec,
photoobj_fields=['u', 'g', 'r', 'i', 'z'])
while self.info_table is None and self.r <= 10:
self.r = self.r + 0.4
self.info_table = sdss.query_region(self.loc,
radius=self.r * u.arcsec)
self.photo_data_table = sdss.query_region(
self.loc,
radius=self.r * u.arcsec,
photoobj_fields=['u', 'g', 'r', 'i', 'z'])
self.objid = self.info_table['objid'][0]
def fetch_spectra_SDSS(object_name, save_dir, coords):
"""
saves a textfile in self.save_dir where the first column is the wavelength in angstroms and the second
column is flux in erg cm-2 s-1 AA-1
:return: the path to the saved spectrum file
"""
if os.path.exists(save_dir + object_name + 'spectrum.dat'):
getLogger(__name__).info('Spectrum already loaded, will not be reloaded')
spectrum_file = save_dir + object_name + 'spectrum.dat'
return spectrum_file
getLogger(__name__).info('Looking for {} spectrum in SDSS catalog'.format(object_name))
result = SDSS.query_region(coords, spectro=True)
if not result:
getLogger(__name__).warning('Could not find spectrum for {} at {},{} in SDSS catalog'.format(object_name, coords.ra, coords.dec))
spectrum_file = None
return spectrum_file
spec = SDSS.get_spectra(matches=result)
data = spec[0][1].data
lamb = 10**data['loglam'] * u.AA
flux = data['flux'] * 10 ** -17 * u.Unit('erg cm-2 s-1 AA-1')
spectrum = Spectrum1D(spectral_axis=lamb, flux=flux)
res = np.array([spectrum.spectral_axis, spectrum.flux])
res = res.T
spectrum_file = save_dir + object_name + 'spectrum.dat'
np.savetxt(spectrum_file, res, fmt='%1.4e')
getLogger(__name__).info('Spectrum loaded for {} from SDSS catalog'.format(object_name))
return spectrum_file
def query_sdss(coor, radius=None):
try:
pos = coords.SkyCoord(coor, frame='icrs')
except:
pos = coords.SkyCoord(raw_to_skycoor(coor), frame='icrs')
if not radius:
radius = 20. * units.arcsec
return SDSS.query_region(pos ,radius=radius, spectro=True)
def standardQuery(self):
self.result = SDSS.query_region(self.position, radius=self.rad, spectro=True)
try:
for i in range(0, len(self.result)):
self.ra.append(self.result[i]['ra'])
self.dec.append(self.result[i]['dec'])
return self.result
except:
raise ValueError("No Results found. Try a different search area.")
def query_sdss(ra, dec, unit='deg', frame='icrs', band='i', spectro=False):
'''Query SDSS. Many filters are available. See this URL for more:
http://skyserver.sdss.org/dr2/en/proj/advanced/color/sdssfilters.asp.'''
position = coords.SkyCoord(ra, dec, unit=unit, frame=frame)
id = SDSS.query_region(position, spectro=spectro)
images = SDSS.get_images(matches=id, band=band)
return images[0] # use first image, which is the corrected one I think
def sdss_fits(coo, filtro='r'):
try:
n_coo = len(coo)
except:
n_coo = 1
coo = [coo]
n_col = np.min([n_coo, 4])
n_row = np.ceil(n_coo * 1. / n_col)
fig, ax = plt.subplots(figsize=(5 * n_col, 5 * n_row),
sharex=True,
sharey=True)
for i in range(len(coo)):
ax = plt.subplot(n_row, n_col, i + 1)
print 'Procesando galaxia ' + str(i)
xid = SDSS.query_region(coo[i], spectro=True)
image = SDSS.get_images(matches=xid, band=filtro)[0][0]
im_h = image.header
im_data = image.data
im_median = np.median(im_data)
im_std = np.std(im_data)
im_wcs = WCS(im_h)
im_data = Cutout2D(im_data,
coo[i],
u.Quantity((1., 1.), u.arcmin),
wcs=im_wcs).data
# ax.imshow(im_data,vmin=im_median-1*im_std, vmax=im_median+5*im_std, cmap=plt.get_cmap('gray'), interpolation='nearest')
ax.imshow(imtoasinh(im_data.T),
vmin=0.1,
vmax=0.8,
cmap=plt.get_cmap('gray'),
interpolation='nearest',
origin='lower')
ax.axis('off')
ax.text(0.05,
0.05,
str(i),
transform=ax.transAxes,
color='white',
fontsize=16)
ax.text(0.95,
0.05,
'Filtro ' + filtro,
transform=ax.transAxes,
color='white',
fontsize=16,
horizontalalignment='right')
ax.invert_xaxis()
fig.subplots_adjust(hspace=0.1, wspace=0.1)
def getimg(ira, idec, imsize, BW=False, DSS=None):
''' Grab an SDSS image from the given URL, if possible
Parameters:
----------
ira: (float or Quantity) RA in decimal degrees
idec: (float or Quantity) DEC in decimal degrees
imsize: Image size in arcmin (without units)
'''
import PIL
from PIL import Image
# Strip units as need be
try:
ra = ira.value
except AttributeError:
ra = ira
dec = idec
else:
dec = idec.value
# Get URL
if DSS == None: # Default
url = sdsshttp(ra, dec, imsize)
else:
url = dsshttp(ra, dec, imsize) # DSS
# Request
rtv = requests.get(url)
# Query for photometry
coord = SkyCoord(ra=ra * u.degree, dec=dec * u.degree)
phot = SDSS.query_region(coord, radius=0.02 * u.deg)
if phot is None:
print('getimg: Pulling from DSS instead of SDSS')
BW = 1
url = dsshttp(ra, dec, imsize) # DSS
rtv = requests.get(url)
# Python 3
try:
img = Image.open(StringIO(rtv.content))
except:
img = Image.open(BytesIO(rtv.content))
# B&W ?
if BW:
import PIL.ImageOps
img2 = img.convert("L")
img2 = PIL.ImageOps.invert(img2)
img = img2
return img, BW
def loop_through__sep(table, f, length, mag_limit, z_lim):
sep_list = []
for i in np.arange(length):
righta = table["RA"][i]
declin = table["DEC"][i]
if np.abs(table["GLAT"][i]) < 20:
continue
pos = coords.SkyCoord(ra=righta * u.degree, dec=declin * u.degree)
galatic_pos = pos.galactic
xid = SDSS.query_region(galatic_pos,
spectro=True,
radius=2.5 * u.arcmin,
specobj_fields=['Z', 'class'],
photoobj_fields=[
'ra', 'dec', 'modelMag_u', 'modelMag_g',
'modelMag_r', 'modelMag_i'
])
if xid is None:
continue
xid = unique(xid, keys=['ra', 'dec'])
xid.sort(f)
mask_redshift = xid['Z'] < z_lim
xid = xid[mask_redshift]
if xid is None:
continue
for v in np.arange(len(xid)):
max_mag_object = xid[v]
max_mag_object = Table(max_mag_object)
if max_mag_object[f] > mag_limit and v > 0:
break
if max_mag_object["class"] == "GALAXY":
righta_max = max_mag_object["ra"]
declin_max = max_mag_object["dec"]
sep = pos.separation(
coords.SkyCoord(ra=righta_max * u.degree,
dec=declin_max * u.degree))
sep_list.append(sep.arcsecond[0])
return sep_list
def lco_xid_sdss_query():
"""
Get sdss star properties, rmag and wcs for 112 target fields in our LCOLSS program.
Needed if want to do a ZP calibration to the LCO data.
Note requires Visiblity.csv stored locally. Matches ra/dec of lco targets from Visibility.csv
to stars from sdss database
"""
from astroquery.sdss import SDSS
visibility = ascii.read('Visibility.csv')
Source_IDs = visibility['col1'] # Source IDs
ra_deg = visibility['col2']
dec_deg = visibility['col3']
for idx in range(1, len(visibility[1:]) + 1):
print("------------------------------")
obj, ra, dec = Source_IDs[idx], ra_deg[idx], dec_deg[idx]
print(idx, obj, ra, dec)
"""
full_radius ~ pixscale * 2048 is arcsec from center of an LCO exposure image
go to 90% of that radius to account for target ra/dec dithers i.e. not being perfectly centered and edge effects
"""
full_radius = 0.389 * (4096 / 2)
radius = 0.85 * full_radius
strradius = str(radius) + ' arcsec'
print(
radius, 'ra ~ [{:.2f},{:.2f}], dec ~ [{:.2f},{:.2f}]'.format(
float(ra) - radius / 3600,
float(ra) + radius / 3600,
float(dec) - radius / 3600,
float(dec) + radius / 3600))
fields = [
'ra', 'dec', 'objid', 'run', 'rerun', 'camcol', 'field', 'r',
'mode', 'nChild', 'type', 'clean', 'probPSF', 'psfMag_r',
'psfMagErr_r'
]
pos = SkyCoord(ra, dec, unit="deg", frame='icrs')
xid = SDSS.query_region(pos,
radius=strradius,
fields='PhotoObj',
photoobj_fields=fields)
Star = xid[xid['probPSF'] == 1]
Gal = xid[xid['probPSF'] == 0]
print(len(xid), len(Star), len(Gal))
Star = Star[Star['clean'] == 1]
print(len(Star))
ascii.write(Star, f"{obj}_SDSS_CleanStar.csv")
idx += 1
def getimg(ira, idec, imsize, BW=False, DSS=None):
''' Grab an SDSS image from the given URL, if possible
Parameters:
----------
ira: (float or Quantity) RA in decimal degrees
idec: (float or Quantity) DEC in decimal degrees
imsize: Image size in arcmin (without units)
'''
import PIL
from PIL import Image
# Strip units as need be
try:
ra = ira.value
except AttributeError:
ra = ira
dec = idec
else:
dec = idec.value
# Get URL
if DSS == None: # Default
url = sdsshttp(ra,dec,imsize)
else:
url = dsshttp(ra,dec,imsize) # DSS
# Request
rtv = requests.get(url)
# Query for photometry
coord = SkyCoord(ra=ra*u.degree, dec=dec*u.degree)
phot = SDSS.query_region(coord, radius=0.02*u.deg)
if phot is None:
print('getimg: Pulling from DSS instead of SDSS')
BW = 1
url = dsshttp(ra,dec,imsize) # DSS
rtv = requests.get(url)
img = Image.open(StringIO(rtv.content))
# B&W ?
if BW:
import PIL.ImageOps
img2 = img.convert("L")
img2 = PIL.ImageOps.invert(img2)
img = img2
return img, BW
def loop_through_planck_petro(table, f, length, mag_limit, z_lim):
new_table_galaxy = Table(names=(table.colnames))
for i in np.arange(length):
righta = table["RA"][i]
declin = table["DEC"][i]
if np.abs(table["GLAT"][i]) < 20:
continue
pos = coords.SkyCoord(ra=righta * u.degree, dec=declin * u.degree)
galatic_pos = pos.galactic
xid = SDSS.query_region(galatic_pos,
spectro=True,
radius=2.5 * u.arcmin,
specobj_fields=['Z', 'class'],
photoobj_fields=[
'ra', 'dec', 'petroMag_u', 'petroMag_g',
'petroMag_r', 'petroMag_i'
])
if xid is None:
continue
xid = unique(xid, keys=['ra', 'dec'])
mask_redshift = xid['Z'] < z_lim
xid = xid[mask_redshift]
if xid is None:
continue
xid.sort(f)
for v in np.arange(len(xid)):
max_mag_object = xid[v]
max_mag_object = Table(max_mag_object)
if max_mag_object[f] > mag_limit and v > 0:
break
if max_mag_object["class"] == "GALAXY":
new_table_galaxy = vstack([new_table_galaxy, max_mag_object])
return [new_table_galaxy]
def cross_match_sdss(imageFile, extension, sources, quality_detections, extent, search_radius=3):
data, image, hdulist, size, mid_point = load_image_data(imageFile, extent, extension=extension)
# garbage collect data and image
data = None
image = None
# cross match quality detections with SDSS
filter = hdulist[extension].header["HIERARCH FPA.FILTERID"].split(".")[0]
# get WCS info from fits header
wcs = WCS(hdulist[extension].header)
reference_dict = {}
pos_output = open(imageFile+".quality.coo", "w")
count = 0
for index in quality_detections:
if count == 30:
break
print
pixcrd = np.array([[sources['xcentroid'][index]+((size[0]/2.0)-extent), \
sources['ycentroid'][index]+((size[1]/2.0)-extent)]], np.float_)
world = wcs.wcs_pix2world(pixcrd, 1)
pos = coords.SkyCoord(ra=world[0][0]*u.degree,dec=world[0][1]*u.degree, frame='icrs')
# search ? arsec region in SDSS
xid = SDSS.query_region(pos, radius=search_radius*(1/3600.0)*u.degree)
print xid
try:
for i in range(len(xid["objid"])):
id = xid["objid"][i]
mag, mag_err = get_reference_mags(id, filter)
if mag == "NULL":
continue
break
except TypeError:
continue
print
print "[*] %s, %s, %s, %s" % (id, str((sources['xcentroid'][index], sources['ycentroid'][index])), str(mag), str(mag_err))
if mag != "NULL" and mag_err != "NULL":
reference_dict[index] = {"mag":float(mag), "mag_err":float(mag_err), \
"id":id, "pos":(sources['xcentroid'][index], \
sources['ycentroid'][index])}
pos_output.write("%s %s\n" % (str(pixcrd[0][0]), str(pixcrd[0][1])))
count += 1
pos_output.close()
return reference_dict
def loop_through__redshift(table, f, length, mag_limit, z_lim):
new_table_galaxy = Table()
for i in np.arange(length):
righta = table["RA"][i]
declin = table["DEC"][i]
if np.abs(table["GLAT"][i]) < 20:
continue
pos = coords.SkyCoord(ra=righta * u.degree, dec=declin * u.degree)
galatic_pos = pos.galactic
xid = SDSS.query_region(galatic_pos,
spectro=True,
radius=2.5 * u.arcmin,
specobj_fields=['Z', 'class'],
photoobj_fields=[
'ra', 'dec', 'modelMag_u', 'modelMag_g',
'modelMag_r', 'modelMag_i'
])
if xid is None:
continue
xid = unique(xid, keys=['ra', 'dec'])
mask_gal = (xid["class"] == "GALAXY")
xid = xid[mask_gal]
if len(xid) == 0:
continue
xid.sort(f)
data_mask = xid[f] > mag_limit
data = xid[data_mask]
if len(data) == 0:
data = Table(xid[0])
new_table_galaxy = vstack([new_table_galaxy, data])
print(len(new_table_galaxy))
# print(new_table_galaxy)
return new_table_galaxy
def download_sdss_spec(self, add_r=0):
sdss = SDSS()
self.spec_data_table = sdss.query_region(self.loc,
radius=(self.r + add_r) *
u.arcsec,
spectro=True)
if self.has_spec() == True:
print("在r=%f角秒内找到了%d个光谱" %
(self.r + add_r, len(self.spec_data_table)))
self.spec = SDSS.get_spectra(matches=self.spec_data_table)
i = 0
for match in self.spec_data_table:
self.spec[i] = Spectra(match['objid'], self.spec[i])
i = i + 1
else:
print("在r=%f角秒内没有找到光谱" % (self.r + add_r))
def xgetsdss(ra, dec):
#hcg7_center = SkyCoord.from_name('HCG 7')
#hcg7_center = "20.81625, 0.88806"
print("ra=%f, dec=%f\n" % (ra, dec))
hcg7_center = str(ra) + "," + str(dec)
print("hcg7 is %s\n" % (hcg7_center))
sdss = SDSS.query_region(
coordinates=hcg7_center,
radius=20 * u.arcsec,
spectro=False,
photoobj_fields=['ra', 'dec', 'u', 'g', 'r', 'i', 'z'])
print(sdss)
filename = str(hcg7_center) + "_sdss.txt"
# with open(filename, 'a') as f: # 如果filename不存在会自动创建， 'a'表示追加数据
# f.write(str(sdss))
np.savetxt(filename, sdss, fmt='%f', header='ra, dec, u, g, r, i, z')
def get_spec_img(ra, dec):
from PIL import Image
from cStringIO import StringIO
# Coord
coord = SkyCoord(ra=ra*u.degree, dec=dec*u.degree)
# Query database
radius = 1*u.arcsec
spec_catalog = SDSS.query_region(coord,spectro=True, radius=radius.to('degree'))
# Request
url = 'http://skyserver.sdss.org/dr12/en/get/SpecById.ashx?id='+str(int(spec_catalog['specobjid']))
rtv = requests.get(url)
img = Image.open(StringIO(rtv.content))
return img
def get_spec_img(ra, dec):
from PIL import Image
from cStringIO import StringIO
# Coord
coord = SkyCoord(ra=ra * u.degree, dec=dec * u.degree)
# Query database
radius = 1 * u.arcsec
spec_catalog = SDSS.query_region(coord,
spectro=True,
radius=radius.to('degree'))
# Request
url = 'http://skyserver.sdss.org/dr12/en/get/SpecById.ashx?id=' + str(
int(spec_catalog['specobjid']))
rtv = requests.get(url)
img = Image.open(StringIO(rtv.content))
return img
def sdss_check(x, y):
"""
Check whether stars are in the SDSS catalogue.
This function accepts either a single x and y coordinate,
or an array of each.
"""
w = WCS('a100.fits')
sfilt = []
# Check which format x and y are given in.
if not (isinstance(x, (np.ndarray, list, float, int)) &
isinstance(y, (np.ndarray, list, float, int)) &
(np.shape(x) == np.shape(y))):
print('Error: Need a set of pixel coordinates.')
print(' X and Y must have same non-zero size.')
raise TypeError
x = [x] if (np.shape(x) == ()) else x
y = [y] if (np.shape(y) == ()) else y
lon, lat = w.all_pix2world(x, y, 1)
pos = coords.SkyCoord(lon, lat, unit="deg")
if len(pos) == 1:
pos = [pos]
table_fields = ['RA', 'Dec', 'psfMag_r', 'psfMagErr_r',
'psffwhm_r', 'nDetect', 'X_pixel', 'Y_pixel']
sfilt = AstroTable(names=table_fields)
for index, position in enumerate(pos):
sfull = SDSS.query_region(position, radius='1arcsec', data_release=13,
photoobj_fields=table_fields[:-2])
try:
sline = (sfull[np.where((sfull['nDetect'] > 0) &
(sfull['psfMag_r'] > -99))[0]][0])
slist = [sl for sl in sline]
slist.append(x[index])
slist.append(y[index])
sfilt.add_row(slist)
except (TypeError, IndexError):
print("Star at " + str(position)[39:-1] + " not found :-(.")
slist = np.zeros(len(table_fields))
slist[-2:] = x[index], y[index]
sfilt.add_row(slist)
return sfilt
def get_obj_data(ra, dec):
# Coordinates from SDSS SQL search
objCoord = SkyCoord(ra=ra * u.degree, dec=dec * u.degree)
# Get SDSS images
xObj = SDSS.query_region(objCoord, spectro=True)
imgObj = SDSS.get_images(matches=xObj)
image_i = imgObj[0][0]
data_i = image_i.data
# Get image coordinates
wcs = WCS(image_i.header)
# Cut the Field of view 25.0 x 25.0 arcsec
FoV = np.array([ra_cut, ra_cut])
FoV_dimen = u.Quantity((FoV[0], FoV[1]), u.arcsec)
cutout = Cutout2D(data_i, objCoord, FoV_dimen, wcs=wcs)
wcs_cut = cutout.wcs
ret = cutout.data.astype(float)
#normalizing cutout data
ret = normalize_data(ret)
#for i in cutout.data.size: ret.append(cutout.data[i])
#plot(objCoord,cutout)
#print(cutout.data.size)
return ret
def getPlateFits(position,bandName):
"""Get SDSS plate in fits format
This function takes a position and band and returns the available fits images from
SDSS using Astroquery
Parameters
----------
position: string
Ra/Dec position with units e.g. ' 35.2345342d 5.3452346d'
bandName: string
Name of band e.g. i from ugrizy
Returns
-------
images astropy.table.Table
i think the return is an HDUlist of all the available fits for a position/band.
"""
#First check if it is already there by looping through files
pos = coordinates.SkyCoord(position, frame='icrs')
xid = SDSS.query_region(pos)
# bandName = 'g'
# plate = xid[0]['plate']
images = SDSS.get_images(matches=xid, band=bandName)
# filename = str(plate) + '-' + bandName + '.fits'
# alreadyDownloaded = False
# for f in os.listdir('/Users/rs548/Documents/Science/PeteHurley/SDSS/'):
# print(f)
# if f == filename:
# alreadyDownloaded = True
#
# if alreadyDownloaded == False:
# im = SDSS.get_images(matches=xid, band=bandName)
# im.writeto('/Users/rs548/Documents/Science/PeteHurley/SDSS/' + filename)
# else:
# im = fits.open('/Users/rs548/Documents/Science/PeteHurley/SDSS/' + filename)
return images
def sdss_query(ra,dec,radius=5*u.arcmin,minmag=16.5,maxmag=20):
from astroquery.sdss import SDSS
from astropy import coordinates as coords
import astropy.units as u
pos = coords.SkyCoord(ra,dec,unit="deg", frame='icrs')
table = SDSS.query_region(pos,fields=['type','ra','dec','u','g','r','i','z','err_u','err_g','err_r','err_i','err_z'],radius=5*u.arcmin)
mask = (table["type"]==6) * (table["r"] > minmag) * (table["r"] < maxmag) * (table["g"] > minmag) * (table["g"] < maxmag)* (table["i"] > minmag) * (table["i"] < maxmag)* (table["u"] > minmag) * (table["u"] < maxmag)
table = table[mask]
newtable = np.zeros(len(table), dtype=[("ra", np.double), ("dec", np.double), ("rmag", np.float),("umag", np.float), ("gmag", np.float), ("imag", np.float),("zmag", np.float),("Imag", np.float),("Umag", np.float)])
newtable["ra"] = table["ra"]
newtable["dec"] = table["dec"]
newtable["gmag"] = table["g"]
newtable["rmag"] = table["r"]
newtable["umag"] = table["u"]
newtable["imag"] = table["i"]
newtable["zmag"] = table["z"]
newtable["Imag"] = table["i"]-0.386*(table["i"]-table["z"])-0.397
B = table["g"]+0.313*(table["g"]-table["r"])+0.2271
newtable["Umag"] = B+0.77*(table["u"]-table["g"])-0.88
return newtable
def rand_loop_through__redshift(table, f, length, width):
new_table_galaxy = Table()
while len(new_table_galaxy) < length:
righta = np.random.uniform(-180, 180)
declin = np.random.uniform(-90, 90)
pos = coords.SkyCoord(ra=righta * u.degree, dec=declin * u.degree)
galatic_pos = pos.galactic
xid = SDSS.query_region(galatic_pos,
spectro=True,
radius=width * u.arcmin,
specobj_fields=['Z'],
photoobj_fields=['ra', 'dec'])
if xid is None:
continue
xid = unique(xid, keys=['ra', 'dec'])
new_table_galaxy = vstack([new_table_galaxy, xid])
print(len(new_table_galaxy))
# print(new_table_galaxy)
return new_table_galaxy
from astroquery.simbad import Simbad
result_table = Simbad.query_object("m1")
result_table.pprint(show_unit=True)
from astroquery.sdss import SDSS
from astropy import coordinates as coords
#pos = coords.SkyCoord(packet['candidate']['ra'],packet['candidate']['dec'], unit="deg”) #to use info from avro packet
pos = coords.SkyCoord(244.566202,16.138884, unit="deg”) #to test query
xid = SDSS.query_region(pos, spectro=True)
print(xid)
print(xid.columns)
xid['z']
sp = SDSS.get_spectra(matches=xid)
im = SDSS.get_images(matches=xid, band='r')
from __future__ import print_function
import matplotlib.pyplot as plt
from astroquery.sdss import SDSS
from astropy import units
# Photoobj_fields: UGRIZ
# UGRIZ: http://www1.cadc-ccda.hia-iha.nrc-cnrc.gc.ca/community/CFHTLS-SG/docs/extra/sdsscfhtlsugriz.gif
# Let's get g and r magnitudes of stars in the globular cluster M13, in the 10 arcmin radius
result_table = SDSS.query_region('m13',
radius=10 * units.deg / 60,
photoobj_fields=['ra', 'dec', 'g', 'r'])
# Stars in the random part of the sky, with no clusters (stars at r = 22 and g-r = 0.5 are halo stars)
#result_table = SDSS.query_region('22h46m24.00s +31d42m00.0s', radius=0.5*units.deg, photoobj_fields=['ra', 'dec', 'g', 'r'])
# Start in the random part of the sky (with a cluster in the halo!) - Monoceros Ring
# result_table = SDSS.query_region('7h40m48.00s +32d42m00.0s', radius=0.5*units.deg, photoobj_fields=['ra', 'dec', 'g', 'r'])
print(result_table)
r_mags = []
gr_mags = []
for row in result_table:
g = row[2]
r = row[3]
def grab_sdss_spectra(radec, radius=0.1*u.deg, outfil=None,
debug=False, maxsep=None, timeout=600., zmin=None):
""" Grab SDSS spectra
Parameters
----------
radec : tuple
RA, DEC in deg
radius : float, optional (0.1*u.deg)
Search radius -- Astroquery actually makes a box, not a circle
timeout : float, optional
Timeout limit for connection with SDSS
outfil : str ('tmp.fits')
Name of output file for FITS table
maxsep : float (None) :: Mpc
Maximum separation to include
zmin : float (None)
Minimum redshift to include
Returns
-------
tbl : Table
"""
cC = coords.SkyCoord(ra=radec[0], dec=radec[1])
# Query
photoobj_fs = ['ra', 'dec', 'objid', 'run', 'rerun', 'camcol', 'field']
mags = ['petroMag_u', 'petroMag_g', 'petroMag_r', 'petroMag_i', 'petroMag_z']
magsErr = ['petroMagErr_u', 'petroMagErr_g', 'petroMagErr_r', 'petroMagErr_i', 'petroMagErr_z']
phot_catalog = SDSS.query_region(cC,spectro=True,radius=radius, timeout=timeout,
photoobj_fields=photoobj_fs+mags+magsErr) # Unique
spec_catalog = SDSS.query_region(cC,spectro=True, radius=radius, timeout=timeout) # Duplicates exist
nobj = len(phot_catalog)
#
print('grab_sdss_spectra: Found {:d} sources in the search box.'.format(nobj))
# Coordinates
cgal = SkyCoord(ra=phot_catalog['ra']*u.degree, dec=phot_catalog['dec']*u.degree)
sgal = SkyCoord(ra=spec_catalog['ra']*u.degree, dec=spec_catalog['dec']*u.degree)
sepgal = cgal.separation(cC) #in degrees
# Check for problems and parse z
zobj = np.zeros(nobj)
idx, d2d, d3d = coords.match_coordinates_sky(cgal, sgal, nthneighbor=1)
if np.max(d2d) > 1.*u.arcsec:
print('No spectral match!')
xdb.set_trace()
else:
zobj = spec_catalog['z'][idx]
idx, d2d, d3d = coords.match_coordinates_sky(cgal, cgal, nthneighbor=2)
if np.min(d2d.to('arcsec')) < 1.*u.arcsec:
print('Two photometric sources with same RA/DEC')
xdb.set_trace()
#xdb.set_trace()
# Cut on Separation
if not maxsep is None:
print('grab_sdss_spectra: Restricting to {:g} Mpc separation.'.format(maxsep))
sepgal_kpc = cosmo.kpc_comoving_per_arcmin(zobj) * sepgal.to('arcmin')
sepgal_mpc = sepgal_kpc.to('Mpc')
gdg = np.where( sepgal_mpc < (maxsep * u.Unit('Mpc')))[0]
phot_catalog = phot_catalog[gdg]
#xdb.set_trace()
nobj = len(phot_catalog)
print('grab_sdss_spectra: Grabbing data for {:d} sources.'.format(nobj))
# Grab Spectra from SDSS
# Generate output table
attribs = galaxy_attrib()
npix = 5000 #len( spec_hdus[0][1].data.flux )
spec_attrib = [(str('FLUX'), np.float32, (npix,)),
(str('SIG'), np.float32, (npix,)),
(str('WAVE'), np.float64, (npix,))]
tbl = np.recarray( (nobj,), dtype=attribs+spec_attrib)
tbl['RA'] = phot_catalog['ra']
tbl['DEC'] = phot_catalog['dec']
tbl['TELESCOPE'] = str('SDSS 2.5-M')
# Deal with spectra separately (for now)
npix = 5000 #len( spec_hdus[0][1].data.flux )
for idx,obj in enumerate(phot_catalog):
#print('idx = {:d}'.format(idx))
# Grab spectra (there may be duplicates)
mt = np.where( sgal.separation(cgal[idx]).to('arcsec') < 1.*u.Unit('arcsec'))[0]
if len(mt) > 1:
# Use BOSS if you have it
mmt = np.where( spec_catalog[mt]['instrument'] == 'BOSS')[0]
if len(mmt) > 0:
mt = mt[mmt[0]]
else:
mt = mt[0]
elif len(mt) == 0:
xdb.set_trace()
else:
mt = mt[0]
# Grab spectra
spec_hdus = SDSS.get_spectra(matches=Table(spec_catalog[mt]))
tbl[idx]['INSTRUMENT'] = spec_catalog[mt]['instrument']
spec = spec_hdus[0][1].data
npp = len(spec.flux)
tbl[idx]['FLUX'][0:npp] = spec.flux
sig = np.zeros(npp)
gdi = np.where(spec.ivar > 0.)[0]
if len(gdi) > 0:
sig[gdi] = np.sqrt( 1./spec.ivar[gdi] )
tbl[idx]['SIG'][0:npp] = sig
tbl[idx]['WAVE'][0:npp] = 10.**spec.loglam
# Redshifts
meta = spec_hdus[0][2].data
for attrib in ['Z','Z_ERR']:
tbl[idx][attrib] = meta[attrib]
if debug:
sep_to_qso = cgal[idx].separation(cC).to('arcmin')
print('z = {:g}, Separation = {:g}'.format(tbl[idx].Z, sep_to_qso))
xdb.set_trace()
# Fill in rest
tbl[idx].SDSS_MAG = np.array( [obj[phot] for phot in mags])
tbl[idx].SDSS_MAGERR = np.array( [obj[phot] for phot in magsErr])
# Clip on redshift to excise stars/quasars
if zmin is not None:
gd = np.where(tbl['Z'] > zmin)[0]
tbl = tbl[gd]
# Write to FITS file
if outfil is not None:
prihdr = fits.Header()
prihdr['COMMENT'] = 'SDSS Spectra'
prihdu = fits.PrimaryHDU(header=prihdr)
tbhdu = fits.BinTableHDU(tbl)
thdulist = fits.HDUList([prihdu, tbhdu])
thdulist.writeto(outfil,clobber=True)
print('Wrote SDSS table to {:s}'.format(outfil))
return tbl
def sdss_spectra(coo, redshift=0., columns=1):
try:
n_coo=len(coo)
except:
n_coo=1
coo=[coo]
try:
n_redshift=len(redshift)
except:
n_redshift=1
redshift=[redshift]
if n_coo>1 & n_redshift==1:
redshift=np.ones(n_coo)*redshift[0]
n_col=np.min([n_coo,columns])
n_row=np.ceil(n_coo*1./n_col)
fig, ax = plt.subplots(figsize=(16,6*n_row/(n_col*1.)), sharex=True, sharey=True)
# fig, ax = plt.subplots(figsize=(20,8*n_coo), sharex=True, sharey=True)
for i in range(len(coo)):
ax = plt.subplot(n_row, n_col, i+1)
#ax = plt.subplot(n_coo, 1,i+1)
print 'Procesando galaxia '+str(i)
xid = SDSS.query_region(coo[i], spectro=True)
spec=SDSS.get_spectra(matches=xid)[0][1]
spec_h=spec.header
spec_data=spec.data
loglam=spec_data['loglam'] # Logaritmo de la longitud de onda
flux=spec_data['flux'] # Flujo medido en unidades de Ergs/cm^2/s/AA
window_len=9
s=np.r_[flux[window_len-1:0:-1],flux,flux[-1:-window_len:-1]]
w=np.ones(window_len,'d')
w=eval('np.bartlett(window_len)')
flux_smooth=np.convolve(w/w.sum(),s,mode='valid')[(window_len-1)/2:-(window_len-1)/2]
gv=(loglam>np.log10(4000.)) & (loglam<np.log10(8000.))
flux_scale=80./np.percentile(flux_smooth[gv],98)
#ax.plot(10.**loglam, flux*flux_scale, label=xid['instrument'][0], color='black', linewidth=1)
ax.plot(10.**loglam, flux_smooth*flux_scale, label=xid['instrument'][0], color='black', linewidth=1)
for j in range(len(absorption_lines['name'])):
ax.plot(absorption_lines['lambda'][j]*np.ones(2)*(1.+redshift[i]), [0., 1e5], absorption_lines['color']+'--')
ax.text(absorption_lines['lambda'][j]*(1.+redshift[i])+absorption_lines['offset'][j], absorption_lines['position'][j]*100., absorption_lines['name'][j], color=absorption_lines['color'], alpha=0.7, fontsize=16/(n_col*0.8), horizontalalignment=absorption_lines['align'][j])
for j in range(len(emission_lines['name'])):
ax.plot(emission_lines['lambda'][j]*np.ones(2)*(1.+redshift[i]), [0., 1e5], emission_lines['color']+'--')
ax.text(emission_lines['lambda'][j]*(1.+redshift[i])+emission_lines['offset'][j], emission_lines['position'][j]*100., emission_lines['name'][j], color=emission_lines['color'], alpha=0.7, fontsize=16/(n_col*0.8), horizontalalignment=emission_lines['align'][j])
if (i % n_col == 0):
ax.set_ylabel(r'Flujo [10$^{-17}$ ergs/cm$^2$/s/$\AA$]', fontsize=14/(n_col*0.8))
if (i >= (n_col*(n_row-1))):
ax.set_xlabel(r'Longitud de onda [$\AA$]', fontsize=14)
ax.set_title('Galaxia '+str(i))
ax.set_xlim(3500,8000)
ax.set_ylim(0.,100.)
fig.subplots_adjust(hspace=0.3, wspace=0.1)
def loop_through_planck(table,f,length,mag_limit,z_lim):
new_table_galaxy = Table(names=(table.colnames))
col = Column(name='Aperture Type', length = len(new_table_galaxy))
new_table_galaxy.add_column(col)
new_table_star = Table(names=(table.colnames))
new_table_other = Table(names=(table.colnames))
sep_list = []
mag_list = []
mag_list_diff_one_two = []
mag_list_diff_two_three = []
for i in np.arange(length):
righta = table["RA"][i]
declin = table["DEC"][i]
if np.abs(table["GLAT"][i]) < 20:
continue
pos = coords.SkyCoord( ra = righta*u.degree , dec = declin*u.degree)
galatic_pos = pos.galactic
#objID not working correctly gives error "invalid load key, '\x00'."
#print("HI")
xid = SDSS.query_region(galatic_pos, spectro = True , radius = 2.5*u.arcmin , specobj_fields=['Z','class'], photoobj_fields=['ra','dec','modelMag_u','modelMag_g','modelMag_r','modelMag_i','lnLExp_u','lnLDeV_u'])
#xid = SDSS.query_region(galatic_pos, spectro = True , radius = 2.5*u.arcmin , fields=['Z','objID','class','ra','dec','modelMag_u','modelMag_g','modelMag_r','modelMag_i'],field_help = 'deVlnL')
# print("HEEEEYYYYYYYYYYYYYYYYYYYYYYYY")
# for q in np.arange(len(xid["photoobj_all"])):
# print(xid["photoobj_all"][q])
#
# print('HOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO')
# for q in np.arange(len(xid['specobj_all'])):
# print(xid['specobj_all'][q])
if xid is None:
continue
xid = unique(xid,keys=['ra', 'dec'])
xid.sort(f)
mag_list = np.concatenate((mag_list,xid[f]))
# if len(xid) == 1:
# mag_list_diff_one_two.append(xid[f][0])
if len(xid) == 2:
mag_list_diff_one_two.append(xid[f][1] - xid[f][0])
elif len(xid) > 2:
mag_list_diff_one_two.append(xid[f][1] - xid[f][0])
mag_list_diff_two_three.append(xid[f][2] - xid[f][1])
mask_redshift = xid['Z'] < z_lim
xid = xid[mask_redshift]
if xid is None:
continue
for v in np.arange(len(xid)):
max_mag_object = xid[v]
max_mag_object = Table(max_mag_object)
if max_mag_object[f] > mag_limit and v > 0:
break
if max_mag_object["class"] == "GALAXY":
if max_mag_object['lnLDeV_u'] > max_mag_object['lnLExp_u']:
max_mag_object['Aperture Type'] = 0
else:
max_mag_object['Aperture Type'] = 1
new_table_galaxy = vstack([new_table_galaxy, max_mag_object])
righta_max = max_mag_object["ra"]
declin_max = max_mag_object["dec"]
sep = pos.separation(coords.SkyCoord( ra = righta_max*u.degree , dec = declin_max*u.degree))
sep_list.append(sep.arcsecond)
elif max_mag_object["class"] == "STAR":
new_table_star = vstack([new_table_star, max_mag_object])
else:
new_table_other = vstack([new_table_other, max_mag_object])
return [new_table_galaxy,new_table_star,new_table_other,sep_list,mag_list,mag_list_diff_one_two,mag_list_diff_two_three]
def grab_sdss_spectra(radec,
radius=0.1 * u.deg,
outfil=None,
debug=False,
maxsep=None,
timeout=600.,
zmin=None):
""" Grab SDSS spectra
Parameters
----------
radec : tuple
RA, DEC in deg
radius : float, optional (0.1*u.deg)
Search radius -- Astroquery actually makes a box, not a circle
timeout : float, optional
Timeout limit for connection with SDSS
outfil : str ('tmp.fits')
Name of output file for FITS table
maxsep : float (None) :: Mpc
Maximum separation to include
zmin : float (None)
Minimum redshift to include
Returns
-------
tbl : Table
"""
cC = coords.SkyCoord(ra=radec[0], dec=radec[1])
# Query
photoobj_fs = ['ra', 'dec', 'objid', 'run', 'rerun', 'camcol', 'field']
mags = [
'petroMag_u', 'petroMag_g', 'petroMag_r', 'petroMag_i', 'petroMag_z'
]
magsErr = [
'petroMagErr_u', 'petroMagErr_g', 'petroMagErr_r', 'petroMagErr_i',
'petroMagErr_z'
]
phot_catalog = SDSS.query_region(cC,
spectro=True,
radius=radius,
timeout=timeout,
photoobj_fields=photoobj_fs + mags +
magsErr) # Unique
spec_catalog = SDSS.query_region(cC,
spectro=True,
radius=radius,
timeout=timeout) # Duplicates exist
nobj = len(phot_catalog)
#
print('grab_sdss_spectra: Found {:d} sources in the search box.'.format(
nobj))
# Coordinates
cgal = SkyCoord(ra=phot_catalog['ra'] * u.degree,
dec=phot_catalog['dec'] * u.degree)
sgal = SkyCoord(ra=spec_catalog['ra'] * u.degree,
dec=spec_catalog['dec'] * u.degree)
sepgal = cgal.separation(cC) #in degrees
# Check for problems and parse z
zobj = np.zeros(nobj)
idx, d2d, d3d = coords.match_coordinates_sky(cgal, sgal, nthneighbor=1)
if np.max(d2d) > 1. * u.arcsec:
print('No spectral match!')
xdb.set_trace()
else:
zobj = spec_catalog['z'][idx]
idx, d2d, d3d = coords.match_coordinates_sky(cgal, cgal, nthneighbor=2)
if np.min(d2d.to('arcsec')) < 1. * u.arcsec:
print('Two photometric sources with same RA/DEC')
xdb.set_trace()
#xdb.set_trace()
# Cut on Separation
if not maxsep is None:
print('grab_sdss_spectra: Restricting to {:g} Mpc separation.'.format(
maxsep))
sepgal_kpc = cosmo.kpc_comoving_per_arcmin(zobj) * sepgal.to('arcmin')
sepgal_mpc = sepgal_kpc.to('Mpc')
gdg = np.where(sepgal_mpc < (maxsep * u.Unit('Mpc')))[0]
phot_catalog = phot_catalog[gdg]
#xdb.set_trace()
nobj = len(phot_catalog)
print('grab_sdss_spectra: Grabbing data for {:d} sources.'.format(nobj))
# Grab Spectra from SDSS
# Generate output table
attribs = galaxy_attrib()
npix = 5000 #len( spec_hdus[0][1].data.flux )
spec_attrib = [(str('FLUX'), np.float32, (npix, )),
(str('SIG'), np.float32, (npix, )),
(str('WAVE'), np.float64, (npix, ))]
tbl = np.recarray((nobj, ), dtype=attribs + spec_attrib)
tbl['RA'] = phot_catalog['ra']
tbl['DEC'] = phot_catalog['dec']
tbl['TELESCOPE'] = str('SDSS 2.5-M')
# Deal with spectra separately (for now)
npix = 5000 #len( spec_hdus[0][1].data.flux )
for idx, obj in enumerate(phot_catalog):
#print('idx = {:d}'.format(idx))
# Grab spectra (there may be duplicates)
mt = np.where(
sgal.separation(cgal[idx]).to('arcsec') < 1. * u.Unit('arcsec'))[0]
if len(mt) > 1:
# Use BOSS if you have it
mmt = np.where(spec_catalog[mt]['instrument'] == 'BOSS')[0]
if len(mmt) > 0:
mt = mt[mmt[0]]
else:
mt = mt[0]
elif len(mt) == 0:
xdb.set_trace()
else:
mt = mt[0]
# Grab spectra
spec_hdus = SDSS.get_spectra(matches=Table(spec_catalog[mt]))
tbl[idx]['INSTRUMENT'] = spec_catalog[mt]['instrument']
spec = spec_hdus[0][1].data
npp = len(spec.flux)
tbl[idx]['FLUX'][0:npp] = spec.flux
sig = np.zeros(npp)
gdi = np.where(spec.ivar > 0.)[0]
if len(gdi) > 0:
sig[gdi] = np.sqrt(1. / spec.ivar[gdi])
tbl[idx]['SIG'][0:npp] = sig
tbl[idx]['WAVE'][0:npp] = 10.**spec.loglam
# Redshifts
meta = spec_hdus[0][2].data
for attrib in ['Z', 'Z_ERR']:
tbl[idx][attrib] = meta[attrib]
if debug:
sep_to_qso = cgal[idx].separation(cC).to('arcmin')
print('z = {:g}, Separation = {:g}'.format(tbl[idx].Z, sep_to_qso))
xdb.set_trace()
# Fill in rest
tbl[idx].SDSS_MAG = np.array([obj[phot] for phot in mags])
tbl[idx].SDSS_MAGERR = np.array([obj[phot] for phot in magsErr])
# Clip on redshift to excise stars/quasars
if zmin is not None:
gd = np.where(tbl['Z'] > zmin)[0]
tbl = tbl[gd]
# Write to FITS file
if outfil is not None:
prihdr = fits.Header()
prihdr['COMMENT'] = 'SDSS Spectra'
prihdu = fits.PrimaryHDU(header=prihdr)
tbhdu = fits.BinTableHDU(tbl)
thdulist = fits.HDUList([prihdu, tbhdu])
thdulist.writeto(outfil, clobber=True)
print('Wrote SDSS table to {:s}'.format(outfil))
return tbl
def downloadsdss(_ra,_dec,_band,_radius=20, force=False):
from astroquery.sdss import SDSS
from astropy import coordinates as coords
import astropy.units as u
from astropy.io import fits
import os
import sys
import string
import numpy as np
from scipy import interpolate
pos = coords.SkyCoord(ra=float(_ra)*u.deg,dec=float(_dec)*u.deg)
print 'pos =', pos
xid = SDSS.query_region(pos, spectro=False, radius=_radius*u.arcsec)
print xid
if xid:
pointing=[]
for i in xid:
if i['run'] > 300:
if (i['run'],i['camcol'],i['field']) not in pointing:
pointing.append((i['run'],i['camcol'],i['field']))
# if too many pointing, take only first 40
if len(pointing) > 50:
nn=50
else:
nn=len(pointing)
filevec=[]
print len(pointing)
for run, camcol, field in pointing[:nn]:
# naomaggie image
output1 = _band+'_SDSS_'+str(run)+'_'+str(camcol)+'_'+str(field)+'.fits'
# image in count
output2 = _band+'_SDSS_'+str(run)+'_'+str(camcol)+'_'+str(field)+'c.fits'
# weight image
output3 = _band+'_SDSS_'+str(run)+'_'+str(camcol)+'_'+str(field)+'.weight.fits'
# sky image
output4 = _band+'_SDSS_'+str(run)+'_'+str(camcol)+'_'+str(field)+'.sky.fits'
if os.path.isfile(output1) and not force:
print 'already downloaded', output1
filevec.append(output2)
filevec.append(output3)
continue
im = SDSS.get_images(run=run, camcol=camcol, field=field, band=_band, cache=True)
if os.path.isfile(output1):
os.system('rm '+output1)
if os.path.isfile(output2):
os.system('rm '+output2)
if os.path.isfile(output3):
os.system('rm '+output3)
if os.path.isfile(output4):
os.system('rm '+output4)
im[0].writeto(output1)
# im[0][0].writeto(output2)
FITS_file = fits.open(output1)
new_header = FITS_file[0].header
camcol = FITS_file[0].header['CAMCOL'] # camcol
ugriz = FITS_file[0].header['FILTER'] # ugriz filter
run1 = FITS_file[0].header['RUN'] # run
gain, dark_var = SDSS_gain_dark(camcol, ugriz, run1)
new_header['gain'] = gain
new_header['dark'] = dark_var
new_header['BUNIT'] = 'counts'
new_header['rdnoise'] = 2
frame_image = FITS_file[0].data.transpose()
allsky = FITS_file[2].data['ALLSKY'].transpose()
allsky = allsky[:,:,0]
xinterp = FITS_file[2].data['XINTERP'].transpose()
xinterp = xinterp[:,0]
yinterp = FITS_file[2].data['YINTERP'].transpose()
yinterp = yinterp[:,0]
sky_function = interpolate.interp2d(np.arange(allsky.shape[1]),\
np.arange(allsky.shape[0]), allsky, kind='linear')
sky_image = sky_function(yinterp, xinterp) # in counts
calib = FITS_file[1].data # nanomaggies per count
calib_image = np.empty_like(frame_image)
for i in np.arange(calib_image.shape[1]):
calib_image[:,i] = calib
# Calculate the error in the frame image for use fitting algorithms later.
dn_image = frame_image / calib_image # + sky_image # counts
dn_err_image = np.sqrt((dn_image + sky_image)/ gain + dark_var)
# frame_image_err = dn_err_image * calib_image converts to nanomaggies
frame_weight = 1 / ((dn_err_image)**2)
new_header['SKYLEVEL'] = np.mean(sky_image)
# save image in count
fits.writeto(output2, dn_image.transpose(), new_header,overwrite=True)
# save weight image
fits.writeto(output3, frame_weight.transpose(), new_header,overwrite=True)
# save sky image
fits.writeto(output4, sky_image.transpose(), new_header,overwrite=True)
filevec.append(output2)
filevec.append(output3)
return filevec
else:
return ''
def sdss(obsids_table,
data_folder,
moc_folder,
nir_moc=None,
data_release=14,
radius=15 * u.arcmin,
moc_order=15,
overwrite=True):
"""
Get SDSS data using astroquery.
For each observation in obsids_table, saves a fits file with
name 'OBS_ID.fits' in 'data_folder/groups'.
The function sends a query and selects all sources within 'radius'
of the RA,DEC of the observation, then it filters the result
selecting the sources in the corresponding MOC stored in 'moc_folder/mocs'
(moc_order must be consistent with the order used to calculate the MOC).
If overwrite is True, always create a new fits file. If False, checks for
an existing file and uses it to calculate the number of SDSS sources
in the field. If it doesn't exist, creates the file.
The function returns obsids_table with an additional column 'NSRC_SDSS'
with the number of sources in the field.
"""
# Groups folder
if nir_moc is None:
groups_folder = os.path.join(data_folder, 'groups')
else:
root, _ = os.path.splitext(os.path.basename(nir_moc))
survey = root.split('_')[-1]
groups_folder = os.path.join(data_folder, 'groups_' + survey)
moc_nirsurvey = MOC()
read_moc_fits(moc_nirsurvey, nir_moc)
if not os.path.exists(groups_folder):
os.makedirs(groups_folder)
moc_folder = os.path.join(moc_folder, 'mocs')
nsources_field = np.full((len(obsids_table), ), np.nan)
hp = HEALPix(nside=2**moc_order, order='nested', frame=ICRS())
photoobj_fields = ['objID', 'mode', 'ra', 'dec', 'raErr', 'decErr']
for i, row in enumerate(tqdm(obsids_table, desc="Making SDSS groups")):
## Group file name
field_table_file = os.path.join(data_folder, groups_folder,
'{}.fits'.format(row['OBS_ID']))
is_field_table = os.path.exists(field_table_file)
if overwrite or (not overwrite and not is_field_table):
## Select all sources in the field
field_coords = SkyCoord(ra=row['RA'] * u.deg,
dec=row['DEC'] * u.deg)
src_table = SDSS.query_region(field_coords,
radius=radius,
photoobj_fields=photoobj_fields,
data_release=data_release)
# Filter table
# In ARCHES, the only filter is selecting primary objects,
# no filtering in the quality of photometry (clean).
src_table = src_table[src_table['mode'] == 1]
## Select sources in the non-overlaping area
moc_field = MOC()
read_moc_fits(
moc_field,
os.path.join(moc_folder, '{}.moc'.format(row['OBS_ID'])))
if nir_moc is not None:
moc_field = moc_nirsurvey.intersection(moc_field)
inmoc_table = sources_inmoc(src_table,
hp,
moc_field,
moc_order=moc_order,
ra='ra',
dec='dec',
units=u.deg)
## Save sources
inmoc_table.remove_columns(['mode'])
inmoc_table.meta['description'] = 'SDSS'
inmoc_table.write(field_table_file, overwrite=True)
else:
inmoc_table = Table.read(field_table_file)
nsources_field[i] = len(inmoc_table)
colsrc = Table.Column(nsources_field, name='NSRC_SDSS')
obsids_table.add_column(colsrc)
return obsids_table
def downloadsdss(_ra, _dec, _band, _radius=20, force=False):
from astroquery.sdss import SDSS
from astropy import coordinates as coords
import astropy.units as u
from astropy.io import fits
import os
import sys
import string
import numpy as np
from scipy import interpolate
pos = coords.SkyCoord(ra=float(_ra) * u.deg, dec=float(_dec) * u.deg)
print 'pos =', pos
xid = SDSS.query_region(pos, spectro=False, radius=_radius * u.arcsec)
print xid
if xid:
pointing = []
for i in xid:
if i['run'] > 300:
if (i['run'], i['camcol'], i['field']) not in pointing:
pointing.append((i['run'], i['camcol'], i['field']))
# if too many pointing, take only first 40
if len(pointing) > 50:
nn = 50
else:
nn = len(pointing)
filevec = []
print len(pointing)
for run, camcol, field in pointing[:nn]:
# naomaggie image
output1 = _band + '_SDSS_' + str(run) + '_' + str(
camcol) + '_' + str(field) + '.fits'
# image in count
output2 = _band + '_SDSS_' + str(run) + '_' + str(
camcol) + '_' + str(field) + 'c.fits'
# weight image
output3 = _band + '_SDSS_' + str(run) + '_' + str(
camcol) + '_' + str(field) + '.weight.fits'
# sky image
output4 = _band + '_SDSS_' + str(run) + '_' + str(
camcol) + '_' + str(field) + '.sky.fits'
if os.path.isfile(output1) and not force:
print 'already downloaded', output1
filevec.append(output2)
filevec.append(output3)
continue
im = SDSS.get_images(run=run,
camcol=camcol,
field=field,
band=_band,
cache=True)
if os.path.isfile(output1):
os.system('rm ' + output1)
if os.path.isfile(output2):
os.system('rm ' + output2)
if os.path.isfile(output3):
os.system('rm ' + output3)
if os.path.isfile(output4):
os.system('rm ' + output4)
im[0].writeto(output1)
# im[0][0].writeto(output2)
FITS_file = fits.open(output1)
new_header = FITS_file[0].header
camcol = FITS_file[0].header['CAMCOL'] # camcol
ugriz = FITS_file[0].header['FILTER'] # ugriz filter
run1 = FITS_file[0].header['RUN'] # run
gain, dark_var = SDSS_gain_dark(camcol, ugriz, run1)
new_header['gain'] = gain
new_header['dark'] = dark_var
new_header['BUNIT'] = 'counts'
new_header['rdnoise'] = 2
frame_image = FITS_file[0].data.transpose()
allsky = FITS_file[2].data['ALLSKY'].transpose()
allsky = allsky[:, :, 0]
xinterp = FITS_file[2].data['XINTERP'].transpose()
xinterp = xinterp[:, 0]
yinterp = FITS_file[2].data['YINTERP'].transpose()
yinterp = yinterp[:, 0]
sky_function = interpolate.interp2d(np.arange(allsky.shape[1]),\
np.arange(allsky.shape[0]), allsky, kind='linear')
sky_image = sky_function(yinterp, xinterp) # in counts
calib = FITS_file[1].data # nanomaggies per count
calib_image = np.empty_like(frame_image)
for i in np.arange(calib_image.shape[1]):
calib_image[:, i] = calib
# Calculate the error in the frame image for use fitting algorithms later.
dn_image = frame_image / calib_image # + sky_image # counts
dn_err_image = np.sqrt((dn_image + sky_image) / gain + dark_var)
# frame_image_err = dn_err_image * calib_image converts to nanomaggies
frame_weight = 1 / ((dn_err_image)**2)
new_header['SKYLEVEL'] = np.mean(sky_image)
# save image in count
fits.writeto(output2,
dn_image.transpose(),
new_header,
clobber=True)
# save weight image
fits.writeto(output3,
frame_weight.transpose(),
new_header,
clobber=True)
# save sky image
fits.writeto(output4,
sky_image.transpose(),
new_header,
clobber=True)
filevec.append(output2)
filevec.append(output3)
return filevec
else:
return ''
additional["BAL"].append(row[8])
additional["z"].append(row[9])
additional["AV"].append(row[10])
masterframe = pd.DataFrame.from_dict(additional)
masternames = masterframe['NTT_study'].to_numpy(dtype=str)
# Because there's no spectral IDs, use the coordinates to search on SDSS
ra = masterframe['RA'].to_numpy()
dec = masterframe['Dec'].to_numpy()
extra_specid = list()
for r, d in tqdm(zip(ra, dec)):
co = coords.SkyCoord(r, d, unit=(u.hourangle, u.deg))
# Perform the search
result = SDSS.query_region(co, data_release=12, spectro=True)
if result == None:
extra_specid.append('')
else:
# Save the id, if it is there
extra_specid.append(result['specobjid'][-1])
# Similar to what was done for the fits file objects
masterurls = np.array(extra_specid, dtype=object)
for n, s in enumerate(extra_specid):
if s != '':
masterurls[
n] = f'http://skyserver.sdss.org/dr12/en/get/SpecById.ashx?id={s}'
else:
masterurls[n] = ''
# Get position of object for 2000 time and and given time
RA2000 = objd.get_ra()
DEC2000 = objd.get_dec()
RACurr = objd.get_ra(basetime)
DECCurr = objd.get_dec(basetime)
Objcoord = coordinates.SkyCoord(ra = RACurr, dec = DECCurr, unit=u.deg)
fields = ['objID','type', 'ra','dec']
for l in 'urigzHJK':
fields.append(l)
fields.append('Err_' + l)
Sdobjs = SDSS.query_region(Objcoord, photoobj_fields=fields,radius=radius*u.deg)
if Sdobjs is None:
print("No objects found in region of", objname, file=sys.stderr)
sys.exit(1)
# Convert to temp type for fiddling with eliminating too faint objs and ones with no mags
convsdobjs = []
for r in Sdobjs:
if onlytype is not None and r['type'] != onlytype:
continue
maglist = []
for i in 'urigz':
maglist.append(r[i])
mm = np.min(maglist)
