def panstarrs_query(ra_deg, dec_deg, rad_deg, maxmag=20,
maxsources=10000):
"""
Query PanSTARRS @ VizieR using astroquery.vizier
:param ra_deg: RA in degrees
:param dec_deg: Declination in degrees
:param rad_deg: field radius in degrees
:param maxmag: upper limit R magnitude (optional)
:param maxsources: maximum number of sources
:return: astropy.table object
"""
# vquery = Vizier(columns=['objID', 'RAJ2000', 'DEJ2000',
# 'e_RAJ2000', 'e_DEJ2000',
# 'gmag', 'e_gmag',
# 'rmag', 'e_rmag',
# 'imag', 'e_imag',
# 'zmag', 'e_zmag',
# 'ymag', 'e_ymag'],
# column_filters={"rmag":
# ("<%f" % maxmag)},
# row_limit=maxsources)
vquery = Vizier(columns=['objID', 'RAJ2000', 'DEJ2000',
'e_RAJ2000', 'e_DEJ2000',
'gmag', 'e_gmag',
'rmag', 'e_rmag',
'imag', 'e_imag',
'zmag', 'e_zmag',
'ymag', 'e_ymag'],
column_filters={"rmag":
("<%f" % maxmag)},
row_limit=maxsources)
field = coord.SkyCoord(ra=ra_deg, dec=dec_deg,
unit=(u.deg, u.deg),
frame='icrs')
return vquery.query_region(field,
width=("%fd" % rad_deg),
catalog="II/349/ps1")[0]
def _2MASS_query(ra_deg, dec_deg, rad_deg, maxmag=20, maxsources=-1):
"""
Query 2MASS @ VizieR using astroquery.vizier
parameters: ra_deg, dec_deg, rad_deg: RA, Dec, field
radius in degrees
maxmag: upper limit magnitude (optional)
maxsources: maximum number of sources
returns: astropy.table object
"""
vquery = Vizier(
columns=[
'+_r', '2MASS', 'RAJ2000', 'DEJ2000', 'Jmag', 'e_Jmag', 'Jsnr',
'Hmag', 'e_Hmag', 'Hsnr', 'Kmag', 'e_Kmag', 'Ksnr', 'dup', 'Ndet'
],
# column_filters={"gmag":
# ("<%f" % maxmag)
# "imag":
# ("<%f" % maxmag)},
row_limit=maxsources)
field = SkyCoord(ra=ra_deg, dec=dec_deg, unit=(u.deg, u.deg), frame='icrs')
return vquery.query_region(field,
width=("%fd" % rad_deg),
catalog="II/246")[0]
def USNO_A2_query(ra_deg, dec_deg, rad_deg, maxmag=20,
maxsources=-1):
"""
Query USNO_A2 @ VizieR using astroquery.vizier
parameters: ra_deg, dec_deg, rad_deg: RA, Dec, field
radius in degrees
maxmag: upper limit G magnitude (optional)
maxsources: maximum number of sources
returns: astropy.table object
"""
vquery = Vizier(columns=['+_r', 'USNO-A2.0', 'RAJ2000', 'DEJ2000',
'Bmag','Rmag'],
# column_filters={"gmag":
# ("<%f" % maxmag)
# "imag":
# ("<%f" % maxmag)},
row_limit = maxsources)
field = SkyCoord(ra=ra_deg, dec=dec_deg,
unit=(u.deg, u.deg),
frame='icrs')
return vquery.query_region(field,
width=("%fd" % rad_deg),
catalog="I/252/out")[0]
def gaia_query(ra_deg, dec_deg, rad_deg, maxmag=18, maxsources=10000):
"""
Query Gaia DR1 @ VizieR using astroquery.vizier
:param ra_deg: RA in degrees
:param dec_deg: Declination in degrees
:param rad_deg: field radius in degrees
:param maxmag: upper limit G magnitude (optional)
:param maxsources: maximum number of sources
:return: astropy.table object
"""
vquery = Vizier(
columns=['Source', 'RA_ICRS', 'DE_ICRS', 'Gmag', "Teff", "RPlx"],
column_filters={"Gmag": ("<%f" % maxmag)},
row_limit=maxsources)
field = coord.SkyCoord(ra=ra_deg,
dec=dec_deg,
unit=(u.deg, u.deg),
frame='icrs')
return vquery.query_region(field,
width=("%fd" % rad_deg),
catalog="I/345/gaia2")[0]
def get_gaia(basePrefix="lris_targsNGC2506",
groupInclude=[1]):
""" Gets the Gaia info for a table
Parameters
--------------
basePrefix: str
"lris_targsNGC2506" is the list of solar analog candidates
"lris_alignmentNGC2506" is the list of alignment stars
groupInclude: list
List of integers describing the groups of stars to include
These are priority levels on stars with 1 the highest
"""
fullDat = ascii.read('../pan_starrs/pro/output/{}.csv'.format(basePrefix))
pts = np.zeros(len(fullDat),dtype=np.bool)
for oneGroup in groupInclude:
pts = pts | (fullDat['GROUP'] == oneGroup)
dat = fullDat[pts]
coor = SkyCoord(dat['RA'],dat['DEC'],unit=(u.deg,u.deg))
## Set up Vizier Query
vquery = Vizier(row_limit = 1)
outList = vquery.query_region(coor,radius=1*u.arcsec,catalog="I/345/gaia2")
outDat = outList[0]
for oneColumn in dat.colnames:
outDat["{}_PS".format(oneColumn)] = dat[oneColumn]
outDat['diffRA'] = (outDat['RA_ICRS'] - outDat['RA_PS']) * 3600.
outDat['diffDEC'] = (outDat['DE_ICRS'] - outDat['DEC_PS']) * 3600.
for oneFormat in ['fits','csv']:
outDat.write('lists/gaia_coord/gaia_{}.{}'.format(basePrefix,oneFormat),
overwrite=True)
def search_star(**kwargs):
""" Searches position on VizieR and returns a catalogue.
Parameters:
coord (str, SkyCoord): Coordinate to perform the search.
code (str): Gaia Source_id of the star
columns (list): List of strings with the name of the columns to retrieve.
radius (int, float, unit.quantity): Radius to search around coordinate
catalog (str): VizieR catalogue to search.
Returns:
catalogue(astropy.Table): An astropy Table with the catalogue informations.
"""
input_tests.check_kwargs(kwargs,
allowed_kwargs=[
'catalog', 'code', 'columns', 'coord', 'log',
'radius'
])
row_limit = 100
if 'log' in kwargs and kwargs['log']:
print('\nDownloading star parameters from {}'.format(
kwargs['catalog']))
vquery = Vizier(columns=kwargs['columns'],
row_limit=row_limit,
timeout=600)
if 'code' in kwargs:
catalogue = vquery.query_constraints(catalog=kwargs['catalog'],
Source=kwargs['code'],
cache=False)
elif 'coord' in kwargs:
catalogue = vquery.query_region(kwargs['coord'],
radius=kwargs['radius'],
catalog=kwargs['catalog'],
cache=False)
else:
raise ValueError('At least a code or coord should be given as input')
return catalogue
def download_vizier(pointing,
radius,
catalog='UCAC4',
band='i',
maglimit=None):
catalogs = {'UCAC4': 'I/322A', 'Gaia': 'I/345/gaia2'}
if catalog not in catalogs.keys():
print(f'{catalog} not in {catalogs.keys()}')
raise NotImplementedError
if band not in ['r', 'i']:
print(f'Band {band} not supported')
raise NotImplementedError
columns = {
'UCAC4': ['_RAJ2000', '_DEJ2000', 'rmag', 'imag'],
'Gaia': ['RA_ICRS', 'DE_ICRS', 'Gmag', 'RPmag']
}
ra_colname = {'UCAC4': '_RAJ2000', 'Gaia': 'RA_ICRS'}
dec_colname = {'UCAC4': '_DEJ2000', 'Gaia': 'DE_ICRS'}
mag_colname = {'UCAC4': f'{band}mag', 'Gaia': 'RPmag'}
filter_string = '>0' if maglimit is None else f"<{maglimit}"
column_filter = {mag_colname[catalog]: filter_string}
v = Vizier(columns=columns[catalog], column_filters=column_filter)
v.ROW_LIMIT = 2e4
try:
stars = Table(
v.query_region(pointing,
catalog=catalogs[catalog],
radius=c.Angle(radius, "deg"))[0])
stars.add_column(Column(data=stars[ra_colname[catalog]], name='RA'))
stars.add_column(Column(data=stars[dec_colname[catalog]], name='DEC'))
stars.add_column(Column(data=stars[mag_colname[catalog]], name='mag'))
except:
stars = None
return stars
def query_EPIC(self, ID=None, radius = 10.0*u.arcsec):
import warnings
from astropy.utils.metadata import MergeConflictWarning
warnings.filterwarnings("ignore", category = MergeConflictWarning)
if ID is None:
ID = self.IDs['EPIC']
tbl = Table(names = ('ID',), dtype = (int,))
for i, id in tqdm(enumerate(ID)):
id = id.replace('EPIC ','')
if not isinstance(id, str):
add_empty_row(tbl)
else:
v = Vizier(column_filters={"ID":f"=={id}", 'OType':'STAR'})
job = v.get_catalogs('IV/34/epic')
ridx = job[0]['ID'].quantity == int(id)
if len(job[0][ridx]) > 0:
tbl = avstack([tbl, job[0][ridx][0]])
else:
add_empty_row(tbl)
self.EPIC = tbl
# Fill in blank IDs where possible
if not hasattr(self,'simbad'):
self.query_simbad(ID)
for i in range(len(self.IDs)):
if len(self.IDs['2MASS'][i])==0:
self.IDs['2MASS'][i] = '2MASS J'+self.EPIC['_2MASS'][i]
self.query_simbad(self.IDs['2MASS'])
return self.EPIC
def make_jmmc_query(self, mag_range=(1, 6), ra_range=(30, 100), dec_range=(30, 100)):
"""
Query the JMMC catalog using VizieR
:param mag_range: the magnitude range you wish to constrain the query by
:param ra_range: the RA range you wish to constrain the query by
:param dec_range: The DEC range you wish to constrain the query by
:return: appends results to the catalogs results array
"""
columns = ['RAJ2000','DEJ2000','2MASS','Tessmag','Teff','R*','M*','logg','Dis','Gmag','Vmag','Bmag']
v = Vizier()
v.ROW_LIMIT = -1
print("Retrieving Catalogue")
local_dat = [d for d in os.listdir() if '.dat' in d]
result = v.query_constraints(catalog="II/346/jsdc_v2",
Bmag='>%s & <%s' %(mag_range[0], mag_range[1]),
RAJ2000=">%s & <%s"%(ra_range[0], ra_range[1]),
DEJ2000='>%s & <%s'%(dec_range[0], dec_range[1]))
if result:
good_val = np.where(~np.isnan(result[0]['Dis']))
self.jmmc = result[0][good_val]
self.catalogs.append(self.jmmc)
self.cat_names.append("JMMC")
def make_charm2_query(self, mag_range=(1, 6), ra_range=(30, 100), dec_range=(30, 100)):
"""
Query the CHARM2 catalog using VizieR
:param mag_range: the magnitude range you wish to constrain the query by
:param ra_range: the RA range you wish to constrain the query by
:param dec_range: The DEC range you wish to constrain the query by
:return: appends results to the catalogs results array
"""
columns = ['N', 'Type','Id1', 'Method', 'Lambda', 'UD', 'e_UD', 'LD', 'e_LD', 'RAJ2000', 'DEJ2000', 'Vmag', 'Kmag', 'Bmag']
v = Vizier(columns=columns)
v.ROW_LIMIT = -1
print("Retrieving Catalogue")
local_dat = [d for d in os.listdir() if '.dat' in d]
result = v.query_constraints(catalog="J/A+A/431/773",
Bmag='>%s & <%s' %(mag_range[0], mag_range[1]),
RAJ2000=">%s & <%s"%(ra_range[0], ra_range[1]),
DEJ2000='>%s & <%s'%(dec_range[0], dec_range[1]))
if result:
good_val = np.where(~np.isnan(result[0]['UD']))
self.charm2 = result[0][good_val]
self.catalogs.append(self.charm2)
self.cat_names.append("CHARM2")
def make_gaia_query(self, mag_range=(1, 6), ra_range=(30, 100), dec_range=(30, 100)):
'''
Query gaia's data release 2 (DR2) using VizieR
:param mag_range: the magnitude range you wish to constrain the query by
:param ra_range: the RA range you wish to constrain the query by
:param dec_range: The DEC range you wish to constrain the query by
:return: appends results to the catalogs results array
'''
columns = ['N', 'RAJ2000','DEJ2000','Gmag','BPmag','RPmag','Teff','Rad','Lum','Plx']
v = Vizier(columns=columns)
v.ROW_LIMIT = -1
print("Retrieving Catalogue")
Vizier.query_constraints_async()
result = v.query_constraints(catalog="I/345/gaia2",
BPmag='>%s & <%s' %(mag_range[0], mag_range[1]),
RAJ2000=">%s & <%s"%(ra_range[0], ra_range[1]),
DEJ2000='>%s & <%s'%(dec_range[0], dec_range[1]))
asdf=123
if result:
good_vals = np.where(~np.isnan(result[0]['Rad']))
self.gaia = result[0][good_vals]
self.catalogs.append(self.gaia)
self.cat_names.append("GAIA")
def __query_circle(self, ra, dec, radius, catalog):
"""Vizier.query_region in a circle FoV using astroquery module."""
radius_str = str(radius) + 'd'
catalog_constraints = Vizier(catalog=[self.catalog],
columns=[
'*', '_RAJ2000', '_DEJ2000',
self.column_1, self.column_2
],
column_filters={
self.column_1: self.filter_1,
self.column_2: self.filter_2
})
catalog_constraints.ROW_LIMIT = -1 # completed catalog
query_result = catalog_constraints.query_region(SkyCoord(ra=ra,
dec=dec,
unit=(u.deg,
u.deg),
frame='icrs'),
radius=radius_str)
return query_result
def __query_box(self, ra, dec, base, height, catalog):
"""Vizier.query_region in a square/rectangular FoV using astroquery module."""
base_str, height_str = str(base) + 'd', str(height) + 'd'
catalog_constraints = Vizier(catalog=[self.catalog],
columns=[
'*', '_RAJ2000', '_DEJ2000',
self.column_1, self.column_2
],
column_filters={
self.column_1: self.filter_1,
self.column_2: self.filter_2
})
catalog_constraints.ROW_LIMIT = -1 # completed catalog
query_result = catalog_constraints.query_region(SkyCoord(ra=ra,
dec=dec,
unit=(u.deg,
u.deg),
frame='icrs'),
width=height_str,
height=base_str)
return query_result
def catalog_info(self, id):
"""Takes KIC_ID, returns stellar information from online catalog using Vizier"""
if type(id) is not int:
raise TypeError('KIC_ID ID must be of type "int"')
columns = [
"Teff", "log(g)", "Rad", "E_Rad", "e_Rad", "Mass", "E_Mass",
"e_Mass"
]
catalog = "J/ApJS/229/30/catalog"
result = (Vizier(columns=columns).query_constraints(
KIC=id, catalog=catalog)[0].as_array())
Teff = result[0][0]
logg = result[0][1]
radius = result[0][2]
radius_max = result[0][3]
radius_min = result[0][4]
mass = result[0][5]
mass_max = result[0][6]
mass_min = result[0][7]
lum = self.star_luminosity(Teff, radius)
ld, mass, mass_min, mass_max, radius, radius_min, radius_max = tls.catalog_info(
KIC_ID=id)
return (ld, Teff, lum, logg, radius, radius_min, radius_max, mass,
mass_min, mass_max)
def sdss_query(ra_deg, dec_deg, rad_deg, maxmag=20, maxsources=-1):
"""
Query SDSS DR12 @ VizieR using astroquery.vizier
parameters: ra_deg, dec_deg, rad_deg: RA, Dec, field
radius in degrees
maxmag: upper limit magnitude (optional)
maxsources: maximum number of sources
returns: astropy.table object
"""
vquery = Vizier(
columns=[
'+_r', 'objID', 'RA_ICRS', 'e_RA_ICRS', 'DE_ICRS', 'e_DE_ICRS',
'umag', 'e_umag', 'gmag', 'e_gmag', 'rmag', 'e_rmag', 'imag',
'e_imag', 'zmag', 'e_zmag', 'zsp', 'spCl', 'subCl'
],
# column_filters={"gmag":
# ("<%f" % maxmag),
# "imag":
# ("<%f" % maxmag)},
row_limit=maxsources)
field = SkyCoord(ra=ra_deg, dec=dec_deg, unit=(u.deg, u.deg), frame='icrs')
return vquery.query_region(field,
width=("%fd" % rad_deg),
catalog="V/147/sdss12")[0]
def __init__(self, *args, **kwargs):
"""
The constructor ...
:param kwargs:
"""
# Call the constructor of the base class
super(S4G, self).__init__(*args, **kwargs)
# Names
self.ngc_name = None
self.ngc_name_nospaces = None
# The Vizier querying object, specifying the necessary columns for this class
self.vizier = Vizier(columns=[
'Name', 'RAJ2000', 'DEJ2000', 'Dmean', 'e_Dmean', 'amaj', 'ell',
'[3.6]', '[4.5]', 'e_[3.6]', 'e_[4.5]', 'PA'
])
self.vizier.ROW_LIMIT = -1
# The DustPedia database
#self.database = DustPediaDatabase()
# The path for the S4G decomposition models
#self.components_2d_s4g_path = None
# The galaxy properties object
self.properties = None
# The dictionary of components
self.components = dict()
#
self.disk_pa = None
self.disk = None
self.bulge = None
def stars_moc(field, radius, moc_order=15):
"""
MOC with the field area cover by bright stars (V<15).
(HST Guide Star Catalog, Version 2.3.2 (GSC2.3))
"""
v = Vizier(columns=['RAJ2000', 'DEJ2000', 'Vmag'],
column_filters={"Vmag": "<15"},
row_limit=np.inf,
timeout=6000)
vrsp = v.query_region(field,
radius=(radius + 1.5 * u.arcmin),
catalog='I/305')
moc_stars = MOC()
if vrsp:
stars = vrsp[0]
stars_coords = SkyCoord(ra=stars['RAJ2000'], dec=stars['DEJ2000'])
stars_radius = (16 - stars['Vmag']) * 6 * u.arcsec # Aird+2015
for coord, r in zip(stars_coords, stars_radius):
moc_stars += catalog_to_moc(coord, r, moc_order)
return moc_stars
def get_2mass_cat(tab):
"""
Get 2MASS catalog
Parameters
----------
tab: astropy table
Table of objects to search. Must have "ra" and "dec" columns for sources
"""
vizier = Vizier(catalog='II/246/out')
vizier.ROW_LIMIT = 99999
ra_med = np.median(tab['ra'])
dec_med = np.median(tab['dec'])
med_coord = SkyCoord(ra_med * u.deg, dec_med * u.deg)
coord_tab = SkyCoord(tab['ra'] * u.deg, tab['dec'] * u.deg)
sep = med_coord.separation(coord_tab)
search_rad = np.max(sep) + 10. * u.arcsec
tm_res = vizier.query_region(med_coord, radius=search_rad)[0]
tm_coord = SkyCoord(tm_res['RAJ2000'], tm_res['DEJ2000'])
idx, d2d, d3d = coord_tab.match_to_catalog_sky(tm_coord)
max_sep = 1.0 * u.arcsec
sep_constraint = d2d < max_sep
bad_sep = d2d > max_sep
fig, axArr = plt.subplots(3, 2, figsize=(10, 10)) #,sharey=True)
#axArr[0].plot(tab['J mag'],diff,'.')
for bandInd, oneBand in enumerate(['J', 'H', 'K']):
tab['{}mag_2mass'.format(oneBand)] = tm_res['{}mag'.format(
oneBand)][idx]
tab['{}mag_2mass'.format(oneBand)][bad_sep] = np.nan
diff = tab['{} mag'.format(oneBand)] - tab['{}mag_2mass'.format(
oneBand)]
plot_density_scatter(axArr[bandInd, 0], tab['{} mag'.format(oneBand)],
diff)
axArr[bandInd, 0].set_ylim(-0.2, 0.2)
axArr[bandInd, 0].set_ylabel(r"{} (UKIRT) - {} (2MASS)".format(
oneBand, oneBand))
axArr[bandInd, 0].set_xlabel("{} (UKIRT)".format(oneBand))
plot_density_scatter(axArr[bandInd, 1], tab['J mag'] - tab['K mag'],
diff)
axArr[bandInd, 1].set_xlabel("J (UKIRT) - K (UKIRT)")
axArr[bandInd, 1].set_ylim(-0.2, 0.2)
# minmax_show = [np.nanmin(tab['J mag']),np.nanmax(tab['Jmag_2mass'])]
#plt.plot(minmax_show,1.0)
plt.show()
return tm_res
result_table.add_column(const,name="Constellation", index = 2)
otype = result_table['OTYPE_3']
internal_id = [otype[i]+'_'+const_abr[i]+'_'+str(i+1) for i in range(len(const))]
result_table.add_column(internal_id, name = "Internal ID Number", index = 0)
result_table.write("messier_objects.csv",format="csv",overwrite="True")#creates a csv file
Simbad.reset_votable_fields()#renders the prev changes to simbad class temporary.
print('\n')
print('Done')
print('\n')
print('Downloading NGC catalogue...')
#CHANGE GET_CONSTELLATION EQUINOX FROM B1875 TO 2000
v = Vizier(columns = ['Name','Type','mag','RA (deg)','Dec (deg)'])#Columns added to table
v.ROW_LIMIT = -1
result_table = v.get_catalogs("VII/118/ngc2000")[0]
result_table['Name'] = ['IC '+x[1:] if x[0]=='I' else 'NGC '+x for x in result_table['Name']]
result_table['Type'] = ['Gal' if x=='Gx' else 'OpC' if x=='OC' else 'GlC' if x=='Gb' else 'PN' if x=='Pl' else 'Str' if x=='*' or x=='D*' or x=='***' else '-' if x == '' or x=='-' or x=='?' else x for x in result_table['Type']]
coords = SkyCoord(result_table['_RAJ2000'],result_table['_DEJ2000'],unit="deg")
const = coords.get_constellation()
const_abr = coords.get_constellation(short_name = "True")
result_table.add_column(const,name="Constellation", index = 2)
otype = result_table['Type']
internal_id = [otype[i]+'_'+const_abr[i]+'_'+str(i+1) if otype[i]!='-' else 'notype'+'_'+const_abr[i]+'_'+str(i+1) for i in range(len(const))]
result_table.add_column(internal_id, name = "Internal ID Number", index = 0)
result_table.write("NGC.csv",format="csv",overwrite="True")
def tmass(obsids_table,
data_folder,
moc_folder,
opt_moc=None,
radius=15 * u.arcmin,
moc_order=16,
overwrite=True):
"""
Get 2MASS data using astroquery and Vizier
For each observation in obsids_table, saves a fits file with
name 'OBS_ID.fits' in 'data_folder/groups'.
The function sends a Vizier query and selects all sources within 'radius'
arcmin 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 WISE sources
in the field. If it doesn't exist, creates the file.
The function returns obsids_table with an additional column 'NSRC_2M'
with the number of sources in the field.
"""
# Groups folder
groups_folder = os.path.join(data_folder, 'groups')
if not os.path.exists(groups_folder):
os.makedirs(groups_folder)
moc_folder = os.path.join(moc_folder, 'mocs')
if opt_moc is not None:
moc_optsurvey = MOC()
read_moc_fits(moc_optsurvey, opt_moc)
nsources_field = np.full((len(obsids_table), ), np.nan)
hp = HEALPix(nside=2**moc_order, order='nested', frame=ICRS())
v = Vizier(columns=[
'Cntr', 'RAJ2000', 'DEJ2000', 'errMaj', 'errMin', 'errPA', 'Qflg'
],
row_limit=np.inf,
timeout=6000)
for i, row in enumerate(tqdm(obsids_table, desc="Making 2MASS 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)
vrsp = v.query_region_async(field_coords,
radius=radius,
catalog='II/246/out',
return_type='asu-tsv')
# Fix bug in the vizier response
# (returns the id as a short int and fails to load
# properly as an astropy table)
with open('/tmp/tmp.tab', 'wb') as tmpfile:
tmpfile.write(vrsp.content)
src_table = Table.read('/tmp/tmp.tab', format='ascii.tab')
src_table = src_table[2:]
objid = np.array(src_table['Cntr']).astype(np.int64)
ra = np.array(src_table['RAJ2000']).astype(np.float) * u.deg
dec = np.array(src_table['DEJ2000']).astype(np.float) * u.deg
errMaj = np.array(src_table['errMaj']).astype(np.float) * u.arcsec
# err_ra[err_ra == ' '] = '-1'
# err_ra = err_ra.astype(np.float) * u.arcsec
# err_ra[err_ra == -1] = np.nan
errMin = np.array(src_table['errMin']).astype(np.float) * u.arcsec
# err_dec[err_dec == ' '] = '-1'
# err_dec = err_dec.astype(np.float) * u.arcsec
# err_dec[err_dec == -1] = np.nan
errPA = np.array(src_table['errPA']).astype(np.float) * u.deg
flag = np.array(src_table['Qflg'])
src_table = Table([objid, ra, dec, errMaj, errMin, errPA, flag],
names=[
'objID', 'RAJ2000', 'DEJ2000', 'errMaj',
'errMin', 'errPA', 'Qflg'
])
# Filter table
# Sources detected with SNR>=5 in J, H or K
flgJ = [f[0] in ['A', 'B', 'C'] for f in src_table['Qflg']]
flgH = [f[1] in ['A', 'B', 'C'] for f in src_table['Qflg']]
flgK = [f[2] in ['A', 'B', 'C'] for f in src_table['Qflg']]
msk_good = np.logical_and(flgJ, np.logical_and(flgH, flgK))
src_table_new = src_table[msk_good]
## 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 opt_moc is not None:
moc_field = moc_optsurvey.intersection(moc_field)
inmoc_table = sources_inmoc(src_table_new,
hp,
moc_field,
moc_order=moc_order,
ra='RAJ2000',
dec='DEJ2000')
## Save sources
field_table_file = os.path.join(data_folder, groups_folder,
'{}.fits'.format(row['OBS_ID']))
inmoc_table.meta['description'] = '2MASS'
inmoc_table.remove_column('Qflg')
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_2M')
obsids_table.add_column(colsrc)
return obsids_table
def get_catalogue(self, catalogue, boundary_value="nan"):
cat_ids = {
"SUMSS": "VIII/81B/sumss212",
"NVSS": "VIII/65/nvss",
"MGPS2": "VIII/82/mgpscat"
}
if catalogue not in cat_ids:
self.logger.error("Requested catalogue not recongised.")
return
elif catalogue == "SUMSS":
search_cat = [cat_ids["SUMSS"], cat_ids["MGPS2"]]
elif catalogue == "NVSS":
search_cat = [
cat_ids["NVSS"],
]
else:
search_cat = [
cat_ids["MGPS2"],
]
if not self.wcs:
self.load_wcs()
if not self.header:
self.load_header()
if not self.centre:
self.load_position_dimensions()
if np.abs(self.size_x -
self.size_y) > max([self.size_x, self.size_y]) * 0.05:
self.logger.warning(
"Non square image detected! Will pad the Vizier search area by 1.6 (default 1.3)."
)
pad = 1.6
else:
pad = 1.3
# if not self.data:
# self.load_data()
v = Vizier(columns=["_r", "_RAJ2000", "_DEJ2000", "**"])
v.ROW_LIMIT = -1
self.logger.info("Querying {} using Vizier...".format(catalogue))
result = v.query_region(self.centre,
radius=self.radius * pad,
catalog=search_cat)
if catalogue == "SUMSS":
catalogs_returned = result.keys()
#Searching the galactic plane survey as well, check if there are any found in that one
if len(catalogs_returned) == 2:
#Here we have to merge them together, MGPS2 has two extra columns: 'MGPS' and 'E' pandas can just merge them
df_result = result[cat_ids["SUMSS"]].to_pandas()
mgps2_result = result[cat_ids["MGPS2"]].to_pandas()
# mgps2_result.drop(["MGPS", "E"])
#And just append the mgps2 sources to the sumss result
df_result = df_result.append(mgps2_result)
else:
df_result = result[0].to_pandas()
else:
df_result = result[0].to_pandas()
if catalogue == "NVSS":
df_result["PA"].fillna(0.0, inplace=True)
self.raw_nvss_sources = df_result
self.logger.info("{} sources obtained.".format(catalogue))
self.logger.info(
"Filtering {} sources to only those within the image area...".
format(catalogue))
self.nvss_sources = self._filter_catalogue(
self.raw_nvss_sources, boundary_value=boundary_value)
return self.nvss_sources
else:
self.raw_sumss_sources = df_result
self.logger.info("{} sources obtained.".format(catalogue))
self.logger.info(
"Filtering {} sources to only those within the image area...".
format(catalogue))
self.sumss_sources = self._filter_catalogue(
self.raw_sumss_sources, boundary_value=boundary_value)
return self.sumss_sources
def pstarrs(obsids_table,
data_folder,
moc_folder,
nir_moc=None,
radius=15 * u.arcmin,
moc_order=16,
overwrite=True):
"""
Get Pan-STARRS data using astroquery and Vizier.
For each observation in obsids_table, saves a fits file with
name 'OBS_ID.fits' in 'data_folder/groups'.
The function sends a Vizier query and selects all sources within 'radius'
arcmin 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 Pan-STARRS sources
in the field. If it doesn't exist, creates the file.
The function returns obsids_table with an additional column 'NSRC_PS' 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())
v = Vizier(columns=[
'objID', 'RAJ2000', 'DEJ2000', 'e_RAJ2000', 'e_DEJ2000', 'Nd', 'Qual'
],
column_filters={"Nd": ">1"},
row_limit=np.inf,
timeout=6000)
for i, row in enumerate(tqdm(obsids_table,
desc="Making Pan-STARRS 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)
vrsp = v.query_region_async(field_coords,
radius=radius,
catalog='II/349',
return_type='asu-tsv')
# Fix bug in the vizier response
# (returns the objID as a short int and fails to load
# properly as an astropy table)
with open('/tmp/tmp.tab', 'wb') as tmpfile:
tmpfile.write(vrsp.content)
src_table = Table.read('/tmp/tmp.tab', format='ascii.tab')
src_table = src_table[2:]
objid = np.array(src_table['objID']).astype(np.int64)
ra = np.array(src_table['RAJ2000']).astype(np.float) * u.deg
dec = np.array(src_table['DEJ2000']).astype(np.float) * u.deg
err_ra = np.array(src_table['e_RAJ2000'])
err_ra[err_ra == ' '] = '-1'
err_ra = err_ra.astype(np.float) * u.arcsec
err_ra[err_ra == -1] = np.nan
err_dec = np.array(src_table['e_DEJ2000'])
err_dec[err_dec == ' '] = '-1'
err_dec = err_dec.astype(np.float) * u.arcsec
err_dec[err_dec == -1] = np.nan
flag = np.array(src_table['Qual']).astype(np.int32)
src_table = Table([objid, ra, dec, err_ra, err_dec, flag],
names=[
'objID', 'RAJ2000', 'DEJ2000', 'e_RAJ2000',
'e_DEJ2000', 'Qual'
])
# Filter table
msk_good = (src_table['Qual'] & 16) != 0
src_table_new = src_table[msk_good]
## 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_new,
hp,
moc_field,
moc_order=moc_order,
ra='RAJ2000',
dec='DEJ2000')
## Save sources
inmoc_table.remove_columns(['Qual'])
inmoc_table.meta['description'] = 'Pan-STARRS'
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_PS')
obsids_table.add_column(colsrc)
return obsids_table
def wise(obsids_table,
data_folder,
moc_folder,
nir_moc=None,
opt_moc=None,
radius=15 * u.arcmin,
moc_order=16,
overwrite=True):
"""
Get All-WISE data using astroquery and Vizier
For each observation in obsids_table, saves a fits file with
name 'OBS_ID.fits' in 'data_folder/groups'.
The function sends a Vizier query and selects all sources within 'radius'
arcmin 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 WISE sources
in the field. If it doesn't exist, creates the file.
The function returns obsids_table with an additional column 'NSRC_WS'
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')
if opt_moc is not None:
moc_optsurvey = MOC()
read_moc_fits(moc_optsurvey, opt_moc)
nsources_field = np.full((len(obsids_table), ), np.nan)
hp = HEALPix(nside=2**moc_order, order='nested', frame=ICRS())
v = Vizier(columns=['ID', 'RAJ2000', 'DEJ2000', 'eeMaj', 'eeMin', 'eePA'],
row_limit=np.inf,
timeout=6000)
for i, row in enumerate(tqdm(obsids_table, desc="Making WISE 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)
vrsp = v.query_region(field_coords,
radius=radius,
catalog='II/328/allwise')
## 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 opt_moc is not None:
moc_field = moc_optsurvey.intersection(moc_field)
if nir_moc is not None:
moc_field = moc_nirsurvey.intersection(moc_field)
inmoc_table = sources_inmoc(vrsp[0],
hp,
moc_field,
moc_order=moc_order,
ra='RAJ2000',
dec='DEJ2000')
## Save sources
field_table_file = os.path.join(data_folder, groups_folder,
'{}.fits'.format(row['OBS_ID']))
inmoc_table.meta['description'] = 'AllWISE'
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_WS')
obsids_table.add_column(colsrc)
return obsids_table
'DEJ2000',
'e_RAJ2000',
'e_DEJ2000',
'EpRA',
'gmag'
]
for icat in range(len(names)):
Ncatname = Nnames[icat]
catname = names[icat]
link = links[icat]
test = True
try:
table = Vizier(columns=['all']).query_region(
coord.SkyCoord(ra=str(r0),
dec=str(d0),
unit=(u.deg, u.deg),
frame='icrs'),
Angle(fov, "deg"),
catalog=[link])[0]
print(
Ncatname + ': SUCCESS! NUMBER OF STARS IN FOV=' +
str(fov * 3600) + ' arcsec: ', str(len(table)))
with open(outfile, 'a') as f: # 'a'
f.write(Ncatname + ': SUCCESS! NUMBER OF STARS IN FOV=' +
str(fov * 3600) + ' arcsec: ' + str(len(table)) +
'\n')
for star in table:
ra = star[signs[6 * icat]]
dec = star[signs[6 * icat + 1]]
mag = star[signs[6 * icat + 5]]
def get_gaia_coords(img,
ota,
inst,
output='test.gaia',
cluster=False,
**kwargs):
"""
Query the online Gaia DR1 based on the central coordinates of the current
OTA. If the ``cluster`` flag is set to ``True``, the querey will avoid
a crowded region based on coordinates and a radius set by the user in
the configuration files.
Parameters
----------
img : ODIImage or StackedImage object
Name of image
ota : str
Name of OTA
int : str
Version of ODI used, ``podi`` or ``5odi``
"""
from astropy import units as u
from astropy.coordinates import SkyCoord
try:
from astroquery.vizier import Vizier
from astropy import __version__ as astropyversion
except ImportError:
print "astroquery not installed"
print "try pip --user --no-deps install astroquery or contact admin"
hdulist = fits.open(img.f)
if ota == 'None':
hdu_ota = hdulist[0]
else:
hdu_ota = odi.tan_header_fix(hdulist[ota])
w = WCS(hdu_ota.header)
naxis1 = hdu_ota.header['NAXIS1']
naxis2 = hdu_ota.header['NAXIS2']
ota_center_radec = w.wcs_pix2world([[naxis1 / 2., naxis2 / 2.]], 1)
corners = w.calc_footprint()
center_skycoord = SkyCoord(ota_center_radec[0][0] * u.deg,
ota_center_radec[0][1] * u.deg,
frame='icrs')
corner_skycoord = SkyCoord(corners[0, 0] * u.deg,
corners[0, 1] * u.deg,
frame='icrs')
cone_radius = center_skycoord.separation(corner_skycoord).value
# tqdm.write('{:4.0f} {:4.0f} {:6.4f}'.format(naxis1/2., naxis2/2., cone_radius))
#Set up vizier query for Gaia DR1
#Taken from example at: github.com/mommermi/photometrypipeline
vquery = Vizier(columns=[
'RA_ICRS', 'DE_ICRS', 'e_RA_ICRS', 'e_DE_ICRS', 'phot_g_mean_mag'
],
column_filters={"phot_g_mean_mag": ("<%f" % 21.0)},
row_limit=-1)
gaia_table = vquery.query_region(SkyCoord(ra=ota_center_radec[0][0],
dec=ota_center_radec[0][1],
unit=(u.deg, u.deg),
frame='icrs'),
radius=cone_radius * u.deg,
catalog=['I/337/gaia'])[0]
# print gaia_table
hdulist.close()
if cluster == True:
try:
racenter = kwargs['racenter']
deccenter = kwargs['deccenter']
min_radius = kwargs['min_radius']
G_lim = kwargs['G_lim']
except KeyError:
print 'Must provide racenter, deccenter, and min_radius'
cluster_center = SkyCoord(racenter * u.degree,
deccenter * u.degree,
frame='icrs')
gaia_coords = SkyCoord(gaia_table['RA_ICRS'],
gaia_table['DE_ICRS'],
frame='icrs')
dist_from_center = cluster_center.separation(gaia_coords).arcmin
gaia_table['dis'] = dist_from_center
# ota_gaia_df = ota_gaia_df[(ota_gaia_df.dis >= min_radius) &
# (ota_gaia_df.phot_g_mean_mag <= G_lim)]
gaia_table = gaia_table[gaia_table['dis'] > min_radius]
ra_min, ra_max = min(corners[:, 0]), max(corners[:, 0])
dec_min, dec_max = min(corners[:, 1]), max(corners[:, 1])
# print ra_min, ra_max, dec_min, dec_max
gaia_table_cut = gaia_table[(gaia_table['RA_ICRS'] > ra_min)
& (gaia_table['RA_ICRS'] < ra_max) &
(gaia_table['DE_ICRS'] > dec_min) &
(gaia_table['DE_ICRS'] < dec_max)]
gaia_table_cut['e_RA_ICRS'].convert_unit_to(u.deg)
gaia_table_cut['e_DE_ICRS'].convert_unit_to(u.deg)
ota_gaia_df = gaia_table_cut.to_pandas()
cols_needed = ['RA_ICRS', 'DE_ICRS', '__Gmag_', 'e_RA_ICRS', 'e_DE_ICRS']
ota_gaia_df = ota_gaia_df[cols_needed]
ota_gaia_df.columns = ['ra', 'dec', 'phot_g_mean_mag', 'e_ra', 'e_dec']
gaia_catalog_out = output
ota_gaia_df.to_csv(
gaia_catalog_out,
columns=['ra', 'dec', 'phot_g_mean_mag', 'e_ra', 'e_dec'],
index=False)
return ota_gaia_df
import matplotlib
matplotlib.use('Qt5Agg')
import matplotlib.pyplot as plt
# import seaborn as sns
import aplpy
# sns.set_style('whitegrid')
# plt.close('all')
# sns.set_context('talk')
# v = Vizier(columns=['_RAJ2000', '_DEJ2000',
# 'RA_ICRS', 'e_RA_ICRS', 'DE_ICRS', 'e_DE_ICRS', 'Source', '<Gmag>'],
# column_filters={'<Gmag>': '<22'})
v = Vizier()
v.ROW_LIMIT = -1
v.TIMEOUT = 3600
def load_sta_eop(_inp, _date, station_name='KP-VLBA'):
const = constants()
''' load cats '''
_, sta, eops = load_cats(_inp, 'DUMMY', 'S', [station_name], _date)
''' calculate site positions in geodetic coordinate frame
+ transformation matrix VW from VEN to the Earth-fixed coordinate frame '''
for ii, st in enumerate(sta):
sta[ii].geodetic(const)
return sta, eops
def download_nir(aperture, coords_host, host_file_path):
host_file = open(host_file_path, 'a')
# Searching for Wise data
if aperture == 'default/Petro':
# searching for UKIDSS
print('Searching UKIDSS data...')
v = Vizier(
columns=['RAJ2000', 'DEJ2000', 'pYmag', 'pJmag', 'pHmag', 'pKmag', 'e_pYmag', 'e_pJmag', 'e_pHmag',
'e_pKmag', "+_r"])
result = v.query_region(coords_host, radius=0.0014 * units.deg, catalog=['II/314/las8'])
try:
obj = result[0]
Y, J, H, K = tools.vega_to_ab(obj['pYmag'][0], 'Y'), tools.vega_to_ab(obj['pJmag'][0], 'J'), \
tools.vega_to_ab(obj['pHmag'][0], 'H'), tools.vega_to_ab(obj['pKmag'][0], 'K')
e_Y, e_J, e_H, e_K = obj['e_pYmag'][0], obj['e_pJmag'][0], obj['e_pHmag'][0], obj['e_pKmag'][0]
if np.isfinite(K):
host_file.write(tools.format_host_photo('K', 21874, K, e_K, 'UKIDSS', 'Petrosian'))
if np.isfinite(H):
host_file.write(tools.format_host_photo('H', 16206, H, e_H, 'UKIDSS', 'Petrosian'))
if np.isfinite(J):
host_file.write(tools.format_host_photo('J', 12418, J, e_J, 'UKIDSS', 'Petrosian'))
if np.isfinite(Y):
host_file.write(tools.format_host_photo('Y', 10170, Y, e_Y, 'UKIDSS', 'Petrosian'))
except:
print('No UKIDSS data found')
pass
# Searching for 2MASS data if UKIDSS data were not found
if len(result) == 0:
print('Searching 2MASS data...')
v = Vizier(
columns=['RAJ2000', 'DEJ2000', 'Jmag', 'Hmag', 'Kmag', 'e_Jmag', 'e_Hmag', 'e_Kmag', "+_r"])
result = v.query_region(coords_host, radius=0.0014 * units.deg, catalog=['II/246'])
try:
obj = result[0]
J, H, Ks = tools.vega_to_ab(obj['Jmag'][0], 'J'), tools.vega_to_ab(obj['Hmag'][0], 'H'), \
tools.vega_to_ab(obj['Kmag'][0], 'Ks')
e_J, e_H, e_Ks = obj['e_Jmag'][0], obj['e_Hmag'][0], obj['e_Kmag'][0]
if np.isfinite(Ks):
host_file.write(tools.format_host_photo('Ks', 21590, Ks, e_Ks, '2MASS', 'default'))
if np.isfinite(H):
host_file.write(tools.format_host_photo('H', 16620, H, e_H, '2MASS', 'default'))
if np.isfinite(J):
host_file.write(tools.format_host_photo('J', 12350, J, e_J, '2MASS', 'default'))
except:
print('No 2MASS Data found')
pass
elif aperture == 'standard/PSF':
# searching for UKIDSS
print('Searching UKIDSS data...')
v = Vizier(
columns=['RAJ2000', 'DEJ2000', 'pYmag', 'pJmag', 'pHmag', 'pKmag', 'e_pYmag', 'e_pJmag', 'e_pHmag',
'e_pKmag', "+_r"])
result = v.query_region(coords_host, radius=0.0014 * units.deg, catalog=['II/314/las8'])
try:
obj = result[0]
Y, J, H, K = tools.vega_to_ab(obj['pYmag'][0], 'Y'), tools.vega_to_ab(obj['pJmag'][0], 'J'), \
tools.vega_to_ab(obj['pHmag'][0], 'H'), tools.vega_to_ab(obj['pKmag'][0], 'K')
e_Y, e_J, e_H, e_K = obj['e_pYmag'][0], obj['e_pJmag'][0], obj['e_pHmag'][0], obj['e_pKmag'][0]
if np.isfinite(K):
host_file.write(tools.format_host_photo('K', 21874, K, e_K, 'UKIDSS', 'PSF'))
if np.isfinite(H):
host_file.write(tools.format_host_photo('H', 16206, H, e_H, 'UKIDSS', 'PSF'))
if np.isfinite(J):
host_file.write(tools.format_host_photo('J', 12418, J, e_J, 'UKIDSS', 'PSF'))
if np.isfinite(Y):
host_file.write(tools.format_host_photo('Y', 10170, Y, e_Y, 'UKIDSS', 'PSF'))
except:
print('No UKIDSS data found')
pass
# Searching for 2MASS data if UKIDSS data were not found
if len(result) == 0:
print('Searching 2MASS data...')
v = Vizier(
columns=['RAJ2000', 'DEJ2000', 'Jstdap', 'Hstdap', 'Kstdap', 'e_Jstdap', 'e_Hstdap', 'e_Kstdap',
"+_r"])
result = v.query_region(coords_host, radius=0.0014 * units.deg, catalog=['II/246'])
try:
obj = result[0]
J, H, Ks = tools.vega_to_ab(obj['Jstdap'][0], 'J'), tools.vega_to_ab(obj['Hstdap'][0], 'H'), \
tools.vega_to_ab(obj['Kstdap'][0], 'Ks')
e_J, e_H, e_Ks = obj['e_Jstdap'][0], obj['e_Hstdap'][0], obj['e_Kstdap'][0]
if np.isfinite(Ks):
host_file.write(tools.format_host_photo('Ks', 21590, Ks, e_Ks, '2MASS', 'standard'))
if np.isfinite(H):
host_file.write(tools.format_host_photo('H', 16620, H, e_H, '2MASS', 'standard'))
if np.isfinite(J):
host_file.write(tools.format_host_photo('J', 12350, J, e_J, '2MASS', 'standard'))
except:
print('No 2MASS Data found')
pass
host_file.close()
def download_opt(aperture, coords_host, host_file_path):
host_file = open(host_file_path, 'a')
dec_host = coords_host.dec.deg
if aperture == 'Kron/Petro':
print('Searching SDSS data...')
v = Vizier(
columns=['RAJ2000', 'DEJ2000', 'petroMag_g', 'petroMagErr_g', 'petroMag_r', 'petroMagErr_r', 'petroMag_i', 'petroMagErr_i', 'petroMag_z', 'petroMagErr_z', "+_r"])
result_sdss = v.query_region(coords_host, radius=0.0014 * units.deg, catalog=['V/147/sdss12'])
try:
obj = result_sdss[0]
z, i, r, g = obj['zPmag'][0], obj['iPmag'][0], obj['rPmag'][0], obj['gPmag'][0]
e_z, e_i, e_r, e_g = obj['e_zPmag'][0], obj['e_iPmag'][0], obj['e_rPmag'][0], \
obj['e_gPmag'][0]
if np.isfinite(z):
host_file.write(tools.format_host_photo('z', 8932, z, e_z, 'SDSS', 'Petrosian'))
if np.isfinite(i):
host_file.write(tools.format_host_photo('i', 7480, i, e_i, 'SDSS', 'Petrosian'))
if np.isfinite(r):
host_file.write(tools.format_host_photo('r', 6166, r, e_r, 'SDSS', 'Petrosian'))
if np.isfinite(g):
host_file.write(tools.format_host_photo('g', 4686, g, e_g, 'SDSS', 'Petrosian'))
except:
print('No SDSS Data found')
pass
if len(result_sdss) == 0:
result_pan = []
if dec_host > -30:
print('Searching PAN-STARRS data...')
v = Vizier(
columns=['RAJ2000', 'DEJ2000', 'objID', 'yKmag', 'zKmag', 'iKmag', 'rKmag', 'gKmag', 'e_yKmag',
'e_zKmag',
'e_iKmag', 'e_rKmag', 'e_gKmag', "+_r"])
result_pan = v.query_region(coords_host, radius=0.0014 * units.deg, catalog=['II/349/ps1'])
try:
obj = result_pan[0]
y, z, i, r, g = obj['yKmag'][0], obj['zKmag'][0], obj['iKmag'][0], obj['rKmag'][0], obj['gKmag'][0]
e_y, e_z, e_i, e_r, e_g = obj['e_yKmag'][0], obj['e_zKmag'][0], obj['e_iKmag'][0], obj['e_rKmag'][0], \
obj['e_gKmag'][0]
if np.isfinite(y):
host_file.write(tools.format_host_photo('y', 9633, y, e_y, 'PAN-STARRS', 'Kron'))
if np.isfinite(z):
host_file.write(tools.format_host_photo('z', 8679, z, e_z, 'PAN-STARRS', 'Kron'))
if np.isfinite(i):
host_file.write(tools.format_host_photo('i', 7545, i, e_i, 'PAN-STARRS', 'Kron'))
if np.isfinite(r):
host_file.write(tools.format_host_photo('r', 6215, r, e_r, 'PAN-STARRS', 'Kron'))
if np.isfinite(g):
host_file.write(tools.format_host_photo('g', 4866, g, e_g, 'PAN-STARRS', 'Kron'))
except:
print('No PAN-STARRS Data found')
pass
if dec_host <= -30 | (len(result_pan) == 0 and dec_host <= 0):
print('Searching DES data...')
v = Vizier(
columns=['RAJ2000', 'DEJ2000', 'Ymag', 'zmag', 'imag', 'rmag', 'gmag', 'e_Ymag', 'e_zmag', 'e_imag',
'e_rmag', 'e_gmag', "+_r"])
result_des = v.query_region(coords_host,
radius=0.0014 * units.deg,
catalog=['II/357/des_dr1'])
try:
obj = result_des[0]
Y, z, i, r, g = obj['Ymag'][0], obj['zmag'][0], obj['imag'][0], obj['rmag'][0], obj['gmag'][0]
e_Y, e_z, e_i, e_r, e_g = obj['e_Ymag'][0], obj['e_zmag'][0], obj['e_imag'][0], obj['e_rmag'][0], \
obj['e_gmag'][0]
if np.isfinite(Y):
host_file.write(tools.format_host_photo('Y', 10305, Y, e_Y, 'DES', 'Kron'))
if np.isfinite(z):
host_file.write(tools.format_host_photo('z', 8660, z, e_z, 'DES', 'Kron'))
if np.isfinite(i):
host_file.write(tools.format_host_photo('i', 7520, i, e_i, 'DES', 'Kron'))
if np.isfinite(r):
host_file.write(tools.format_host_photo('r', 6170, r, e_r, 'DES', 'Kron'))
if np.isfinite(g):
host_file.write(tools.format_host_photo('g', 4810, g, e_g, 'DES', 'Kron'))
except:
print('No DES Data found')
pass
if len(result_des) == 0:
print('Searching SkyMapper data...')
v = Vizier(
columns=['RAJ2000', 'DEJ2000', 'vPetro', 'gPetro', 'rPetro', 'iPetro',
'zPetro',
'e_vPetro',
'e_gPetro', 'e_rPetro', 'e_iPetro', 'e_zPetro', "+_r"])
result = v.query_region(coords_host, radius=0.0014 * units.deg, catalog=['II/358/smss'])
try:
obj = result[0]
z, i, r, g, v = obj['zPetro'][0], obj['iPetro'][0], obj['rPetro'][0], \
obj['gPetro'][0], obj['vPetro'][0]
e_z, e_i, e_r, e_g, e_v = obj['e_zPetro'][0], obj['e_iPetro'][0], \
obj['e_rPetro'][0], obj['e_gPetro'][0], obj['e_vPetro'][0]
if np.isfinite(z):
host_file.write(tools.format_host_photo('z', 9091, z, e_z, 'SkyMapper', 'Petrosian'))
if np.isfinite(i):
host_file.write(tools.format_host_photo('i', 7712, i, e_i, 'SkyMapper', 'Petrosian'))
if np.isfinite(r):
host_file.write(tools.format_host_photo('r', 6040, r, e_r, 'SkyMapper', 'Petrosian'))
if np.isfinite(g):
host_file.write(tools.format_host_photo('g', 4968, g, e_g, 'SkyMapper', 'Petrosian'))
if np.isfinite(v):
host_file.write(tools.format_host_photo('v', 3870, v, e_v, 'SkyMapper', 'Petrosian'))
except:
print('No SkyMapper Data found')
pass
# Searching SDSS u band photometry
v = Vizier(
columns=['RAJ2000', 'DEJ2000', 'petroMag_u', 'petroMagErr_u', "+_r"])
result = v.query_region(coords_host, radius=0.0014 * units.deg, catalog=['V/147/sdss12'])
try:
obj = result[0]
u, e_u = obj['uPmag'][0], obj['e_uPmag'][0]
if np.isfinite(u):
host_file.write(tools.format_host_photo('u', 3551, u, e_u, 'SDSS', 'Petrosian'))
else:
print('No SDSS u band mag found')
try:
#print('Searching SkyMapper u band data...')
v = Vizier(
columns=['RAJ2000', 'DEJ2000', 'uPetro', 'e_uPetro', "+_r"])
result = v.query_region(coords_host, radius=0.0014 * units.deg, catalog=['II/358/smss'])
obj = result[0]
u, e_u = obj['uPetro'][0], obj['e_uPetro'][0]
if np.isfinite(u):
host_file.write(tools.format_host_photo('u', 3551, u, e_u, 'SkyMapper', 'Petrosian'))
except:
pass
except:
pass
elif aperture == 'PSF':
print('Searching SDSS data...')
v = Vizier(
columns=['RAJ2000', 'DEJ2000', 'gpmag', 'e_gpmag', 'rpmag', 'e_rpmag', 'ipmag', 'e_ipmag', 'zpmag', 'e_zpmag',
"+_r"])
result_sdss = v.query_region(coords_host, radius=0.0014 * units.deg, catalog=['V/147/sdss12'])
try:
obj = result_sdss[0]
z, i, r, g = obj['zpmag'][0], obj['ipmag'][0], obj['rpmag'][0], obj['gpmag'][0]
e_z, e_i, e_r, e_g = obj['e_zpmag'][0], obj['e_ipmag'][0], obj['e_rpmag'][0], \
obj['e_gpmag'][0]
if np.isfinite(z):
host_file.write(tools.format_host_photo('z', 8932, z, e_z, 'SDSS', 'Model'))
if np.isfinite(i):
host_file.write(tools.format_host_photo('i', 7480, i, e_i, 'SDSS', 'Model'))
if np.isfinite(r):
host_file.write(tools.format_host_photo('r', 6166, r, e_r, 'SDSS', 'Model'))
if np.isfinite(g):
host_file.write(tools.format_host_photo('g', 4686, g, e_g, 'SDSS', 'Model'))
except:
print('No SDSS Data found')
pass
if len(result_sdss) == 0:
result_pan = []
if dec_host > -30:
print('Searching PAN-STARRS data...')
v = Vizier(
columns=['RAJ2000', 'DEJ2000', 'objID', 'ymag', 'zmag', 'imag', 'rmag', 'gmag', 'e_ymag',
'e_zmag',
'e_imag', 'e_rmag', 'e_gmag', "+_r"])
result_pan = v.query_region(coords_host, radius=0.0014 * units.deg, catalog=['II/349/ps1'])
try:
obj = result_pan[0]
y, z, i, r, g = obj['ymag'][0], obj['zmag'][0], obj['imag'][0], obj['rmag'][0], obj['gmag'][0]
e_y, e_z, e_i, e_r, e_g = obj['e_ymag'][0], obj['e_zmag'][0], obj['e_imag'][0], obj['e_rmag'][0], \
obj['e_gmag'][0]
if np.isfinite(y):
host_file.write(tools.format_host_photo('y', 9633, y, e_y, 'PAN-STARRS', 'PSF'))
if np.isfinite(z):
host_file.write(tools.format_host_photo('z', 8679, z, e_z, 'PAN-STARRS', 'PSF'))
if np.isfinite(i):
host_file.write(tools.format_host_photo('i', 7545, i, e_i, 'PAN-STARRS', 'PSF'))
if np.isfinite(r):
host_file.write(tools.format_host_photo('r', 6215, r, e_r, 'PAN-STARRS', 'PSF'))
if np.isfinite(g):
host_file.write(tools.format_host_photo('g', 4866, g, e_g, 'PAN-STARRS', 'PSF'))
except:
print('No PAN-STARRS Data found')
pass
if dec_host <= -30 | (len(result_pan) == 0 and dec_host <= 0):
print('Searching DES data...')
v = Vizier(
columns=['RAJ2000', 'DEJ2000', 'YmagPSF', 'zmagPSF', 'imagPSF', 'rmagPSF', 'gmagPSF', 'e_YmagPSF',
'e_zmagPSF', 'e_imagPSF', 'e_rmagPSF', 'e_gmagPSF', "+_r"])
result_des = v.query_region(coords_host,
radius=0.0014 * units.deg,
catalog=['II/357/des_dr1'])
try:
obj = result_des[0]
Y, z, i, r, g = obj['YmagPSF'][0], obj['zmagPSF'][0], obj['imagPSF'][0], obj['rmagPSF'][0], \
obj['gmagPSF'][0]
e_Y, e_z, e_i, e_r, e_g = obj['e_YmagPSF'][0], obj['e_zmagPSF'][0], obj['e_imagPSF'][0], \
obj['e_rmagPSF'][0], \
obj['e_gmagPSF'][0]
if np.isfinite(Y):
host_file.write(tools.format_host_photo('Y', 10305, Y, e_Y, 'DES', 'PSF'))
if np.isfinite(z):
host_file.write(tools.format_host_photo('z', 8660, z, e_z, 'DES', 'PSF'))
if np.isfinite(i):
host_file.write(tools.format_host_photo('i', 7520, i, e_i, 'DES', 'PSF'))
if np.isfinite(r):
host_file.write(tools.format_host_photo('r', 6170, r, e_r, 'DES', 'PSF'))
if np.isfinite(g):
host_file.write(tools.format_host_photo('g', 4810, g, e_g, 'DES', 'PSF'))
except:
print('No DES Data found')
pass
if len(result_des) == 0:
print('Searching SkyMapper data...')
v = Vizier(
columns=['RAJ2000', 'DEJ2000', 'vPSF', 'gPSF', 'rPSF', 'iPSF',
'zPSF', 'e_vPSF', 'e_gPSF', 'e_rPSF', 'e_iPSF', 'e_zPSF', "+_r"])
result = v.query_region(coords_host, radius=0.0014 * units.deg, catalog=['II/358/smss'])
try:
obj = result[0]
z, i, r, g, v =obj['zPSF'][0], obj['iPSF'][0], obj['rPSF'][0], \
obj['gPSF'][0], obj['vPSF'][0]
e_z, e_i, e_r, e_g, e_v = obj['e_zPSF'][0], obj['e_iPSF'][0], \
obj['e_rPSF'][0], obj['e_gPSF'][0], obj['e_vPSF'][0]
if np.isfinite(z):
host_file.write(tools.format_host_photo('z', 9091, z, e_z, 'SkyMapper', 'PSF'))
if np.isfinite(i):
host_file.write(tools.format_host_photo('i', 7712, i, e_i, 'SkyMapper', 'PSF'))
if np.isfinite(r):
host_file.write(tools.format_host_photo('r', 6040, r, e_r, 'SkyMapper', 'PSF'))
if np.isfinite(g):
host_file.write(tools.format_host_photo('g', 4968, g, e_g, 'SkyMapper', 'PSF'))
if np.isfinite(v):
host_file.write(tools.format_host_photo('v', 3870, v, e_v, 'SkyMapper', 'PSF'))
except:
print('No SkyMapper Data found')
pass
# Searching SDSS u band photometry
v = Vizier(
columns=['RAJ2000', 'DEJ2000', 'umag', 'e_umag', "+_r"])
result = v.query_region(coords_host, radius=0.0014 * units.deg, catalog=['V/147/sdss12'])
try:
obj = result[0]
u, e_u = obj['upmag'][0], obj['e_upmag'][0]
if np.isfinite(u):
host_file.write(tools.format_host_photo('u', 3551, u, e_u, 'SDSS', 'PSF'))
else:
print('No SDSS Data found')
try:
v = Vizier(
columns=['RAJ2000', 'DEJ2000', 'uPetro', 'e_uPetro', "+_r"])
result = v.query_region(coords_host, radius=0.0014 * units.deg, catalog=['II/358/smss'])
obj = result[0]
u, e_u = obj['uPSF'][0], obj['e_uPSF'][0]
if np.isfinite(u):
host_file.write(tools.format_host_photo('u', 3498, u, e_u, 'SkyMapper', 'PSF'))
except:
pass
except:
pass
host_file.close()
class SdssSpec:
sdss = Vizier(columns=[
'RA_ICRS', 'DE_ICRS', 'umag', 'gmag', 'rmag', 'imag', 'zmag', 'subCl'
],
column_filters={"SpObjID": ">0"})
sources = None
stats = None
m_stats = None
def __init__(self, row_limit=100000, path=None):
"""
Class to download and handle SDSS spectroscopic identificated sources
:param row_limit: Number sources to download
:type row_limit: int
:param path: Path to a file with the data from SDSS DR12. Default is None.
:type path: str
"""
self.sdss.ROW_LIMIT = row_limit
if path is not None:
self.sources = Table.read(path)
def download_classification(self, cache=True, r_min=20):
"""
Downloads the classifications and magnitudes of sources from the SDSS DR12 catalog
:param cache:
If a path was set, cache=True means that it will use the data from the file.
False means that it will download a new set. Default is True.
:type cache: bool
:param r_min: Minimal brightness in the r-band
:type r_min: float
:return: Table with the downloaded data
:rtype: astropy.table.Table
"""
try:
if cache and self.sources is not None:
return self.sources
# query the SDSS DR12 for objects with a spectral identification
# and a set sub-class identification with the
# astroquery vizier class
self.sources = self.sdss.query_constraints(
catalog='V/147/sdss12',
SpObjID='>0',
subCl='!= ',
rmag='<{}'.format(r_min))[0]
self.sources = __sub_class_rename__(self.sources)
self.__stats__()
return self.sources
except IndexError:
return None
def __stats__(self):
"""
Counts how often a spectral type appears in the data set
:return: The counts of the spectral type
:type: astropy.table.Table
"""
sub_classes, sub_class_counts = np.unique(self.sources['subCl'],
return_counts=True)
self.stats = Table()
self.stats['subCl'] = sub_classes
self.stats['count'] = sub_class_counts
self.__main_identification_stats__()
return self.stats
def __main_identification_stats__(self):
"""
Returns the main identification of the sources and how often they are in the sample.
A main identification is for a star the main spectral type.
Galaxies and QSO's are compressed to only one type (AGN and STARFORMING).
:return: Dict with the main identifications as keys and the values are how often they are in the sample.
:rtype: dict
"""
m_stats = {}
for s in self.stats:
sub_cl = s['subCl']
# if the length is two, it is likely a star identification
if len(sub_cl) == 2:
if sub_cl[-1].isdigit():
# take only the spectral identification key
sub_cl = sub_cl[0]
m_stats = __add_counts__(m_stats, sub_cl, s)
# if the second key is not a number
else:
if 'OB' in sub_cl:
sub_cl = 'O'
m_stats = __add_counts__(m_stats, sub_cl, s)
# if the length is larger than two
else:
# Compress galaxy and QSO's types
if sub_cl == 'BROADLINE':
sub_cl = "AGN"
elif sub_cl == 'STARBURST':
sub_cl = 'GALAXY'
elif sub_cl == 'STARFORMING':
sub_cl = 'GALAXY'
elif sub_cl == 'Ldwarf':
sub_cl = 'L'
elif sub_cl == 'Carbon_lines':
sub_cl = 'Carbon'
m_stats = __add_counts__(m_stats, sub_cl, s)
self.m_stats = m_stats
return m_stats
def show_sub_classes(self):
"""
Plots the distribution of different main spectral identifications
as a bar plot
:return:
"""
pl.clf()
sp = pl.subplot()
x = np.zeros((len(self.m_stats), 2))
for i, k in enumerate(self.m_stats):
x[i, 0] = i
x[i, 1] = self.m_stats[k]
sp.bar(x[:, 0], x[:, 1])
pl.xticks(x[:, 0], list(self.m_stats.keys()), rotation='vertical')
sp.set_ylabel('counts')
sp.set_xlabel('main subclass type')
sp.set_yscale('log')
pl.show()
"""
This is the code used to generate the polynomial relations
used in sedkit's calculations
"""
from pkg_resources import resource_filename
import astropy.io.ascii as ii
import astropy.units as q
import astropy.table as at
from astroquery.vizier import Vizier
from bokeh.plotting import figure, show
import numpy as np
from . import utilities as u
V = Vizier(columns=["**"])
class SpectralTypeRadius:
def __init__(self, orders=(5, 3), name='Spectral Type vs. Radius'):
"""Initialize the object
Parameters
----------
order: int
The order polynomial to fit to the spt-radius data
"""
self.name = name
self.generate(orders)
def get_radius(self, spt, plot=False):
