def _significance_cube(self, cubes): p = self.parameters if p['method'] == 'lima': scube = significance(cubes['counts'], cubes['background'], method='lima') elif p['method'] == 'simple': scube = significance(cubes['counts'], cubes['background'], method='simple') elif p['method'] == 'asmooth': scube = _significance_asmooth(cubes['counts'], cubes['background']) elif p['method'] == 'ts': raise NotImplementedError else: raise ValueError("Not a valid significance estimation method." " Choose one of the following: 'lima', 'simple'," " 'asmooth' or 'ts'") return scube
def cli(n_observed, mu_background, method): """Compute significance for a Poisson count observation. The significance is the tail probability to observe N_OBSERVED counts or more, given a known background level MU_BACKGROUND.""" s = significance(n_observed, mu_background, method) print(s)
def info_dict(self, in_safe_energy_range=True): """Info dict with summary statistics, summed over energy Parameters ---------- in_safe_energy_range : bool Whether to sum only in the safe energy range Returns ------- info_dict : dict Dictionary with summary info. """ info = dict() mask = self.mask_safe if in_safe_energy_range else slice(None) info["name"] = self.name info["livetime"] = self.livetime.copy() info["n_on"] = self.counts.data[mask].sum() info["background"] = self.background.data[mask].sum() info["excess"] = self.excess.data[mask].sum() info["significance"] = significance( self.counts.data[mask].sum(), self.background.data[mask].sum(), ) info["background_rate"] = info["background"] / info["livetime"] info["gamma_rate"] = info["excess"] / info["livetime"] return info
def make_significance_image(): counts_image = fits.open("counts_image.fits")[1] bkg_image = fits.open("bkg_image.fits")[1] counts = disk_correlate(counts_image.data, 10) bkg = disk_correlate(bkg_image.data, 10) s = significance(counts, bkg) s_image = fits.ImageHDU(data=s, header=counts_image.header) s_image.writeto("significance_image.fits", clobber=True)
def compute_correlated_maps(self, kernel): """Compute significance image for a given kernel. """ self.counts_corr = convolve(self.counts, kernel) self.background_corr = convolve(self.background, kernel) self.significance = significance(self.counts_corr, self.background_corr) return self
def compute_correlated_maps(self, kernel): """Compute significance image for a given kernel. """ #import IPython; IPython.embed() self.counts_corr = convolve(self.counts, kernel) self.background_corr = convolve(self.background, kernel) self.significance = significance(self.counts_corr, self.background_corr) return self
def test_significance_on_off_against_known_background(): # Check that the Li & Ma limit formula is correct # With small alpha and high counts, the significance # and significance_on_off should be very close actual = significance(n_on=1300, mu_bkg=1100, method="lima") assert_allclose(actual, 5.8600870406703329) actual = significance_on_off(n_on=1300, n_off=1100 / 1.0e-8, alpha=1e-8, method="lima") assert_allclose(actual, 5.8600864348078519)
def _significance_cube(cubes, method): if method in {"lima", "simple"}: scube = significance(cubes["counts"], cubes["background"], method="lima") elif method == "asmooth": scube = _significance_asmooth(cubes["counts"], cubes["background"]) elif method == "ts": raise NotImplementedError() else: raise ValueError("Not a valid significance estimation method." " Choose one of the following: 'lima', 'simple'," " 'asmooth' or 'ts'") return scube
def residual_images(model_file, data_file, out_file, thetas, overwrite): """Compute source model residual images. The input `data_file` must contain the following HDU extensions: * 'On' -- Counts image * 'Background' -- Background image """ import logging logging.basicConfig(level=logging.DEBUG, format='%(levelname)s - %(message)s') import numpy as np from astropy.io import fits from gammapy.image import disk_correlate from gammapy.stats import significance logging.info('Reading {0}'.format(data_file)) hdu_list = fits.open(data_file) header = hdu_list[0].header counts = hdu_list['On'].data.astype(np.float64) background = hdu_list['Background'].data.astype(np.float64) diffuse = hdu_list['Diffuse'].data.astype(np.float64) logging.info('Reading {0}'.format(model_file)) model = fits.getdata(model_file) background_plus_model_diffuse = background + model + diffuse out_hdu_list = fits.HDUList() for theta in thetas: logging.info('Processing theta = {0} deg'.format(theta)) theta_pix = theta / header['CDELT2'] counts_corr = disk_correlate(counts, theta_pix) background_plus_model_corr = disk_correlate( background_plus_model_diffuse, theta_pix) # excess_corr = counts_corr - background_plus_model_corr significance_corr = significance(counts_corr, background_plus_model_corr) name = 'RESIDUAL_SIGNIFICANCE_{0}'.format(theta) logging.info('Appending HDU extension: {0}'.format(name)) hdu = fits.ImageHDU(significance_corr, header, name) out_hdu_list.append(hdu) logging.info('Writing {0}'.format(out_file)) out_hdu_list.writeto(out_file, clobber=overwrite)
def significance_image(self, radius): """Make the significance image from the counts and bkg images. Parameters ---------- radius : float Disk radius in pixels. """ image = SkyImage.empty_like(self.empty_image) disk = Tophat2DKernel(radius) disk.normalize('peak') counts = self.images["counts"].convolve(disk.array) bkg = self.images["bkg"].convolve(disk.array) image.data = significance(counts.data, bkg.data) self.images["significance"] = image
def residual_images(model_file, data_file, out_file, thetas, overwrite): """Compute source model residual images. The input `data_file` must contain the following HDU extensions: * 'On' -- Counts image * 'Background' -- Background image """ import numpy as np from astropy.io import fits from gammapy.image import disk_correlate from gammapy.stats import significance log.info('Reading {0}'.format(data_file)) hdu_list = fits.open(data_file) header = hdu_list[0].header counts = hdu_list['On'].data.astype(np.float64) background = hdu_list['Background'].data.astype(np.float64) diffuse = hdu_list['Diffuse'].data.astype(np.float64) log.info('Reading {0}'.format(model_file)) model = fits.getdata(model_file) background_plus_model_diffuse = background + model + diffuse out_hdu_list = fits.HDUList() for theta in thetas: log.info('Processing theta = {0} deg'.format(theta)) theta_pix = theta / header['CDELT2'] counts_corr = disk_correlate(counts, theta_pix) background_plus_model_corr = disk_correlate(background_plus_model_diffuse, theta_pix) # excess_corr = counts_corr - background_plus_model_corr significance_corr = significance(counts_corr, background_plus_model_corr) name = 'RESIDUAL_SIGNIFICANCE_{0}'.format(theta) log.info('Appending HDU extension: {0}'.format(name)) hdu = fits.ImageHDU(significance_corr, header, name) out_hdu_list.append(hdu) log.info('Writing {0}'.format(out_file)) out_hdu_list.writeto(out_file, clobber=overwrite)
def compute_lima_image(counts, background, kernel): """Compute Li & Ma significance and flux images for known background. Parameters ---------- counts : `~gammapy.maps.WcsNDMap` Counts image background : `~gammapy.maps.WcsNDMap` Background image kernel : `astropy.convolution.Kernel2D` Convolution kernel Returns ------- images : dict Dictionary containing result maps Keys are: significance, counts, background and excess See Also -------- gammapy.stats.significance """ # Kernel is modified later make a copy here kernel = copy.deepcopy(kernel) kernel.normalize("peak") # fft convolution adds numerical noise, to ensure integer results we call # np.rint counts_conv = np.rint(counts.convolve(kernel.array).data) background_conv = background.convolve(kernel.array).data excess_conv = counts_conv - background_conv significance_conv = significance(counts_conv, background_conv, method="lima") return { "significance": counts.copy(data=significance_conv), "counts": counts.copy(data=counts_conv), "background": counts.copy(data=background_conv), "excess": counts.copy(data=excess_conv), }
from gammapy.stats import significance from gammapy.image.utils import disk_correlate from aplpy import FITSFigure from npred_general import prepare_images model, gtmodel, ratio, counts, header = prepare_images() # Top hat correlation correlation_radius = 3 correlated_gtmodel = disk_correlate(gtmodel, correlation_radius) correlated_counts = disk_correlate(counts, correlation_radius) correlated_model = disk_correlate(model, correlation_radius) # Fermi significance fermi_significance = np.nan_to_num(significance(correlated_counts, gtmodel, method='lima')) # Gammapy significance significance = np.nan_to_num(significance(correlated_counts, correlated_model, method='lima')) titles = ['Gammapy Significance', 'Fermi Tools Significance'] # Plot fig = plt.figure(figsize=(10, 5)) hdu1 = fits.ImageHDU(significance, header) f1 = FITSFigure(hdu1, figure=fig, convention='wells', subplot=(1, 2, 1)) f1.set_tick_labels_font(size='x-small') f1.tick_labels.set_xformat('ddd') f1.tick_labels.set_yformat('ddd') f1.show_colorscale(vmin=0, vmax=10, cmap='afmhot')
from gammapy.stats import significance from gammapy.image.utils import disk_correlate from npred_general import prepare_images from aplpy import FITSFigure model, gtmodel, ratio, counts, header = prepare_images() # Top hat correlation correlation_radius = 3 correlated_gtmodel = disk_correlate(gtmodel, correlation_radius) correlated_counts = disk_correlate(counts, correlation_radius) correlated_model = disk_correlate(model, correlation_radius) # Fermi significance fermi_significance = np.nan_to_num(significance(correlated_counts, gtmodel, method='lima')) # Gammapy significance significance = np.nan_to_num(significance(correlated_counts, correlated_model, method='lima')) titles = ['Gammapy Significance', 'Fermi Tools Significance'] # Plot fig = plt.figure(figsize=(10, 5)) hdu1 = fits.ImageHDU(significance, header) f1 = FITSFigure(hdu1, figure=fig, convention='wells', subplot=(1,2,1)) f1.set_tick_labels_font(size='x-small') f1.tick_labels.set_xformat('ddd') f1.tick_labels.set_yformat('ddd') f1.show_colorscale(vmin=0, vmax=10, cmap='afmhot')
"""Plot significance image with HESS and MILAGRO colormap. """ import numpy as np import matplotlib.pyplot as plt from gammapy.datasets import load_poisson_stats_image from gammapy.image import disk_correlate from gammapy.stats import significance from gammapy.image import colormap_hess, colormap_milagro from astropy.visualization.mpl_normalize import ImageNormalize from astropy.visualization import LinearStretch # Compute an example significance image counts = load_poisson_stats_image() counts = disk_correlate(counts, radius=5, mode='reflect') background = np.median(counts) * np.ones_like(counts) image = significance(counts, background) # Plot with the HESS and Milagro colormap vmin, vmax, vtransition = -5, 15, 5 plt.figure(figsize=(8, 4)) normalize = ImageNormalize(vmin=vmin, vmax=vmax, stretch=LinearStretch()) transition = normalize(vtransition) plt.subplot(121) cmap = colormap_hess(transition=transition) plt.imshow(image, cmap=cmap, norm=normalize) plt.axis('off') plt.colorbar() plt.title('HESS-style colormap')
from gammapy.image.utils import disk_correlate from aplpy import FITSFigure from npred_general import prepare_images model, gtmodel, ratio, counts, header = prepare_images() # Top hat correlation correlation_radius = 3 correlated_gtmodel = disk_correlate(gtmodel, correlation_radius) correlated_counts = disk_correlate(counts, correlation_radius) correlated_model = disk_correlate(model, correlation_radius) # Fermi significance fermi_significance = np.nan_to_num( significance(correlated_counts, gtmodel, method='lima')) # Gammapy significance significance = np.nan_to_num( significance(correlated_counts, correlated_model, method='lima')) titles = ['Gammapy Significance', 'Fermi Tools Significance'] # Plot fig = plt.figure(figsize=(10, 5)) hdu1 = fits.ImageHDU(significance, header) f1 = FITSFigure(hdu1, figure=fig, convention='wells', subplot=(1, 2, 1)) f1.set_tick_labels_font(size='x-small') f1.tick_labels.set_xformat('ddd') f1.tick_labels.set_yformat('ddd') f1.show_colorscale(vmin=0, vmax=10, cmap='afmhot')
def test_significance(p): s = significance(p["n_on"], p["mu_bkg"], p["method"]) assert_allclose(s, p["s"], atol=1e-5)
show_image(images['excess'], vmax=2) # In[18]: # Significance image # Just for fun, let's compute it by hand ... from astropy.convolution import Tophat2DKernel kernel = Tophat2DKernel(4) kernel.normalize('peak') counts_conv = images['counts'].convolve(kernel.array) background_conv = images['background'].convolve(kernel.array) from gammapy.stats import significance significance_image = SkyImage.empty_like(ref_image) significance_image.data = significance(counts_conv.data, background_conv.data) show_image(significance_image, vmax=8) # ## Source Detection # # Use the class [TSImageEstimator](http://docs.gammapy.org/dev/api/gammapy.detect.compute_ts_image.html#gammapy.detect.TSImageEstimator.html) and [photutils.find_peaks](http://photutils.readthedocs.io/en/stable/api/photutils.find_peaks.html) to detect point-like sources on the images: # In[19]: # cut out smaller piece of the PSF image to save computing time # for covenience we're "misusing" the SkyImage class represent the PSF on the sky. kernel = images['psf'].cutout(target_position, size=1.1 * u.deg) kernel.show() # In[20]: