def datafetcher():
# This function fetches a sample SDSS data for ra, dec, run from PhotoObj within certain magnitudes.
# The resulting data table is then saved for future reference as a .csv file.
query1 = """
select
ra, dec, run
from PhotoObj
where psfMag_g BETWEEN 16.96 and 16.99
"""
query2 = """
select
ra, dec, run
from PhotoObj
where psfMag_g BETWEEN 17 and 17.041
"""
query3 = """
select
ra, dec, run
from PhotoObj
where psfMag_g BETWEEN 17.041 and 17.08
"""
query4 = """
select
ra, dec, run
from PhotoObj
where psfMag_g BETWEEN 17.08 and 18.02
"""
res1 = SDSS.query_sql(query1, timeout=3600).to_pandas()
res2 = SDSS.query_sql(query2, timeout=3600).to_pandas()
res3 = SDSS.query_sql(query3, timeout=3600).to_pandas()
res4 = SDSS.query_sql(query4, timeout=3600).to_pandas()
concat_res = pd.concat([res1, res2, res3, res4], ignore_index=True)
concat_res.to_csv('SDSSdatasample.csv')
return concat_res
def sdss_template(tipo='eliptica'):
if tipo=='eliptica':
template = SDSS.get_spectral_template('galaxy_early')
title='Espectro de galaxia eliptica'
lines=absorption_lines
elif tipo=='espiral':
template = SDSS.get_spectral_template('galaxy_late')
title='Espectro de galaxia espiral'
lines=emission_lines
spec_h=template[0][0].header
spec_data=template[0][0].data
wcs=WCS(spec_h)
index = np.arange(spec_h['NAXIS1'])
loglam=wcs.wcs_pix2world(index, np.zeros(len(index)), 0)[0]
flux=spec_data[0]
gv=(loglam>np.log10(4000.)) & (loglam<np.log10(8000.))
flux_scale=80./np.max(flux[gv])
fig, ax = plt.subplots(figsize=(20,8), sharex=True, sharey=True)
plt.plot(10**loglam, flux*flux_scale, '-', color='black', linewidth=1)
for j in range(len(lines['name'])):
ax.plot(lines['lambda'][j]*np.ones(2), [0., 1e5], lines['color']+'--')
ax.text(lines['lambda'][j]+lines['offset'][j], lines['position'][j]*100., lines['name'][j], color='black', fontsize=18, horizontalalignment=lines['align'][j])
ax.set_ylabel(r'Flujo [10$^{-17}$ ergs/cm$^2$/s/\AA]', fontsize=14)
ax.set_xlabel(r'Longitud de onda [\AA]', fontsize=14)
ax.set_title(title)
ax.set_xlim(3500,8000)
ax.set_ylim(0.,100.)
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 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_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 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 SDSS_get_calib(self, rad_min = 5):
'''
Parameters
----------
rad_min (optional, int or float) : search radius in decimal arcminutes
Output
------
file : writes processed calibration file and sets member variables
'''
# formulate SQL query and execute
query = '''SELECT p.ra, p.dec, p.u, p.Err_u, p.g, p.Err_g, p.r, p.Err_r, p.i, p.Err_i, p.z, p.Err_z
FROM fGetNearbyObjEq({},{},{}) n, PhotoPrimary p
WHERE n.objID = p.objID AND p.type = 6'''.format(self.targetra, self.targetdec, rad_min)
data = SDSS.query_sql(query)
# process and return results
if data is None:
print('Search of SDSS for calibration information failed...')
return None
for filt in 'ugriz':
data.rename_column('Err_' + filt, filt + 'Err')
self.cal_source = 'SDSS'
self.cal_filename = 'cal_{}_{}.dat'.format(self.targetname, self.cal_source)
ascii.write(data, os.path.join(self.relative_path, self.cal_filename))
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 SDSS_QUERY_SPEC_Z(TILE_RA_LOWER_LIMIT, TILE_DEC_LOWER_LIMIT,
TILE_RA_UPPER_LIMIT, TILE_DEC_UPPER_LIMIT):
query = "SELECT objID, ra, dec,z FROM SpecPhoto WHERE (ra between %s and %s) and (dec between %s and %s)" % (
TILE_RA_UPPER_LIMIT, TILE_RA_LOWER_LIMIT, TILE_DEC_LOWER_LIMIT,
TILE_DEC_UPPER_LIMIT)
data = SDSS.query_sql(query, data_release=15)
name = 'SDSS_Tile_Sources.csv'
file = open(os.path.join(Main_Path, name), 'w')
file.write('specobjID,ra,dec,z')
file.write('\n')
specobjID = data['objID']
ra = data['ra']
dec = data['dec']
z = data['z']
for i in range(len(z)):
info = '%s,%s,%s,%s' % (specobjID[i], ra[i], dec[i], z[i])
file.write(info)
file.write('\n')
file.close()
print data
def __init__(self, query=None, table=None):
# Either query or table, but not both (query xor table).
if (query and table is not None) or\
(not query and table is None):
raise Exception('Either the query or the table parameter is '
'required. But not both.')
if table is not None:
# Use table if it was provided.
self.table = table
else:
# Otherwise use the query to create the table.
self.table = SDSS.query_sql(query)
self.catalog = np.array(self.table)
self.catalog = rename_fields(self.catalog, {'objID': 'id'})
# Calculate B and V like the VizieR data.
# Use Robert Lupton's derived equations found here:
# http://www.sdss3.org/dr8/algorithms/sdssUBVRITransform.php
g = self.catalog['g']
r = self.catalog['r']
B = g + 0.3130 * (g - r) + 0.2271 # sigma = 0.0107
V = g - 0.5784 * (g - r) - 0.0038 # sigma = 0.0054
self.catalog = append_fields(self.catalog, 'B', B)
self.catalog = append_fields(self.catalog, 'V', V)
def query_sdss(query_str, filename, obj_key='objID', data_release=14):
objid = -1
cnt = 0
row_count = 500000
print('querying', filename)
while row_count == 500000:
start = time.time()
print('query number', cnt)
table = SDSS.query_sql(query_str.format(objid),
timeout=600,
data_release=data_release)
print('seconds taken:', int(time.time() - start))
row_count = len(table)
objid = table[row_count - 1][obj_key]
print('row_count', row_count)
print('head')
print(table[:5])
print('tail')
print(table[-5:])
ascii.write(table,
filename.format(cnt),
format='csv',
fast_writer=False)
print('saved to csv')
cnt += 1
def get_photometry(N=10000):
"""Get photometry from the SDSS Database
Parameters
----------
N : int
specifies the number of objects to query
Returns
-------
data : astropy.Table
table of queried photometry
"""
query = """
SELECT TOP {N}
p.psfMag_r, p.fiberMag_r, p.fiber2Mag_r, p.petroMag_r,
p.deVMag_r, p.expMag_r, p.modelMag_r, p.cModelMag_r,
s.class
FROM PhotoObjAll AS p JOIN specObjAll s ON s.bestobjid = p.objid
WHERE p.mode = 1 AND s.sciencePrimary = 1 AND p.clean = 1 AND s.class != 'QSO'
ORDER BY p.objid ASC
"""
data = SDSS.query_sql(query.format(N=N))
return data
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 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 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 objid2dr7id(objID):
"""
This function takes a SDSS DR13 objID and returns a DR7 objID based on
RA/DEC
"""
sql = """
SELECT
p.ra,p.dec
FROM PhotoObj AS p
WHERE p.objid = {objID}
""".format(**vars())
result = SDSS.query_sql_async(sql)
radecstring = result.content.split('\n')
try:
ra,dec = radecstring[2].split(',')
except:
return False, 'empty'
ra,dec = float(ra),float(dec)
print( ra,dec)
sql2 = """
SELECT
p.objid,p.ra,p.dec
FROM PhotoObj AS p
JOIN dbo.fGetNearestObjEq({ra},{dec}, 1) AS pN
ON p.objID = pN.objID
""".format(**vars())
result2 = SDSS.query_sql_async(sql2, data_release=7)
datastring = result2.content
try:
data = datastring.split('\n')[1]
dr7objid,ra2,dec2 = data.split(',')
ra2,dec2 = float(ra2),float(dec2)
print(dr7objid,ra2,dec2 )
except:
print('No neighbour found for ',objID)
dr7objid = 'empty'
try:
assert abs(ra - ra2) < 0.0003 #1 arcsec = 0.000277 deg
assert abs(dec - dec2) < 0.0003
matchfound = True
except:
print('No match found for ',objID)
matchfound = False
return matchfound,dr7objid
def download_and_save_image(self):
pos = coords.SkyCoord(ra=self.ra * u.degree,
dec=self.dec * u.degree,
frame='fk5')
img = SDSS.get_images(self.sdss_id, band='g')[0]
print(pos)
print(img[0])
img.writeto('test.fits', overwrite=True)
def query_objects(self, names: TList[str]) -> TList[CatalogSource]:
"""
Return a list of SDSS catalog objects with the specified names
:param names: object names
:return: list of catalog objects with the specified names
"""
sdss = SDSS()
rows = []
for name in names:
rows.append(
sdss.query_object(name,
data_release=15,
photoobj_fields=self._columns,
cache=False)[0])
return self.table_to_sources(rows)
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 querySpectra(self):
try:
self.standardQuery()
coord = []
for i in range(0, len(self.ra)):
coord.append(coords.SkyCoord(self.ra[i], self.dec[i], frame='icrs', unit='deg'))
self.spectra = SDSS.query_crossid(coord, photoobj_fields=['modelMag_g', 'modelMag_r'])
return self.spectra
except:
raise ValueError("No Results found. Try a different search area.")
def load_image(self):
im_size = self.cutout_size.to(u.arcsec).value
mag_aperture = self.aperture.to(u.arcsec).value
# keep original coords of image for bounds checking later
self.orig_coords = self.coords
with self.bottombox:
try:
self.cutout = self.catlib.get_cutouts(
position=self.coords,
side=im_size,
aperture=mag_aperture,
dynamic=False,
filter=["r", "g", "f606W"],
first=True,
)[0]
im = NDData(self.cutout["cutout"].data,
wcs=self.cutout["cutout"].wcs)
self.im_path = self.cutout["path"]
self.imw.load_nddata(im)
except:
try:
sdss_im = SDSS.get_images(coordinates=self.coords,
band="g")
im = sdss_im[0][0]
except:
sdss_im = SDSS.get_images(coordinates=self.coords,
band="g",
radius=30.0 * u.arcsec)
im = sdss_im[0][0]
self.im_path = "SDSS Astroquery result"
self.imw.load_fits(im)
self.imw.center_on(self.coords)
self.imw.zoom_level = self.zoom
self.textimpath.value = self.im_path
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 sdss_template(tipo='eliptica'):
if tipo == 'eliptica':
template = SDSS.get_spectral_template('galaxy_early')
title = 'Espectro de galaxia eliptica'
lines = absorption_lines
elif tipo == 'espiral':
template = SDSS.get_spectral_template('galaxy_late')
title = 'Espectro de galaxia espiral'
lines = emission_lines
spec_h = template[0][0].header
spec_data = template[0][0].data
wcs = WCS(spec_h)
index = np.arange(spec_h['NAXIS1'])
loglam = wcs.wcs_pix2world(index, np.zeros(len(index)), 0)[0]
flux = spec_data[0]
gv = (loglam > np.log10(4000.)) & (loglam < np.log10(8000.))
flux_scale = 80. / np.max(flux[gv])
fig, ax = plt.subplots(figsize=(20, 8), sharex=True, sharey=True)
plt.plot(10**loglam, flux * flux_scale, '-', color='black', linewidth=1)
for j in range(len(lines['name'])):
ax.plot(lines['lambda'][j] * np.ones(2), [0., 1e5],
lines['color'] + '--')
ax.text(lines['lambda'][j] + lines['offset'][j],
lines['position'][j] * 100.,
lines['name'][j],
color='black',
fontsize=18,
horizontalalignment=lines['align'][j])
ax.set_ylabel(r'Flujo [10$^{-17}$ ergs/cm$^2$/s/\AA]', fontsize=14)
ax.set_xlabel(r'Longitud de onda [\AA]', fontsize=14)
ax.set_title(title)
ax.set_xlim(3500, 8000)
ax.set_ylim(0., 100.)
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 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 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 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 res(ra, dec, ang):
"""Fetches SDSS data with GetNearbyObj function and given parameters"""
query = """
SELECT
s.ra, s.dec,
s.dered_g as g, s.dered_r as r,
s.err_g, s.err_r,
s.flags
FROM
dbo.fGetNearbyObjEq({}, {}, {}) AS n
JOIN Star AS s ON n.objID = s.objID
WHERE
g - r BETWEEN -0.5 AND 2.5
AND g BETWEEN 14 and 24
""".format(ra,dec,ang)
return SDSS.query_sql(query, timeout = 600)
# 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)
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 get_sdss_spectra(outfile = "outfile", N_spec = 5):
from urllib2 import HTTPError
from astroquery.sdss import SDSS
# query = "SELECT TOP 1000 p.objid, p.dec, p.r,p.i, p.run, p.rerun, p.camcol, p.field, s.specobjid, s.class, s.z as redshift FROM PhotoObj AS p JOIN SpecObj AS s ON s.bestobjid = p.objid WHERE p.r BETWEEN 0 AND 17.0 AND s.class = 'QSO' AND s.z BETWEEN 1.0 AND 2.3 AND p.dec >= 15.0"
query = "SELECT TOP "+str(N_spec)+" specObjID, plate, mjd, subClass, fiberID FROM SpecPhoto WHERE (class = 'QSO') AND" \
" (psfmag_r <= 17.0) AND (dec >= 15.0) AND (z BETWEEN 1.0 AND 2.3) AND zwarning = 0 AND" \
" (subClass = 'BROADLINE') AND nChild = 0 AND (mode = 1) AND ((0x10000000) != 0)" \
" AND (bossprimary= 0) AND programname = 'legacy'"
res = SDSS.query_sql(query)
# (subClass = 'BROADLINE') AND
# print(res['subClass'])
spectra = []
var = []
waves = []
mask = []
z = []
# print(res['plate'], res['mjd'], res['fiberID'])
num_skipped = 0
count = 1
n_spec = len(res['specObjID'])
for i in range(n_spec):
# print(res['subClass'][i])
try:
sp = SDSS.get_spectra(plate=res['plate'][i], mjd=res['mjd'][i], fiberID=res['fiberID'][i])[0]
data = (sp[1].data)
wave = (10**data.field('loglam'))
flux = data.field('flux')
err = data.field('ivar')
masking = data.field('and_mask')
mask.append(masking)
z.append(sp[2].data.field('Z'))
spectra.append(flux)
var.append(err)
waves.append(wave)
# print(res['plate'][i],res['mjd'][i], res['fiberID'][i])
# pl.plot(wave, flux)
# pl.show()
count += 1
except HTTPError:
num_skipped += 1
print("%i, %i, %i not found" % (res['plate'][i], res['mjd'][i], res['fiberID'][i]))
continue
except ValueError:
num_skipped += 1
print("%i, %i, %i ValueError" % (res['plate'][i], res['mjd'][i], res['fiberID'][i]))
continue
except TypeError:
num_skipped += 1
print("%i, %i, %i TypeError" % (res['plate'][i], res['mjd'][i], res['fiberID'][i]))
continue
print('Number of spectrum processed: {0} out of {1}'.format(count, n_spec - num_skipped))
print(" %i spectra skipped" % num_skipped)
# exit()
np.savez(outfile,
wave = waves,
spectra=spectra,
var = var,
mask = mask,
plate = res['plate'],
mjd = res['mjd'],
fiberID = res['fiberID'],
z = z
)
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)
#Get the object SDSS parameters
Name, Catalogue, mjd, plate, fiberID, alfalfa_code = Candiates_frame.index[i], row['catalogue'].values[0], row['mjd'].values[0], row['plate'].values[0], row['fiber'].values[0], row['alfalfa_name'].values[0]
#Generate object folder
CodeName = pv.generate_catalogue_tree(Catalogue_Dic, obj = Name)
FileFolder = Catalogue_Dic['Obj_Folder'] + CodeName + '/'
#Store parameter in object log file
pv.SetLogFile(CodeName + pv.ObjectLog_extension, FileFolder)
#Query the object table
#----------------Sloan objects----------------------
if Catalogue == 'sloan':
mjd, plate, fiberID = int(mjd), int(plate), int(fiberID)
obj_table = SDSS.query_specobj(mjd = mjd, plate = plate, fiberID=fiberID)
if obj_table != None:
#print Name, str(ephem.hours(math.radians(obj_table['ra'][0]))), str(ephem.degrees(math.radians(obj_table['dec'][0]))), '\n'
SDSS_RA = obj_table['ra'][0]
SDSS_DEC = obj_table['dec'][0]
SDSS_RA_hours = str(ephem.hours(math.radians(obj_table['ra'][0])))
SDSS_DEC_hours = str(ephem.degrees(math.radians(obj_table['dec'][0])))
co = coords.SkyCoord(float(SDSS_RA), float(SDSS_DEC), unit="deg")
Obj_query = SDSS.query_crossid(co, photoobj_fields=['modelMag_u', 'modelMag_g', 'modelMag_r'])
mag_u, mag_g, mag_r = Obj_query['modelMag_u'][0], Obj_query['modelMag_g'][0], Obj_query['modelMag_r'][0]
website = "http://dr12.sdss3.org/spectrumDetail?mjd={mjd}&fiber={fiber}&plateid={plateid}".format(mjd = mjd, fiber = fiberID, plateid = plate)
print Name, website
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 ''
