def get_rectangle(ras, decs, ra_size, dec_size):
ras[ras > 180.0] = ras[ras > 180.0] - 360.0
poly = MultiPoint([(x, y) for x, y in zip(ras, decs)]).envelope
minx, miny, maxx, maxy = poly.bounds
width = maxx - minx
height = maxy - miny
while (width < ra_size) or (height < dec_size):
ra_mean, dec_mean = np.mean(ras), np.mean(decs)
dist = angular_distance(ra_mean, dec_mean, ras, decs)
idx = np.setdiff1d(np.arange(len(ras)), np.argmax(dist))
ras, decs = ras[idx], decs[idx]
if len(ras) == 1:
return np.mod(ras[0], 360.0), decs[0]
poly = MultiPoint([(x, y) for x, y in zip(ras, decs)]).envelope
minx, miny, maxx, maxy = poly.bounds
width = maxx - minx
height = maxy - miny
return np.mod((minx + maxx) / 2.0, 360.0), (miny + maxy) / 2.0
def find_tile(exposureids_tile,
exposureids,
probs,
idxs=None,
exptimecheckkeys=[],
current_ra=np.nan,
current_dec=np.nan,
slew_rate=1,
readout=1):
# exposureids_tile: {expo id}-> list of the tiles available for observation
# exposureids: list of tile ids for every exposure it is allocated to observe
if idxs is not None:
for idx in idxs:
if len(exposureids_tile["exposureids"]) - 1 < idx: continue
idx2 = exposureids_tile["exposureids"][idx]
if idx2 in exposureids and not idx2 in exptimecheckkeys:
idx = exposureids.index(idx2)
exposureids.pop(idx)
probs.pop(idx)
return idx2, exposureids, probs
findTile = True
while findTile:
if not exposureids_tile["probs"]:
idx2 = -1
findTile = False
break
if (not np.isnan(current_ra)) and (not np.isnan(current_dec)):
dist = angular_distance(current_ra, current_dec,
np.array(exposureids_tile["ras"]),
np.array(exposureids_tile["decs"]))
slew_readout = readout / (dist / slew_rate)
slew_readout[slew_readout > 1] = 1.0
score = np.array(exposureids_tile["probs"]) * slew_readout
idx = np.argmax(score)
else:
idx = np.argmax(exposureids_tile["probs"])
idx2 = exposureids_tile["exposureids"][idx]
if exposureids:
if idx2 in exposureids and not idx2 in exptimecheckkeys:
idx = exposureids.index(idx2)
exposureids.pop(idx)
probs.pop(idx)
findTile = False
else:
exposureids_tile["exposureids"].pop(idx)
exposureids_tile["probs"].pop(idx)
exposureids_tile["ras"].pop(idx)
exposureids_tile["decs"].pop(idx)
else:
findTile = False
return idx2, exposureids, probs
def computeSlewReadoutTime(config_struct, coverage_struct):
slew_rate = config_struct['slew_rate']
readout = config_struct['readout']
prev_ra = config_struct["latitude"]
prev_dec = config_struct["longitude"]
acc_time = 0
for dat in coverage_struct['data']:
dist = angular_distance(prev_ra, prev_dec, dat[0], dat[1])
slew_readout_time = np.max([dist / slew_rate, readout])
acc_time += slew_readout_time
prev_dec = dat[0]
prev_ra = dat[1]
return acc_time
def galaxy(params, map_struct, catalog_struct):
nside = params["nside"]
tile_structs = {}
for telescope in params["telescopes"]:
config_struct = params["config"][telescope]
# Combine in a single pointing, galaxies that are distant by
# less than FoV * params['galaxies_FoV_sep']
# Take galaxy with highest proba at the center of new pointing
FoV = params["config"][telescope]['FOV'] * params['galaxies_FoV_sep']
if 'FOV_center' in params["config"][telescope]:
FoV_center = params["config"][telescope]['FOV_center'] * params[
'galaxies_FoV_sep']
else:
FoV_center = params["config"][telescope]['FOV'] * params[
'galaxies_FoV_sep']
new_ra = []
new_dec = []
new_Sloc = []
new_Smass = []
new_S = []
galaxies = []
idxRem = np.arange(len(catalog_struct["ra"])).astype(int)
while len(idxRem) > 0:
ii = idxRem[0]
ra, dec, Sloc, S, Smass = catalog_struct["ra"][ii], catalog_struct[
"dec"][ii], catalog_struct["Sloc"][ii], catalog_struct["S"][
ii], catalog_struct["Smass"][ii]
if config_struct["FOV_type"] == "square":
decCorners = (dec - FoV, dec + FoV)
# assume small enough to use average dec for corners
raCorners = (ra - FoV / np.cos(np.deg2rad(dec)),
ra + FoV / np.cos(np.deg2rad(dec)))
idx1 = np.where(
(catalog_struct["ra"][idxRem] >= raCorners[0])
& (catalog_struct["ra"][idxRem] <= raCorners[1]))[0]
idx2 = np.where(
(catalog_struct["dec"][idxRem] >= decCorners[0])
& (catalog_struct["dec"][idxRem] <= decCorners[1]))[0]
mask = np.intersect1d(idx1, idx2)
if len(mask) > 1:
ra_center, dec_center = get_rectangle(
catalog_struct["ra"][idxRem][mask],
catalog_struct["dec"][idxRem][mask],
FoV / np.cos(np.deg2rad(dec)), FoV)
decCorners = (dec_center - FoV / 2.0,
dec_center + FoV / 2.0)
raCorners = (ra_center - FoV /
(2.0 * np.cos(np.deg2rad(dec))), ra_center +
FoV / (2.0 * np.cos(np.deg2rad(dec))))
idx1 = np.where(
(catalog_struct["ra"][idxRem] >= raCorners[0])
& (catalog_struct["ra"][idxRem] <= raCorners[1]))[0]
idx2 = np.where(
(catalog_struct["dec"][idxRem] >= decCorners[0])
& (catalog_struct["dec"][idxRem] <= decCorners[1]))[0]
mask2 = np.intersect1d(idx1, idx2)
decCorners = (dec_center - FoV_center / 2.0,
dec_center + FoV_center / 2.0)
raCorners = (ra_center - FoV_center /
(2.0 * np.cos(np.deg2rad(dec))), ra_center +
FoV_center / (2.0 * np.cos(np.deg2rad(dec))))
idx1 = np.where(
(catalog_struct["ra"][idxRem] >= raCorners[0])
& (catalog_struct["ra"][idxRem] <= raCorners[1]))[0]
idx2 = np.where(
(catalog_struct["dec"][idxRem] >= decCorners[0])
& (catalog_struct["dec"][idxRem] <= decCorners[1]))[0]
mask3 = np.intersect1d(idx1, idx2)
# did the optimization help?
if (len(mask2) > 2) and (len(mask3) > 0):
mask = mask2
else:
ra_center, dec_center = np.mean(
catalog_struct["ra"][idxRem][mask]), np.mean(
catalog_struct["dec"][idxRem][mask])
elif config_struct["FOV_type"] == "circle":
dist = angular_distance(ra, dec, catalog_struct["ra"][idxRem],
catalog_struct["dec"][idxRem])
mask = np.where((2 * FoV) >= dist)[0]
if len(mask) > 1:
ra_center, dec_center = get_rectangle(
catalog_struct["ra"][idxRem][mask],
catalog_struct["dec"][idxRem][mask],
(FoV / np.sqrt(2)) / np.cos(np.deg2rad(dec)),
FoV / np.sqrt(2))
dist = angular_distance(ra_center, dec_center,
catalog_struct["ra"][idxRem],
catalog_struct["dec"][idxRem])
mask2 = np.where(FoV >= dist)[0]
# did the optimization help?
if len(mask2) > 2:
mask = mask2
else:
ra_center, dec_center = np.mean(
catalog_struct["ra"][idxRem][mask]), np.mean(
catalog_struct["dec"][idxRem][mask])
new_ra.append(ra_center)
new_dec.append(dec_center)
new_Sloc.append(np.sum(catalog_struct["Sloc"][idxRem][mask]))
new_S.append(np.sum(catalog_struct["S"][idxRem][mask]))
new_Smass.append(np.sum(catalog_struct["Smass"][idxRem][mask]))
galaxies.append(idxRem[mask])
idxRem = np.setdiff1d(idxRem, idxRem[mask])
# redefine catalog_struct
catalog_struct_new = {}
catalog_struct_new["ra"] = new_ra
catalog_struct_new["dec"] = new_dec
catalog_struct_new["Sloc"] = new_Sloc
catalog_struct_new["S"] = new_S
catalog_struct_new["Smass"] = new_Smass
catalog_struct_new["galaxies"] = galaxies
moc_struct = {}
cnt = 0
for ra, dec, Sloc, S, Smass, galaxies in zip(
catalog_struct_new["ra"], catalog_struct_new["dec"],
catalog_struct_new["Sloc"], catalog_struct_new["S"],
catalog_struct_new["Smass"], catalog_struct_new["galaxies"]):
moc_struct[cnt] = gwemopt.moc.Fov2Moc(params, config_struct,
telescope, ra, dec, nside)
moc_struct[cnt]["galaxies"] = galaxies
cnt = cnt + 1
if params["timeallocationType"] == "absmag":
tile_struct = absmag_tiles_struct(params, config_struct, telescope,
map_struct, moc_struct)
elif params["timeallocationType"] == "powerlaw":
tile_struct = powerlaw_tiles_struct(params,
config_struct,
telescope,
map_struct,
moc_struct,
catalog_struct=catalog_struct)
tile_struct = gwemopt.segments.get_segments_tiles(
params, config_struct, tile_struct)
cnt = 0
for ra, dec, Sloc, S, Smass, galaxies in zip(
catalog_struct_new["ra"], catalog_struct_new["dec"],
catalog_struct_new["Sloc"], catalog_struct_new["S"],
catalog_struct_new["Smass"], catalog_struct_new["galaxies"]):
if params["galaxy_grade"] == "Sloc":
tile_struct[cnt]['prob'] = Sloc
elif params["galaxy_grade"] == "S":
tile_struct[cnt]['prob'] = S
elif params["galaxy_grade"] == "Smass":
tile_struct[cnt]['prob'] = Smass
tile_struct[cnt]['galaxies'] = galaxies
if config_struct["FOV_type"] == "square":
tile_struct[cnt]['area'] = params["config"][telescope][
'FOV']**2
elif config_struct["FOV_type"] == "circle":
tile_struct[cnt][
'area'] = 4 * np.pi * params["config"][telescope]['FOV']**2
cnt = cnt + 1
tile_structs[telescope] = tile_struct
return tile_structs
def summary(params, map_struct, coverage_struct):
idx50 = len(map_struct["cumprob"]) - np.argmin(
np.abs(map_struct["cumprob"] - 0.50))
idx90 = len(map_struct["cumprob"]) - np.argmin(
np.abs(map_struct["cumprob"] - 0.90))
mapfile = os.path.join(params["outputDir"], 'map.dat')
fid = open(mapfile, 'w')
fid.write('%.5f %.5f\n' % (map_struct["pixarea_deg2"] * idx50,
map_struct["pixarea_deg2"] * idx90))
fid.close()
filts = list(set(coverage_struct["filters"]))
for jj, telescope in enumerate(params["telescopes"]):
schedulefile = os.path.join(params["outputDir"],
'schedule_%s.dat' % telescope)
schedulexmlfile = os.path.join(params["outputDir"],
'schedule_%s.xml' % telescope)
config_struct = params["config"][telescope]
write_xml(schedulexmlfile, map_struct, coverage_struct, config_struct)
if (params["tilesType"] == "hierarchical") or (params["tilesType"]
== "greedy"):
fields = np.zeros((params["Ntiles"][jj], len(filts) + 2))
else:
fields = np.zeros(
(len(config_struct["tesselation"]), len(filts) + 2))
fid = open(schedulefile, 'w')
for ii in range(len(coverage_struct["ipix"])):
if not telescope == coverage_struct["telescope"][ii]:
continue
data = coverage_struct["data"][ii, :]
filt = coverage_struct["filters"][ii]
ipix = coverage_struct["ipix"][ii]
patch = coverage_struct["patch"][ii]
FOV = coverage_struct["FOV"][ii]
area = coverage_struct["area"][ii]
rand = np.random.randint(2)
prob = np.sum(map_struct["prob"][ipix])
ra, dec = data[0], data[1]
observ_time, exposure_time, field_id, prob, airmass = data[
2], data[4], data[5], data[6], data[7]
fid.write('%d %.5f %.5f %.5f %d %.5f %.5f %s %d\n' %
(field_id, ra, dec, observ_time, exposure_time, prob,
airmass, filt, rand))
dist = angular_distance(data[0], data[1],
config_struct["tesselation"][:, 1],
config_struct["tesselation"][:, 2])
idx1 = np.argmin(dist)
idx2 = filts.index(filt)
fields[idx1, 0] = config_struct["tesselation"][idx1, 0]
fields[idx1, 1] = prob
fields[idx1, idx2 + 2] = fields[idx1, idx2 + 2] + 1
fid.close()
idx = np.where(fields[:, 1] > 0)[0]
fields = fields[idx, :]
idx = np.argsort(fields[:, 1])[::-1]
fields = fields[idx, :]
fields_sum = np.sum(fields[:, 2:], axis=1)
idx = np.where(fields_sum >= 2)[0]
print('%d/%d fields were observed at least twice\n' %
(len(idx), len(fields_sum)))
print('Integrated probability, All: %.5f, 2+: %.5f' %
(np.sum(fields[:, 1]), np.sum(fields[idx, 1])))
slew_readout_time = computeSlewReadoutTime(config_struct,
coverage_struct)
print('Expected time spent on slewing and readout ' +
str(slew_readout_time) + ' s.')
coveragefile = os.path.join(params["outputDir"],
'coverage_%s.dat' % telescope)
fid = open(coveragefile, 'w')
for field in fields:
fid.write('%d %.10f ' % (field[0], field[1]))
for ii in range(len(filts)):
fid.write('%d ' % (field[2 + ii]))
fid.write('\n')
fid.close()
summaryfile = os.path.join(params["outputDir"], 'summary.dat')
fid = open(summaryfile, 'w')
gpstime = params["gpstime"]
event_mjd = Time(gpstime, format='gps', scale='utc').mjd
tts = np.array([1, 7, 60])
for tt in tts:
radecs = np.empty((0, 2))
mjds_floor = []
mjds = []
ipixs = np.empty((0, 2))
cum_prob = 0.0
cum_area = 0.0
for ii in range(len(coverage_struct["ipix"])):
data = coverage_struct["data"][ii, :]
filt = coverage_struct["filters"][ii]
ipix = coverage_struct["ipix"][ii]
patch = coverage_struct["patch"][ii]
FOV = coverage_struct["FOV"][ii]
area = coverage_struct["area"][ii]
prob = np.sum(map_struct["prob"][ipix])
if data[2] > event_mjd + tt:
continue
ipixs = np.append(ipixs, ipix)
ipixs = np.unique(ipixs).astype(int)
cum_prob = np.sum(map_struct["prob"][ipixs])
cum_area = len(ipixs) * map_struct["pixarea_deg2"]
mjds.append(data[2])
mjds_floor.append(int(np.floor(data[2])))
if len(mjds_floor) == 0:
print("No images after %.1f days..." % tt)
fid.write('%.1f,-1,-1,-1,-1\n' % (tt))
else:
mjds = np.unique(mjds)
mjds_floor = np.unique(mjds_floor)
print("After %.1f days..." % tt)
print("Number of hours after first image: %.5f" %
(24 * (np.min(mjds) - event_mjd)))
print("MJDs covered: %s" % (" ".join(str(x) for x in mjds_floor)))
print("Cumultative probability: %.5f" % cum_prob)
print("Cumultative area: %.5f degrees" % cum_area)
fid.write('%.1f,%.5f,%.5f,%.5f,%s\n' %
(tt, 24 * (np.min(mjds) - event_mjd), cum_prob, cum_area,
" ".join(str(x) for x in mjds_floor)))
fid.close()
def coverage(params, map_struct, coverage_struct, catalog_struct=None):
unit = 'Gravitational-wave probability'
cbar = False
plotName = os.path.join(params["outputDir"], 'mollview_coverage.pdf')
plt.figure()
hp.mollview(map_struct["prob"], title='', unit=unit, cbar=cbar, cmap=cmap)
hp.projplot(coverage_struct["data"][:, 0],
coverage_struct["data"][:, 1],
'wx',
lonlat=True,
coord='G')
add_edges()
plt.show()
plt.savefig(plotName, dpi=200)
plt.close('all')
idx = np.isfinite(coverage_struct["data"][:, 4])
if not idx.size: return
min_time = np.min(coverage_struct["data"][idx, 4])
max_time = np.max(coverage_struct["data"][idx, 4])
plotName = os.path.join(params["outputDir"], 'coverage.pdf')
plt.figure(figsize=(10, 8))
ax = plt.gca()
for ii in range(len(coverage_struct["ipix"])):
data = coverage_struct["data"][ii, :]
filt = coverage_struct["filters"][ii]
ipix = coverage_struct["ipix"][ii]
patch = coverage_struct["patch"][ii]
FOV = coverage_struct["FOV"][ii]
if filt == "g":
color = "g"
elif filt == "r":
color = "r"
else:
color = "k"
plt.scatter(data[2], data[5], s=20, color=color)
plt.xlabel("Time [MJD]")
plt.ylabel("Tile Number")
plt.show()
plt.savefig(plotName, dpi=200)
plt.close('all')
plotName = os.path.join(params["outputDir"], 'tiles_coverage.pdf')
plt.figure()
hp.mollview(map_struct["prob"], title='', unit=unit, cbar=cbar, cmap=cmap)
add_edges()
ax = plt.gca()
for ii in range(len(coverage_struct["ipix"])):
data = coverage_struct["data"][ii, :]
filt = coverage_struct["filters"][ii]
ipix = coverage_struct["ipix"][ii]
patch = coverage_struct["patch"][ii]
FOV = coverage_struct["FOV"][ii]
#hp.visufunc.projplot(corners[:,0], corners[:,1], 'k', lonlat = True)
if patch == []:
continue
patch_cpy = copy.copy(patch)
patch_cpy.axes = None
patch_cpy.figure = None
patch_cpy.set_transform(ax.transData)
hp.projaxes.HpxMollweideAxes.add_patch(ax, patch_cpy)
#tiles.plot()
plt.show()
plt.savefig(plotName, dpi=200)
plt.close('all')
diffs = []
if params["tilesType"] == "galaxy":
coverage_ras = coverage_struct["data"][:, 0]
coverage_decs = coverage_struct["data"][:, 1]
coverage_mjds = coverage_struct["data"][:, 2]
for ii in range(len(coverage_ras) - 1):
current_ra, current_dec = coverage_ras[ii], coverage_decs[ii]
current_mjd = coverage_mjds[ii]
dist = angular_distance(current_ra, current_dec,
coverage_ras[ii + 1:],
coverage_decs[ii + 1:])
idx = np.where(dist <= 1 / 3600.0)[0]
if len(idx) > 0:
jj = idx[0]
diffs.append(
np.abs(coverage_struct["data"][ii, 2] -
coverage_struct["data"][jj, 2]))
else:
for ii in range(len(coverage_struct["ipix"])):
ipix = coverage_struct["ipix"][ii]
for jj in range(len(coverage_struct["ipix"])):
if ii >= jj: continue
if coverage_struct["telescope"][ii] == coverage_struct[
"telescope"][jj]:
continue
ipix2 = coverage_struct["ipix"][jj]
overlap = np.intersect1d(ipix, ipix2)
rat = np.array([
float(len(overlap)) / float(len(ipix)),
float(len(overlap)) / float(len(ipix2))
])
if np.any(rat > 0.5):
diffs.append(
np.abs(coverage_struct["data"][ii, 2] -
coverage_struct["data"][jj, 2]))
filename = os.path.join(params["outputDir"], 'tiles_coverage_hist.dat')
fid = open(filename, 'w')
for ii in range(len(diffs)):
fid.write('%.10f\n' % diffs[ii])
fid.close()
plotName = os.path.join(params["outputDir"], 'tiles_coverage_hist.pdf')
fig = plt.figure(figsize=(12, 8))
#hist, bin_edges = np.histogram(diffs, bins=20)
bins = np.linspace(0.0, 24.0, 25)
plt.hist(24.0 * np.array(diffs), bins=bins)
plt.xlabel('Difference Between Observations [hours]')
plt.ylabel('Number of Observations')
plt.show()
plt.savefig(plotName, dpi=200)
plt.close('all')
gpstime = params["gpstime"]
event_mjd = Time(gpstime, format='gps', scale='utc').mjd
colors = cm.rainbow(np.linspace(0, 1, len(params["telescopes"])))
plotName = os.path.join(params["outputDir"], 'tiles_coverage_int.pdf')
fig = plt.figure(figsize=(12, 8))
gs = fig.add_gridspec(4, 1)
ax1 = fig.add_subplot(gs[0:3, 0], projection='astro hours mollweide')
ax2 = fig.add_subplot(gs[3, 0])
ax3 = ax2.twinx() # mirror them
plt.axes(ax1)
hp.mollview(map_struct["prob"],
title='',
unit=unit,
cbar=cbar,
cmap=cmap,
hold=True)
add_edges()
ax = plt.gca()
data = {}
if params["tilesType"] == "galaxy":
for telescope, color in zip(params["telescopes"], colors):
idx = np.where(coverage_struct["telescope"] == telescope)[0]
hp.projscatter(coverage_struct["data"][idx, 0],
coverage_struct["data"][idx, 1],
lonlat=True,
s=10,
color=color)
else:
for ii in range(len(coverage_struct["ipix"])):
data = coverage_struct["data"][ii, :]
filt = coverage_struct["filters"][ii]
ipix = coverage_struct["ipix"][ii]
patch = coverage_struct["patch"][ii]
FOV = coverage_struct["FOV"][ii]
idx = params["telescopes"].index(coverage_struct["telescope"][ii])
if patch == []:
continue
#hp.visufunc.projplot(corners[:,0], corners[:,1], 'k', lonlat = True)
patch_cpy = copy.copy(patch)
patch_cpy.axes = None
patch_cpy.figure = None
patch_cpy.set_transform(ax.transData)
patch_cpy.set_facecolor(colors[idx])
hp.projaxes.HpxMollweideAxes.add_patch(ax, patch_cpy)
#tiles.plot()
idxs = np.argsort(coverage_struct["data"][:, 2])
plt.axes(ax2)
for telescope, color in zip(params["telescopes"], colors):
ipixs = np.empty((0, 2))
cum_prob = 0.0
cum_area = 0.0
tts, cum_probs, cum_areas = [], [], []
if params["tilesType"] == "galaxy":
cum_galaxies = []
for jj, ii in enumerate(idxs):
if np.mod(jj, 100) == 0:
print('%s: %d/%d' % (telescope, jj, len(idxs)))
data = coverage_struct["data"][ii, :]
filt = coverage_struct["filters"][ii]
ipix = coverage_struct["ipix"][ii]
patch = coverage_struct["patch"][ii]
FOV = coverage_struct["FOV"][ii]
area = coverage_struct["area"][ii]
if params["tilesType"] == "galaxy":
galaxies = coverage_struct["galaxies"][ii]
if not telescope == coverage_struct["telescope"][ii]:
continue
if params["tilesType"] == "galaxy":
overlap = np.setdiff1d(galaxies, cum_galaxies)
if len(overlap) > 0:
for galaxy in galaxies:
if galaxy in cum_galaxies: continue
if catalog_struct is None: continue
if params["galaxy_grade"] == "Sloc":
cum_prob = cum_prob + catalog_struct["Sloc"][galaxy]
elif params["galaxy_grade"] == "S":
cum_prob = cum_prob + catalog_struct["S"][galaxy]
cum_galaxies = np.append(cum_galaxies, galaxies)
cum_galaxies = np.unique(cum_galaxies).astype(int)
cum_area = len(cum_galaxies)
else:
ipixs = np.append(ipixs, ipix)
ipixs = np.unique(ipixs).astype(int)
cum_prob = np.sum(map_struct["prob"][ipixs])
cum_area = len(ipixs) * map_struct["pixarea_deg2"]
cum_probs.append(cum_prob)
cum_areas.append(cum_area)
tts.append(data[2] - event_mjd)
ax2.plot(tts, cum_probs, color=color, linestyle='-', label=telescope)
ax3.plot(tts, cum_areas, color=color, linestyle='--')
ax2.set_xlabel('Time since event [days]')
if params["tilesType"] == "galaxy":
ax2.set_ylabel('Integrated Metric')
else:
ax2.set_ylabel('Integrated Probability')
if params["tilesType"] == "galaxy":
ax3.set_ylabel('Number of galaxies')
else:
ax3.set_ylabel('Sky area [sq. deg.]')
ipixs = np.empty((0, 2))
cum_prob = 0.0
cum_area = 0.0
tts, cum_probs, cum_areas = [], [], []
if params["tilesType"] == "galaxy":
cum_galaxies = []
for jj, ii in enumerate(idxs):
data = coverage_struct["data"][ii, :]
filt = coverage_struct["filters"][ii]
ipix = coverage_struct["ipix"][ii]
patch = coverage_struct["patch"][ii]
FOV = coverage_struct["FOV"][ii]
area = coverage_struct["area"][ii]
if params["tilesType"] == "galaxy":
galaxies = coverage_struct["galaxies"][ii]
if params["tilesType"] == "galaxy":
overlap = np.setdiff1d(galaxies, cum_galaxies)
if len(overlap) > 0:
for galaxy in galaxies:
if galaxy in cum_galaxies: continue
if catalog_struct is None: continue
if params["galaxy_grade"] == "Sloc":
cum_prob = cum_prob + catalog_struct["Sloc"][galaxy]
elif params["galaxy_grade"] == "S":
cum_prob = cum_prob + catalog_struct["S"][galaxy]
cum_galaxies = np.append(cum_galaxies, galaxies)
cum_galaxies = np.unique(cum_galaxies).astype(int)
cum_area = len(cum_galaxies)
else:
ipixs = np.append(ipixs, ipix)
ipixs = np.unique(ipixs).astype(int)
cum_prob = np.sum(map_struct["prob"][ipixs])
cum_area = len(ipixs) * map_struct["pixarea_deg2"]
tts.append(data[2] - event_mjd)
cum_probs.append(cum_prob)
cum_areas.append(cum_area)
ax2.plot(tts, cum_probs, color='k', linestyle='-', label='All')
ax3.plot(tts, cum_areas, color='k', linestyle='--')
if len(params["telescopes"]) > 3:
ax2.legend(loc=1, ncol=3, fontsize=10)
ax2.set_ylim([0, 1])
ax3.set_ylim([0, 2000])
elif "IRIS" in params["telescopes"]:
ax2.set_ylim([0, 0.3])
ax3.set_ylim([0, 1200])
ax2.legend(loc=1)
elif "ZTF" in params["telescopes"]:
ax2.set_ylim([0, 0.6])
ax3.set_ylim([0, 6000])
ax2.legend(loc=1)
elif "PS1" in params["telescopes"]:
ax2.set_ylim([0, 0.6])
ax3.set_ylim([0, 6000])
ax2.legend(loc=1)
else:
ax2.legend(loc=1)
plt.show()
plt.savefig(plotName, dpi=200)
plt.close('all')
filename = os.path.join(params["outputDir"], 'tiles_coverage_int.dat')
fid = open(filename, 'w')
for ii in range(len(tts)):
fid.write('%.10f %.10e %.10f\n' %
(tts[ii], cum_probs[ii], cum_areas[ii]))
fid.close()
print('Total Cumulative Probability, Area: %.5f, %.5f' %
(cum_probs[-1], cum_areas[-1]))
plotName = os.path.join(params["outputDir"], 'tiles_coverage_scaled.pdf')
plt.figure()
hp.mollview(map_struct["prob"], title='', unit=unit, cbar=cbar, cmap=cmap)
add_edges()
ax = plt.gca()
for ii in range(len(coverage_struct["ipix"])):
data = coverage_struct["data"][ii, :]
filt = coverage_struct["filters"][ii]
ipix = coverage_struct["ipix"][ii]
patch = coverage_struct["patch"][ii]
FOV = coverage_struct["FOV"][ii]
if patch == []:
continue
#hp.visufunc.projplot(corners[:,0], corners[:,1], 'k', lonlat = True)
patch_cpy = copy.copy(patch)
patch_cpy.axes = None
patch_cpy.figure = None
patch_cpy.set_transform(ax.transData)
current_alpha = patch_cpy.get_alpha()
if current_alpha > 0.0:
alpha = data[4] / max_time
if alpha > 1:
alpha = 1.0
patch_cpy.set_alpha(alpha)
hp.projaxes.HpxMollweideAxes.add_patch(ax, patch_cpy)
#tiles.plot()
plt.show()
plt.savefig(plotName, dpi=200)
plt.close('all')
if params["doMovie"]:
idx = np.isfinite(coverage_struct["data"][:, 2])
mjd_min = np.min(coverage_struct["data"][idx, 2])
mjd_max = np.max(coverage_struct["data"][idx, 2])
mjd_N = 100
mjds = np.linspace(mjd_min, mjd_max, num=mjd_N)
moviedir = os.path.join(params["outputDir"], 'movie')
if not os.path.isdir(moviedir): os.mkdir(moviedir)
#for jj in range(len(coverage_struct["ipix"])):
# mjd = coverage_struct["data"][jj,3]
for jj in range(len(mjds)):
mjd = mjds[jj]
plotName = os.path.join(moviedir, 'coverage-%04d.png' % jj)
title = "Coverage Map: %.2f" % mjd
plt.figure()
hp.mollview(map_struct["prob"],
title=title,
unit=unit,
cbar=cbar,
cmap=cmap)
add_edges()
ax = plt.gca()
idx = np.where(coverage_struct["data"][:, 2] <= mjd)[0]
#for ii in range(jj):
for ii in idx:
data = coverage_struct["data"][ii, :]
filt = coverage_struct["filters"][ii]
ipix = coverage_struct["ipix"][ii]
patch = coverage_struct["patch"][ii]
FOV = coverage_struct["FOV"][ii]
if patch == []:
continue
#hp.visufunc.projplot(corners[:,0], corners[:,1], 'k', lonlat = True)
patch_cpy = copy.copy(patch)
patch_cpy.axes = None
patch_cpy.figure = None
patch_cpy.set_transform(ax.transData)
#alpha = data[4]/max_time
#if alpha > 1:
# alpha = 1.0
#patch_cpy.set_alpha(alpha)
hp.projaxes.HpxMollweideAxes.add_patch(ax, patch_cpy)
#tiles.plot()
plt.show()
plt.savefig(plotName, dpi=200)
plt.close('all')
moviefiles = os.path.join(moviedir, "coverage-%04d.png")
filename = os.path.join(params["outputDir"], "coverage.mpg")
ffmpeg_command = 'ffmpeg -an -y -r 20 -i %s -b:v %s %s' % (
moviefiles, '5000k', filename)
os.system(ffmpeg_command)
filename = os.path.join(params["outputDir"], "coverage.gif")
ffmpeg_command = 'ffmpeg -an -y -r 20 -i %s -b:v %s %s' % (
moviefiles, '5000k', filename)
os.system(ffmpeg_command)
rm_command = "rm %s/*.png" % (moviedir)
os.system(rm_command)
