def diff_flux_threshold(self, skydir, fn, ts_thresh, min_counts):
"""Compute the differential flux threshold for a point source at
position ``skydir`` with spectral parameterization ``fn``.
"""
sig, bkg = self.compute_counts(skydir, fn)
norms = irfs.compute_norm(sig,
bkg,
ts_thresh,
min_counts,
sum_axes=[1, 2])
npred = np.squeeze(np.apply_over_axes(np.sum, norms * sig, [1, 2]))
norms = np.squeeze(norms)
flux = norms * fn.flux(self.ebins[:-1], self.ebins[1:])
eflux = norms * fn.eflux(self.ebins[:-1], self.ebins[1:])
dnde = norms * fn.dnde(self.ectr)
e2dnde = self.ectr**2 * dnde
return dict(e_min=self.ebins[:-1],
e_max=self.ebins[1:],
e_ref=self.ectr,
npred=npred,
flux=flux,
eflux=eflux,
dnde=dnde,
e2dnde=e2dnde)
def int_flux_threshold(self, skydir, fn, ts_thresh, min_counts):
"""Compute the integral flux threshold for a point source at
position ``skydir`` with spectral parameterization ``fn``.
"""
ebins = 10**np.linspace(np.log10(self.ebins[0]),
np.log10(self.ebins[-1]), 33)
ectr = np.sqrt(ebins[0] * ebins[-1])
sig, bkg, bkg_fit = self.compute_counts(skydir, fn, ebins)
norms = irfs.compute_norm(sig,
bkg,
ts_thresh,
min_counts,
sum_axes=[1, 2, 3],
bkg_fit=bkg_fit,
rebin_axes=[4, 10, 1])
npred = np.squeeze(np.apply_over_axes(np.sum, norms * sig, [1, 2, 3]))
npred = np.array(npred, ndmin=1)
flux = np.squeeze(norms) * fn.flux(ebins[0], ebins[-1])
eflux = np.squeeze(norms) * fn.eflux(ebins[0], ebins[-1])
dnde = np.squeeze(norms) * fn.dnde(ectr)
e2dnde = ectr**2 * dnde
o = dict(e_min=self.ebins[0],
e_max=self.ebins[-1],
e_ref=ectr,
npred=npred,
flux=flux,
eflux=eflux,
dnde=dnde,
e2dnde=e2dnde)
sig, bkg, bkg_fit = self.compute_counts(skydir, fn)
npred = np.squeeze(np.apply_over_axes(np.sum, norms * sig, [2, 3]))
flux = np.squeeze(
np.squeeze(norms, axis=(1, 2, 3))[:, None] *
fn.flux(self.ebins[:-1], self.ebins[1:]))
eflux = np.squeeze(
np.squeeze(norms, axis=(1, 2, 3))[:, None] *
fn.eflux(self.ebins[:-1], self.ebins[1:]))
dnde = np.squeeze(
np.squeeze(norms, axis=(1, 2, 3))[:, None] * fn.dnde(self.ectr))
e2dnde = ectr**2 * dnde
o['bins'] = dict(npred=npred,
flux=flux,
eflux=eflux,
dnde=dnde,
e2dnde=e2dnde,
e_min=self.ebins[:-1],
e_max=self.ebins[1:],
e_ref=self.ectr)
return o
def int_flux_threshold(self, skydir, fn, ts_thresh, min_counts):
"""Compute the integral flux threshold for a point source at
position ``skydir`` with spectral parameterization ``fn``.
"""
ebins = 10**np.linspace(np.log10(self.ebins[0]),
np.log10(self.ebins[-1]), 33)
ectr = np.sqrt(ebins[0] * ebins[-1])
sig, bkg, bkg_fit = self.compute_counts(skydir, fn, ebins)
norms = irfs.compute_norm(sig, bkg, ts_thresh,
min_counts, sum_axes=[1, 2, 3], bkg_fit=bkg_fit,
rebin_axes=[4, 10, 1])
npred = np.squeeze(np.apply_over_axes(np.sum, norms * sig, [1, 2, 3]))
npred = np.array(npred, ndmin=1)
flux = np.squeeze(norms) * fn.flux(ebins[0], ebins[-1])
eflux = np.squeeze(norms) * fn.eflux(ebins[0], ebins[-1])
dnde = np.squeeze(norms) * fn.dnde(ectr)
e2dnde = ectr**2 * dnde
o = dict(e_min=self.ebins[0], e_max=self.ebins[-1], e_ref=ectr,
npred=npred, flux=flux, eflux=eflux,
dnde=dnde, e2dnde=e2dnde)
sig, bkg, bkg_fit = self.compute_counts(skydir, fn)
npred = np.squeeze(np.apply_over_axes(np.sum, norms * sig,
[2, 3]))
flux = np.squeeze(np.squeeze(norms, axis=(1, 2, 3))[:, None] *
fn.flux(self.ebins[:-1], self.ebins[1:]))
eflux = np.squeeze(np.squeeze(norms, axis=(1, 2, 3))[:, None] *
fn.eflux(self.ebins[:-1], self.ebins[1:]))
dnde = np.squeeze(np.squeeze(norms, axis=(1, 2, 3))
[:, None] * fn.dnde(self.ectr))
e2dnde = ectr**2 * dnde
o['bins'] = dict(npred=npred,
flux=flux,
eflux=eflux,
dnde=dnde,
e2dnde=e2dnde,
e_min=self.ebins[:-1], e_max=self.ebins[1:],
e_ref=self.ectr)
return o
def diff_flux_threshold(self, skydir, fn, ts_thresh, min_counts):
"""Compute the differential flux threshold for a point source at
position ``skydir`` with spectral parameterization ``fn``.
Parameters
----------
skydir : `~astropy.coordinates.SkyCoord`
Sky coordinates at which the sensitivity will be evaluated.
fn : `~fermipy.spectrum.SpectralFunction`
ts_thresh : float
Threshold on the detection test statistic (TS).
min_counts : float
Threshold on the minimum number of counts.
"""
sig, bkg, bkg_fit = self.compute_counts(skydir, fn)
norms = irfs.compute_norm(sig,
bkg,
ts_thresh,
min_counts,
sum_axes=[2, 3],
rebin_axes=[10, 1],
bkg_fit=bkg_fit)
npred = np.squeeze(np.apply_over_axes(np.sum, norms * sig, [2, 3]))
norms = np.squeeze(norms)
flux = norms * fn.flux(self.ebins[:-1], self.ebins[1:])
eflux = norms * fn.eflux(self.ebins[:-1], self.ebins[1:])
dnde = norms * fn.dnde(self.ectr)
e2dnde = self.ectr**2 * dnde
return dict(e_min=self.ebins[:-1],
e_max=self.ebins[1:],
e_ref=self.ectr,
npred=npred,
flux=flux,
eflux=eflux,
dnde=dnde,
e2dnde=e2dnde)
def diff_flux_threshold(self, skydir, fn, ts_thresh, min_counts):
"""Compute the differential flux threshold for a point source at
position ``skydir`` with spectral parameterization ``fn``.
"""
sig, bkg = self.compute_counts(skydir, fn)
norms = irfs.compute_norm(sig, bkg, ts_thresh,
min_counts, sum_axes=[1, 2])
npred = np.squeeze(np.apply_over_axes(np.sum, norms * sig, [1, 2]))
norms = np.squeeze(norms)
flux = norms * fn.flux(self.ebins[:-1], self.ebins[1:])
eflux = norms * fn.eflux(self.ebins[:-1], self.ebins[1:])
dnde = norms * fn.dnde(self.ectr)
e2dnde = self.ectr**2 * dnde
return dict(e_min=self.ebins[:-1], e_max=self.ebins[1:],
e_ref=self.ectr,
npred=npred, flux=flux, eflux=eflux,
dnde=dnde, e2dnde=e2dnde)
def diff_flux_threshold(self, skydir, fn, ts_thresh, min_counts):
"""Compute the differential flux threshold for a point source at
position ``skydir`` with spectral parameterization ``fn``.
Parameters
----------
skydir : `~astropy.coordinates.SkyCoord`
Sky coordinates at which the sensitivity will be evaluated.
fn : `~fermipy.spectrum.SpectralFunction`
ts_thresh : float
Threshold on the detection test statistic (TS).
min_counts : float
Threshold on the minimum number of counts.
"""
sig, bkg, bkg_fit = self.compute_counts(skydir, fn)
norms = irfs.compute_norm(sig, bkg, ts_thresh,
min_counts, sum_axes=[2, 3],
rebin_axes=[10, 1],
bkg_fit=bkg_fit)
npred = np.squeeze(np.apply_over_axes(np.sum, norms * sig, [2, 3]))
norms = np.squeeze(norms)
flux = norms * fn.flux(self.ebins[:-1], self.ebins[1:])
eflux = norms * fn.eflux(self.ebins[:-1], self.ebins[1:])
dnde = norms * fn.dnde(self.ectr)
e2dnde = self.ectr**2 * dnde
return dict(e_min=self.ebins[:-1], e_max=self.ebins[1:],
e_ref=self.ectr,
npred=npred, flux=flux, eflux=eflux,
dnde=dnde, e2dnde=e2dnde)