def get_hip(name):
"""
Given a star's Bayer designation, queries
VizieR and attempts to locate a Hipparcos
star ID at the location.
Returns an integer HIP ID if found, or None otherwise
Maintains a .hip_cache_stars file to speed up lookups;
you can delete the .hip_cache_stars file to perform
fresh lookups.
"""
# Search the Hipparcos catalog, and only return results that include
# a HIP (Hipparcos) column, sorting the results by magnitude. The
# top result is almost certainly the star we want.
v = Vizier(catalog='I/239/hip_main', columns=["HIP", "+Vmag"])
try:
result = v.query_object(name)
except EOFError:
# if we get no results we might get an EOFError
return None
try:
table = result['I/239/hip_main']
except TypeError:
# A TypeError means that the results didn't include anything from
# the I/239/hip_main catalog. The "in" operator doesn't seem to
# work with Table objects.
return None
else:
return table['HIP'][0]
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 G 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={"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="II/349/ps1")[0]
def query_nvss(options, ra0, dec0, s=">0.0", proj='SIN'):
'''
query_nvss: module which queries the NVSS using the Vizier protocol.
inputs: ra0, dec0, s="<20"
ra0 = the central ra in degrees
dec0 = the central dec in degrees
s = the flux cutoff
returns L, M (relative coordinates in degrees), N (number of sources), S (1.4GHz Flux
Density in mJy)
'''
v = Vizier(column_filters={"S1.4":s})
v.ROW_LIMIT = 10000
result = v.query_region(coord.SkyCoord(ra=ra0, dec=dec0, unit=(u.deg, u.deg), frame='icrs'),
radius=Angle(1, "deg"), catalog='NVSS')
ra = result[0]['_RAJ2000']
dec = result[0]['_DEJ2000']
N = len(result[0])
if proj.upper()=='SIN':
L = (ra-ra0)*pl.cos(dec*deg2rad)
M = dec-dec0
if proj.upper()=='NCP':
L = 57.2957795*pl.cos(deg2rad*dec)*pl.sin(deg2rad*(ra-ra0))
M = 57.2957795*(pl.cos(deg2rad*dec0) - pl.cos(deg2rad*dec)*pl.cos(deg2rad*(ra-ra0)))/pl.sin(deg2rad*dec0)
S = result[0]['S1.4']
ascii.write(result[0], options.outfile+'.dat', format='tab')
ann_writer(options, result[0])
return L, M, N, S
def get_catalog(object):
from astroquery.vizier import Vizier
viz = Vizier( columns=['Star', '*'])
star = object.replace('_', ' ') + '*'
try:
return viz.query_constraints(catalog='II/183A/table2',Star=star)[0]
except IndexError:
return None
def galaxies_in_box(center, ra_span, dec_span):
"""
This function ...
:param center:
:param ra_span:
:param dec_span:
:return:
"""
# Initialize a list to contain the galaxies
names = []
# Other way ?? Much more results ?
#ra_radius = 0.5 * ra_span.value
#dec_radius = 0.5 * dec_span.value
#radius = math.sqrt(ra_radius**2 + dec_radius**2)
#result_table = Ned.query_region(center, radius=radius)
# Create a new Vizier object and set the row limit to -1 (unlimited)
viz = Vizier(keywords=["galaxies", "optical"])
viz.ROW_LIMIT = -1
# Debugging
log.debug("Querying the HYPERLEDA catalog ...")
# Query Vizier and obtain the resulting table
result = viz.query_region(center.to_astropy(), width=ra_span, height=dec_span, catalog=["VII/237"])
# I noticed something strange happening once; where there were no entries in the result,
# with the following parameters:
# center = (149.07614359, 69.24847936)
# ra_span = 1.600000128 deg
# dec_span = 1.3966667784 deg
# catalog = ["VII/237"]
# When ra_span was only slightly changed (e.g. change the last digit to a '7'), output was normal
# Thus, it seems that the query goes wrong with specific values of the width (and/or height), in which
# case changing the value very slightly resolves the problem...
# I am baffled by this and I see no reasonable explanation.
if len(result) == 0:
ra_span *= 1.0 + 1e-5
result = viz.query_region(center.to_astropy(), width=ra_span, height=dec_span, catalog=["VII/237"])
table = result[0]
# Loop over the rows in the table
for entry in table:
name = "PGC " + str(entry["PGC"])
coordinate = SkyCoordinate(ra=entry["_RAJ2000"], dec=entry["_DEJ2000"], unit="deg", frame="fk5")
namepluscoordinate = (name, coordinate)
names.append(namepluscoordinate)
# Return the list of galaxies
return names
def serendipitous_variablestars(catalogs, display=True):
"""match catalogs with VSX catalog using astroquery.Vizier
"""
if display:
print('# match frames with variable star database... ', end=' ',
flush=True)
logging.info('match frames with variable star database')
# derive center and radius of field of view of all images
ra_deg, dec_deg, rad_deg = skycenter(catalogs)
logging.info('FoV center (%.7f/%+.7f) and radius (%.2f deg) derived' %
(ra_deg, dec_deg, rad_deg))
# derive observation midtime of sequence
midtime = np.average([cat.obstime[0] for cat in catalogs])
# setup Vizier query
# note: column filters uses original Vizier column names
# -> green column names in Vizier
logging.info(('query Vizier for VSX at %7.3f/%+8.3f in '
+ 'a %.2f deg radius') %
(ra_deg, dec_deg, rad_deg))
field = coord.SkyCoord(ra=ra_deg, dec=dec_deg, unit=(u.deg, u.deg),
frame='icrs')
vquery = Vizier(columns=['Name', 'RAJ2000', 'DEJ2000'])
try:
data = vquery.query_region(field,
width=("%fd" % rad_deg),
catalog="B/vsx/vsx")[0]
except IndexError:
if display:
print('no data available from VSX')
logging.error('no data available from VSX')
return []
objects = []
for cat_idx, cat in enumerate(catalogs):
for star in data:
objects.append({'ident': star['Name'],
'obsdate.jd': cat.obstime[0],
'cat_idx': cat_idx,
'ra_deg': star['RAJ2000'],
'dec_deg': star['DEJ2000']})
if display:
print(len(objects)/len(catalogs), 'variable stars found')
return objects
def fetch_objects_in_box(box, catalog, keywords, radius, limit=None, column_filters=None):
"""
This function ...
:param box:
:param catalog:
:param keywords:
:param radius:
:param limit:
:param column_filters:
:return:
"""
# Define the center coordinate for the box
coordinate = SkyCoordinate(ra=box[0], dec=box[1], unit="deg", frame="fk5") # frame: icrs, fk5... ?
# Make a Vizier object
if column_filters is None:
viz = Vizier(columns=['_RAJ2000', '_DEJ2000','B-V', 'Vmag', 'Plx'], keywords=keywords)
else:
viz = Vizier(columns=['_RAJ2000', '_DEJ2000','B-V', 'Vmag', 'Plx'], column_filters=column_filters, keywords=keywords)
# No limit on the number of entries
viz.ROW_LIMIT = limit if limit is not None else -1
# Query the box of our image frame
result = viz.query_region(coordinate.to_astropy(), width=box[3] * Unit("deg"), height=box[2] * Unit("deg"), catalog=catalog)
region_string = "# Region file format: DS9 version 3.0\n"
region_string += "global color=green\n"
# Result may contain multiple tables (for different catalogs)
for table in result:
# For every entry in the table
for entry in table:
# Get the right ascension and the declination
ra = entry[0]
dec = entry[1]
# Create a string with the coordinates of the star
regline = "fk5;circle(%s,%s,%.2f\")\n" % (ra, dec, radius)
# Add the parameters of this star to the region string
region_string += regline
# Return the region
return regions.parse(region_string)
def get_galaxy_s4g_one_component_info(name):
"""
This function ...
:param name:
:return:
"""
# The Vizier querying object
vizier = Vizier()
vizier.ROW_LIMIT = -1
# Get the "galaxies" table
result = vizier.query_object(name, catalog=["J/ApJS/219/4/galaxies"])
# No results?
if len(result) == 0: return None, None, None, None, None, None
# Get table
table = result[0]
# PA: [0.2/180] Outer isophote position angle
# e_PA: [0/63] Standard deviation in PA
# Ell: [0.008/1] Outer isophote ellipticity
# e_Ell: [0/0.3] Standard deviation in Ell
# PA1: Elliptical isophote position angle in deg
# n: Sersic index
# Re: effective radius in arcsec
# Tmag: total magnitude
s4g_name = table["Name"][0]
pa = Angle(table["PA"][0] - 90., "deg")
pa_error = Angle(table["e_PA"][0], "deg")
ellipticity = table["Ell"][0]
ellipticity_error = table["e_Ell"][0]
n = table["n"][0]
re = table["Re"][0] * u("arcsec")
mag = table["Tmag"][0]
# Return the results
return s4g_name, pa, ellipticity, n, re, mag
def catalog_search(frame_wcs, shape, desired_catalog,
ra_column='RAJ2000',
dec_column='DEJ2000',
radius=0.5,
clip_by_frame=True):
"""
Description: This function takes coordinate data from an image and a
catalog name and returns the positions of those stars.
Preconditions:frame_wcs is a WCS object, shape is tuple, list or array of
numerical values, desired_catalog is a string and radius is a numerical
value.
Postconditions:
"""
rad = radius * units.deg
# Find the center of the frame
center_coord = frame_wcs.all_pix2world([[shape[1] / 2, shape[0] / 2]], 0)
center = SkyCoord(center_coord, frame='icrs', unit='deg')
# Get catalog via cone search
Vizier.ROW_LIMIT = -1 # Set row_limit to have no limit
cat = Vizier.query_region(center, radius=rad, catalog=desired_catalog)
# Vizier always returns list even if there is only one element. Grab that
# element.
cat = cat[0]
cat_coords = SkyCoord(ra=cat[ra_column], dec=cat[dec_column])
if clip_by_frame:
in_fov = in_frame(frame_wcs, cat_coords)
else:
in_fov = np.ones([len(cat_coords)], dtype=np.bool)
x, y = frame_wcs.all_world2pix(cat_coords.ra, cat_coords.dec, 0)
return (cat[in_fov], x[in_fov], y[in_fov])
def selected_catalog( ra, dec, FOV_base, FOV_height, catalog ):
'''
Vizier.query_region in selected FoV. The hist of the apparent blue magnitude
and the sky coordinates are provided if GWGC catalog is selected
'''
from astroquery.vizier import Vizier
import astropy.coordinates as coord
import astropy.units as u
import aladinSAMP
# setting rows limit
Vizier.ROW_LIMIT = None
# no reduced query size (rq)
reduce_query_size = 1
FOV_base_reduced, FOV_height_reduced = FOV_base * reduce_query_size, FOV_height * reduce_query_size
FOV_base_str, FOV_height_str = str( FOV_base_reduced ) + 'd', str( FOV_height_reduced ) + 'd'
result = Vizier.query_region(coord.SkyCoord(ra = ra, dec = dec, unit = (u.deg, u.deg), frame='icrs'),
width = FOV_height_str, height = FOV_base_str, catalog = [ catalog ])
result.pprint()
print result.values()
def __init__(self, config=None):
"""
The constructor ...
"""
# Call the constructor of the base class
super(SEDFetcher, self).__init__(config, "modeling")
# -- Attributes --
# The name of the galaxy
self.galaxy_name = None
# The NGC ID of the galaxy
self.ngc_id = None
# The Vizier querying object
self.vizier = Vizier(keywords=["galaxies"])
self.vizier.ROW_LIMIT = -1
# The observed SED
self.seds = dict()
# The filters
self.filters = dict()
def query_color(self,
ra,
dec,
radius=0.01,
min_mag=10,
max_mag=20,
max_sources=100):
"""
Query NOMAD object
@param ra: RA of field center for search, format: degrees or hh:mm:ss
@type ra: str
@param dec: DEC of field center for search, format: degrees or hh:mm:ss
@type dec: str
@param radius: Radius.
@type radius: float
@param min_mag: Minimum magnitude value of query.
@type min_mag: float
@param max_mag: Maximum magnitude value of query.
@type max_mag: float
@param max_sources: Maximum strs to be queried..
@type max_sources: int
@return: astropy.table
"""
c = coord.SkyCoord(ra,
dec,
unit=(u.deg, u.deg),
frame='icrs')
r = radius * u.deg
vquery = Vizier(columns=['NOMAD1',
'RAJ2000',
'DEJ2000',
'Bmag',
'Vmag',
'Rmag'],
column_filters={"Rmag":
(">{:f}".format(min_mag)),
"Rmag":
("<{:f}".format(max_mag))},
row_limit=max_sources)
result = vquery.query_region(c, radius=r, catalog="NOMAD")[0]
return(result)
def query_vizier(self, catalog='APASS'):
'''
Uses the astroquery environment to get the data from Vizier.
Possible selection of catalogues:
'''
result = Vizier.query_region("%.6f %.6f"%(self.ra, self.dec), radius=Angle(self.rad, "deg"), \
catalog=catalog) #column_filters={"rmag":">%s"%self.minmag,"rmag":"<%s"%self.maxmag }
return result[0]
def green_catalog_download():
# This allows easy access to Vizier tables:
# https://astroquery.readthedocs.org/en/latest/vizier/vizier.html
from astroquery.vizier import Vizier
Vizier.ROW_LIMIT = -1
# This is the 2014-05 version of Green's catalog
# http://vizier.u-strasbg.fr/viz-bin/VizieR?-source=VII/272
results = Vizier.get_catalogs(['VII/272'])
table = results[0]
return table
def get_hip(ra, dec, mag):
"""
Given an RA (in hours and decimals), and Dec (in
degrees and decimals), and a magnitude (in
visual magnitudes), queries VizieR and attempts
to locate a Hipparcos star ID at the location.
Returns an integer HIP ID if found, or None otherwise
Maintains a .hip_cache file to speed up lookups;
you can delete the .hip_cache file to perform
fresh lookups.
"""
coord = SkyCoord(ra=Angle("{} hours".format(ra)),
dec=Angle("{} degree".format(dec)),
obstime="J2000.0")
# Search the Hipparcos catalog, and only return results that include
# a HIP (Hipparcos) column, sorting the results by magnitude. The
# top result is almost certainly the star we want.
v = Vizier(catalog='I/239/hip_main', columns=["HIP", "+Vmag"])
# Constrain the search to stars within 1 Vmag of our target
v.query_constraints(Vmag="{}..{}".format(mag - 0.5, mag + 0.5))
# Start with a targeted search, which returns more quickly from the
# API. If that fails to find a star, query a 3 degree diameter circle
# around the ra/dec. This is because Sky & Telescope has a convention
# of stopping their constellation lines a degree or so away from the
# star, if that star isn't actually part of the constellation
# (example: Alpheratz, which is part of the Pegasus figure, but the
# star is in Andromeda)
for radius in (0.05, 1.5):
result = v.query_region(coord, radius=radius*u.deg)
try:
table = result['I/239/hip_main']
except TypeError:
# A TypeError means that the results didn't include anything from
# the I/239/hip_main catalog. The "in" operator doesn't seem to
# work with Table objects.
continue
else:
return table['HIP'][0]
return None
def showVizierCatalogs(self):
(ra, dec) = self.centre
from astroquery.vizier import Vizier
Vizier.ROW_LIMIT = 50
from astropy import coordinates
from astropy import units as u
c = coordinates.SkyCoord(ra,dec,unit=('deg','deg'),frame='icrs')
skyHeight= coordinates.Angle(self.raRange, unit = u.deg)
results = Vizier.query_region(coordinates = c, radius= 1.0 * u.deg)
print results
def query_circle(self, ra, dec, radius, catalog):
"""Vizier.query_region in a circle FoV."""
Vizier.ROW_LIMIT = None
radius_str = str(radius) + "d"
query_result = Vizier.query_region(
SkyCoord(ra=ra, dec=dec, unit=(u.deg, u.deg), frame="icrs"), radius=radius_str, catalog=[catalog]
)
return query_result
def calc_frame_phot_correction(objects, cat_file, vizier_var, phot_var, cat_name='SDSS',
separation=2*u.arcsec, fields=['*']):
positions = coords.SkyCoord(objects['ra'], objects['dec'], frame='icrs', unit='deg')
print('Querying Vizier')
v_cat = Vizier(columns=fields, catalog=catalog_info[cat_name]['vizier name'])
result = v_cat.query_region(positions, radius=separation)
# Vizier returns a table list with a table for each catalog
# Since we have only chosen one catalog, we take the first (and only) table
catalog = result[0]
catalog.rename_column('_RAJ2000','ra')
catalog.rename_column('_DEJ2000','dec')
catalog.rename_column(vizier_var, phot_var)
# remove results that have bad photometry
#catalog = catalog[catalog[phot_var]>-9000]
# only keep the catalog entries that are primary stars
catalog = catalog[catalog['cl']==catalog_info[cat_name]['class']['star']]
catalog = (catalog[catalog[catalog_info[cat_name]['mode']] ==
catalog_info[cat_name]['modes']['primary']])
print('Finding matches for catalog stars')
# find the corresonding object for each entry in the catalog array
dr = coords.Angle(separation).to('degree').value
cat_coords = coords.SkyCoord(catalog['ra'], catalog['dec'], frame='icrs', unit='deg')
matches, d2d, d3d = cat_coords.match_to_catalog_sky(positions)
match_col = Column(matches)
catalog['matches'] = match_col
# Remove all sources with duplicate entries (there can be a difference between
# the astropy catalog match and the match from Vizier in a few rare cases)
duplicates = np.where(np.bincount(match_col)>1)[0]
for duplicate in duplicates:
match_col[np.where(match_col==duplicate)]=-1
catalog = catalog[match_col>=0]
catalog = catalog.group_by('matches')
print('Total matches:', len(catalog.groups.keys['matches']))
cat_array=np.array(catalog)
np.save(cat_file, cat_array)
print('Saving file',cat_file)
return catalog
def get_s4g_properties(self):
"""
This function ...
:return:
"""
# Inform the user
log.info("Querying the S4G catalog ...")
# The Vizier querying object
vizier = Vizier(columns=['Name', 'RAJ2000', 'DEJ2000', 'amaj', 'ell', 'Dmean', "e_Dmean", "PA"])
vizier.ROW_LIMIT = -1
# Get parameters from S4G catalog
result = vizier.query_object(self.galaxy_name, catalog=["J/PASP/122/1397/s4g"])
table = result[0]
# Galaxy name for S4G catalog
self.properties.name = table["Name"][0]
# Galaxy center from decomposition (?)
ra_center = table["RAJ2000"][0]
dec_center = table["DEJ2000"][0]
center = SkyCoordinate(ra=ra_center, dec=dec_center, unit="deg", frame='fk5')
self.properties.center = center
# Center position
#self.properties.center = SkyCoordinate(ra=self.info["RA"][0], dec=self.info["DEC"][0], unit="deg") # center position from DustPedia
# Distance
self.properties.distance = table["Dmean"][0] * u("Mpc")
self.properties.distance_error = table["e_Dmean"][0] * u("Mpc")
# Major axis, ellipticity, position angle
self.properties.major_arcsec = table["amaj"][0] * u("arcsec")
self.properties.major = (self.properties.distance * self.properties.major_arcsec).to("pc", equivalencies=dimensionless_angles())
# Ellipticity
self.properties.ellipticity = table["ell"][0]
self.properties.position_angle = Angle(table["PA"][0] + 90.0, u("deg"))
def get_usnob1_cat(ra, dec, blim):
ra_u = ra*u.degree
dec_u = dec*u.degree
coords = SkyCoord(ra_u, dec_u, frame='icrs') #Should this be ICRS or FK5
#Only Class 0 (stars) - unable to implement this at the current time. Need to understand
#USNO-B1 s/g classification
v = Vizier(columns=['USNO-B1.0', '_RAJ2000', '_DEJ2000',
'B1mag', 'R1mag', 'B2mag', 'R2mag',
'pmRA', 'pmDE', 'Imag', 'B1s/g', '_r'],
row_limit=500000,
column_filters={"B2mag":">6", 'B2mag':'<{}'.format(blim)}) #B2mag fainter than 6, brighter than blim
new_table_list = v.query_region(coords,
radius=900*u.arcsecond, #Search 900 arcseconds
catalog = 'I/284')
if len(new_table_list) ==0:
return None
else:
new_table = new_table_list[0]
#Get the 5000 closest
new_table.sort('_r')
if len(new_table) > 5000:
new_table.remove_rows(np.arange(5001, len(new_table)))
#Sort with brightest star first
new_table.sort(['B2mag'])
#Fill in blank values with 99.99
new_table['B1mag'].fill_value = 99.99
new_table['R1mag'].fill_value = 99.99
new_table['B2mag'].fill_value = 99.99
new_table['R2mag'].fill_value = 99.99
new_table['Imag'].fill_value = 99.99
new_table['pmRA'].fill_value = 99.99
new_table['pmDE'].fill_value = 99.99
filled_table = new_table.filled()
filled_table.write('search.ub1', overwrite=True, format='ascii.fixed_width_no_header', delimiter=' ')
searchcenter_ofile = open('searchcenter.ub1', 'w')
searchcenter_ofile.write('{},{}'.format(ra, dec))
searchcenter_ofile.close()
return 'success'
def GAIAplx(ra,de):
v = Vizier(columns=["*", "+_r"], catalog='I/345/gaia2')
pos=coord.SkyCoord(ra=ra, dec=de,unit=(u.hourangle,u.deg),frame='icrs',obstime='J2000')
result=v.query_region(pos, radius="10s", catalog='I/345/gaia2')
# Moving the positions to 2000
try:
nlines=len(result[0]['RA_ICRS'])
deltat=-15.5
sep=[]
for ig,name in enumerate(result[0]['Source']):
raold=result[0]['RA_ICRS'].data[ig]+(result[0]['pmRA'].data[ig] *deltat)/3600000.
deold=result[0]['DE_ICRS'].data[ig]+(result[0]['pmDE'].data[ig] *deltat)/3600000.
posold = coord.ICRS(ra=raold * u.deg, dec=deold * u.deg)
sep.append(pos.separation(posold).arcsecond)
indG=np.argmin(sep)
if sep[indG]<1.5 and result[0]['Plx'].data[indG]>0:
return str(round(result[0]['Plx'].data[indG],2)), str(round(result[0]['e_Plx'].data[indG],2))
except:
return 'NULL','NULL'
return 'NULL','NULL'
def gaia_query(self, ra_deg, dec_deg, rad_deg, max_mag=20,
max_coo_err=1,
max_sources=100):
"""
Query Gaia DR1 @ VizieR using astroquery.vizier
parameters: ra_deg, dec_deg, rad_deg: RA, Dec, field
@param ra_deg: RA in degrees
@type ra_dec: float
@param dec_deg: DEC in degrees
@type dec_deg: float
@param max_mag: Limit G magnitude to be queried object(s)
@type max_mag: float
@max_coo_err: Max error of position
@type max_coo_err: float
@max_sources: Maximum number of sources
@type max_sources: int
@returns: astropy.table object
"""
vquery = Vizier(columns=['Source', 'RA_ICRS',
'DE_ICRS', 'e_RA_ICRS',
'e_DE_ICRS', 'phot_g_mean_mag',
'pmRA', 'pmDE',
'e_pmRA', 'e_pmDE',
'Epoch', 'Plx'],
column_filters={"phot_g_mean_mag":
("<{:f}".format(max_mag)),
"e_RA_ICRS":
("<{:f}".format(max_coo_err)),
"e_DE_ICRS":
("<{:f}".format(max_coo_err))},
row_limit=max_sources)
field = coord.SkyCoord(ra=ra_deg, dec=dec_deg,
unit=(u.deg, u.deg),
frame='icrs')
return(vquery.query_region(field,
width="{:f}d".format(rad_deg),
catalog="I/337/gaia")[0])
def query_box(self, ra, dec, base, height, catalog):
"""Vizier.query_region in a square/rectangular FoV."""
Vizier.ROW_LIMIT = None
base_str, height_str = str(base) + "d", str(height) + "d"
query_result = Vizier.query_region(
SkyCoord(ra=ra, dec=dec, unit=(u.deg, u.deg), frame="icrs"),
width=height_str,
height=base_str,
catalog=[catalog],
)
return query_result
def gaia_query(ra_deg, dec_deg, rad_deg, maxmag=20,
maxsources=10000):
"""
Query Gaia DR1 @ 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=['Source', 'RA_ICRS', 'DE_ICRS',
'phot_g_mean_mag'],
column_filters={"phot_g_mean_mag":
("<%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/337/gaia")[0]
def query_cat(catalog, min_ra, max_ra, min_dec, max_dec, columns=None,
column_filters=None):
"""
Use vizquery to get a reference catalog from vizier
"""
from astroquery.vizier import Vizier
import numpy as np
from astropy.coordinates import SkyCoord
# Build vizquery statement
width = int(np.ceil((max_ra-min_ra)*60))
height = int(np.ceil((max_dec-min_dec)*60))
center = SkyCoord((min_ra+max_ra)/2, (min_dec+max_dec)/2, unit='deg')
# If no column filters are specified, use the defaults
if column_filters is None:
if catalog.startswith('SDSS'):
column_filters = {
'cl': '=6',
'q_mode':'=+'
}
elif catalog.startswith('UKIDSS'):
column_filters = {
'cl': '=-1',
'm': '=1'
}
else:
column_filters = {}
# Query the catalog in Vizier
logger.info('columns:{0}'.format(columns))
v = Vizier(columns=columns, column_filters=column_filters,
catalog=catalog_info[catalog]['info']['vizier_id'])
v.ROW_LIMIT=200000
result = v.query_region(center, width='{0}m'.format(width*1.25),
height='{0}m'.format(height*1.25))
logger.warn(result[0].columns)
refcat = result[0]
return refcat
def get_k2_epic_catalog():
"""
Parameters
----------
Returns
-------
"""
global k2_epic_table
if k2_epic_table is None:
catalogs = Vizier.get_catalogs(huber2016)
k2_epic_table = catalogs[0] # This is the table with the data
k2_epic_table.add_index('EPIC')
return k2_epic_table
def get_duncan_catalog():
"""
Parameters
----------
Returns
-------
"""
global sindex_catalog
if sindex_catalog is None:
catalogs = Vizier.get_catalogs(duncan1991)
sindex_catalog = catalogs[0] # This is the table with the data
return sindex_catalog
def getSDSS(galaxy):
"""
Query SDSS through Vizier, pick out only the stellar sources,
and put the SDSS magnitudes into AB
"""
Vizier.ROW_LIMIT = -1 # Removes row limit on output table
result = Vizier.query_region(galaxy, radius=Angle(0.1, "deg"), catalog='SDSS')
# Only select stellar sources
index = []
for i, entry in enumerate(result[1]):
if entry['cl'] != 6:
index.append(i)
result[1].remove_rows(index)
# SDSS magnitudes are not exactly in AB so need to correct
return result[1]
def getVizierObjects(self, catalogName):
""" Make a request to Vizier to get an Astropy Table of catalog object for this field. """
(ra, dec) = self.centre
availableCatalogs = catalogMetadata.keys()
if catalogName not in availableCatalogs:
print "The definitions for this catalogue are unknown. Available catalogues are:", availableCatalogs
return
# First look for a cached copy of this data
filenameParts = self.filename.split('.')
catalogCache = filenameParts[0] + "_" + catalogName + "_cache.fits"
cached = False
if not self.ignorecache:
print "Looking for a cached copy of the catalogue:", catalogCache,
if os.path.exists(catalogCache):
print "FOUND"
cached = True
else: print "NOT FOUND"
if cached:
newCatalog = Table.read(catalogCache)
else:
print "Going online to fetch %s results from Vizier with mag limit %f."%(catalogName, self.magLimit)
from astroquery.vizier import Vizier
Vizier.ROW_LIMIT = 1E5
Vizier.column_filters={"r":"<%d"%self.magLimit}
from astropy import coordinates
from astropy import units as u
c = coordinates.SkyCoord(ra,dec,unit=('deg','deg'),frame='icrs')
skyRA = coordinates.Angle(self.raRange, unit = u.deg)
skyDEC = coordinates.Angle(self.decRange, unit = u.deg)
print "Sky RA, DEC range:", skyRA, skyDEC
print "going to Astroquery for:", catalogMetadata[catalogName]['VizierLookup']
result = Vizier.query_region(coordinates = c, width = skyRA, height = skyDEC, catalog = catalogMetadata[catalogName]['VizierName'], verbose=True)
print result
newCatalog = result[catalogMetadata[catalogName]['VizierName']]
newCatalog.pprint()
# Write the new catalog to the cache file
newCatalog.write(catalogCache, format='fits', overwrite=True)
self.addCatalog(newCatalog, catalogName)
return
def __init__(self, config=None):
"""
The constructor ...
:param config:
:return:
"""
# Call the constructor of the base class
super(GalaxyDecomposer, self).__init__(config)
# The NGC name of the galaxy
self.ngc_id = None
self.ngc_id_nospaces = None
# The Vizier querying object
self.vizier = Vizier()
self.vizier.ROW_LIMIT = -1
# The bulge and disk parameters
self.parameters = Map()
# The SKIRT execution context
self.skirt = SkirtExec()
# The bulge and disk model
self.bulge = None
self.disk = None
# The bulge and disk image
self.bulge_image = None
self.disk_image = None
self.model_image = None
# The projection systems
self.projections = dict()
# The instruments
self.instruments = dict()
# The reference coordinate system
self.reference_wcs = None
# The PSF (of the reference image) for convolution with the simulated images
self.psf = None
from astroquery.vizier import Vizier
v = Vizier(columns=['Vmag', 'b-y','m1','c1','Beta'], catalog="II/215/catalog")
result = v.query_object('HD 48915')[0][0]
print (result)
unit=u.arcsec), index=3)
# remove error ellipse columns
data.remove_column('errMaj')
data.remove_column('errMin')
data.remove_column('errPA')
return data
max_mag = 21
max_sources = 1e5
vquery = Vizier(columns=['2MASS', 'RAJ2000', 'DEJ2000', 'errMaj', 'errMin',
'errPA', 'Jmag', 'e_Jmag', 'Hmag', 'e_Hmag', 'Kmag',
'e_Kmag', 'Qflg'],
column_filters={"Jmag": ("<%f" % max_mag)},
row_limit=max_sources)
data = numpy.genfromtxt('../catalogs/PSZ2_unconfirmed_catalog - Master.csv',
delimiter=',', names=True, dtype=None)
for i, (ra, dec, name) in enumerate(zip(data['RA'], data['DEC'],
data['Name'])):
print(data['Name'][i])
result = work(vquery, ra, dec, '{}'.format(name))
ascii.write(result, format='csv', output='./2MASS/%s_2MASS_catalog.csv' %
(name.decode()))
sleep(1)
def get_catalog(params, map_struct):
if not os.path.isdir(params["catalogDir"]):
os.makedirs(params["catalogDir"])
catalogFile = os.path.join(params["catalogDir"],
"%s.hdf5" % params["galaxy_catalog"])
"""AB Magnitude zero point."""
MAB0 = -2.5 * np.log10(3631.e-23)
pc_cm = 3.08568025e18
const = 4. * np.pi * (10. * pc_cm)**2.
if params["galaxy_catalog"] == "2MRS":
if not os.path.isfile(catalogFile):
import astropy.constants as c
cat, = Vizier.get_catalogs('J/ApJS/199/26/table3')
ra, dec = cat["RAJ2000"], cat["DEJ2000"]
cz = cat["cz"]
magk = cat["Ktmag"]
z = (u.Quantity(cat['cz']) / c.c).to(u.dimensionless_unscaled)
completeness = 0.5
alpha = -1.0
MK_star = -23.55
MK_max = MK_star + 2.5 * np.log10(
gammaincinv(alpha + 2, completeness))
MK = magk - cosmo.distmod(z)
idx = (z > 0) & (MK < MK_max)
ra, dec = ra[idx], dec[idx]
z = z[idx]
magk = magk[idx]
distmpc = cosmo.luminosity_distance(z).to('Mpc').value
with h5py.File(catalogFile, 'w') as f:
f.create_dataset('ra', data=ra)
f.create_dataset('dec', data=dec)
f.create_dataset('z', data=z)
f.create_dataset('magk', data=magk)
f.create_dataset('distmpc', data=distmpc)
else:
with h5py.File(catalogFile, 'r') as f:
ra, dec = f['ra'][:], f['dec'][:]
z = f['z'][:]
magk = f['magk'][:]
distmpc = f['distmpc'][:]
r = distmpc * 1.0
mag = magk * 1.0
elif params["galaxy_catalog"] == "GLADE":
if not os.path.isfile(catalogFile):
cat, = Vizier.get_catalogs('VII/281/glade2')
ra, dec = cat["RAJ2000"], cat["DEJ2000"]
distmpc, z = cat["Dist"], cat["z"]
magb, magk = cat["Bmag"], cat["Kmag"]
# Keep track of galaxy identifier
GWGC, PGC, HyperLEDA = cat["GWGC"], cat["PGC"], cat["HyperLEDA"]
_2MASS, SDSS = cat["_2MASS"], cat["SDSS-DR12"]
idx = np.where(distmpc >= 0)[0]
ra, dec = ra[idx], dec[idx]
distmpc, z = distmpc[idx], z[idx]
magb, magk = magb[idx], magk[idx]
GWGC, PGC, HyperLEDA = GWGC[idx], PGC[idx], HyperLEDA[idx]
_2MASS, SDSS = _2MASS[idx], SDSS[idx]
with h5py.File(catalogFile, 'w') as f:
f.create_dataset('ra', data=ra)
f.create_dataset('dec', data=dec)
f.create_dataset('distmpc', data=distmpc)
f.create_dataset('magb', data=magb)
f.create_dataset('magk', data=magk)
f.create_dataset('z', data=z)
# Add galaxy identifier
f.create_dataset('GWGC', data=GWGC)
f.create_dataset('PGC', data=PGC)
f.create_dataset('HyperLEDA', data=HyperLEDA)
f.create_dataset('2MASS', data=_2MASS)
f.create_dataset('SDSS', data=SDSS)
else:
with h5py.File(catalogFile, 'r') as f:
ra, dec = f['ra'][:], f['dec'][:]
distmpc, z = f['distmpc'][:], f['z'][:]
magb, magk = f['magb'][:], f['magk'][:]
GWGC, PGC, _2MASS = f['GWGC'][:], f['PGC'][:], f['2MASS'][:]
HyperLEDA, SDSS = f['HyperLEDA'][:], f['SDSS'][:]
# Convert bytestring to unicode
GWGC = GWGC.astype('U')
PGC = PGC.astype('U')
HyperLEDA = HyperLEDA.astype('U')
_2MASS = _2MASS.astype('U')
SDSS = SDSS.astype('U')
# Keep only galaxies with finite B mag when using it in the grade
if params["galaxy_grade"] == "S":
idx = np.where(~np.isnan(magb))[0]
ra, dec, distmpc = ra[idx], dec[idx], distmpc[idx]
magb, magk = magb[idx], magk[idx]
GWGC, PGC, HyperLEDA = GWGC[idx], PGC[idx], HyperLEDA[idx]
_2MASS, SDSS = _2MASS[idx], SDSS[idx]
r = distmpc * 1.0
mag = magb * 1.0
elif params["galaxy_catalog"] == "CLU":
if not os.path.isfile(catalogFile):
raise ValueError("Please add %s." % catalogFile)
t = Table.read(catalogFile)
name = t["name"]
ra, dec = t["ra"], t["dec"]
sfr_fuv, mstar = t["sfr_fuv"], t["mstar"]
distmpc, magb = t["distmpc"], t["magb"]
a, b2a, pa = t["a"], t["b2a"], t["pa"]
btc = t["btc"]
idx = np.where(distmpc >= 0)[0]
ra, dec = ra[idx], dec[idx]
sfr_fuv, mstar = sfr_fuv[idx], mstar[idx]
distmpc, magb = distmpc[idx], magb[idx]
a, b2a, pa = a[idx], b2a[idx], pa[idx]
btc = btc[idx]
idx = np.where(~np.isnan(magb))[0]
ra, dec = ra[idx], dec[idx]
sfr_fuv, mstar = sfr_fuv[idx], mstar[idx]
distmpc, magb = distmpc[idx], magb[idx]
a, b2a, pa = a[idx], b2a[idx], pa[idx]
btc = btc[idx]
z = -1 * np.ones(distmpc.shape)
r = distmpc * 1.0
mag = magb * 1.0
n, cl = params["powerlaw_n"], params["powerlaw_cl"]
dist_exp = params["powerlaw_dist_exp"]
prob_scaled = copy.deepcopy(map_struct["prob"])
prob_sorted = np.sort(prob_scaled)[::-1]
prob_indexes = np.argsort(prob_scaled)[::-1]
prob_cumsum = np.cumsum(prob_sorted)
index = np.argmin(np.abs(prob_cumsum - cl)) + 1
prob_scaled[prob_indexes[index:]] = 0.0
prob_scaled = prob_scaled**n
theta = 0.5 * np.pi - dec * 2 * np.pi / 360.0
phi = ra * 2 * np.pi / 360.0
ipix = hp.ang2pix(map_struct["nside"], ra, dec, lonlat=True)
if "distnorm" in map_struct:
if map_struct["distnorm"] is not None:
#creat an mask to cut at 3 sigma in distance
mask = np.zeros(len(r))
condition_indexer = np.where(
(r < (map_struct["distmu"][ipix] +
(3 * map_struct["distsigma"][ipix])))
& (r > (map_struct["distmu"][ipix] -
(3 * map_struct["distsigma"][ipix]))))
mask[condition_indexer] = 1
Sloc = prob_scaled[ipix] * (map_struct["distnorm"][ipix] * norm(
map_struct["distmu"][ipix], map_struct["distsigma"][ipix]).pdf(
r))**params["powerlaw_dist_exp"] / map_struct["pixarea"]
#multiplie the Sloc by 1 or 0 according to the 3 sigma condistion
Sloc = Sloc * mask
idx = np.where(condition_indexer)[0]
else:
Sloc = copy.copy(prob_scaled[ipix])
idx = np.arange(len(r)).astype(int)
else:
Sloc = copy.copy(prob_scaled[ipix])
idx = np.arange(len(r)).astype(int)
# this happens when we are using a tiny catalog...
if len(idx) == 0:
idx = np.arange(len(r)).astype(int)
if np.all(Sloc == 0.0):
Sloc[:] = 1.0
L_nu = const * 10.**((mag + MAB0) / (-2.5))
idx2 = np.where(~np.isfinite(L_nu))[0]
L_nu[idx2] = 0.0
L_nu = L_nu / np.nanmax(L_nu[idx])
L_nu = L_nu**params["catalog_n"]
L_nu[L_nu < 0.001] = 0.001
L_nu[L_nu > 1.0] = 1.0
Slum = L_nu / np.sum(L_nu)
mlim, M_KNmin, M_KNmax = 22, -17, -12
L_KNmin = const * 10.**((M_KNmin + MAB0) / (-2.5))
L_KNmax = const * 10.**((M_KNmax + MAB0) / (-2.5))
Llim = 4. * np.pi * (r * 1e6 * pc_cm)**2. * 10.**((mlim + MAB0) / (-2.5))
Sdet = (L_KNmax - Llim) / (L_KNmax - L_KNmin)
Sdet[Sdet < 0.01] = 0.01
Sdet[Sdet > 1.0] = 1.0
# Set nan values to zero
Sloc[np.isnan(Sloc)] = 0
Slum[np.isnan(Slum)] = 0
S = Sloc * Slum * Sdet
prob = np.zeros(map_struct["prob"].shape)
if params["galaxy_grade"] == "Sloc":
for j in range(len(ipix)):
prob[ipix[j]] += Sloc[j]
grade = Sloc
elif params["galaxy_grade"] == "S":
for j in range(len(ipix)):
prob[ipix[j]] += S[j]
grade = S
#prob[prob==0] = 1e-10
prob = prob / np.sum(prob)
map_struct['prob_catalog'] = prob
if params["doUseCatalog"]:
map_struct['prob'] = prob
idx = np.where(~np.isnan(grade))[0]
grade = grade[idx]
ra, dec, Sloc, S = ra[idx], dec[idx], Sloc[idx], S[idx]
distmpc, z = distmpc[idx], z[idx]
if params["galaxy_catalog"] == "GLADE":
GWGC, PGC, HyperLEDA = GWGC[idx], PGC[idx], HyperLEDA[idx]
_2MASS, SDSS = _2MASS[idx], SDSS[idx]
"""
Sthresh = np.max(grade)*0.01
idx = np.where(grade >= Sthresh)[0]
grade = grade[idx]
ra, dec, Sloc, S = ra[idx], dec[idx], Sloc[idx], S[idx]
distmpc, z = distmpc[idx], z[idx]
if params["galaxy_catalog"] == "GLADE":
GWGC, PGC, HyperLEDA = GWGC[idx], PGC[idx], HyperLEDA[idx]
_2MASS, SDSS = _2MASS[idx], SDSS[idx]
"""
idx = np.argsort(grade)[::-1]
grade = grade[idx]
ra, dec, Sloc, S = ra[idx], dec[idx], Sloc[idx], S[idx]
distmpc, z = distmpc[idx], z[idx]
if params["galaxy_catalog"] == "GLADE":
GWGC, PGC, HyperLEDA = GWGC[idx], PGC[idx], HyperLEDA[idx]
_2MASS, SDSS = _2MASS[idx], SDSS[idx]
# Keep only galaxies within 3sigma in distance
mask = Sloc > 0
ra, dec, Sloc, S = ra[mask], dec[mask], Sloc[mask], S[mask]
distmpc, z = distmpc[mask], z[mask]
if params["galaxy_catalog"] == "GLADE":
GWGC, PGC, HyperLEDA = GWGC[mask], PGC[mask], HyperLEDA[mask]
_2MASS, SDSS = _2MASS[mask], SDSS[mask]
if len(ra) > 2000:
print('Cutting catalog to top 2000 galaxies...')
idx = np.arange(2000).astype(int)
ra, dec, Sloc, S = ra[idx], dec[idx], Sloc[idx], S[idx]
distmpc, z = distmpc[idx], z[idx]
if params["galaxy_catalog"] == "GLADE":
GWGC, PGC, HyperLEDA = GWGC[idx], PGC[idx], HyperLEDA[idx]
_2MASS, SDSS = _2MASS[idx], SDSS[idx]
# now normalize the distributions
S = S / np.sum(S)
Sloc = Sloc / np.sum(Sloc)
catalog_struct = {}
catalog_struct["ra"] = ra
catalog_struct["dec"] = dec
catalog_struct["Sloc"] = Sloc
catalog_struct["S"] = S
if params["writeCatalog"]:
catalogfile = os.path.join(params["outputDir"], 'catalog.csv')
fid = open(catalogfile, 'w')
cnt = 1
if params["galaxy_catalog"] == "GLADE":
fid.write(
"id, RAJ2000, DEJ2000, Sloc, S, Dist, z, GWGC, PGC, HyperLEDA, 2MASS, SDSS\n"
)
for a, b, c, d, e, f, g, h, i, j, k in zip(ra, dec, Sloc, S,
distmpc, z, GWGC, PGC,
HyperLEDA, _2MASS,
SDSS):
fid.write(
"%d, %.5f, %.5f, %.5e, %.5e, %.4f, %.4f, %s, %s, %s, %s, %s\n"
% (cnt, a, b, c, d, e, f, g, h, i, j, k))
cnt = cnt + 1
else:
fid.write("id, RAJ2000, DEJ2000, Sloc, S, Dist, z\n")
for a, b, c, d, e, f in zip(ra, dec, Sloc, S, distmpc, z):
fid.write("%d, %.5f, %.5f, %.5e, %.5e, %.4f, %.4f\n" %
(cnt, a, b, c, d, e, f))
cnt = cnt + 1
fid.close()
return map_struct, catalog_struct
def __init__(
self, path_to_iad_file, hip_num, num_secondary_bodies,
alphadec0_epoch=1991.25, renormalize_errors=False
):
self.path_to_iad_file = path_to_iad_file
self.renormalize_errors = renormalize_errors
# infer if the IAD file is an older DVD file or a new file
with open(path_to_iad_file, 'r') as f:
first_char = f.readline()[0]
# newer format files don't start with comments
if first_char == '#':
dvd_file = False
else:
dvd_file = True
self.hip_num = hip_num
self.num_secondary_bodies = num_secondary_bodies
self.alphadec0_epoch = alphadec0_epoch
# dvd files don't contain the Hipparcos astrometric solution, so
# we need to look it up
if dvd_file:
# load best-fit astrometric solution from Sep 08 van Leeuwen catalog
# (https://cdsarc.unistra.fr/ftp/I/311/ReadMe)
Vizier.ROW_LIMIT = -1
hip_cat = Vizier(
catalog='I/311/hip2',
columns=[
'RArad', 'e_RArad', 'DErad', 'e_DErad', 'Plx', 'e_Plx', 'pmRA',
'e_pmRA', 'pmDE', 'e_pmDE', 'F2', 'Sn'
]
).query_constraints(HIP=self.hip_num)[0]
self.plx0 = hip_cat['Plx'][0] # [mas]
self.pm_ra0 = hip_cat['pmRA'][0] # [mas/yr]
self.pm_dec0 = hip_cat['pmDE'][0] # [mas/yr]
self.alpha0 = hip_cat['RArad'][0] # [deg]
self.delta0 = hip_cat['DErad'][0] # [deg]
self.plx0_err = hip_cat['e_Plx'][0] # [mas]
self.pm_ra0_err = hip_cat['e_pmRA'][0] # [mas/yr]
self.pm_dec0_err = hip_cat['e_pmDE'][0] # [mas/yr]
self.alpha0_err = hip_cat['e_RArad'][0] # [mas]
self.delta0_err = hip_cat['e_DErad'][0] # [mas]
solution_type = hip_cat['Sn'][0]
f2 = hip_cat['F2'][0]
else:
# read the Hipparcos best-fit solution from the IAD file
astrometric_solution = pd.read_csv(path_to_iad_file, skiprows=9, sep='\s+', nrows=1)
self.plx0 = astrometric_solution['Plx'].values[0] # [mas]
self.pm_ra0 = astrometric_solution['pm_RA'].values[0] # [mas/yr]
self.pm_dec0 = astrometric_solution['pm_DE'].values[0] # [mas/yr]
self.alpha0 = astrometric_solution['RAdeg'].values[0] # [deg]
self.delta0 = astrometric_solution['DEdeg'].values[0] # [deg]
self.plx0_err = astrometric_solution['e_Plx'].values[0] # [mas]
self.pm_ra0_err = astrometric_solution['e_pmRA'].values[0] # [mas/yr]
self.pm_dec0_err = astrometric_solution['e_pmDE'].values[0] # [mas/yr]
self.alpha0_err = astrometric_solution['e_RA'].values[0] # [mas]
self.delta0_err = astrometric_solution['e_DE'].values[0] # [mas]
solution_details = pd.read_csv(path_to_iad_file, skiprows=5, sep='\s+', nrows=1)
solution_type = solution_details['isol_n'].values[0]
f2 = solution_details['F2'].values[0]
if solution_type != 5:
raise ValueError(
"""
Currently, we only handle stars with 5-parameter astrometric
solutions from Hipparcos. Let us know if you'd like us to add
functionality for stars with >5 parameter solutions.
"""
)
# read in IAD
if dvd_file:
iad = np.transpose(np.loadtxt(path_to_iad_file, skiprows=1))
else:
iad = np.transpose(np.loadtxt(path_to_iad_file))
n_lines = len(iad)
times = iad[1] + 1991.25
self.cos_phi = iad[3] # scan direction
self.sin_phi = iad[4]
self.R = iad[5] # abscissa residual [mas]
self.eps = iad[6] # error on abscissa residual [mas]
# reject negative errors (scans that were rejected by Hipparcos team)
good_scans = np.where(self.eps > 0)[0]
if n_lines - len(good_scans) > 0:
print('{} Hipparcos scans rejected.'.format(n_lines - len(good_scans)))
times = times[good_scans]
self.cos_phi = self.cos_phi[good_scans]
self.sin_phi = self.sin_phi[good_scans]
self.R = self.R[good_scans]
self.eps = self.eps[good_scans]
epochs = Time(times, format='decimalyear')
self.epochs = epochs.decimalyear
self.epochs_mjd = epochs.mjd
if self.renormalize_errors:
D = len(epochs) - 6
G = f2
f = (
G * np.sqrt(2 / (9 * D)) +
1 -
(2 / (9 * D))
)**(3/2)
self.eps *= f
# compute Earth XYZ position in barycentric coordinates
bary_pos, _ = get_body_barycentric_posvel('earth', epochs)
self.X = bary_pos.x.value # [au]
self.Y = bary_pos.y.value # [au]
self.Z = bary_pos.z.value # [au]
# reconstruct ephemeris of star given van Leeuwen best-fit (Nielsen+ 2020 Eqs 1-2) [mas]
changein_alpha_st = (
self.plx0 * (
self.X * np.sin(np.radians(self.alpha0)) -
self.Y * np.cos(np.radians(self.alpha0))
) + (self.epochs - 1991.25) * self.pm_ra0
)
changein_delta = (
self.plx0 * (
self.X * np.cos(np.radians(self.alpha0)) * np.sin(np.radians(self.delta0)) +
self.Y * np.sin(np.radians(self.alpha0)) * np.sin(np.radians(self.delta0)) -
self.Z * np.cos(np.radians(self.delta0))
) + (self.epochs - 1991.25) * self.pm_dec0
)
# compute abcissa point (Nielsen+ Eq 3)
self.alpha_abs_st = self.R * self.cos_phi + changein_alpha_st
self.delta_abs = self.R * self.sin_phi + changein_delta
error_tot = np.sqrt(error.dot(error.T)) * 1e3
if error_tot > 100:
warnings.warn("Satellite position off by more than 100 m")
velocity_stk_eci = np.array([1.031261, 0.146421, 7.510402])
error = np.array([position_ecef.velocity.d_x.value,position_ecef.velocity.d_y.value,position_ecef.velocity.d_z.value]) - \
velocity_stk_eci
error_tot = np.sqrt(error.dot(error.T)) * 1e3
if error_tot > 500:
warnings.warn("Satellite velocity off by more than 500 m/s")
#Find look vector for tangent point of MATS (92 km in orbit plane)
#Find orbit plane for two positions
#test star gazing
Vizier.ROW_LIMIT = 50
catalog_list = Vizier.find_catalogs('UCAC4')
catalogs = Vizier.get_catalogs(catalog_list.keys())
v = Vizier(columns=['_RAJ2000', '_DEJ2000', 'Vmag'],
column_filters={"Vmag": "<10"})
result = v.query_region(coord.SkyCoord(ra=299.590,
dec=35.201,
unit=(u.deg, u.deg),
frame='icrs'),
width="60m",
height="60m",
catalog=["I/322A"])
def WDGaiaRadius(ra,dec,teff,teff_err=None,searchradius=5.0,modelmass=0.6,
modelpath='AllModels/',A_G=0):
"""Estimate WD Radius from Gaia astrometry.
Queries for Gaia data and distances from Bailer-Jones et al. (2018, ApJ, 156, 2).
Scales Bergeron et al. DA (no DBs currently) cooling models
(http://www.astro.umontreal.ca/~bergeron/CoolingModels/)
until the radius reproduces the Gaia magnitude at the parallactic distance.
Corrects for extinction if coefficient A_G is provided in magnitudes,
following the prescription of Gentile-Fusillo et al. (2019, MNRAS, 482, 4570).
Uses https://github.com/keatonb/BergeronToPandas to read in Bergeron models.
If error on Teff given, includes contribution roughly in quadrature.
Returns measurement and lower, upper bounds defined by Bailer-Jones et al.
confidence interval.
ra, dec should be in decimal degrees
teff,teff_err in Kelvin from spectroscopy
searchradius is in arcseconds
modelmass in solar units must match a file from the Bergeron models
that is new enough to include synthetic Gaia magnitudes.
"""
#First query Gaia sources
coord = SkyCoord(ra=ra, dec=dec, unit=(u.degree, u.degree), frame='icrs')
searchradius = u.Quantity(searchradius, u.arcsec)
j = Gaia.cone_search_async(coord, searchradius)
r = j.get_results()
print("Gaia sources within {}: {}".format(searchradius,len(r)))
if len(r) > 0:
r.sort("dist")
#Accept nearest
sourceid = r["source_id"][0]
Gmag = r["phot_g_mean_mag"][0]
print("Nearest has Gaia G mag of {}.".format(Gmag))
b = r["b"][0] #Galactic latitude in degrees
#Extinction correction following Gentile-Fusillo et al. 2019
parallax = r["parallax"][0]*1e-3 #arcsec
extcorr = -A_G*(1. - np.exp(-np.sin(np.abs(b*np.pi/180)) / (200*parallax)))
Gmag += extcorr
print("Extinction correction of {} then applied to get G = {} mag.".format(extcorr,Gmag))
#Then get Bailer-Jones distance
v = Vizier(columns=['*'],
column_filters={"Source":str(sourceid)}).get_catalogs('I/347')
dist = np.array([v[0]["rest"][0],v[0]["b_rest"][0],v[0]["B_rest"][0]])
print("Distance constraints from Bailer-Jones et al: {}".format(dist))
#Referencing Bergeron cooling models
modelfile = os.path.join(modelpath, "Table_Mass_{:.1f}".format(modelmass))
print("Referencing Bergeron model file at "+modelfile)
models = list(BergeronToPandas(modelfile).values())[0]
#Constants
G = 6.67259e-8 #cm3 g-1 s-2
Msun = 1.99e33 #g
Rsun = 6.96e10 #cm
modelteff = models['Teff'].values
modellogg = models['logg'].values
modelradius = np.sqrt(G*modelmass*Msun/(10.**modellogg))/Rsun #solar radii
modelGmag = models['G'].values
#Define interpolation functions
teff2radius = interp1d(modelteff,modelradius)
teff2Gmag = interp1d(modelteff,modelGmag)
distancemodulus = 5.*np.log10(dist)-5.
#Start with values assuming along loaded model track
trackradius = teff2radius(teff)
trackGmag = teff2Gmag(teff)
estGmag = trackGmag + distancemodulus
#Scale to measured magnitude
remaining = estGmag - Gmag
fluxratio = 2.512**remaining
radiusratio = np.sqrt(fluxratio)
gaiaradius = trackradius * radiusratio
#Include effect of Teff_err if given
if teff_err is not None:
testteff = np.array([teff,teff+teff_err,teff-teff_err])
trackradius = teff2radius(testteff)
trackGmag = teff2Gmag(testteff)
estGmag = trackGmag + distancemodulus[0]
remaining = estGmag - Gmag
fluxratio = 2.512**remaining
radiusratio = np.sqrt(fluxratio)
gr2 = trackradius * radiusratio
#combine roughly in quadrature
gaiaradius = gaiaradius[0] + np.sqrt((gaiaradius - gaiaradius[0])**2. +
(gr2 - gr2[0])**2.)*np.array([1,-1,1])
return gaiaradius
else: #No Gaia results?
print("Returning 'None's")
return None,None,None
import astropy.units as u
from astropy.coordinates import SkyCoord
from astroquery.vizier import Vizier
import numpy as np
import mixfit
import matplotlib.pyplot as plt
import json
from scipy.stats import norm
from mpl_toolkits.mplot3d import Axes3D
center_coord = SkyCoord('02h21m00s +57d07m42s')
vizier = Vizier(
column_filters={'Bmag': '<13'}, # число больше — звёзд больше
row_limit=10000)
stars = vizier.query_region(center_coord,
width=1.5 * u.deg,
height=1.5 * u.deg,
catalog='USNO-A2.0')[0]
# print(stars)
ra = stars['RAJ2000'].data # прямое восхождение, аналог долготы
dec = stars['DEJ2000'].data # склонение, аналог широты
x1 = (ra - ra.mean()) * np.cos(dec / 180 * np.pi)
x2 = dec
def data(tmp):
for i in range(len(x1)):
tmp.append([x1[i], x2[i]])
tmp = np.asarray(tmp)
return tmp
if args.individual == 'True' or args.individual == 'yes':
for sci in sci_list:
with fits.open(red_path + os.path.basename(sci),
mode='update') as hdr_ind:
header = hdr_ind[0].header
header['CRVAL1'] = gaia_star[0][0]
header['CRVAL2'] = gaia_star[0][1]
header['CRPIX1'] = source_star[0][0]
header['CRPIX2'] = source_star[0][1]
if args.phot == 'True' or args.phot == 'yes':
zp_cal = True
if fil == 'Y':
twomass_filter = 'Ymag'
twomass = Vizier.query_region(SkyCoord(
hdr[0].header['CRVAL1'] * u.deg,
hdr[0].header['CRVAL2'] * u.deg,
frame='fk5'),
catalog="II/319",
radius=4 * u.arcmin)[0]
else:
twomass_filter = fil.lower() + '_m'
twomass = Irsa.query_region(SkyCoord(
hdr[0].header['CRVAL1'] * u.deg,
hdr[0].header['CRVAL2'] * u.deg,
frame='fk5'),
catalog="fp_psc",
spatial="Cone",
radius=4 * u.arcmin)
if len(twomass) != 0:
pass
else:
log.info('No 2MASS stars available in this field.')
Ng = 0 #we put the object to the beggining, so its index = 0 now
with open(outfile, 'a') as f:
f.write('Gaia index of the object: ' + str(Ng) + '\n')
f.write('-----------------------------------------------------------------------------------------------' + '\n')
#all the cats without ucac4 (it will be after all ##############################################################
# --------------------------------------------------------------------------------------------------------------
for icat in range(len(names)):
object = True
Ncatname = Nnames[icat]
catname = names[icat]
link = links[icat]
#print(catname)
test = True
try:
table = Vizier(columns=['all']).query_region(
coord.SkyCoord(ra=str(ra0), dec=str(dec0), unit=(u.deg, u.deg), frame='icrs'), Angle(fov, "deg"),
catalog=[link])[0]
except IndexError:
test = False
print(Ncatname + ': connection attempt FAILED')
logstring = logstring + '\t' + '|' + 'nan' + '\t' + 'nan' + '\t' + 'nan' + '\t' + 'nan' + '\t' + 'nan' + '\t' + 'nan'
with open(outfile, 'a') as f:
f.write(catname + ': connection attempt FAILED' + '\n')
#break
if test:
print(Ncatname + ': SUCCESS! PREVIOUS NUMBER OF STARS IN FOV = ' + str(fov*3600) + ' arcsec: ', len(table))
# break
#if (catname == '2MASS All-Sky'):
# print(table.columns)
# print(table.columns)
# for column in table.columns:
bj = np.zeros(len(data), dtype=str)
bh = np.zeros(len(data), dtype=str)
bk = np.zeros(len(data), dtype=str)
flag = np.zeros(len(data), dtype=int)
start, J, H, K, sig_J, sig_H, sig_K, qj, qh, qk, bj, bh, bk, flag = pickle.load(
open(datafile.split('.')[0] + '_X2MASS_progress.pkl', 'rb'))
pdb.set_trace()
for i in range(start, len(data)):
queryname = 'Gaia DR2 ' + str(
data.source_id.values[i]) ##The official object name out of Gaia
try:
#stuff0 = Vizier.query_region(queryname,radius="0d0m5s",catalog='I/345/gaia2')
stuff1 = Vizier.query_region(queryname,
radius="0d0m3s",
catalog='II/246/out')
except: ##try at least twice before quitting
print('Excepted on first query??!!??')
#stuff0 = Vizier.query_region(queryname,radius="0d0m5s",catalog='I/345/gaia2')
stuff1 = Vizier.query_region(queryname,
radius="0d0m3s",
catalog='II/246/out')
#if len(stuff0) == 0:
# print('Cant find Gaia DR2 entry, thats bad...')
# pdb.set_trace()
if (len(stuff1) > 1): pdb.set_trace()
if (len(stuff1) == 1
): ##if something in 2mass and assuming Gaia source is found
cl = np.argmin(stuff1[0]['_r'])
class SEDFetcher(OldConfigurable):
"""
This class ...
"""
def __init__(self, config=None):
"""
The constructor ...
"""
# Call the constructor of the base class
super(SEDFetcher, self).__init__(config, "modeling")
# -- Attributes --
# The name of the galaxy
self.galaxy_name = None
# The NGC ID of the galaxy
self.ngc_id = None
# The Vizier querying object
self.vizier = Vizier(keywords=["galaxies"])
self.vizier.ROW_LIMIT = -1
# The observed SED
self.seds = dict()
# The filters
self.filters = dict()
# -----------------------------------------------------------------
@classmethod
def from_arguments(cls, arguments):
"""
This function ...
:param arguments:
:return:
"""
# Create a new SEDFetcher instance
if arguments.config is not None: fetcher = cls(arguments.config)
elif arguments.settings is not None: fetcher = cls(arguments.settings)
else: fetcher = cls()
# Set the output path
if arguments.output_path is not None:
fetcher.config.output_path = arguments.output_path
# Run from the command line, so always write out the SEDs
fetcher.config.write_seds = True
fetcher.config.writing.seds_path = "SEDs"
# Return the new instance
return fetcher
# -----------------------------------------------------------------
def run(self, galaxy_name):
"""
This function ...
:param galaxy_name
"""
# 1. Call the setup function
self.setup(galaxy_name)
# 2. If requested, query the GALEX ultraviolet atlas of nearby galaxies catalog (Gil de Paz+, 2007)
if "GALEX" in self.config.catalogs: self.get_galex()
# 3. If requested, query the 2MASS Extended sources catalog (IPAC/UMass, 2003-2006)
if "2MASS" in self.config.catalogs: self.get_2mass()
# SDSS ?
# Ilse "Voor de galaxieen in de noordelijke hemisfeer heb je SDSS data beschikbaar, en die kan je dan
# beter gebruiken (ipv. SINGS) om je fit te constrainen in het optische gebied. Er zal binnenkort een nieuwe
# paper van Daniel Dale uitkomen met gehercalibreerde fluxen in de optische banden, die je dan kan gebruiken.
# 5. If requested, query the Radial distribution in SINGS galaxies (I.) catalogs (Munoz-Mateos+, 2009)
# Opm. Ilse: "voor vele SINGS galaxieen is de calibratie van de optische data heel slecht, dus krijg je een
# offset en datapunten die een beetje random blijken te zijn."
if "SINGS" in self.config.catalogs: self.get_sings()
# If requested, query the LVL global optical photometry (Cook+, 2014) catalog
if "LVL" in self.config.catalogs: self.get_lvl()
# If requested, query the Spitzer Local Volume Legacy: IR photometry (Dale+, 2009)
if "Spitzer" in self.config.catalogs: self.get_spitzer()
# If requested, query the Spitzer/IRS ATLAS project source (Hernan-Caballero+, 2011)
if "Spitzer/IRS" in self.config.catalogs: self.get_spitzer_irs()
# If requested, query the Compendium of ISO far-IR extragalactic data (Brauher+, 2008)
if "IRAS" in self.config.catalogs: self.get_iras()
# If requested, query the Imperial IRAS-FSC redshift catalogue (IIFSCz) (Wang+, 2009)
if "IRAS-FSC" in self.config.catalogs: self.get_iras_fsc()
# If requested, query the S4G catalog for IRAC fluxes
if "S4G" in self.config.catalogs: self.get_s4g()
# If requested, query the Spectroscopy and abundances of SINGS galaxies (Moustakas+, 2010) catalog
if "Emission lines" in self.config.catalogs: self.get_emission_lines()
# If requested, query the Atlas of UV-to-MIR galaxy SEDs (Brown+, 2014)
if "Brown" in self.config.catalogs: self.get_brown()
# If requested, query the Planck Catalog of Compact Sources Release 1 (Planck, 2013)
if "Planck" in self.config.catalogs: self.get_planck()
# SPECIFIC for M81: not enabled, no time to figure out the unit conversion now
#if self.ngc_id == "NGC 3031": self.get_m81()
# Other interesting catalogs:
# http://vizier.cfa.harvard.edu/viz-bin/VizieR-3?-source=J/ApJS/199/22
# http://vizier.cfa.harvard.edu/viz-bin/VizieR-3?-source=J/ApJS/212/18/sample&-c=NGC%203031&-c.u=arcmin&-c.r=2&-c.eq=J2000&-c.geom=r&-out.max=50&-out.form=HTML%20Table&-oc.form=sexa
# http://vizier.cfa.harvard.edu/viz-bin/VizieR-3?-source=J/ApJS/220/6
# Writing
self.write()
# -----------------------------------------------------------------
def setup(self, galaxy_name):
"""
This function ...
:param galaxy_name:
:return:
"""
# Call the setup function of the base class
super(SEDFetcher, self).setup()
# Set the galaxy name
self.galaxy_name = galaxy_name
# Get the NGC ID of the galaxy
self.ngc_id = catalogs.get_ngc_name(self.galaxy_name)
# Create a dictionary of filters
keys = [
"Ha", "FUV", "NUV", "U", "B", "V", "R", "J", "H", "K", "IRAS 12",
"IRAS 25", "IRAS 60", "IRAS 100", "I1", "I2", "I3", "I4",
"MIPS 24", "MIPS 70", "MIPS 160", "SDSS u", "SDSS g", "SDSS r",
"SDSS i", "SDSS z"
]
for key in keys:
self.filters[key] = Filter.from_string(key)
# -----------------------------------------------------------------
def get_galex(self):
"""
This function ...
:return:
"""
# Inform the user
log.info(
"Getting fluxes from the GALEX ultraviolet atlas of nearby galaxies ..."
)
# GALEX: "J/ApJS/173/185" of "J/ApJS/173/185/galex": B and V (2007ApJS..173..185G)
# Interesting columns:
#
# - "MajAxis": Major-axis diameter of the D25 ellipse [arcmin]
# - "MinAxis": Minor-axis diameter of the D25 ellipse [arcmin]
# - "PA": Position angle of the D25 ellipse [deg]
# - "Dist": Distance to the galaxy [Mpc]
# - "Morph": Morphological type
# - "T": Morphological type T
# - "FUV": FUV (120-177nm) image mean sky background [ct/s]
# - "sigFUV": Mean standard deviation of the FUV sky. Note (2): Measured by averaging the standard deviation within several regions around the position of the object. [ct/s]
# - "e_FUV": The standard deviation of the mean FUV sky [ct/s]
# - "NUV": Mean NUV (177-300nm) sky background [ct/s]
# - "sigNUV": Mean standard deviation of the NUV sky [ct/s]
# - "e_NUV": The standard deviation of the mean NUV sky [ct/s]
# - "D25FUV": Observed D25 ellipse FUV band AB magnitude [mag]
# - "e_D25FUV": Uncertainty in D25FUV [mag]
# - "D25NUV": Observed D25 ellipse NUV band AB magnitude [mag]
# - "e_D25NUV": Uncertainty in D25NUV [mag]
# - "AFUV": Foreground FUV extinction [mag]
# - "ANUV": Foreground NUV extinction [mag]
# - "asyFUV": Observed asymptotic FUV (120-177nm) AB magnitude [mag]
# - "e_asyFUV": Uncertainty in asyFUV [mag]
# - "asyNUV": Observed asymptotic NUV (177-300nm) AB magnitude [mag]
# - "e_asyNUV": Uncertainty in asyNUV [mag]
# - "logFUV": Log of the FUV (120-177nm) luminosity [W]
# - "logNUV": Log of the NUV (177-300nm) luminosity [W]
# - "Umag": Johnson U band integrated magnitude [mag] Note (1): In the Vega scale. Published as part of the RC3 catalog, Cat. VII/155)
# - "e_Umag": Uncertainty in Umag [mag]
# - "Bmag": Johnson B band integrated magnitude [mag]
# - "e_Bmag": Uncertainty in Bmag [mag]
# - "Vmag": Johnson V band integrated magnitude [mag]
# - "e_Vmag": Uncertainty in Vmag [mag]
# - "Jmag": 2MASS J band total magnitude [mag]
# - "e_Jmag": Uncertainty in Jmag [mag]
# - "Hmag": 2MASS H band total magnitude [mag]
# - "e_Hmag": Uncertainty in Hmag [mag]
# - "Kmag": 2MASS K band total magnitude [mag]
# - "e_Kmag": Uncertainty in Kmag [mag]
# - "F12um": IRAS 12 micron flux density [Jy]
# - "e_F12um": Uncertainty in F12um [Jy]
# - "F25um": IRAS 25 micron flux density [Jy]
# - "e_F25um": Uncertainty in F25um [Jy]
# - "F60um": IRAS 60 micron flux density [Jy]
# - "e_F60um": Uncertainty in F60um [Jy]
# - "F100um": IRAS 100 micron flux density [Jy]
# - "e_F100um": Uncertainty in F100um [Jy]
result = self.vizier.query_object(self.galaxy_name,
catalog="J/ApJS/173/185/galex")
# Result is a list of tables, we only have one table with one entry
# Create an SED
sed = ObservedSED()
# All AB magnitudes
# FUV --
if not result[0]["asyFUV"].mask[0]:
fuv_mag = result[0]["asyFUV"][0]
fuv_mag_error = result[0][0]["e_asyFUV"]
fuv_mag_lower = fuv_mag - fuv_mag_error
fuv_mag_upper = fuv_mag + fuv_mag_error
# flux
fuv = unitconversion.ab_to_jansky(fuv_mag)
fuv_lower = unitconversion.ab_to_jansky(fuv_mag_upper)
fuv_upper = unitconversion.ab_to_jansky(fuv_mag_lower)
fuv_error = ErrorBar(fuv_lower, fuv_upper, at=fuv)
sed.add_entry(self.filters["FUV"], fuv, fuv_error)
# NUV --
if not result[0]["asyNUV"].mask[0]:
nuv_mag = result[0][0]["asyNUV"]
nuv_mag_error = result[0][0]["e_asyNUV"]
nuv_mag_lower = nuv_mag - nuv_mag_error
nuv_mag_upper = nuv_mag + nuv_mag_error
# flux
nuv = unitconversion.ab_to_jansky(nuv_mag)
nuv_lower = unitconversion.ab_to_jansky(nuv_mag_upper)
nuv_upper = unitconversion.ab_to_jansky(nuv_mag_lower)
nuv_error = ErrorBar(nuv_lower, nuv_upper, at=nuv)
sed.add_entry(self.filters["NUV"], nuv, nuv_error)
# U band --
if not result[0]["Umag"].mask[0]:
# From Vega magnitude system to AB magnitudes
u_mag = unitconversion.vega_to_ab(result[0][0]["Umag"], "U")
u_mag_error = unitconversion.vega_to_ab(result[0][0]["e_Umag"],
"U")
u_mag_lower = u_mag - u_mag_error
u_mag_upper = u_mag + u_mag_error
# U band flux
u = unitconversion.ab_to_jansky(u_mag)
u_lower = unitconversion.ab_to_jansky(u_mag_upper)
u_upper = unitconversion.ab_to_jansky(u_mag_lower)
u_error = ErrorBar(u_lower, u_upper, at=u)
sed.add_entry(self.filters["U"], u, u_error)
# B band --
if not result[0]["Bmag"].mask[0]:
b_mag = unitconversion.vega_to_ab(result[0][0]["Bmag"], "B")
b_mag_error = unitconversion.vega_to_ab(result[0][0]["e_Bmag"],
"B")
b_mag_lower = b_mag - abs(b_mag_error)
b_mag_upper = b_mag + abs(b_mag_error)
#print("bmag", b_mag)
#print("bmagerror", b_mag_error)
#print("bmaglower", b_mag_lower)
#print("bmagupper", b_mag_upper)
# B band flux
b = unitconversion.ab_to_jansky(b_mag)
b_lower = unitconversion.ab_to_jansky(b_mag_upper)
b_upper = unitconversion.ab_to_jansky(b_mag_lower)
b_error = ErrorBar(b_lower, b_upper, at=b)
sed.add_entry(self.filters["B"], b, b_error)
# V band --
if not result[0]["Vmag"].mask[0]:
v_mag = unitconversion.vega_to_ab(result[0][0]["Vmag"], "V")
v_mag_error = unitconversion.vega_to_ab(result[0][0]["e_Vmag"],
"V")
v_mag_lower = v_mag - v_mag_error
v_mag_upper = v_mag + v_mag_error
# V band flux
v = unitconversion.ab_to_jansky(v_mag)
v_lower = unitconversion.ab_to_jansky(v_mag_upper)
v_upper = unitconversion.ab_to_jansky(v_mag_lower)
v_error = ErrorBar(v_lower, v_upper, at=v)
sed.add_entry(self.filters["V"], v, v_error)
# In 2MASS magnitude system -> can be converted directly into Jy (see below)
# J band --
if not result[0]["Jmag"].mask[0]:
j_mag = result[0][0]["Jmag"]
j_mag_error = result[0][0]["e_Jmag"]
j_mag_lower = j_mag - j_mag_error
j_mag_upper = j_mag + j_mag_error
# J band flux
j = unitconversion.photometry_2mass_mag_to_jy(j_mag, "J")
j_lower = unitconversion.photometry_2mass_mag_to_jy(
j_mag_upper, "J")
j_upper = unitconversion.photometry_2mass_mag_to_jy(
j_mag_lower, "J")
j_error = ErrorBar(j_lower, j_upper, at=j)
sed.add_entry(self.filters["J"], j, j_error)
# H band --
if not result[0]["Hmag"].mask[0]:
h_mag = result[0][0]["Hmag"]
h_mag_error = result[0][0]["e_Hmag"]
h_mag_lower = h_mag - h_mag_error
h_mag_upper = h_mag + h_mag_error
# H band flux
h = unitconversion.photometry_2mass_mag_to_jy(h_mag, "H")
h_lower = unitconversion.photometry_2mass_mag_to_jy(
h_mag_upper, "H")
h_upper = unitconversion.photometry_2mass_mag_to_jy(
h_mag_lower, "H")
h_error = ErrorBar(h_lower, h_upper, at=h)
sed.add_entry(self.filters["H"], h, h_error)
# K band --
if not result[0]["Kmag"].mask[0]:
k_mag = result[0][0]["Kmag"]
k_mag_error = result[0][0]["e_Kmag"]
k_mag_lower = k_mag - k_mag_error
k_mag_upper = k_mag + k_mag_error
# K band flux
k = unitconversion.photometry_2mass_mag_to_jy(k_mag, "Ks")
k_lower = unitconversion.photometry_2mass_mag_to_jy(
k_mag_upper, "Ks")
k_upper = unitconversion.photometry_2mass_mag_to_jy(
k_mag_lower, "Ks")
k_error = ErrorBar(k_lower, k_upper, at=k)
sed.add_entry(self.filters["K"], k, k_error)
# F12 band flux
if not result[0]["F12um"].mask[0]:
f12 = result[0][0]["F12um"]
f12_error = ErrorBar(result[0][0]["e_F12um"])
sed.add_entry(self.filters["IRAS 12"], f12, f12_error)
# F25 band flux
if not result[0]["F25um"].mask[0]:
f25 = result[0][0]["F25um"]
f25_error = ErrorBar(result[0][0]["e_F25um"])
sed.add_entry(self.filters["IRAS 25"], f25, f25_error)
# F60 band flux
if not result[0]["F60um"].mask[0]:
f60 = result[0][0]["F60um"]
f60_error = ErrorBar(result[0][0]["e_F60um"])
sed.add_entry(self.filters["IRAS 60"], f60, f60_error)
# F100 band flux
if not result[0]["F100um"].mask[0]:
f100 = result[0][0]["F100um"]
f100_error = ErrorBar(result[0][0]["e_F100um"])
sed.add_entry(self.filters["IRAS 100"], f100, f100_error)
# Add the SED to the dictionary
self.seds["GALEX"] = sed
# -----------------------------------------------------------------
def get_2mass(self):
"""
This function ...
:return:
"""
# Inform the user
log.info("Getting fluxes from the 2MASS Extended Catalog ...")
# 2MASS Extended Catalog: "VII/233/xsc": J, H, K (2006AJ....131.1163S)
# Interesting columns:
#
# - "J.ext": J magnitude in r.ext (j_m_ext) [mag]
# - "e_J.ext": σ(J.ext) (j_msig_ext) [mag]
# - "H.ext": H magnitude in r.ext (h_m_ext) [mag]
# - "e_H.ext": σ(H.ext) (h_msig_ext) [mag]
# - "K.ext": J magnitude in r.ext (k_m_ext) [mag]
# - "e_K.ext": σ(K.ext) (k_msig_ext) [mag]
result = self.vizier.query_object(self.galaxy_name,
catalog="VII/233/xsc")
# Create an SED
sed = ObservedSED()
# In 2MASS magnitude system -> can be converted directly into Jy (see below)
j_mag = result[0][0]["J.ext"]
j_mag_error = result[0][0]["e_J.ext"]
j_mag_lower = j_mag - j_mag_error
j_mag_upper = j_mag + j_mag_error
h_mag = result[0][0]["H.ext"]
h_mag_error = result[0][0]["e_H.ext"]
h_mag_lower = h_mag - h_mag_error
h_mag_upper = h_mag + h_mag_error
k_mag = result[0][0]["K.ext"]
k_mag_error = result[0][0]["e_K.ext"]
k_mag_lower = k_mag - k_mag_error
k_mag_upper = k_mag + k_mag_error
# J band flux
j = unitconversion.photometry_2mass_mag_to_jy(j_mag, "J")
j_lower = unitconversion.photometry_2mass_mag_to_jy(j_mag_upper, "J")
j_upper = unitconversion.photometry_2mass_mag_to_jy(j_mag_lower, "J")
j_error = ErrorBar(j_lower, j_upper, at=j)
sed.add_entry(self.filters["J"], j, j_error)
# H band flux
h = unitconversion.photometry_2mass_mag_to_jy(h_mag, "H")
h_lower = unitconversion.photometry_2mass_mag_to_jy(h_mag_upper, "H")
h_upper = unitconversion.photometry_2mass_mag_to_jy(h_mag_lower, "H")
h_error = ErrorBar(h_lower, h_upper, at=h)
sed.add_entry(self.filters["H"], h, h_error)
# K band flux
k = unitconversion.photometry_2mass_mag_to_jy(k_mag, "Ks")
k_lower = unitconversion.photometry_2mass_mag_to_jy(k_mag_upper, "Ks")
k_upper = unitconversion.photometry_2mass_mag_to_jy(k_mag_lower, "Ks")
k_error = ErrorBar(k_lower, k_upper, at=k)
sed.add_entry(self.filters["K"], k, k_error)
# Add the SED to the dictionary
self.seds["2MASS"] = sed
# -----------------------------------------------------------------
def get_sings(self):
"""
This function ...
:return:
"""
# Inform the user
log.info("Getting fluxes from the SINGS catalog ...")
# Radial distribution in SINGS galaxies. I.
# J/ApJ/703/1569/table1 (c)Sample (75 rows)
# J/ApJ/703/1569/table2 UV, optical and NIR surface photometry profiles (2206 rows)
# J/ApJ/703/1569/table3 UV, optical (SDSS) and NIR photometry profiles (2161 rows)
# J/ApJ/703/1569/table4 IRAC and MIPS surface photometry (4319 rows)
# J/ApJ/703/1569/table5 UV, optical, and near-IR asymptotic magnitudes for SINGS galaxies lacking SDSS data (43 rows)
# J/ApJ/703/1569/table6 UV, optical (SDSS), and near-IR asymptotic magnitudes (32 rows)
# J/ApJ/703/1569/table7 IRAC and MIPS asymptotic magnitudes (75 rows)
# J/ApJ/703/1569/table8 Non-parametrical morphological estimators (300 rows)
result = self.vizier.get_catalogs("J/ApJ/703/1569")
# Result is a TableList with 8 tables (0 to 7)
# We need:
# - Table6 -> index 5
# - Table7 -> index 6
# Table6
# - "Name": Galaxy name (NGC ...)
# - "FUV": GALEX FUV 0.153um-band AB magnitude [mag]
# - "e_FUV": FUV uncertainty [mag]
# - "NUV": GALEX NUV 0.227um-band AB magnitude [mag]
# - "e_NUV": NUV uncertainty [mag]
# - "umag": SDSS u-band 0.354um AB magnitude [mag]
# - "e_umag": umag uncertainty [mag]
# - "gmag": SDSS g-band 0.477um AB magnitude [mag]
# - "e_gmag": gmag uncertainty [mag]
# - "rmag": SDSS r-band 0.623um AB magnitude [mag]
# - "e_rmag": rmag uncertainty [mag]
# - "imag": SDSS i-band 0.762um AB magnitude [mag]
# - "e_imag": imag uncertainty [mag]
# - "zmag": SDSS z-band 0.913um AB magnitude [mag]
# - "e_zmag": zmag uncertainty [mag]
# - "Jmag": 2MASS J-band 1.25um AB magnitude [mag]
# - "e_Jmag": Jmag uncertainty [mag]
# - "Hmag": 2MASS H-band 1.65um AB magnitude [mag]
# - "e_Hmag": Hmag uncertainty [mag]
# - "Ksmag": 2MASS Ks-band 2.17um AB magnitude [mag]
# - "e_Ksmag": Ksmag uncertainty [mag]
# Find the row index that corresponds with the specified galaxy
galaxy_index = tables.find_index(result[5], self.ngc_id)
# FUV
fuv_mag = result[5][galaxy_index]["FUV"]
fuv_mag_error = result[5][galaxy_index]["e_FUV"]
fuv_mag_lower = fuv_mag - fuv_mag_error
fuv_mag_upper = fuv_mag + fuv_mag_error
# NUV
nuv_mag = result[5][galaxy_index]["NUV"]
nuv_mag_error = result[5][galaxy_index]["e_NUV"]
nuv_mag_lower = nuv_mag - nuv_mag_error
nuv_mag_upper = nuv_mag + nuv_mag_error
# u
u_mag = result[5][galaxy_index]["umag"]
u_mag_error = result[5][galaxy_index]["e_umag"]
u_mag_lower = u_mag - u_mag_error
u_mag_upper = u_mag + u_mag_error
# g
g_mag = result[5][galaxy_index]["gmag"]
g_mag_error = result[5][galaxy_index]["e_gmag"]
g_mag_lower = g_mag - abs(g_mag_error)
g_mag_upper = g_mag + abs(g_mag_error)
#print("gmag", g_mag)
#print("gmagerror", g_mag_error)
#print("gmaglower", g_mag_lower)
#print("gmagupper", g_mag_upper)
# r
r_mag = result[5][galaxy_index]["rmag"]
r_mag_error = result[5][galaxy_index]["e_rmag"]
r_mag_lower = r_mag - r_mag_error
r_mag_upper = r_mag + r_mag_error
# i
i_mag = result[5][galaxy_index]["imag"]
i_mag_error = result[5][galaxy_index]["e_imag"]
i_mag_lower = i_mag - i_mag_error
i_mag_upper = i_mag + i_mag_error
# z
z_mag = result[5][galaxy_index]["zmag"]
z_mag_error = result[5][galaxy_index]["e_zmag"]
z_mag_lower = z_mag - z_mag_error
z_mag_upper = z_mag + z_mag_error
# J
j_mag = result[5][galaxy_index]["Jmag"]
j_mag_error = result[5][galaxy_index]["e_Jmag"]
j_mag_lower = j_mag - j_mag_error
j_mag_upper = j_mag + j_mag_error
# H
h_mag = result[5][galaxy_index]["Hmag"]
h_mag_error = result[5][galaxy_index]["e_Hmag"]
h_mag_lower = h_mag - h_mag_error
h_mag_upper = h_mag + h_mag_error
# Ks
k_mag = result[5][galaxy_index]["Ksmag"]
k_mag_error = result[5][galaxy_index]["e_Ksmag"]
k_mag_lower = k_mag - k_mag_error
k_mag_upper = k_mag + k_mag_error
# Create an SED
sed = ObservedSED()
# FUV
fuv = unitconversion.ab_to_jansky(fuv_mag)
fuv_lower = unitconversion.ab_to_jansky(fuv_mag_upper)
fuv_upper = unitconversion.ab_to_jansky(fuv_mag_lower)
fuv_error = ErrorBar(fuv_lower, fuv_upper, at=fuv)
sed.add_entry(self.filters["FUV"], fuv, fuv_error)
# NUV
nuv = unitconversion.ab_to_jansky(nuv_mag)
nuv_lower = unitconversion.ab_to_jansky(nuv_mag_upper)
nuv_upper = unitconversion.ab_to_jansky(nuv_mag_lower)
nuv_error = ErrorBar(nuv_lower, nuv_upper, at=nuv)
sed.add_entry(self.filters["NUV"], nuv, nuv_error)
# u
u = unitconversion.ab_to_jansky(u_mag)
u_lower = unitconversion.ab_to_jansky(u_mag_upper)
u_upper = unitconversion.ab_to_jansky(u_mag_lower)
u_error = ErrorBar(u_lower, u_upper, at=u)
sed.add_entry(self.filters["SDSS u"], u, u_error)
# g
g = unitconversion.ab_to_jansky(g_mag)
g_lower = unitconversion.ab_to_jansky(g_mag_upper)
g_upper = unitconversion.ab_to_jansky(g_mag_lower)
g_error = ErrorBar(g_lower, g_upper, at=g)
sed.add_entry(self.filters["SDSS g"], g, g_error)
# r
r = unitconversion.ab_to_jansky(r_mag)
r_lower = unitconversion.ab_to_jansky(r_mag_upper)
r_upper = unitconversion.ab_to_jansky(r_mag_lower)
r_error = ErrorBar(r_lower, r_upper, at=r)
sed.add_entry(self.filters["SDSS r"], r, r_error)
# i
i = unitconversion.ab_to_jansky(i_mag)
i_lower = unitconversion.ab_to_jansky(i_mag_upper)
i_upper = unitconversion.ab_to_jansky(i_mag_lower)
i_error = ErrorBar(i_lower, i_upper, at=i)
sed.add_entry(self.filters["SDSS i"], i, i_error)
# z
z = unitconversion.ab_to_jansky(z_mag)
z_lower = unitconversion.ab_to_jansky(z_mag_upper)
z_upper = unitconversion.ab_to_jansky(z_mag_lower)
z_error = ErrorBar(z_lower, z_upper, at=z)
sed.add_entry(self.filters["SDSS z"], z, z_error)
# J
j = unitconversion.ab_to_jansky(j_mag)
j_lower = unitconversion.ab_to_jansky(j_mag_upper)
j_upper = unitconversion.ab_to_jansky(j_mag_lower)
j_error = ErrorBar(j_lower, j_upper, at=j)
sed.add_entry(self.filters["J"], j, j_error)
# H
h = unitconversion.ab_to_jansky(h_mag)
h_lower = unitconversion.ab_to_jansky(h_mag_upper)
h_upper = unitconversion.ab_to_jansky(h_mag_lower)
h_error = ErrorBar(h_lower, h_upper, at=h)
sed.add_entry(self.filters["H"], h, h_error)
# Ks
k = unitconversion.ab_to_jansky(k_mag)
k_lower = unitconversion.ab_to_jansky(k_mag_upper)
k_upper = unitconversion.ab_to_jansky(k_mag_lower)
k_error = ErrorBar(k_lower, k_upper, at=k)
sed.add_entry(self.filters["K"], k, k_error)
# Table7: IRAC and MIPS asymptotic magnitudes
# - "logF3.6": Spitzer/IRAC 3.6um flux density [logJy]
# - "e_logF3.6": logF3.6 uncertainty [logJy]
# - "logF4.5": Spitzer/IRAC 4.5um flux density [logJy]
# - "e_logF4.5": logF4.5 uncertainty [logJy]
# - "logF5.8": Spitzer/IRAC 5.8um flux density [logJy]
# - "e_logF5.8": logF5.8 uncertainty [logJy]
# - "logF8.0": Spiter/IRAC 8.0um flux density [logJy]
# - "e_logF8.0": logF8.0 uncertainty [logJy]
# - "logF24": Spiter/MIPS 24um flux density [logJy]
# - "e_logF24": logF24 uncertainty [logJy]
# - "logF70": Spiter/MIPS 70um flux density [logJy]
# - "e_logF70": logF70 uncertainty [logJy]
# - "logF160": Spiter/MIPS 160um flux density [logJy]
# - "e_logF160": logF160 uncertainty [logJy]
# Table7 -> index 6
galaxy_index = tables.find_index(result[6], self.ngc_id)
# 3.6 micron
i1_log = result[6][galaxy_index]["logF3.6"]
i1_log_error = result[6][galaxy_index]["e_logF3.6"]
i1_log_lower = i1_log - i1_log_error
i1_log_upper = i1_log + i1_log_error
# 4.5 micron
i2_log = result[6][galaxy_index]["logF4.5"]
i2_log_error = result[6][galaxy_index]["e_logF4.5"]
i2_log_lower = i2_log - i2_log_error
i2_log_upper = i2_log + i2_log_error
# 5.8 micron
i3_log = result[6][galaxy_index]["logF5.8"]
i3_log_error = result[6][galaxy_index]["e_logF5.8"]
i3_log_lower = i3_log - i3_log_error
i3_log_upper = i3_log + i3_log_error
# 8.0 micron
i4_log = result[6][galaxy_index]["logF8.0"]
i4_log_error = result[6][galaxy_index]["e_logF8.0"]
i4_log_lower = i4_log - i4_log_error
i4_log_upper = i4_log + i4_log_error
#print("i4log", i4_log)
#print("i4_log_error", i4_log_error)
#print("i4_log_lower", i4_log_lower)
#print("i4_log_upper", i4_log_upper)
# 24 micron
mips24_log = result[6][galaxy_index]["logF24"]
mips24_log_error = result[6][galaxy_index]["e_logF24"]
mips24_log_lower = mips24_log - mips24_log_error
mips24_log_upper = mips24_log + mips24_log_error
# 70 micron
mips70_log = result[6][galaxy_index]["logF70"]
mips70_log_error = result[6][galaxy_index]["e_logF70"]
mips70_log_lower = mips70_log - mips70_log_error
mips70_log_upper = mips70_log + mips70_log_error
# 160 micron
mips160_log = result[6][galaxy_index]["logF160"]
mips160_log_error = result[6][galaxy_index]["e_logF160"]
mips160_log_lower = mips160_log - mips160_log_error
mips160_log_upper = mips160_log + mips160_log_error
# Calculate data points and errobars in Janskys, add to the SED
# 3.6 micron
i1 = 10.**i1_log
i1_lower = 10.**i1_log_lower
i1_upper = 10.**i1_log_upper
i1_error = ErrorBar(i1_lower, i1_upper, at=i1)
sed.add_entry(self.filters["I1"], i1, i1_error)
# 4.5 micron
i2 = 10.**i2_log
i2_lower = 10.**i2_log_lower
i2_upper = 10.**i2_log_upper
i2_error = ErrorBar(i2_lower, i2_upper, at=i2)
sed.add_entry(self.filters["I2"], i2, i2_error)
# 5.8 micron
i3 = 10.**i3_log
i3_lower = 10.**i3_log_lower
i3_upper = 10.**i3_log_upper
i3_error = ErrorBar(i3_lower, i3_upper, at=i3)
sed.add_entry(self.filters["I3"], i3, i3_error)
# 8.0 micron
i4 = 10.**i4_log
i4_lower = 10.**i4_log_lower
i4_upper = 10.**i4_log_upper
i4_error = ErrorBar(i4_lower, i4_upper, at=i4)
sed.add_entry(self.filters["I4"], i4, i4_error)
# 24 micron
mips24 = 10.**mips24_log
mips24_lower = 10.**mips24_log_lower
mips24_upper = 10.**mips24_log_upper
mips24_error = ErrorBar(mips24_lower, mips24_upper, at=mips24)
sed.add_entry(self.filters["MIPS 24"], mips24, mips24_error)
# 70 micron
mips70 = 10.**mips70_log
mips70_lower = 10.**mips70_log_lower
mips70_upper = 10.**mips70_log_upper
mips70_error = ErrorBar(mips70_lower, mips70_upper, at=mips70)
sed.add_entry(self.filters["MIPS 70"], mips70, mips70_error)
# 160 micron
mips160 = 10.**mips160_log
mips160_lower = 10.**mips160_log_lower
mips160_upper = 10.**mips160_log_upper
mips160_error = ErrorBar(mips160_lower, mips160_upper, at=mips160)
sed.add_entry(self.filters["MIPS 160"], mips160, mips160_error)
# Add the SED to the dictionary
self.seds["SINGS"] = sed
# -----------------------------------------------------------------
def get_lvl(self):
"""
This function ...
:return:
"""
# Inform the user
log.info("Getting fluxes from the LVL catalog ...")
# Create an SED
sed = ObservedSED()
# "J/MNRAS/445/881": LVL global optical photometry (Cook+, 2014)
# - "J/MNRAS/445/881/sample": Galaxies of the Spitzer Local Volume Legacy (LVL): properties (table1) and R25 photometry
# - "J/MNRAS/445/881/table3": Photometry within the IR apertures of Dale et al. (2009, Cat. J/ApJ/703/517) (258 rows)
# - "J/MNRAS/445/881/table4": Photometry within the UV apertures of Lee et al. (2011, Cat. J/ApJS/192/6) (258 rows)
result = self.vizier.query_object(self.galaxy_name,
catalog="J/MNRAS/445/881/sample")
# ALL IN AB MAGNITUDE SYSTEM
# Umag
# Bmag
# Vmag
# Rmag
# umag
# gmag
# rmag
# imag
# zmag
# On SimBad, only sdss bands are used, from /sample ...
relevant_bands = [("U", "U"), ("B", "B"), ("V", "V"), ("R", "R"),
("u", "SDSS u"), ("g", "SDSS g"), ("r", "SDSS r"),
("i", "SDSS i"), ("z", "SDSS z")]
for band_prefix_catalog, filter_name in relevant_bands:
column_name = band_prefix_catalog + "mag"
error_column_name = "e_" + column_name
# Skip masked values
if result[0][column_name].mask[0]: continue
# AB magnitude
magnitude = result[0][0][column_name]
magnitude_error = result[0][0][error_column_name]
magnitude_lower = magnitude - magnitude_error
magnitude_upper = magnitude + magnitude_error
# Convert to Jy
fluxdensity = unitconversion.ab_to_jansky(magnitude)
fluxdensity_lower = unitconversion.ab_to_jansky(magnitude_upper)
fluxdensity_upper = unitconversion.ab_to_jansky(magnitude_lower)
fluxdensity_error = ErrorBar(fluxdensity_lower,
fluxdensity_upper,
at=fluxdensity)
# Add data point to SED
sed.add_entry(self.filters[filter_name], fluxdensity,
fluxdensity_error)
# Add the SED to the dictionary
self.seds["LVL"] = sed
# -----------------------------------------------------------------
def get_spitzer(self):
"""
This function ...
:return:
"""
# Inform the user
log.info("Getting fluxes from the Spitzer catalog ...")
# "J/ApJ/703/517": The Spitzer Local Volume Legacy: IR photometry (Dale+, 2009)
# "J/ApJ/703/517/sample": Galaxy sample (table 1) and infrared flux densities (table 2) (258 rows)
# Create an SED
sed = ObservedSED()
result = self.vizier.query_object(self.galaxy_name,
catalog="J/ApJ/703/517/sample")
# F1.25: 2MASS J band (1.25 micron) flux density [Jy]
# e_F1.25: Uncertainty in F1.25 [Jy]
# F1.65: 2MASS H band (1.65 micron) flux density [Jy]
# e_F1.65: Uncertainty in F1.65 [Jy]
# F2.17: 2MASS Ks band (2.17 micron) flux density [Jy]
# e_F2.17: Uncertainty in F2.17 [Jy]
# F3.6: Spitzer/IRAC 3.5 micron band flux density [Jy]
# e_F3.6: Uncertainty in F3.6 [Jy]
# F4.5: Spitzer/IRAC 4.5 micron band flux density [Jy]
# e_F4.5: Uncertainty in F4.5 [Jy]
# F5.8: Spitzer/IRAC 5.8 micron band flux density [Jy]
# e_F5.8: Uncertainty in F5.8 [Jy]
# F8.0: Spitzer/IRAC 8.0 micron band flux density [Jy]
# e_F8.0: Uncertainty in F8.0 [Jy]
# F24: Spitzer/MIPS 24 micron flux density [Jy]
# e_F24: Uncertainty in F24 [Jy]
# F70: Spitzer/MIPS 70 micron band flux density [Jy]
# e_F70: Uncertainty in F70 [Jy]
# F160: Spitzer/MIPS 160 micron band flux density [Jy]
# e_F160: Uncertainty in F160 [Jy]
relevant_bands = [("1.25", "J"), ("1.65", "H"), ("2.17", "K"),
("3.6", "I1"), ("4.5", "I2"), ("5.8", "I3"),
("8.0", "I4"), ("24", "MIPS 24"), ("70", "MIPS 70"),
("160", "MIPS 160")]
for band_prefix_catalog, filter_name in relevant_bands:
column_name = "F" + band_prefix_catalog
error_column_name = "e_" + column_name
# Skip masked values
if result[0][column_name].mask[0]: continue
# Flux and error already in Jy
fluxdensity = result[0][0][column_name]
fluxdensity_error = ErrorBar(result[0][0][error_column_name])
# Add data point to SED
sed.add_entry(self.filters[filter_name], fluxdensity,
fluxdensity_error)
# Add the SED to the dictionary
self.seds["Spitzer"] = sed
# -----------------------------------------------------------------
def get_spitzer_irs(self):
"""
This function ...
:return:
"""
# Inform the user
log.info("Getting fluxes from the Spitzer/IRS catalog ...")
# "J/MNRAS/414/500": Spitzer/IRS ATLAS project source (Hernan-Caballero+, 2011)
# - "J/MNRAS/414/500/catalog": Spitzer/IRS ATLAS project source catalog, version 1.0 (739 rows)
# !! Parentheses () are converted into underscores _ in the resulting Astropy tables!!
# F(3.6): IRAC1 (3.6um) flux density [Jy]
# e_F(3.6): rms uncertainty on F(3.6) [Jy]
# F(8.0): IRAC4 (8.0um) flux density [Jy]
# e_F(8.0): rms uncertainty on F(8.0) [Jy]
# F(24): 24um flux density [Jy]
# e_F(24): rms uncertainty on F(24) [Jy]
# F(70): 70um or similar band flux density [Jy]
# e_F(70): rms uncertainty on F(70) [Jy]
# Create an SED
sed = ObservedSED()
result = self.vizier.query_object(self.galaxy_name,
catalog="J/MNRAS/414/500/catalog")
relevant_bands = [("3.6", "I1"), ("8.0", "I4"), ("24", "MIPS 24"),
("70", "MIPS 70")]
for band_prefix_catalog, filter_name in relevant_bands:
column_name = "F_" + band_prefix_catalog + "_"
error_column_name = "e_" + column_name
# Skip masked values
if result[0][column_name].mask[0]: continue
# Flux and error already in Jy
fluxdensity = result[0][0][column_name]
fluxdensity_error = ErrorBar(result[0][0][error_column_name])
# Add data point to SED
sed.add_entry(self.filters[filter_name], fluxdensity,
fluxdensity_error)
# Add the SED to the dictionary
self.seds["Spitzer-IRS"] = sed
# -----------------------------------------------------------------
def get_iras(self):
"""
This function ...
:return:
"""
# Inform the user
log.info("Getting fluxes from the IRAS catalog ...")
# "J/ApJS/178/280": Compendium of ISO far-IR extragalactic data (Brauher+, 2008)
# - "J/ApJS/178/280/table1": *Galaxies and properties
# F12: IRAS 12um band flux density [Jy]
# F25: IRAS 25um band flux density [Jy]
# F60: IRAS 60um band flux density [Jy]
# F100: IRAS 100um band flux density [Jy]
# No errors ...
# Create an SED
sed = ObservedSED()
result = self.vizier.query_object(self.galaxy_name,
catalog="J/ApJS/178/280/table1")
relevant_bands = [("12", "IRAS 12"), ("25", "IRAS 25"),
("60", "IRAS 60"), ("100", "IRAS 100")]
for band_prefix_catalog, filter_name in relevant_bands:
column_name = "F" + band_prefix_catalog
# Skip masked values
if result[0][column_name].mask[0]: continue
# Flux and error already in Jy
fluxdensity = result[0][0][column_name]
fluxdensity_error = ErrorBar(0.0)
# Add data point to SED
sed.add_entry(self.filters[filter_name], fluxdensity,
fluxdensity_error)
# Add the SED to the dictionary
self.seds["IRAS"] = sed
# -----------------------------------------------------------------
def get_iras_fsc(self):
"""
This function ...
:return:
"""
# Inform the user
log.info("Getting fluxes from the IRAS-FSC catalog ...")
# "J/MNRAS/398/109": Imperial IRAS-FSC redshift catalogue (IIFSCz) (Wang+, 2009)
# - "J/MNRAS/398/109/iifsczv4": IIFSCz Catalogue (MRR+LW 18/04/09)[spectrum/SED] (60303 rows)
# S12um: IRAS-FSC flux at 12um [Jy]
# S25um: IRAS-FSC flux at 25um [Jy]
# S60um: IRAS-FSC flux at 60um [Jy]
# S100um: IRAS-FSC flux at 100um [Jy]
# not used in Simbad:
# umag: SDSS u magnitude [mag: which system??]
# e_umag:
# gmag:
# e_gmag:
# rmag:
# e_rmag:
# imag:
# e_imag:
# zmag:
# e_zmag:
# Jmag: 2MASS J magnitude [mag: which system??]
# e_Jmag: rms uncertainty on Jmag [mag: which system??]
# Hmag: 2MASS H magnitude [mag]
# e_Hmag: rms uncertainty on Hmag [mag]
# Kmag: 2MASS K magnitude [mag]
# e_Kmag rms uncertainty on Kmag [mag]
# Create an SED
sed = ObservedSED()
result = self.vizier.query_object(self.galaxy_name,
catalog="J/MNRAS/398/109/iifsczv4")
relevant_bands = [("12", "IRAS 12"), ("25", "IRAS 25"),
("60", "IRAS 60"), ("100", "IRAS 100")]
for band_prefix_catalog, filter_name in relevant_bands:
# Flux and error already in Jy
fluxdensity = result[0][0]["S" + band_prefix_catalog + "um"]
fluxdensity_error = ErrorBar(0.0)
# Add data point to SED
sed.add_entry(self.filters[filter_name], fluxdensity,
fluxdensity_error)
# Add the SED to the dictionary
self.seds["IRAS-FSC"] = sed
# -----------------------------------------------------------------
def get_s4g(self):
"""
This function ...
:return:
"""
# Create an SED
sed = ObservedSED()
# Get parameters from S4G catalog
result = self.vizier.query_object(self.galaxy_name,
catalog=["J/PASP/122/1397/s4g"])
table = result[0]
# Magnitudes
i1_mag = table["__3.6_"][0]
i2_mag = table["__4.5_"][0]
i1_mag_error = table["e__3.6_"][0]
i2_mag_error = table["e__4.5_"][0]
i1_fluxdensity = unitconversion.ab_to_jansky(i1_mag)
i1_fluxdensity_lower = unitconversion.ab_to_jansky(i1_mag +
i1_mag_error)
i1_fluxdensity_upper = unitconversion.ab_to_jansky(i1_mag -
i1_mag_error)
i1_error = ErrorBar(i1_fluxdensity_lower,
i1_fluxdensity_upper,
at=i1_fluxdensity)
# Add data point to SED
sed.add_entry(self.filters["I1"], i1_fluxdensity, i1_error)
i2_fluxdensity = unitconversion.ab_to_jansky(i2_mag)
i2_fluxdensity_lower = unitconversion.ab_to_jansky(i2_mag +
i2_mag_error)
i2_fluxdensity_upper = unitconversion.ab_to_jansky(i2_mag -
i2_mag_error)
i2_error = ErrorBar(i2_fluxdensity_lower,
i2_fluxdensity_upper,
at=i2_fluxdensity)
# Add data point to SED
sed.add_entry(self.filters["I2"], i2_fluxdensity, i2_error)
# Add the SED to the dictionary
self.seds["S4G"] = sed
# -----------------------------------------------------------------
def get_brown(self):
"""
This function ...
:return:
"""
# J/ApJS/212/18/sample
# AB magnitudes for the sample with neither foreground nor intrinsic dust extinction corrections, and modeled Milky Way foreground dust extinction
# Create an SED
sed = ObservedSED()
# FUV: [12.5/22.9] GALEX FUV AB band magnitude
# e_FUV:
# UVW2:
# e_UVW2:
# UVM2:
# e_UVM2:
# NUV:
# e_NUV:
# UVW1:
# e_UVW1:
# Umag: [11.9/15.7] Swift/UVOT U AB band magnitude
# e_Umag:
# umag:
# e_umag:
# gmag:
# e_gmag:
# Vmag:
# e_Vmag:
# rmag:
# e_rmag:
# imag:
# e_imag:
# zmag:
# e_zmag:
# Jmag:
# e_Jmag:
# Hmag:
# e_Hmag:
# Ksmag:
# e_Ksmag:
# W1mag:
# e_W1mag:
# [3.6]:
# e_[3.6]:
# [4.5]:
# e_[4.5]:
# W2mag:
# e_W2mag:
# [5.8]:
# e_[5.8]:
# [8.0]:
# e_[8.0]:
# W3mag:
# e_W3mag:
# W4mag:
# e_W4mag:
# W4'mag: Corrected WISE W4 AB band magnitude
# e_W4'mag:
# [24]:
# e_[24]:
pass
# -----------------------------------------------------------------
def get_planck(self):
"""
This function ...
:return:
"""
# Create an SED
sed = ObservedSED()
# The second release is not yet available ... ??
# -----------------------------------------------------------------
def get_emission_lines(self):
"""
This function ...
:return:
"""
# Create an SED
sed = ObservedSED()
# J/ApJS/190/233/Opt
# Get result
result = self.vizier.get_catalogs("J/ApJS/190/233/Opt")
table = result[0]
galaxy_index = tables.find_index(table, self.ngc_id, "Name")
# FHa: The Hα 6563 Angstrom line flux (aW/m2)
# e_FHa: Uncertainty in Ha (aW/m2)
# FNII: The [NII] 6584Å line flux (aW/m2)
# e_FNII: Uncertainty in NII (aW/m2)
# H alpha
ha_flux = table["FHa"][galaxy_index] * Unit("aW/m2")
ha_flux_error = table["e_FHa"][galaxy_index] * Unit("aW/m2")
# NII
n2_flux = table["FNII"][galaxy_index] * Unit("aW/m2")
n2_flux_error = table["e_FNII"][galaxy_index] * Unit("aW/m2")
ha_filter = self.filters["Ha"]
ha_wavelength = ha_filter.centerwavelength() * Unit("micron")
ha_frequency = ha_wavelength.to("Hz", equivalencies=spectral())
# Calculate flux density
ha_fluxdensity = (ha_flux / ha_frequency).to("Jy")
ha_fluxdensity_error = (ha_flux_error / ha_frequency).to("Jy")
ha_errorbar = ErrorBar(ha_fluxdensity_error)
# Add entry
sed.add_entry(ha_filter, ha_fluxdensity, ha_errorbar)
# Add the SED to the dictionary
self.seds["Lines"] = sed
# -----------------------------------------------------------------
def get_m81(self):
"""
This function ...
:return:
"""
# UV through far-IR analysis of M81 (Perez-Gonzalez+, 2006)
# "J/ApJ/648/987"
# Two tables:
# - "J/ApJ/648/987/table1": Positions and photometry (GLOBALBKG and LOCALBKG cases) for the regions selected at 160um resolution
# - "J/ApJ/648/987/table2": Positions and photometry for the regions selected at 24um resolution
# Table 1
#result = self.vizier.query_object(self.galaxy_name, catalog="J/ApJ/648/987/table1")
# Looks like this (only 3 matches)
#1 M81 09 55 32.2 +69 03 59.0 680.0 40.78 43.18 42.84 42.63 42.61 41.98 42.67 42.99
#2 Reg02 09 55 32.2 +69 03 59.0 64.0 39.67 42.63 42.28 41.98 41.76 41.25 41.83 41.78
#3 Reg03 09 55 32.2 +69 03 59.0 104.0 39.40 42.38 42.03 41.76 41.58 40.90 41.62 41.78
#galaxy_index = tables.find_index(result, self.galaxy_name)
# Table 2
# Interesting rows:
# - logLFUV: Log of the FUV luminosity [1e-7 W] or [erg/s]
# - logLNUV: Log of the NUV luminosity [1e-7 W] or [erg/s]
# - logLHa: Log of the H-alpha luminosity [1e-7 W] or [erg/s]
# - logL8: Log of the 8um luminosity [1e-7 W] or [erg/s]
# - logL24: Log of the 24um luminosity [1e-7 W] or [erg/s]
result = self.vizier.query_object(self.galaxy_name,
catalog="J/ApJ/648/987/table2")
galaxy_index = tables.find_index(result[0], self.galaxy_name)
# Create an SED
sed = ObservedSED()
relevant_bands = [("FUV", "FUV"), ("NUV", "NUV"), ("Ha", "Ha"),
("8", "I4"), ("24", "MIPS 24")]
for band_prefix_catalog, filter_name in relevant_bands:
# Flux and error already in Jy
log = result[0][galaxy_index]["logL" + band_prefix_catalog]
flux = 10.**log # In erg/s
frequency = 0.0 # TODO: calculate this!
# Also: calculate the amount of flux per unit area ! : divide also by 4 pi d_galaxy**2 !
fluxdensity = flux / frequency
fluxdensity_error = ErrorBar(0.0)
# Add data point to SED
sed.add_entry(self.filters[filter_name], fluxdensity,
fluxdensity_error)
# Add the SED to the dictionary
self.seds["IRAS-FSC"] = sed
# -----------------------------------------------------------------
def write(self):
"""
This function ...
:return:
"""
# Inform the user
log.info("Writing ...")
# If requested, write out the SEDs
if self.config.write_seds: self.write_seds()
# -----------------------------------------------------------------
def write_seds(self):
"""
This function ...
:return:
"""
# Inform the user
log.info("Writing the SEDs ...")
# Determine the full path to the SEDs directory
path = self.full_output_path(self.config.writing.seds_path)
# Create the SEDs directory if necessary
fs.create_directory(path)
# Loop over the different SEDs
for label in self.seds:
# Debugging info
log.debug("Writing SED from " + label)
# Determine the path to the new SED file
sed_path = fs.join(path, label + ".dat")
# Save the SED at the specified location
self.seds[label].save(sed_path)
def search(image, headinfo, target_coords, syntax, catalog_syntax, filter_):
"""
Search area around transient/target location in photometric catalogs
Current catalog (selectable in syntax):
- Skymapper: Southern Hemisphere
- Pan Starrs: North of declination -30 degree
- Apass: All-sky survey
- 2MASS: JHK all sky survey
Future:
- SDSS: Future implemtation
- Ability to make custom catalog from different surveys
Input:
- Image: Numpy 2D array
- headinfo: astropy.io.fits.header.Header
- target_coords: astropy.coordinates.sky_coordinate.SkyCoord
- syntax: dict
- catalog_syntax: dict
- filter_: str
Output:
- data: pandas DataFrame
"""
import warnings
if not syntax['catalog_warnings'] or syntax['master_warnings']:
warnings.filterwarnings("ignore")
import numpy as np
import os,sys
import requests
import pathlib
import shutil
import os.path
import logging
from functools import reduce
from astropy.table import Table
from astropy.wcs import wcs
from astroquery.vizier import Vizier
from astropy.io.votable import parse_single_table
from astropy.coordinates import Angle
from autophot.packages.functions import r_dist
logger = logging.getLogger(__name__)
try:
# Get wxs information
w1 = wcs.WCS(headinfo)
# Radius around target
radius = float(syntax['radius'])
# Target name, if applicable
target = syntax['target_name']
# Get workdirectory location,, create directory if needed
dirname = os.path.join(syntax['wdir'],'catalog_queries')
pathlib.Path(dirname).mkdir(parents = True, exist_ok=True)
'''
Getting target Ra and Dec
- if target is none but a Ra and DEC is given, create new target name
- if ra and dec not given us center of image as location - for quick reduction of image
'''
# if target or it's ra/dec - set target name
if target == None:
if syntax['target_ra'] != None and syntax['target_dec'] != None:
target = 'target_ra_'+str(round(syntax['target_ra']))+'_dec_'+str(round(syntax['target_dec']))
logger.info('New target name: %s' %target)
else:
# if not just call target
target = 'target'
# Search limitation with Pan Starrs rlimited to 0.5 deg
if radius > 0.5 and syntax['catalog'] == 'pan_starrs' :
logger.warning('Search Limitation with PanStarrs API -> Radius = 0.5 [deg] ')
radius = 0.5
# Choosen catalog for input.yml, create directory for catalog if needed
catalog_dir = syntax['catalog']
pathlib.Path(os.path.join(dirname ,catalog_dir)).mkdir(parents = True, exist_ok=True)
# Folder for target, create directory if needed
target_dir = reduce(os.path.join,[dirname,catalog_dir,target.lower()])
pathlib.Path(target_dir).mkdir(parents = True, exist_ok=True)
# Filename of fetchec catalog
fname = str(target) + '_r_' + str(radius)
# Can force to use certain catalog - untested 03-10-19
if syntax['force_catalog_csv']:
logger.info('Using '+syntax['force_catalog_csv_name']+' as catalog')
fname = str(syntax['force_catalog_csv_name']) + '_r_' + str(radius)
# if catalog is found via it's filename - use this and return data
if os.path.isfile(os.path.join(target_dir,fname+'.csv')):
logger.info('Catalog found for Target: %s\nCatalog: %s \nFile: %s' % (target,str(catalog_dir).upper(),fname))
data = Table.read(os.path.join(target_dir,fname+'.csv'),format = 'csv')
data = data.to_pandas()
else:
# If no previously catalog found - look for one
logger.info('Searching for new catalog: %s ' % syntax['catalog'])
if syntax['catalog'] in ['gaia']:
import astropy.units as u
from astroquery.gaia import Gaia
import warnings
warnings.filterwarnings('ignore')
width = u.Quantity(radius, u.deg)
height = u.Quantity(radius, u.deg)
data = Gaia.query_object_async(coordinate=target_coords, width=width, height=height)
data = data.to_pandas()
data.to_csv(fname+'.csv', sep=',',index = False)
# Move file to new location - 'catalog queries'
shutil.move(os.path.join(os.getcwd(), fname+'.csv'),
os.path.join(target_dir, fname+'.csv'))
warnings.filterwarnings('default')
if syntax['catalog'] in ['apass','2mass']:
# No row limit
Vizier.ROW_LIMIT = -1
catalog_search = Vizier.query_region(target_coords,
radius = Angle(radius,'deg'),
catalog = syntax['catalog'])
# Select first catalog from list
data = catalog_search[0].to_pandas()
data.to_csv(fname+'.csv', sep=',',index = False)
# Move file to new location - 'catalog queries'
shutil.move(os.path.join(os.getcwd(), fname+'.csv'),
os.path.join(target_dir, fname+'.csv'))
# some catalogs need specific download path using 'requests'
if syntax['catalog'] in ['pan_starrs','skymapper']:
mindet=1
if syntax['catalog'] == 'pan_starrs':
server=('https://archive.stsci.edu/'+'panstarrs/search.php')
params = {'RA': target_coords.ra.degree, 'DEC': target_coords.dec.degree,
'SR': radius, 'max_records': 10000,
'outputformat': 'VOTable',
'ndetections': ('>%d' % mindet)}
if syntax['catalog'] == 'skymapper':
server=('http://skymapper.anu.edu.au/sm-cone/public/query?')
params = {'RA': target_coords.ra.degree, 'DEC': target_coords.dec.degree,
'SR': radius,
'RESPONSEFORMAT': 'VOTABLE'}
with open('temp.xml', "wb") as f:
logger.info('Downloading from %s' % syntax['catalog'] )
response = requests.get(server,params = params)
f.write(response.content)
# Parse local file into astropy.table object
data = parse_single_table('temp.xml')
# Delete temporary file
os.remove('temp.xml')
# Convert table to dataframe
data_table = data.to_table(use_names_over_ids=True)
data = data_table.to_pandas()
# invalid entries in panstarrs are -999 - change to nans
if syntax['catalog'] == 'pan_starrs':
data = data.replace(-999,np.nan)
# No sources in field - temporary fix - will add "check different catalog"
if len(data) == 0:
logging.critical('Catalog: %s : does not cover field' % syntax['catalog'])
sys.exit()
# Save to csv and move to 'catalog_queries'
data.to_csv(fname+'.csv',index = False)
shutil.move(os.path.join(os.getcwd(), fname+'.csv'),
os.path.join(target_dir, fname+'.csv'))
# Add in x and y pixel locatins under wcs
x_pix,y_pix = w1.wcs_world2pix(data[catalog_syntax['RA']], data[catalog_syntax['DEC']],1)
data.insert(loc = 5, column = 'x_pix', value = x_pix)
data.insert(loc = 6, column = 'y_pix', value = y_pix)
# Remove boundary sources
data = data[data.x_pix < image.shape[1] - syntax['pix_bound']]
data = data[data.x_pix > syntax['pix_bound']]
data = data[data.y_pix < image.shape[0] - syntax['pix_bound']]
data = data[data.y_pix > syntax['pix_bound']]
logger.info('Catalog length: %d' % len(data))
warnings.filterwarnings("default")
except Exception as e:
logger.exception(e)
data = None
return data
from astroquery.vizier import Vizier
import numpy as np
import scipy.optimize as op
catalog_list = Vizier.find_catalogs('New white dwarf SDSS DR12')
print({k:v.description for k,v in catalog_list.items()})
Vizier.ROW_LIMIT = -1
catalogs = Vizier.get_catalogs(list(catalog_list))
# Our model has a temperature effect, then absorption features on top of the model
# Constants
h_planck = 4.136e-15 # in eV*s
c_light = 2.998e10 # in cgs
k_boltz = 8.617e-5 # in eV/K
# Balmer line centers (in cgs):
lambda_balmer = np.array([6563, 4861, 4341, 4102, 3970, 3889])
window_dict = {}
# Lorentz distribution:
def lorentz(C_coeff, x_center, gamma, x):
return -C_coeff / (np.pi * gamma * (1.0 + ((x-x_center)/gamma)**2))
from astroquery.vizier import Vizier
from astroquery.simbad import Simbad
import requests
from bs4 import BeautifulSoup
import numpy as np
from astropy.table import Table, vstack
from astropy.io import ascii
from astropy import units as u
from astropy.coordinates import SkyCoord, get_constellation
import pandas as pd
import glob, os
print('Downloading constellation_borders.csv...')
# This loads all the catalogs by the keyword "constellation"
catalogue_list = Vizier.find_catalogs("Constellation")
Vizier.ROW_LIMIT = -1
# Following table contains the relevant data
catalog = Vizier.get_catalogs("VI/49")[1]
catalog.remove_columns(['cst', 'type'])
coords = SkyCoord(catalog['RAJ2000'], catalog['DEJ2000'], unit="deg")
const = coords.get_constellation()
const = ['Bootes' if x == 'Boötes' else x
for x in const] # fixing for the unicode problem
catalog.add_column(const, name="Constellation", index=2)
catalog.write("constellation_borders.csv", format="csv", overwrite="True")
print('Done - Constellation borders\n')
print('Downloading messier_objects.csv...')
#Download magnitdue data from astropixels/SEDS
########################################################################################################
output_path = '/mnt/dwf/archive_NOAO_data/data_outputs/'
output_cats = '/mnt/dwf/archive_NOAO_data/data_outputs/' + year + '/' + month + '/' + field + '/vizier_cats/'
if not os.path.exists(output_cats):
os.makedirs(output_cats)
else:
pass
AAVOS = 'II/336'
#v = Vizier(columns = ['mag', '_RAJ2000', '_DEJ2000'], catalog = AAVOS)
#result = v.query_region(field_RA_DEC, radius=Angle(1.5, "deg"))
result = Vizier.query_region(field_RA_DEC,
radius=Angle(1.5, "deg"),
catalog=AAVOS)
AAVOS_table = Table()
AAVOS_table['RA'] = result[0]['RAJ2000']
AAVOS_table['DEC'] = result[0]['DEJ2000']
AAVOS_table['g_mag'] = result[0]['g_mag']
AAVOS_table['g_mag_err'] = result[0]['e_g_mag']
AAVOS_table['r_mag'] = result[0]['r_mag']
AAVOS_table['r_mag_err'] = result[0]['e_r_mag']
AAVOS_table['i_mag'] = result[0]['i_mag']
AAVOS_table['i_mag_err'] = result[0]['e_i_mag']
AAVOS_output = 'AAVOS.ascii'
AAVOS_table.write(output_cats + AAVOS_output, format='ascii', overwrite=True)
def overlay_catalog(self, magstep=0.5, row_limit=1000):
Vizier.ROW_LIMIT = row_limit
# Get WCS Info From Image Header
h = self.image.get_header()
wcs = WCS(h)
nx, ny = self.image.shape
result = wcs.all_pix2world(np.array(nx / 2), np.array(ny / 2), 1)
center = SkyCoord(result[0], result[1], frame='icrs', unit='deg')
center_str = center.to_string("hmsdms", precision=1, sep=':')
footprint = wcs.calc_footprint()
FoV = ((max(footprint[:, 0]) - min(footprint[:, 0])) *
np.cos(center.dec.deg * np.pi / 180),
max(footprint[:, 1]) - min(footprint[:, 1]))
log.info(f'Found WCS with center coordinate: {center_str}')
log.info(f'WCS has approximate diameter of {max(FoV):.2f} deg '\
f'({max(FoV)*60:.1f} arcmin)')
FoV = ((max(footprint[:, 0]) - min(footprint[:, 0])),
max(footprint[:, 1]) - min(footprint[:, 1]))
catalog_names = ['Gaia DR2', 'UCAC5', '2MASS PSC']
catalog_IDs = ['I/345', 'I/340', 'II/246']
colors = ['green', 'lightblue', 'red']
radii = [10, 13, 16]
RAcolname = ['RA_ICRS', 'RAJ2000', 'RAJ2000']
DEcolname = ['DE_ICRS', 'DEJ2000', 'DEJ2000']
magname = ['Gmag', None, None]
result = Vizier.query_region(center,
width=1.05 * FoV[0] * u.deg,
height=1.05 * FoV[1] * u.deg,
catalog=catalog_IDs)
# Overlay Stars
for i, name in enumerate(catalog_names[:1]):
stars = result.values()[i]
maxmag = max(stars[magname[i]])
nextmag = np.ceil(maxmag / magstep) * magstep - magstep
if magname[i] is not None:
while len(stars) == Vizier.ROW_LIMIT and nextmag > 10:
log.warning(f'Retrieved {len(stars)} stars which is at '
f'the limit of {row_limit} for this query.')
nextmag -= magstep
log.info(f'Reducing {magname[i]} limit to {nextmag:.2f}')
vquery = Vizier(
column_filters={magname[i]: f"<{nextmag:.1f}"},
row_limit=Vizier.ROW_LIMIT)
stars = vquery.query_region(center,
width=1.05 * FoV[0] * u.deg,
height=1.05 * FoV[1] * u.deg,
catalog=catalog_IDs[i])[0]
log.info(f'Retrieved {len(stars)} stars from {name} '
f'catalog and marking in {colors[i]}')
for j, star in enumerate(stars):
c = SkyCoord(star[RAcolname[i]] * u.deg,
star[DEcolname[i]] * u.deg)
c_str = c.to_string('hmsdms', sep=':', precision=1)
x, y = wcs.all_world2pix(c.ra.deg, c.dec.deg, 1)
log.debug(f"{name} {c_str} {x:.1f} {y:.1f}")
if (x > 0) and (x <= nx) and (y > 0) and (y <= ny):
log.debug(f"Plotting {name}: {c_str} {x:.1f} {y:.1f}")
self.canvas.add(
self.dc.Circle(x,
y,
radius=radii[i],
alpha=0.7,
color=colors[i]))
self.canvas.add(
self.dc.Circle(x,
y,
radius=0.5,
alpha=0.7,
color=colors[i]))
log.info(' Done.')
def query_catalogue(infile, catalogue, radius, minflux=0.0):
'''
query_catalogue: module to query the FIRST, NVSS, or WENSS catalogue from Vizier and write it to a record array
skycoords: coordinates of the pointing centre in astropy format
catalogue: catalogue to ask for (NVSS, WENSS, or FIRST)
radius: radius around the pointing centre to ask for in degreees
minflux: minimum real source flux to receive from a VIZIER query. Default is 0.0 since for most operations you want all sources in the radius region
returns: record array with RA, DEC, Major axis, Minor axis, parallactic angle, and flux of the sources in the catalogue
'''
try:
if catalogue == 'FIRST':
v = Vizier(columns=["*", "+_r", "_RAJ2000", "_DEJ2000", "PA"],
column_filters={"Fint": ">" + str(minflux)})
v.ROW_LIMIT = -1
sources = v.query_region(getradec(infile),
radius=Angle(radius, "deg"),
catalog=catalogue)
maj_axis = sources[0]['Maj']
min_axis = sources[0]['Min']
flux = sources[0]['Fint'] / 1000.0
elif catalogue == 'NVSS':
v = Vizier(columns=["*", "+_r", "_RAJ2000", "_DEJ2000", "PA"],
column_filters={"S1.4": ">" + str(minflux)})
v.ROW_LIMIT = -1
sources = v.query_region(getradec(infile),
radius=Angle(radius, "deg"),
catalog=catalogue)
maj_axis = sources[0]['MajAxis']
min_axis = sources[0]['MinAxis']
flux = sources[0]['S1.4'] / 1000.0
elif catalogue == 'WENSS':
v = Vizier(columns=["*", "+_r", "_RAJ2000", "_DEJ2000", "PA"],
column_filters={"Sint": ">" + str(minflux)})
v.ROW_LIMIT = -1
sources = v.query_region(getradec(infile),
radius=Angle(radius, "deg"),
catalog=catalogue)
maj_axis = sources[0]['MajAxis']
min_axis = sources[0]['MinAxis']
flux = sources[0]['Sint'] / 1000.0
catlength = len(sources[0])
dtype = [('RA', float), ('DEC', float), ('MajAxis', float),
('MinAxis', float), ('PA', float), ('flux', float),
('dist', float)
] # create a structured array with the source data
cat = np.zeros((catlength, ), dtype=dtype)
cat['RA'] = sources[0]['_RAJ2000']
cat['DEC'] = sources[0]['_DEJ2000']
cat['MajAxis'] = maj_axis
cat['MinAxis'] = min_axis
cat['PA'] = sources[0]['PA']
cat['flux'] = flux
cat['dist'] = sources[0]['_r']
cat = np.rec.array(
cat
) # transform the structured array to a record array for easier handling
except IndexError:
cat = []
return cat
def get_gaia_dr3_paralax(filename = 'gaiadr2/gaiaid_sc.rdb', fileout= 'gaiadr2/tmp_dr3.rdb', append= True):
if os.path.isfile(fileout):
filetmp = open(fileout,"r")
strlines = filetmp.readlines()
filetmp.close()
name_tmp, gaiaid_tmp = np.loadtxt(fileout, unpack=True,usecols=(0,1), skiprows=2, delimiter="\t", dtype=str)
else:
print("Fresh start")
gaiaid_tmp = []
strlines = ['name\tgaia_id\tPlx\te_Plx\tGmag\te_Gmag\tRPmag\te_RPmag\tBPmag\te_BPmag\tFG\te_FG\tG_flux_std_n\n']
strlines.append('----\t-------\t---\t-----\t----\t------\t-----\t-------\t-----\t-------\t--\t----\t------------\n')
print("Result GAIA vizier")
vq2 = Vizier(columns=['Source','Plx','e_Plx', 'FG','e_FG','Gmag','e_Gmag', 'BPmag','e_BPmag', 'RPmag','e_RPmag', 'o_Gmag'], row_limit=5000)
name, gaia_id = np.loadtxt(filename, unpack=True, usecols=(0,1), skiprows=2, delimiter="\t", dtype=str)
radius_search = 10.0*u.arcsec
#ist = 3100
#for i,gaiadr2 in enumerate(gaia_id[ist:]):
# i += ist
for i,gaiadr2 in enumerate(gaia_id):
print(i, len(gaia_id), name[i], gaiadr2)
if gaiadr2 in gaiaid_tmp and name[i] in name_tmp:
print("This one already in place")
continue
if gaiadr2 == "-1":
print(name[i], "No gaia id dr2")
strlines.append('%s\t%s\t-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\t-1\n' % (name[i], gaiadr2))
else:
result_gaia_vizier_dr3=vq2.query_object("Gaia DR2 "+str(gaiadr2), catalog=["I/350/gaiaedr3"], radius=radius_search*15.)
try:
iline3 = np.where(result_gaia_vizier_dr3[0]['Source'] == int(gaiadr2))[0][0]
print(result_gaia_vizier_dr3[0]['Source','Plx','e_Plx', 'Gmag', 'e_Gmag', 'FG', 'e_FG', 'RPmag', 'e_RPmag', 'BPmag', 'e_BPmag'][iline3])
std_g_flux_norm1_v = result_gaia_vizier_dr3[0]['e_FG'][iline3]*np.sqrt(result_gaia_vizier_dr3[0]['o_Gmag'][iline3])/result_gaia_vizier_dr3[0]['FG'][iline3]
except IndexError:
result_gaia_vizier_dr3=vq2.query_object("Gaia DR2 "+str(gaiadr2), catalog=["I/350/gaiaedr3"], radius=radius_search*25.)
try:
iline3 = np.where(result_gaia_vizier_dr3[0]['Source'] == int(gaiadr2))[0][0]
print(result_gaia_vizier_dr3[0]['Source','Plx','e_Plx', 'Gmag', 'e_Gmag', 'FG', 'e_FG', 'RPmag', 'e_RPmag', 'BPmag', 'e_BPmag'][iline3])
std_g_flux_norm1_v = result_gaia_vizier_dr3[0]['e_FG'][iline3]*np.sqrt(result_gaia_vizier_dr3[0]['o_Gmag'][iline3])/result_gaia_vizier_dr3[0]['FG'][iline3]
except IndexError:
result_gaia_vizier_dr3 = [Table( [[-1], [-1],[-1], [-1] ,[-1], [-1] ,[-1] ,[-1] ,[-1] , [-1] ] ,
names=('Plx','e_Plx','Gmag','e_Gmag','FG','e_FG','RPmag','e_RPmag','BPmag','e_BPmag')) ]
std_g_flux_norm1_v = -1
iline3=0
print("Iline2:", iline3)
strlines.append('%s\t%s\t%7.4f\t%7.4f\t%7.4f\t%7.4f\t%7.4f\t%7.4f\t%7.4f\t%7.4f\t%.3e\t%.3e\t%10.7f\n' % (name[i], gaiadr2,
result_gaia_vizier_dr3[0]['Plx'][iline3], result_gaia_vizier_dr3[0]['e_Plx'][iline3],
result_gaia_vizier_dr3[0]['Gmag'][iline3], result_gaia_vizier_dr3[0]['e_Gmag'][iline3],
result_gaia_vizier_dr3[0]['RPmag'][iline3], result_gaia_vizier_dr3[0]['e_RPmag'][iline3],
result_gaia_vizier_dr3[0]['BPmag'][iline3], result_gaia_vizier_dr3[0]['e_BPmag'][iline3],
result_gaia_vizier_dr3[0]['FG'][iline3], result_gaia_vizier_dr3[0]['e_FG'][iline3],
std_g_flux_norm1_v))
print(strlines[-1])
if append:
fileo = open(fileout, "a")
else:
fileo = open(fileout, "w")
for line in strlines:
fileo.write(line)
fileo.close()
def table(self):
if self._table is None:
table = Vizier.get_catalogs('J/A+A/552/A16/limb1-4')[0]
self._table = table
return self._table
import numpy as np
from astroquery.vizier import Vizier
from astropy.coordinates import SkyCoord
import astropy.units as u
from astropy import table
import numpy as np
usnob_cat = Vizier.find_catalogs('USNO-B1.0')
def get_usnob1_cat(ra, dec, blim):
ra_u = ra*u.degree
dec_u = dec*u.degree
coords = SkyCoord(ra_u, dec_u, frame='icrs') #Should this be ICRS or FK5
#Only Class 0 (stars) - unable to implement this at the current time. Need to understand
#USNO-B1 s/g classification
v = Vizier(columns=['USNO-B1.0', '_RAJ2000', '_DEJ2000',
'B1mag', 'R1mag', 'B2mag', 'R2mag',
'pmRA', 'pmDE', 'Imag', 'B1s/g', '_r'],
row_limit=500000,
column_filters={"B2mag":">6", 'B2mag':'<{}'.format(blim)}) #B2mag fainter than 6, brighter than blim
new_table_list = v.query_region(coords,
radius=900*u.arcsecond, #Search 900 arcseconds
catalog = 'I/284')
if len(new_table_list) ==0:
return None
else:
new_table = new_table_list[0]
#Get the 5000 closest
new_table.sort('_r')
if len(new_table) > 5000:
new_table.remove_rows(np.arange(5001, len(new_table)))
def add_gaia_figure_elements(tpf, fig, magnitude_limit=18):
"""Make the Gaia Figure Elements"""
# Get the positions of the Gaia sources
c1 = SkyCoord(tpf.ra, tpf.dec, frame='icrs', unit='deg')
# Use pixel scale for query size
pix_scale = 4.0 # arcseconds / pixel for Kepler, default
if tpf.mission == 'TESS':
pix_scale = 21.0
# We are querying with a diameter as the radius, overfilling by 2x.
from astroquery.vizier import Vizier
Vizier.ROW_LIMIT = -1
result = Vizier.query_region(c1, catalog=["I/345/gaia2"],
radius=Angle(np.max(tpf.shape[1:]) * pix_scale, "arcsec"))
no_targets_found_message = ValueError('Either no sources were found in the query region '
'or Vizier is unavailable')
too_few_found_message = ValueError('No sources found brighter than {:0.1f}'.format(magnitude_limit))
if result is None:
raise no_targets_found_message
elif len(result) == 0:
raise too_few_found_message
result = result["I/345/gaia2"].to_pandas()
result = result[result.Gmag < magnitude_limit]
if len(result) == 0:
raise no_targets_found_message
# Apply correction for proper motion
year = ((tpf.time[0].jd - 2457206.375) * u.day).to(u.year)
pmra = ((np.nan_to_num(np.asarray(result.pmRA)) * u.milliarcsecond/u.year) * year).to(u.deg).value
pmdec = ((np.nan_to_num(np.asarray(result.pmDE)) * u.milliarcsecond/u.year) * year).to(u.deg).value
result.RA_ICRS += pmra
result.DE_ICRS += pmdec
# Convert to pixel coordinates
radecs = np.vstack([result['RA_ICRS'], result['DE_ICRS']]).T
coords = tpf.wcs.all_world2pix(radecs, 0)
# Gently size the points by their Gaia magnitude
sizes = 64.0 / 2**(result['Gmag']/5.0)
one_over_parallax = 1.0 / (result['Plx']/1000.)
source = ColumnDataSource(data=dict(ra=result['RA_ICRS'],
dec=result['DE_ICRS'],
pmra=result['pmRA'],
pmde=result['pmDE'],
source=result['Source'].astype(str),
Gmag=result['Gmag'],
plx=result['Plx'],
one_over_plx=one_over_parallax,
x=coords[:, 0] + tpf.column,
y=coords[:, 1] + tpf.row,
size=sizes))
r = fig.circle('x', 'y', source=source, fill_alpha=0.3, size='size',
line_color=None, selection_color="firebrick",
nonselection_fill_alpha=0.0, nonselection_line_color=None,
nonselection_line_alpha=0.0, fill_color="firebrick",
hover_fill_color="firebrick", hover_alpha=0.9,
hover_line_color="white")
fig.add_tools(HoverTool(tooltips=[("Gaia source", "@source"),
("G", "@Gmag"),
("Parallax (mas)", "@plx (~@one_over_plx{0,0} pc)"),
("RA", "@ra{0,0.00000000}"),
("DEC", "@dec{0,0.00000000}"),
("pmRA", "@pmra{0,0.000} mas/yr"),
("pmDE", "@pmde{0,0.000} mas/yr"),
("x", "@x"),
("y", "@y")],
renderers=[r],
mode='mouse',
point_policy="snap_to_data"))
return fig, r
def find_source(alt_az, lat_lon=local_latlong,
minute=minute, hour=hour,
day=day, month=month, year=year, tz_offset=5,
return_all_sources=True):
"""Find a source given some coordinates.
Args:
alt_az: Tuple of altitude and azimuth (decimal degrees)
lat_lon: Tuple of latitude and longitude (decimal degrees)
time: Clock time (?)
Returns:
source_name (str):
"""
ra_dec = altaz_to_radec(alt_az, pos=lat_lon,
minute=minute, hour=hour, day=day,
month=month, year=year, tz_offset=5)
coords = coordinates.SkyCoord(ra=ra_dec[0], dec=ra_dec[1],
unit=(u.deg, u.deg), frame='icrs')
# Get the actual results
# For some reason, if this goes too big it stops seeing the actual source.
r = 500 * u.arcminute
results = Vizier.query_region(coords, radius=r, catalog='V/50')[0]
df = results.to_pandas()
candidate_sources = filter(None, [n for n in df['HD']])
sources = []
dmax, vmax = 0, 0
for s in candidate_sources:
source_info = df.loc[df['HD'] == s]
name = source_info['Name']
mag = round(float(source_info['Vmag']), 2)
temp_ra = source_info['RAJ2000'].tolist()[0]
temp_dec = source_info['DEJ2000'].tolist()[0]
source_ra_hms = tuple(map(float, temp_ra.split()))
source_dec_dms = tuple(map(float, temp_dec.split()))
source_ra = Angle(source_ra_hms, unit='hourangle').degree
source_dec = Angle(source_dec_dms, unit=u.deg).degree
dist_from_center = np.sqrt((source_ra - ra_dec[0])**2 +
(source_dec - ra_dec[1])**2)
score = float(c1 * mag + c2 * dist_from_center)
source_dict = {'HD': source_info['HD'].values[0],
'Name': source_info['Name'].values[0],
'RA': source_ra,
'DEC': source_dec,
'Distance': dist_from_center,
'Vmag': source_info['Vmag'],
'Score': score}
sources.append(source_dict)
dmax = dist_from_center if dist_from_center > dmax else dmax
vmax = mag if mag > vmax else mag
for s in range(len(sources)):
d = sources[s]['Distance']/dmax
mag = sources[s]['Vmag'].values[0]/vmax
score = c1 * mag + c2 * d
sources[s]['Score'] = score
sources[s]['Scaled-Distance'] = d
sources[s]['Scaled-Mag'] = mag
sources_df = pd.DataFrame(sources)
# Note that this loop is supremely janky, but df.loc'ing wasn't working.
# best_source = sources_df.loc[sources_df['Score'] == sources_df['Score'].min]
best_source_idx = 0
# best_score = np.array([])
best_score = 10000
for i in range(len(sources)):
score = sources[i]['Score']
if score < best_score:
best_source_idx = i
best_score = score
name = sources_df['Name'].values[0]
out = {'Coords': ra_dec,
'HD-Name': 'HD' + str(int(sources[best_source_idx]['HD'])),
'Name': sources[best_source_idx]['Name'],
'Score': sources[best_source_idx]['Score'],
'Scaled-Distance': sources[best_source_idx]['Scaled-Distance'],
'Scaled-Mag': sources[best_source_idx]['Scaled-Mag']
}
return out
"""
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, order=8, 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(order)
def get_radius(self, spt, plot=False):
def find_location(source_name, source_alt_az,
minute=minute_now, hour=hour_now, day=day_now,
month=month_now, year=year_now, plot_grids=True):
"""Find out where we are on Earth.
Args:
source_name (str):
source_ra_dec (tuple of floats):
minute, hour, day, month, year (ints):
Returns:
lat_long (tuple of floats): your location.
"""
alt, az = source_alt_az
source_obj = Vizier.query_object(source_name, catalog='V/50')[0]
source_ra_dec = (source_obj['RAJ2000'][0], source_obj['DEJ2000'][0])
source_ra_hms = tuple(map(float, source_ra_dec[0].split()))
source_dec_dms = tuple(map(float, source_ra_dec[1].split()))
source_ra = Angle(source_ra_hms, unit='hourangle').degree
source_dec = Angle(source_dec_dms, unit=u.deg).degree
lat_crit = 0.01
step = 20
lats = np.linspace(-90, 90, step)
longs = np.linspace(-180., 180., 2*step)
lat_min, lat_max = 0, len(lats) - 1
long_min, long_max = 0, len(longs) - 1
real_lat, real_long = 41.55, -72.65
counter = 0
while abs(lats[1] - lats[0]) > lat_crit:
lats = np.linspace(lats[lat_min], lats[lat_max], step)
longs = np.linspace(longs[long_min], longs[long_max], 2*step)
score_grid = np.zeros((len(lats), len(longs)))
# Run the grid
for i in range(len(lats)):
for j in range(len(longs)):
lat, long = lats[i], longs[j]
ra, dec = altaz_to_radec((alt, az), pos=(lat, long),
minute=minute, hour=hour, day=day,
month=month, year=year, tz_offset=5)
score = np.sqrt((ra - source_ra)**2 + (dec - source_dec)**2)
score_grid[i, j] = score
idx = np.where(score_grid == np.nanmin(score_grid))
lat_min = idx[0][0] - 2 if idx[0][0] > 1 else 0
lat_max = idx[0][0] + 2 if idx[0][0] < len(lats) - 2 else len(lats) - 1
long_min = idx[1][0] - 2 if idx[1][0] > 1 else 0
long_max = idx[1][0] + 2 if idx[1][0] < len(longs) - 2 else len(longs) - 1
plt.matshow(score_grid, cmap='magma_r')
plt.contour(score_grid, cmap='magma')
xtick_locs = np.arange(0, len(longs), len(longs)/6)
xtick_labs = [int(longs[i]) for i in xtick_locs]
plt.xticks(xtick_locs, xtick_labs)
ytick_locs = np.arange(0, len(lats), len(lats)/6)
ytick_labs = [int(lats[i]) for i in ytick_locs]
plt.yticks(ytick_locs, ytick_labs)
i, j = 0, 0
while longs[i] < real_long and i < len(longs) - 1:
i += 1
while lats[j] < real_lat and j < len(lats) - 1:
j += 1
print i, j
if i != 0 and j != 0 and i != len(longs) and i != len(lats):
plt.plot([i], [j], 'or')
plt.savefig('window-evolution' + str(counter) + '.png')
plt.close
counter += 1
return (lats[idx[0][0]], longs[idx[1][0]])
outname = 'latlong-gridsearch-results_' + str(res)
score_df = pd.DataFrame(score_grid)
score_df.to_csv(outname + '.csv')
if plot_grids is True:
lat_coord = (90 + local_latlong[0]) * res
long_coord = (180 + local_latlong[1]) * res
plt.contour(score_grid)
plt.plot([lat_coord], [long_coord], 'or')
plt.matshow(score_grid, cmap='magma')
xtick_locs = np.arange(0, len(longs), len(longs)/6)
xtick_labs = [int(longs[i]) for i in xtick_locs]
plt.xticks(xtick_locs, xtick_labs)
# plt.ylim(max(lats), min(lats))
ytick_locs = np.arange(0, len(lats), len(lats)/10)
ytick_labs = [int(lats[i]) for i in ytick_locs]
plt.yticks(ytick_locs, ytick_labs)
plt.savefig(outname + '.png', dpi=200)
plt.show(block=False)
return {'RA': ra_grid, 'DEC': dec_grid, 'SCORE': score_grid}
#!/bin/env python
# Downloads the gleam catalog as a VOTable from Vizier
# This is required for running reference sim 1.4.
import os
import sys
try:
from astroquery.vizier import Vizier
except ImportError as e:
raise ImportError(
"astroquery module required to use the download_gleam script") from e
catalog_dir = "first_generation/catalog_files/"
name = "gleam.vot"
opath = os.path.join(catalog_dir, name)
if os.path.exists(opath):
print("GLEAM already downloaded to {}.".format(opath))
sys.exit()
Vizier.ROW_LIMIT = -1
Vizier.columns = ['GLEAM', 'RAJ2000', 'DEJ2000', 'Fintwide']
catname = 'VIII/100/gleamegc'
tab = Vizier.get_catalogs(catname)[0]
tab.write(opath, format='votable')
print("GLEAM catalog downloaded and saved to " + opath)
def find_location_gs(source_name, source_alt_az,
minute, hour, day, month, year,
plot_grids=True):
"""Find out where we are on Earth.
Args:
source_name (str):
source_ra_dec (tuple of floats):
minute, hour, day, month, year (ints):
Returns:
lat_long (tuple of floats): your location.
"""
alt, az = source_alt_az
source_obj = Vizier.query_object(source_name, catalog='V/50')[0]
source_ra_dec = (source_obj['RAJ2000'][0], source_obj['DEJ2000'][0])
source_ra_hms = tuple(map(float, source_ra_dec[0].split()))
source_dec_dms = tuple(map(float, source_ra_dec[1].split()))
source_ra = Angle(source_ra_hms, unit='hourangle').degree
source_dec = Angle(source_dec_dms, unit=u.deg).degree
lats = np.arange(-90., 90, res)
longs = np.arange(-180, 180, res)
ra_grid = np.zeros((len(lats), len(longs)))
dec_grid = np.zeros((len(lats), len(longs)))
score_grid = np.zeros((len(lats), len(longs)))
# Run the grid
lat_counter, long_counter = 0, 0
for i in range(len(lats)):
for j in range(len(longs)):
# Need to sort out angular units
lat, long = lats[i], longs[j]
ra, dec = altaz_to_radec((alt, az), pos=(lat, long),
minute=minute, hour=hour, day=day,
month=month, year=year, tz_offset=5)
# pos_grid[i, j] = {'RA': ra, 'DEC': dec}
ra_grid[i, j] = ra
dec_grid[i, j] = dec
# Bad - planar:
score = np.sqrt((ra - source_ra)**2 + (dec - source_dec)**2)
# Good - spherical:
# score = np.arccos(np.sin(dec) * np.sin(source_dec) + np.cos(dec) * np.cos(source_dec) * np.cos(abs(ra - source_ra)))
score_grid[i, j] = score
verbose = False
if verbose is True:
print('RA, Source RA:', ra, source_ra)
print('DEC, Source DEC:', dec, source_dec)
print('Score:', score)
print('\n')
else:
step = long_counter + lat_counter * len(lats)
print (str(step) + '/' + str(len(lats) * len(longs)))
long_counter += 1
outname = 'latlong-gridsearch-results_' + str(res)
score_df = pd.DataFrame(score_grid)
score_df.to_csv(outname + '.csv')
if plot_grids is True:
lat_coord = (90 + local_latlong[0]) * res
long_coord = (180 + local_latlong[1]) * res
plt.contour(score_grid)
plt.plot([lat_coord], [long_coord], 'or')
plt.matshow(score_grid, cmap='magma')
xtick_locs = np.arange(0, len(longs), len(longs)/6)
xtick_labs = [int(longs[i]) for i in xtick_locs]
plt.xticks(xtick_locs, xtick_labs)
# plt.ylim(max(lats), min(lats))
ytick_locs = np.arange(0, len(lats), len(lats)/10)
ytick_labs = [int(lats[i]) for i in ytick_locs]
plt.yticks(ytick_locs, ytick_labs)
plt.savefig(outname + '.png', dpi=200)
plt.show(block=False)
return {'RA': ra_grid, 'DEC': dec_grid, 'SCORE': score_grid}
from astroquery.simbad import Simbad
S = Simbad()
S.add_votable_fields('rv_value')
dir = sys.argv[1]
files = glob.glob(dir + '/*p08.fits')
templates = glob.glob('/home/rajikak/tools/RV_standards/*')
print("*************")
for file in files:
a = pyfits.open(file)
object_name = a[1].header['OBJNAME']
#get RV data on the standard:
#From Vizier table:
result = Vizier.query_object(object_name)
interesting_table = result['J/ApJS/141/503/table1']
object_RV = float(interesting_table[0]['__RV_']) / 1000.
flux_stamp, wave = ps.read_and_find_star_p08(file)
spectrum, sig = ps.weighted_extract_spectrum(flux_stamp)
rv, rv_sig = ps.calc_rv_template(spectrum, wave, sig, templates,
([0, 5400], [6870, 6890]))
rv += a[1].header['RADVEL']
print("object_name: " + object_name)
print("object RV: " + str(object_RV) + "km/s")
print("Retrieved RV from standards: " + str(rv) + "km/s")
print("*************")
plt.ylim(755.1,755.5)
plt.ylabel('fistar Centroid Location')
plt.xlabel('Frame Number, Cadence')
plt.savefig('fistarYDrift.png',dpi=200,bbox_inches='tight')
plt.show()
#%% m soares code from 5/13/2020
import matplotlib.pyplot as plt
from astropy.visualization import astropy_mpl_style
plt.style.use(astropy_mpl_style)
from astropy.io import fits
from astropy.table import Table
from astroquery.mast import Catalogs
from astroquery.vizier import Vizier
v = Vizier()
from astropy import coordinates
from astropy import units as u
#Live dangerously
import warnings
warnings.filterwarnings("ignore")
# interface with astrometry package instead of opening this fits file
tbl = fits.open('/Users/msoares/Desktop/corr.fits')[1].data
def post(self, obj_id):
"""
---
description: |
get cross-match with Vizier and post them as an annotation
based on cross-matches to some catalog
(default is VII/290, i.e. the million quasar catalog).
parameters:
- in: path
name: obj_id
required: true
schema:
type: string
description: ID of the object to retrieve the Vizier crossmatch for
requestBody:
content:
application/json:
schema:
type: object
properties:
catalog:
required: false
type: string
description: |
The name of the catalog key, associated with a
catalog cross match,
from which the data should be retrieved.
Default is VII/290.
crossmatchRadius:
required: false
type: number
description: |
Crossmatch radius (in arcseconds) to retrieve photoz's
Default is 2.
group_ids:
required: false
type: array
items:
type: integer
description: |
List of group IDs corresponding to which groups
should be able to view annotation.
Defaults to all of requesting user's groups.
responses:
200:
content:
application/json:
schema: Success
400:
content:
application/json:
schema: Error
"""
obj = Obj.query.get(obj_id)
if obj is None:
return self.error('Invalid object id.')
data = self.get_json()
group_ids = data.pop('group_ids', None)
if not group_ids:
groups = self.current_user.accessible_groups
else:
try:
groups = Group.get_if_accessible_by(
group_ids, self.current_user, raise_if_none=True
)
except AccessError:
return self.error(
'At least some of the groups are not accessible.', status=403
)
author = self.associated_user_object
catalog = data.pop('catalog', "VII/290")
radius_arcsec = data.pop('crossmatchRadius', 2.0)
candidate_coord = SkyCoord(ra=obj.ra * u.deg, dec=obj.dec * u.deg)
tl = Vizier.query_region(
coordinates=candidate_coord,
catalog=catalog,
radius=radius_arcsec * u.arcsec,
)
if len(tl) == 0:
return self.error("No successful cross-match available.")
if len(tl) > 1:
return self.error("Should only have one table from that query.")
df = tl[0].filled(fill_value=-99).to_pandas()
keys = [
'Qpct',
'z',
]
annotations = []
for index, row in df.iterrows():
annotation_data = {
k: row.to_dict().get(k, None)
for k in keys
if not row.to_dict().get(k, None) == -99
}
origin = f"{catalog}-{row['Name']}"
annotation = Annotation(
data=annotation_data,
obj_id=obj_id,
origin=origin,
author=author,
groups=groups,
)
annotations.append(annotation)
if len(annotations) == 0:
return self.error("No crossmatch annotation available.")
DBSession().add_all(annotations)
try:
self.verify_and_commit()
except IntegrityError:
return self.error("Annotation already posted.")
self.push_all(
action='skyportal/REFRESH_SOURCE',
payload={'obj_key': obj.internal_key},
)
return self.success()
from astroquery.vizier import Vizier
from astropy import coordinates
from astropy import units as u
v = Vizier()
c = coordinates.SkyCoord(0, 0, unit=('deg', 'deg'), frame='icrs')
result = v.query_region(c, radius=2 * u.deg, catalog=["I/337", "I/345"])
print(result)
#catalog_list = Vizier.find_catalogs('gaia', max_catalogs = 1000)
#print({k:v.description for k,v in catalog_list.items()})