def update_gwemoptconfig(grb_dic, conf_dic, params): """ Update parameters for GRB alert on gwemopt :param gw_dic: :param conf_dic: :param params: dictionary to be used to start gwemopt and that will be updated/completed :return: updated params dictionary """ # For GRB, do false if grb_dic["teles"] == "FERMI": params["do3D"] = False # parsing skymap params["doDatabase"] = True params["dateobs"] = grb_dic["dateobs"] order = hp.nside2order(grb_dic["skymap"]["nside"]) t = rasterize(grb_dic["skymap"]["skymap"], order) result = t['PROB'] flat = hp.reorder(result, 'NESTED', 'RING') params['map_struct'] = {} params['map_struct']['prob'] = flat if params["do3D"]: params["DISTMEAN"] = grb_dic["skymap"]["distmu"] params["DISTSTD"] = grb_dic["skymap"]["distsigma"] # Use galaxies to compute the grade, both for tiling and galaxy # targeting, only when dist_mean + dist_std < 400Mpc if params["DISTMEAN"] + params["DISTSTD"] <= conf_dic["Dist_cut"]: params["doUseCatalog"] = True params["doCatalog"] = True params["writeCatalog"] = True return params
def write_healpix_map(skylocs, nside=16, outdir='./', enable_multiresolution=False, fitsoutname='skymap.fits.gz', nest=True): """ Construct a sky map of the sky localization posterior distribution using Healpix Parameters ========== skylocs : 2d numpy array sky location angle matrix of size Nsamples x 2 [radians] logpvals : array_like log posterior probability values, vector of size Nsamples contour : float or None plot contour enclosing this percentage of probability mass [may be specified multiple times, default: none] theta = EclipticLatitude + np.pi / 2, phi = EclipticLongitude - np.pi """ # Conversion to Ecliptic latitude and longitude latitude = skylocs[:, 0] - np.pi / 2 longitude = skylocs[:, 1] + np.pi # Should we concert into degrees? # latitude *= 180 / np.pi # longitude *= 180 / np.pi # convert angles in right ascension and declination pts = np.column_stack((longitude, latitude)) # Create instance of 2D KDE class skypost = kde.Clustered2DSkyKDE(pts) # # Pickle the skyposterior object # with open(os.path.join(outdir, 'skypost.obj'), 'wb') as out: # pickle.dump(skypost, out) # Making skymap hpmap = skypost.as_healpix() if not enable_multiresolution: hpmap = bayestar.rasterize(hpmap) # Include metadata hpmap.meta.update(io.fits.metadata_for_version_module(version)) hpmap.meta['creator'] = 'Q. Baghi' hpmap.meta['origin'] = 'LISA' hpmap.meta['gps_creation_time'] = Time.now().gps # Write skymap to file if needed io.write_sky_map(os.path.join(outdir, fitsoutname), hpmap, nest=nest)
def flat(self): """Get flat resolution HEALPix dataset, probability density and distance.""" if self.is_3d: order = hp.nside2order(Localization.nside) t = rasterize(self.table, order) result = t['PROB'], t['DISTMU'], t['DISTSIGMA'], t['DISTNORM'] return hp.reorder(result, 'NESTED', 'RING') else: return self.flat_2d,
def plot_skymap(self, maxpts=None, trials=5, jobs=1, enable_multiresolution=True, objid=None, instruments=None, geo=False, dpi=600, transparent=False, colorbar=False, contour=[50, 90], annotate=True, cmap='cylon', load_pickle=False): """ Generate a fits file and sky map from a result Code adapted from ligo.skymap.tool.ligo_skymap_from_samples and ligo.skymap.tool.plot_skymap. Note, the use of this additionally required the installation of ligo.skymap. Parameters ---------- maxpts: int Maximum number of samples to use, if None all samples are used trials: int Number of trials at each clustering number jobs: int Number of multiple threads enable_multiresolution: bool Generate a multiresolution HEALPix map (default: True) objid: str Event ID to store in FITS header instruments: str Name of detectors geo: bool Plot in geographic coordinates (lat, lon) instead of RA, Dec dpi: int Resolution of figure in fots per inch transparent: bool Save image with transparent background colorbar: bool Show colorbar contour: list List of contour levels to use annotate: bool Annotate image with details cmap: str Name of the colormap to use load_pickle: bool, str If true, load the cached pickle file (default name), or the pickle-file give as a path. """ try: from astropy.time import Time from ligo.skymap import io, version, plot, postprocess, bayestar, kde import healpy as hp except ImportError as e: logger.info("Unable to generate skymap: error {}".format(e)) return check_directory_exists_and_if_not_mkdir(self.outdir) logger.info('Reading samples for skymap') data = self.posterior if maxpts is not None and maxpts < len(data): logger.info('Taking random subsample of chain') data = data.sample(maxpts) default_obj_filename = os.path.join( self.outdir, '{}_skypost.obj'.format(self.label)) if load_pickle is False: try: pts = data[['ra', 'dec', 'luminosity_distance']].values confidence_levels = kde.Clustered2Plus1DSkyKDE distance = True except KeyError: logger.warning( "The results file does not contain luminosity_distance") pts = data[['ra', 'dec']].values confidence_levels = kde.Clustered2DSkyKDE distance = False logger.info('Initialising skymap class') skypost = confidence_levels(pts, trials=trials, jobs=jobs) logger.info('Pickling skymap to {}'.format(default_obj_filename)) with open(default_obj_filename, 'wb') as out: pickle.dump(skypost, out) else: if isinstance(load_pickle, str): obj_filename = load_pickle else: obj_filename = default_obj_filename logger.info('Reading from pickle {}'.format(obj_filename)) with open(obj_filename, 'rb') as file: skypost = pickle.load(file) skypost.jobs = jobs distance = isinstance(skypost, kde.Clustered2Plus1DSkyKDE) logger.info('Making skymap') hpmap = skypost.as_healpix() if not enable_multiresolution: hpmap = bayestar.rasterize(hpmap) hpmap.meta.update(io.fits.metadata_for_version_module(version)) hpmap.meta['creator'] = "bilby" hpmap.meta['origin'] = 'LIGO/Virgo' hpmap.meta['gps_creation_time'] = Time.now().gps hpmap.meta['history'] = "" if objid is not None: hpmap.meta['objid'] = objid if instruments: hpmap.meta['instruments'] = instruments if distance: hpmap.meta['distmean'] = np.mean(data['luminosity_distance']) hpmap.meta['diststd'] = np.std(data['luminosity_distance']) try: time = data['geocent_time'] hpmap.meta['gps_time'] = time.mean() except KeyError: logger.warning('Cannot determine the event time from geocent_time') fits_filename = os.path.join(self.outdir, "{}_skymap.fits".format(self.label)) logger.info('Saving skymap fits-file to {}'.format(fits_filename)) io.write_sky_map(fits_filename, hpmap, nest=True) skymap, metadata = io.fits.read_sky_map(fits_filename, nest=None) nside = hp.npix2nside(len(skymap)) # Convert sky map from probability to probability per square degree. deg2perpix = hp.nside2pixarea(nside, degrees=True) probperdeg2 = skymap / deg2perpix if geo: obstime = Time(metadata['gps_time'], format='gps').utc.isot ax = plt.axes(projection='geo degrees mollweide', obstime=obstime) else: ax = plt.axes(projection='astro hours mollweide') ax.grid() # Plot sky map. vmax = probperdeg2.max() img = ax.imshow_hpx((probperdeg2, 'ICRS'), nested=metadata['nest'], vmin=0., vmax=vmax, cmap=cmap) # Add colorbar. if colorbar: cb = plot.colorbar(img) cb.set_label(r'prob. per deg$^2$') if contour is not None: confidence_levels = 100 * postprocess.find_greedy_credible_levels( skymap) contours = ax.contour_hpx((confidence_levels, 'ICRS'), nested=metadata['nest'], colors='k', linewidths=0.5, levels=contour) fmt = r'%g\%%' if rcParams['text.usetex'] else '%g%%' plt.clabel(contours, fmt=fmt, fontsize=6, inline=True) # Add continents. if geo: geojson_filename = os.path.join(os.path.dirname(plot.__file__), 'ne_simplified_coastline.json') with open(geojson_filename, 'r') as geojson_file: geoms = json.load(geojson_file)['geometries'] verts = [ coord for geom in geoms for coord in zip(*geom['coordinates']) ] plt.plot(*verts, color='0.5', linewidth=0.5, transform=ax.get_transform('world')) # Add a white outline to all text to make it stand out from the background. plot.outline_text(ax) if annotate: text = [] try: objid = metadata['objid'] except KeyError: pass else: text.append('event ID: {}'.format(objid)) if contour: pp = np.round(contour).astype(int) ii = np.round( np.searchsorted(np.sort(confidence_levels), contour) * deg2perpix).astype(int) for i, p in zip(ii, pp): text.append(u'{:d}% area: {:d} deg$^2$'.format(p, i)) ax.text(1, 1, '\n'.join(text), transform=ax.transAxes, ha='right') filename = os.path.join(self.outdir, "{}_skymap.png".format(self.label)) logger.info("Generating 2D projected skymap to {}".format(filename)) safe_save_figure(fig=plt.gcf(), filename=filename, dpi=dpi)
def flat_2d(self): """Get flat resolution HEALPix dataset, probability density only.""" order = hp.nside2order(Localization.nside) result = rasterize(self.table_2d, order)['PROB'] return hp.reorder(result, 'NESTED', 'RING')