def desQuery(self,ra,dec,radius_arcmin=1,columns="*"):
radius_degree = CoordinateParser.getMinToDegree(radius_arcmin)
query_template = "SELECT {0:s} FROM des_dr1.main WHERE q3c_radial_query(ra,dec,{1:f},{2:f},{3:f})"
query = query_template.format(columns, ra, dec, radius_degree)
df = None
try:
result = qc.query(self.getToken(), sql=query) # by default the result is a CSV formatted string
result = result.decode('utf8').replace("'", '"')
df = helpers.convert(result, 'pandas')
except Exception as e:
print(e)
return df
def download_deepest_image(self,ra, dec, radius_arcmin=1, path=''):
fov=CoordinateParser.getMinToDegree(radius_arcmin)
size=fov / np.cos(np.array(dec) * np.pi / 180)
imgTable = self._svc.search((ra, dec), (size, fov), verbosity=2)
imgTable=imgTable.votable.to_table()
print("The full image list contains", len(imgTable), "entries")
#sel0 = imgTable['obs_bandpass'].astype(str) == band
#sel0 &
sel = ((imgTable['proctype'].astype(str) == 'Stack') & (
imgTable['prodtype'].astype(str) == 'image')) # basic selection
Table = imgTable[sel] # select
imageSource = None
if (len(Table) > 0):
imageSource = ImageSource(str(ra)+"_"+str(dec), "DES")
for row in Table:
band=row['obs_bandpass'].decode()
if band=='':
band="stackbands"
url = row['access_url'].decode()
#image = io.fits.getdata(utils.data.download_file(url, cache=True, show_progress=False, timeout=120))
#base64 = ImageUtils.imgNpArrayToBase64(image)
local_path = path + "des_band_" + band + ".fits"
imageSource.addFile(band, url, "fits", download=True, local_path=local_path,uncompress=False, thumbnail=True,external=False)
#imageSource.addFile("band-" + band, url, "fits")
thumbnail=imageSource.getFiles()
pos =len(thumbnail)-1
base64img=thumbnail[pos]["thumbnail"]
imageSource.addCutout(base64img, 300, band)
# if (len(Table) > 0):
# row = Table[np.argmax(Table['exptime'].data.data.astype('float'))] # pick image with longest exposure time
# url = row['access_url'].decode() # get the download URL
# print('downloading deepest stacked image...')
# image = io.fits.getdata(utils.data.download_file(url, cache=True, show_progress=False, timeout=120))
#
# else:
# print('No image available.')
# image = None
return imageSource
def query(self, **kwargs):
if "coordinates" in kwargs:
self.__coordinates = kwargs["coordinates"]
elif "ra" in kwargs and "dec" in kwargs:
self.__coordinates = str(kwargs["ra"]) + "," + str(kwargs["dec"])
radius = 1 # arcmin
if "radius" in kwargs:
radius = kwargs["radius"]
radius_degree = CoordinateParser.getMinToDegree(radius)
self.__coordinates = CoordinateParser.validateCoordinates(self.__coordinates)
self.__save_path = self.__save_path.format(
str(self.__coordinates.ra.degree) + "_" + str(self.__coordinates.dec.degree))
try:
result=sha.query(self.__coordinates, size=radius_degree)
except IndexError:
result = []
except ValueError:
result=[]
respond = AstroSource(self.__coordinates)
if len(result)>0:
index,loss = CoordinateParser.getNearPositionIndex(self.__coordinates.ra.degree, self.__coordinates.dec.degree,
result["ra"], result["dec"])
row = result[index]
Utils.createPath(self.__save_path)
catalog = CatalogSource("spitzer", "Search in radius " + str(radius))
VOTableUtil.saveFromTable(result, self.__save_path + "catalog.xml")
catalog.addFile("spitzer", self.__save_path + "catalog.xml", "vo")
respond.addCatalog(catalog)
respond.addSummaryParams("ra", row["ra"])
respond.addSummaryParams("dec", row["dec"])
respond.addSummaryParams("distance", loss)
respond.addSummaryParams("filetype",row["filetype"])
respond.addSummaryParams("modedisplayname", row["modedisplayname"])
respond.addSummaryParams("wavelength", row["wavelength"])
respond.addSummaryParams("minwavelength", row["minwavelength"])
respond.addSummaryParams("maxwavelength", row["maxwavelength"])
return respond
def query(self, **kwargs):
if "coordinates" in kwargs:
self.__coordinates = kwargs["coordinates"]
elif "ra" in kwargs and "dec" in kwargs:
self.__coordinates = str(kwargs["ra"]) + "," + str(kwargs["dec"])
radius = 1 # arcmin
if "radius" in kwargs:
radius = kwargs["radius"]
self.__coordinates = CoordinateParser.validateCoordinates(
self.__coordinates)
self.__save_path = self.__save_path.format(
str(self.__coordinates.ra.degree) + "_" +
str(self.__coordinates.dec.degree))
self.__arcmin_range = radius
self.__degrees_range = CoordinateParser.getMinToDegree(radius)
result = AstroSource(self.__coordinates)
df = self.getCatalogFromSIAS()
# GET catalogs from SIAS DB, the object is selected from the near source using Pythagorean theorem
if len(df.index) > 0:
index, loss = CoordinateParser.getNearPositionIndex(
self.__coordinates.ra.degree, self.__coordinates.dec.degree,
df["ra"].values, df["dec"].values)
self.loss = loss
self.setSummary(result, df.iloc[index])
table = Table.from_pandas(df)
Utils.createPath(self.__save_path)
catalog = CatalogSource(
"des", "Search in radius " + str(self.__arcmin_range))
VOTableUtil.saveFromTable(table, self.__save_path + "catalog.xml")
catalog.addFile("des", self.__save_path + "catalog.xml", "vo")
result.addCatalog(catalog)
#GET IMAGES From SIAS by ra dec radio in arcmin(the service recieve radii in degree)
img = self.getImageFromSIAS()
if img != None:
result.addImage(img)
return result
def query(self, **kwargs):
# check for data release to use
if "coordinates" in kwargs:
self.__coordinates = kwargs["coordinates"]
elif "ra" in kwargs and "dec" in kwargs:
self.__coordinates = str(kwargs["ra"]) + "," + str(kwargs["dec"])
else:
raise ValueError(
"Not valid coordinates found. Used coordinates key or ra dec keys"
)
radius = 1 # arcmin
if "radius" in kwargs:
radius = kwargs["radius"]
self.__coordinates = CoordinateParser.validateCoordinates(
self.__coordinates)
self.__save_path = self.__save_path.format(
str(self.__coordinates.ra.degree) + "_" +
str(self.__coordinates.dec.degree))
self.__radius_degree = CoordinateParser.getMinToDegree(radius)
all_wise = self.getData(self.__service_provider["all_wise"])
wise = self.getData(self.__service_provider["wise"])
result = AstroSource(self.__coordinates)
catalog = None
allWiseWavelenght = WaveLenghtCover.wise()
if len(all_wise) > 0:
Utils.createPath(self.__save_path)
catalog = CatalogSource("allwise",
"Search in radius " + str(radius))
VOTableUtil.saveFromTable(all_wise,
self.__save_path + "allwise_catalog.xml")
catalog.addFile("allwise",
self.__save_path + "allwise_catalog.xml", "vo")
index, loss = CoordinateParser.getNearPositionIndex(
self.__coordinates.ra.degree, self.__coordinates.dec.degree,
all_wise["RAJ2000"], all_wise["DEJ2000"])
result.addSummaryParams("allwise_ra", all_wise["RAJ2000"][index])
result.addSummaryParams("allwise_dec", all_wise["DEJ2000"][index])
result.addSummaryParams("distance", loss)
data = {
"lambda": allWiseWavelenght["w1"],
"ab": str(all_wise["W1mag"][index]),
"err": str(all_wise["e_W1mag"][index])
}
result.addSummaryParams("allwise_w1mag", data)
data = {
"lambda": allWiseWavelenght["w2"],
"ab": str(all_wise["W2mag"][index]),
"err": str(all_wise["e_W2mag"][index])
}
result.addSummaryParams("allwise_w2mag", data)
data = {
"lambda": allWiseWavelenght["w3"],
"ab": str(all_wise["W3mag"][index]),
"err": str(all_wise["e_W3mag"][index])
}
result.addSummaryParams("allwise_w3mag", data)
data = {
"lambda": allWiseWavelenght["w4"],
"ab": str(all_wise["W4mag"][index]),
"err": str(all_wise["e_W4mag"][index])
}
result.addSummaryParams("allwise_w4mag", data)
data = {
"lambda": allWiseWavelenght["j"],
"ab": str(all_wise["Jmag"][index]),
"err": str(all_wise["e_Jmag"][index])
}
result.addSummaryParams("allwise_Jmag", data)
data = {
"lambda": allWiseWavelenght["h"],
"ab": str(all_wise["Hmag"][index]),
"err": str(all_wise["e_Hmag"][index])
}
result.addSummaryParams("allwise_Hmag", data)
data = {
"lambda": allWiseWavelenght["k"],
"ab": str(all_wise["Kmag"][index]),
"err": str(all_wise["e_Kmag"][index])
}
result.addSummaryParams("allwise_Kmag", data)
result.addCatalog(catalog)
if len(wise) > 0:
index, loss = CoordinateParser.getNearPositionIndex(
self.__coordinates.ra.degree, self.__coordinates.dec.degree,
wise["RAJ2000"], wise["DEJ2000"])
if catalog is None:
Utils.createPath(self.__save_path)
catalog = CatalogSource(
"wise", "Search in radius(arcmin) " + str(radius))
VOTableUtil.saveFromTable(wise,
self.__save_path + "wise_catalog.xml")
catalog.addFile("wise", self.__save_path + "wise_catalog.xml",
"vo")
result.addSummaryParams("wise_ra", wise["RAJ2000"][index])
result.addSummaryParams("wise_dec", wise["DEJ2000"][index])
result.addSummaryParams("wise_distance", loss)
data = {
"lambda": allWiseWavelenght["w1"],
"ab": str(wise["W1mag"][index]),
"err": str(wise["e_W1mag"][index])
}
result.addSummaryParams("wise_w1mag", data)
data = {
"lambda": allWiseWavelenght["w2"],
"ab": str(wise["W2mag"][index]),
"err": str(wise["e_W2mag"][index])
}
result.addSummaryParams("wise_w2mag", data)
data = {
"lambda": allWiseWavelenght["w3"],
"ab": str(wise["W3mag"][index]),
"err": str(wise["e_W3mag"][index])
}
result.addSummaryParams("wise_w3mag", data)
data = {
"lambda": allWiseWavelenght["w4"],
"ab": str(wise["W4mag"][index]),
"err": str(wise["e_W4mag"][index])
}
result.addSummaryParams("wise_w4mag", data)
data = {
"lambda": allWiseWavelenght["j"],
"ab": str(wise["Jmag"][index]),
"err": str(wise["e_Jmag"][index])
}
result.addSummaryParams("wise_Jmag", data)
data = {
"lambda": allWiseWavelenght["h"],
"ab": str(wise["Hmag"][index]),
"err": str(wise["e_Hmag"][index])
}
result.addSummaryParams("wise_Hmag", data)
data = {
"lambda": allWiseWavelenght["k"],
"ab": str(wise["Kmag"][index]),
"err": str(wise["e_Kmag"][index])
}
result.addSummaryParams("wise_Kmag", data)
result.addCatalog(catalog)
return result
def query(self, **kwargs):
if "coordinates" in kwargs:
self.__coordinates = kwargs["coordinates"]
elif "ra" in kwargs and "dec" in kwargs:
self.__coordinates = str(kwargs["ra"]) + "," + str(kwargs["dec"])
radius = 1 # arcmin
if "radius" in kwargs:
radius = kwargs["radius"]
self.__coordinates = CoordinateParser.validateCoordinates(
self.__coordinates)
self.__save_path = self.__save_path.format(
str(self.__coordinates.ra.degree) + "_" +
str(self.__coordinates.dec.degree))
degrees_range = CoordinateParser.getMinToDegree(radius)
ra_min = self.__coordinates.ra.degree - (degrees_range / 2)
ra_max = self.__coordinates.ra.degree + (degrees_range / 2)
dec_min = self.__coordinates.dec.degree - (degrees_range / 2)
dec_max = self.__coordinates.dec.degree + (degrees_range / 2)
query = self.__simple_rec_query.format(ra_min, ra_max, dec_min,
dec_max)
respond = self.getTapRequest(query=query)
result = AstroSource(self.__coordinates)
if len(respond) > 0:
Utils.createPath(self.__save_path)
catalog = CatalogSource("decals",
"Search in radius " + str(radius))
VOTableUtil.saveFromTable(respond,
self.__save_path + "catalog.xml")
catalog.addFile("decals", self.__save_path + "catalog.xml", "vo")
result.addCatalog(catalog)
index, loss = CoordinateParser.getNearPositionIndex(
self.__coordinates.ra.degree, self.__coordinates.dec.degree,
respond["ra"], respond["dec"])
result.addSummaryParams("ra", respond["ra"][index])
result.addSummaryParams("dec", respond["dec"][index])
result.addSummaryParams("distance", loss)
decals = WaveLenghtCover.decals()
data = {
"lambda": decals["g"],
"ab": str(respond["mag_g"][index]),
"err": -99
}
result.addSummaryParams("mag_g", data)
data = {
"lambda": decals["r"],
"ab": str(respond["mag_r"][index]),
"err": -99
}
result.addSummaryParams("mag_r", data)
data = {
"lambda": decals["z"],
"ab": str(respond["mag_z"][index]),
"err": -99
}
result.addSummaryParams("mag_z", data)
result.addSummaryParams("flux_g", str(respond["flux_g"][index]))
result.addSummaryParams("flux_r", str(respond["flux_r"][index]))
result.addSummaryParams("flux_z", str(respond["flux_z"][index]))
result.addSummaryParams("type", str(respond["type"][index]))
image = ImageSource(result.getSummary()["id"],
self.__catalog_provider)
bands = ["grz", "gz", "g"]
mag_band = [
result.getSummary()["mag_r"],
result.getSummary()["mag_z"],
result.getSummary()["mag_g"]
]
for index in range(len(bands)):
band = bands[index]
mag = str(mag_band[index]["ab"]) + "+/-" + str(
mag_band[index]["err"])
img = self.getImage(self.__coordinates, band)
link = img["link"]
image.addCutout(img["jpeg"], 256, band, mag, link)
#image.addFile(band,img["fits"])
local_path = self.__save_path + "decals_band_" + band + ".fits"
image.addFile(band,
img["fits"],
"fits",
download=True,
local_path=local_path,
uncompress=False,
thumbnail=False,
external=False)
result.addImage(image)
return result
def query(self, **kwargs):
if "coordinates" in kwargs:
self.__coordinates = kwargs["coordinates"]
elif "ra" in kwargs and "dec" in kwargs:
self.__coordinates = str(kwargs["ra"]) + "," + str(kwargs["dec"])
radius = 1 # arcmin
if "radius" in kwargs:
radius = kwargs["radius"]
self.__coordinates = CoordinateParser.validateCoordinates(
self.__coordinates)
self.__save_path = self.__save_path.format(
str(self.__coordinates.ra.degree) + "_" +
str(self.__coordinates.dec.degree))
degrees_range = CoordinateParser.getMinToDegree(radius)
ra_min = self.__coordinates.ra.degree - (degrees_range / 2)
ra_max = self.__coordinates.ra.degree + (degrees_range / 2)
dec_min = self.__coordinates.dec.degree - (degrees_range / 2)
dec_max = self.__coordinates.dec.degree + (degrees_range / 2)
table = self.__service_provider["video"]["table"]
query = self.__simple_rec_query.format(table, ra_min, ra_max, dec_min,
dec_max)
url = self.__service_provider["video"]["url"]
respond = self.getTapRequest(url=url, query=query)
program = "video"
if len(respond) <= 0:
table = self.__service_provider["viking"]["table"]
query = self.__simple_rec_query.format(table, ra_min, ra_max,
dec_min, dec_max)
url = self.__service_provider["viking"]["url"]
respond = self.getTapRequest(url=url, query=query)
program = "viking"
if len(respond) <= 0:
table = self.__service_provider["vhs"]["table"]
query = self.__simple_rec_query.format(table, ra_min, ra_max,
dec_min, dec_max)
url = self.__service_provider["vhs"]["url"]
respond = self.getTapRequest(url=url, query=query)
program = "vhs"
result = AstroSource(self.__coordinates)
if len(respond) > 0:
vhs = WaveLenghtCover.vhs()
Utils.createPath(self.__save_path)
catalog = CatalogSource("vhs", "Search in radius " + str(radius))
VOTableUtil.saveFromTable(respond,
self.__save_path + "catalog.xml")
catalog.addFile("vhs", self.__save_path + "catalog.xml", "vo")
result.addCatalog(catalog)
index, loss = CoordinateParser.getNearPositionIndex(
self.__coordinates.ra.degree, self.__coordinates.dec.degree,
respond["ra"], respond["dec"])
result.addSummaryParams("ra", respond["ra"][index])
result.addSummaryParams("dec", respond["dec"][index])
result.addSummaryParams("distance", loss)
mag = {
"Y":
str(respond["yAperMag3"][index]) + "+/-" +
str(respond["yAperMag3Err"][index]),
"J":
str(respond["jAperMag3"][index]) + "+/-" +
str(respond["jAperMag3Err"][index]),
"H":
str(respond["hAperMag3"][index]) + "+/-" +
str(respond["hAperMag3Err"][index]),
"Ks":
str(respond["ksAperMag3"][index]) + "+/-" +
str(respond["ksAperMag3Err"][index])
}
if program == "video" or program == "viking":
result.addSummaryParams(
"magpetro_z", {
"lambda": vhs["z"],
"ab": str(respond["zPetroMag"][index]),
"err": str(respond["zPetroMagErr"][index])
})
result.addSummaryParams(
"magAper_z", {
"lambda": vhs["z"],
"ab": str(respond["zAperMag3"][index]),
"err": str(respond["zAperMag3Err"][index])
})
mag["Z"] = str(respond["zAperMag3"][index]) + "+/-" + str(
respond["zAperMag3Err"][index])
result.addSummaryParams(
"magpetro_y", {
"lambda": vhs["y"],
"ab": str(respond["yPetroMag"][index]),
"err": str(respond["yPetroMagErr"][index])
})
result.addSummaryParams(
"magpetro_j", {
"lambda": vhs["j"],
"ab": str(respond["jPetroMag"][index]),
"err": str(respond["jPetroMagErr"][index])
})
result.addSummaryParams(
"magpetro_h", {
"lambda": vhs["h"],
"ab": str(respond["hPetroMag"][index]),
"err": str(respond["hPetroMagErr"][index])
})
result.addSummaryParams(
"magpetro_ks", {
"lambda": vhs["ks"],
"ab": str(respond["ksPetroMag"][index]),
"err": str(respond["ksPetroMagErr"][index])
})
result.addSummaryParams(
"magAper_y", {
"lambda": vhs["y"],
"ab": str(respond["yAperMag3"][index]),
"err": str(respond["yAperMag3Err"][index])
})
result.addSummaryParams(
"magAper_j", {
"lambda": vhs["j"],
"ab": str(respond["jAperMag3"][index]),
"err": str(respond["jAperMag3Err"][index])
})
result.addSummaryParams(
"magAper_h", {
"lambda": vhs["h"],
"ab": str(respond["hAperMag3"][index]),
"err": str(respond["hAperMag3Err"][index])
})
result.addSummaryParams(
"magAper_ks", {
"lambda": vhs["ks"],
"ab": str(respond["ksAperMag3"][index]),
"err": str(respond["ksAperMag3Err"][index])
})
result.addSummaryParams("type", str(respond["mergedClass"][index]))
images = self.getImages(program)
image = ImageSource(result.getSummary()["id"],
self.__catalog_provider)
saved_path = {}
for idx in range(len(images)):
img = images[idx]
band = img["band"]
mag_val = mag[band]
image.addCutout(img["image"], 256, band, mag_val)
index_image = ""
if band in saved_path:
saved_path[band] += 1
index_image = saved_path[band]
else:
saved_path[band] = 0
local_path = self.__save_path + "vhs_band_" + band + str(
index_image) + ".fits"
image.addFile(band,
img["fits"],
"fits",
download=True,
local_path=local_path,
uncompress=True,
thumbnail=False,
external=False)
result.addImage(image)
return result
def query(self, **kwargs):
if "coordinates" in kwargs:
self.__coordinates = kwargs["coordinates"]
elif "ra" in kwargs and "dec" in kwargs:
self.__coordinates = str(kwargs["ra"]) + "," + str(kwargs["dec"])
radius = 1 # arcmin
if "radius" in kwargs:
radius = kwargs["radius"]
self.__coordinates = CoordinateParser.validateCoordinates(
self.__coordinates)
self.__save_path = self.__save_path.format(
str(self.__coordinates.ra.degree) + "_" +
str(self.__coordinates.dec.degree))
width_survey = "w"
deep_survey = "d"
radius_degree = CoordinateParser.getMinToDegree(radius)
query = self.__simple_rec_query.format(deep_survey,
self.__coordinates.ra.degree,
self.__coordinates.dec.degree,
radius_degree)
respond = self.getTapRequest(query=query)
self.wide = False
if len(respond) <= 0:
query = self.__simple_rec_query.format(
width_survey, self.__coordinates.ra.degree,
self.__coordinates.dec.degree, radius_degree)
respond = self.getTapRequest(query=query)
self.wide = True
result = AstroSource(self.__coordinates)
if len(respond) > 0:
Utils.createPath(self.__save_path)
catalog = CatalogSource("cfht", "Search in radius " + str(radius))
VOTableUtil.saveFromTable(respond,
self.__save_path + "catalog.xml")
catalog.addFile("allwise", self.__save_path + "catalog.xml", "vo")
index, loss = CoordinateParser.getNearPositionIndex(
self.__coordinates.ra.degree, self.__coordinates.dec.degree,
respond["RAJ2000"], respond["DEJ2000"])
result.addSummaryParams("ra", respond["RAJ2000"][index])
result.addSummaryParams("dec", respond["DEJ2000"][index])
result.addSummaryParams("distance", loss)
result.addSummaryParams("survey", "wide" if self.wide else "deep")
cfht = WaveLenghtCover.cfht()
data = {
"lambda": cfht["u"],
"ab": str(respond["umag"][index]),
"err": str(respond["e_umag"][index])
}
result.addSummaryParams("mag_u", data)
data = {
"lambda": cfht["g"],
"ab": str(respond["gmag"][index]),
"err": str(respond["e_gmag"][index])
}
result.addSummaryParams("mag_g", data)
data = {
"lambda": cfht["r"],
"ab": str(respond["rmag"][index]),
"err": str(respond["e_rmag"][index])
}
result.addSummaryParams("mag_r", data)
data = {
"lambda": cfht["i"],
"ab": str(respond["imag"][index]),
"err": str(respond["e_imag"][index])
}
result.addSummaryParams("mag_i", data)
data = {
"lambda": cfht["z"],
"ab": str(respond["zmag"][index]),
"err": str(respond["e_zmag"][index])
}
result.addSummaryParams("mag_z", data)
result.addSummaryParams("flux_u", str(respond["uFpk"][index]))
result.addSummaryParams("flux_g", str(respond["gFpk"][index]))
result.addSummaryParams("flux_r", str(respond["rFpk"][index]))
result.addSummaryParams("flux_i", str(respond["iFpk"][index]))
result.addSummaryParams("flux_z", str(respond["zFpk"][index]))
result.addCatalog(catalog)
if self.wide:
#img=self.getWideImages()
url = self.__service_provider[
"width_cutout"] + "?lang=en&object=&ra={0}&dec={1}&size=256"
url = url.format(self.__coordinates.ra.degree,
self.__coordinates.dec.degree)
images = self.delayRequest(url)
image = ImageSource(result.getSummary()["id"],
self.__catalog_provider)
mag = {
"U":
str(respond["umag"][index]) + "+/-" +
str(respond["e_umag"][index]),
"G":
str(respond["gmag"][index]) + "+/-" +
str(respond["e_gmag"][index]),
"R":
str(respond["rmag"][index]) + "+/-" +
str(respond["e_rmag"][index]),
"I":
str(respond["imag"][index]) + "+/-" +
str(respond["e_imag"][index]),
"Z":
str(respond["zmag"][index]) + "+/-" +
str(respond["e_zmag"][index]),
"2":
-99
}
for idx in range(len(images)):
img = images[idx]
band = img["band"]
mag_val = mag[band]
image.addCutout(img["image"], 256, band, mag_val)
local_path = self.__save_path + "cfht_band_" + band + ".fits"
image.addFile(band,
img["fits"],
"fits",
download=True,
local_path=local_path,
uncompress=False,
thumbnail=True,
external=False)
result.addImage(image)
return result
def query(self, **kwargs):
# check for data release to use
if "coordinates" in kwargs:
self.__coordinates = kwargs["coordinates"]
elif "ra" in kwargs and "dec" in kwargs:
self.__coordinates = str(kwargs["ra"]) + "," + str(kwargs["dec"])
else:
raise ValueError("Not valid coordinates found. Used coordinates key or ra dec keys")
radius = 1 # arcmin
if "radius" in kwargs:
radius = kwargs["radius"]
self.__coordinates = CoordinateParser.validateCoordinates(self.__coordinates)
large_suvey="II/319/las9"
galactic_cluster_suvey = "II/319/gcs9"
deep_suvey = "II/319/dxs9"
galatic_plane_survey="II/316/gps6"
radius_degree = CoordinateParser.getMinToDegree(radius)
program_id="ALL"
self.__save_path = self.__save_path.format(
str(self.__coordinates.ra.degree) + "_" + str(self.__coordinates.dec.degree))
query = self.__simple_rec_query.format(large_suvey, self.__coordinates.ra.degree, self.__coordinates.dec.degree,
radius_degree)
respond = self.getTapRequest(query=query)
result = AstroSource(self.__coordinates)
if len(respond) <= 0:
query = self.__simple_rec_query.format(galactic_cluster_suvey, self.__coordinates.ra.degree,
self.__coordinates.dec.degree, radius_degree)
respond = self.getTapRequest(query=query)
program_id = "GCS"
if len(respond) <= 0:
query = self.__simple_rec_query.format(deep_suvey, self.__coordinates.ra.degree,
self.__coordinates.dec.degree, radius_degree)
respond = self.getTapRequest(query=query)
program_id = "DXS"
if len(respond) <= 0:
query = self.__simple_rec_query.format(galatic_plane_survey, self.__coordinates.ra.degree,
self.__coordinates.dec.degree, radius_degree)
respond = self.getTapRequest(query=query)
program_id = "GPS"
if len(respond)>0:
Utils.createPath(self.__save_path)
catalog = CatalogSource("ukidss", "Search in radius " + str(radius))
VOTableUtil.saveFromTable(respond, self.__save_path + "catalog.xml")
catalog.addFile("ukidss", self.__save_path + "catalog.xml", "vo")
result.addCatalog(catalog)
index,loss = CoordinateParser.getNearPositionIndex(self.__coordinates.ra.degree, self.__coordinates.dec.degree,
respond["RAJ2000"], respond["DEJ2000"])
ukidss = WaveLenghtCover.ukidss()
result.addSummaryParams("ra", respond["RAJ2000"][index])
result.addSummaryParams("dec", respond["DEJ2000"][index])
result.addSummaryParams("distance", loss)
magnitudes={"Y":-99,"J":-99,"H":-99,"K":-99,"Z":-99}
try:
data={"lambda": ukidss["h"], "ab": str(respond["Hmag"][index]), "err": str(respond["e_Hmag"][index])}
result.addSummaryParams("mag_h", data)
magnitudes["H"] = data["ab"] + "+/-" + data["err"]
except KeyError:
print("No mag_h found")
try:
data = {"lambda": ukidss["j"], "ab": str(respond["Jmag"][index]), "err": str(respond["e_Jmag"][index])}
result.addSummaryParams("mag_j", data)
magnitudes["J"] = data["ab"] + "+/-" + data["err"]
except KeyError:
print("No mag_j found")
try:
data = {"lambda": ukidss["j"], "ab": str(respond["Jmag1"][index]), "err": str(respond["e_Jmag1"][index])}
result.addSummaryParams("mag_j1", data)
magnitudes["J"] = data["ab"] + "+/-" + data["err"]
except KeyError:
print("No mag_j1 found")
try:
data = {"lambda": ukidss["j"], "ab": str(respond["Jmag2"][index]),"err": str(respond["e_Jmag2"][index])}
result.addSummaryParams("mag_j2", data)
magnitudes["J"] = data["ab"] + "+/-" + data["err"]
except KeyError:
print("No mag_j2 found")
try:
data = {"lambda": ukidss["j"], "ab": str(respond["pJmag"][index]),"err": str(respond["e_pJmag"][index])}
result.addSummaryParams("pmag_j", data)
magnitudes["J"] = data["ab"] + "+/-" + data["err"]
except KeyError:
print("No pmag_j found")
try:
data = {"lambda": ukidss["k"], "ab": str(respond["pKmag"][index]),"err": str(respond["e_pKmag"][index])}
result.addSummaryParams("pmag_k", data)
magnitudes["K"] = data["ab"] + "+/-" + data["err"]
except KeyError:
print("No pmag_k found")
try:
data = {"lambda": ukidss["k"], "ab": str(respond["Kmag"][index]),"err": str(respond["e_Kmag"][index])}
result.addSummaryParams("mag_k", data)
magnitudes["K"] = data["ab"] + "+/-" + data["err"]
except KeyError:
print("No mag_k found")
try:
data = {"lambda": ukidss["k"], "ab": str(respond["Kmag1"][index]), "err": str(respond["e_Kmag1"][index])}
result.addSummaryParams("mag_k1", data)
magnitudes["K"] = data["ab"] + "+/-" + data["err"]
except KeyError:
print("No mag_k1 found")
try:
data = {"lambda": ukidss["k"], "ab": str(respond["Kmag2"][index]),"err": str(respond["e_Kmag2"][index])}
result.addSummaryParams("mag_k2", data)
magnitudes["K"] = data["ab"] + "+/-" + data["err"]
except KeyError:
print("No mag_k2 found")
try:
data = {"lambda": ukidss["y"], "ab": str(respond["Ymag"][index]),"err": str(respond["e_Ymag"][index])}
result.addSummaryParams("mag_y", data)
magnitudes["Y"] = data["ab"] + "+/-" + data["err"]
except KeyError:
print("No mag_y found")
try:
data = {"lambda": ukidss["z"], "ab": str(respond["Zmag"][index]), "err": str(respond["e_Zmag"][index])}
result.addSummaryParams("mag_z", data)
magnitudes["Z"] = data["ab"] + "+/-" + data["err"]
except KeyError:
print("No mag_z found")
images = Ukidss.get_image_list(self.__coordinates,waveband='all', frame_type='stack',
image_width=radius * u.arcmin,
database="UKIDSSDR10PLUS",programme_id=program_id)
display_urls = [link.replace("getFImage", "getImage")for link in images]
image_urls = [link.replace("getFImage", "getJImage") for link in images]
image = ImageSource(result.getSummary()["id"], self.__catalog_provider)
for index in range(len(images)):
img= image_urls[index]
band = str(img[img.find("band")+5:img.find("band")+6]).replace(" ","")
mag=magnitudes[band]
image.addCutout(image_urls[index],300, band, magnitude=mag,link=display_urls[index])
local_path = self.__save_path + "ukidss_band_" + band + ".fits"
image.addFile(name="band-" + band, url=images[index], download=True,
local_path=local_path, uncompress=False, thumbnail=True,external=False)
#image.addFile("band-" + band,images[index] , "fits")
result.addImage(image)
return result