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)