Source code for gammapy.stats.poisson

# Licensed under a 3-clause BSD style license - see LICENSE.rst
"""Poisson significance computations for these two cases.

* known background level ``mu_bkg``
* background estimated from ``n_off`
"""
import numpy as np
from scipy.stats import norm, poisson
from scipy.special import erf
from scipy.optimize import fsolve
from .normal import significance_to_probability_normal

__all__ = [
    "background",
    "background_error",
    "excess",
    "excess_error",
    "significance",
    "significance_on_off",
    "excess_matching_significance",
    "excess_matching_significance_on_off",
    "excess_ul_helene",
]

__doctest_skip__ = ["*"]


[docs]def background(n_off, alpha): r"""Estimate background in the on-region from an off-region observation. .. math:: \mu_{background} = \alpha \times n_{off} Parameters ---------- n_off : array_like Observed number of counts in the off region alpha : array_like On / off region exposure ratio for background events Returns ------- background : `numpy.ndarray` Background estimate for the on region Examples -------- >>> background(n_off=4, alpha=0.1) 0.4 >>> background(n_off=9, alpha=0.2) 1.8 """ n_off = np.asanyarray(n_off, dtype=np.float64) alpha = np.asanyarray(alpha, dtype=np.float64) return alpha * n_off
[docs]def background_error(n_off, alpha): r"""Estimate standard error on background in the on region from an off-region observation. .. math:: \Delta\mu_{bkg} = \alpha \times \sqrt{n_{off}} Parameters ---------- n_off : array_like Observed number of counts in the off region alpha : array_like On / off region exposure ratio for background events Returns ------- background : `numpy.ndarray` Background estimate for the on region Examples -------- >>> background_error(n_off=4, alpha=0.1) 0.2 >>> background_error(n_off=9, alpha=0.2) 0.6 """ n_off = np.asanyarray(n_off, dtype=np.float64) alpha = np.asanyarray(alpha, dtype=np.float64) return alpha * np.sqrt(n_off)
[docs]def excess(n_on, n_off, alpha): r"""Estimate excess in the on region for an on-off observation. .. math:: \mu_{excess} = n_{on} - \alpha \times n_{off} Parameters ---------- n_on : array_like Observed number of counts in the on region n_off : array_like Observed number of counts in the off region alpha : array_like On / off region exposure ratio for background events Returns ------- excess : `numpy.ndarray` Excess estimate for the on region Examples -------- >>> excess(n_on=10, n_off=20, alpha=0.1) 8.0 >>> excess(n_on=4, n_off=9, alpha=0.5) -0.5 """ n_on = np.asanyarray(n_on, dtype=np.float64) n_off = np.asanyarray(n_off, dtype=np.float64) alpha = np.asanyarray(alpha, dtype=np.float64) return n_on - alpha * n_off
[docs]def excess_error(n_on, n_off, alpha): r"""Estimate error on excess for an on-off measurement. .. math:: \Delta\mu_{excess} = \sqrt{n_{on} + \alpha ^ 2 \times n_{off}} TODO: Implement better error and limit estimates (Li & Ma, Rolke)! Parameters ---------- n_on : array_like Observed number of counts in the on region n_off : array_like Observed number of counts in the off region alpha : array_like On / off region exposure ratio for background events Returns ------- excess_error : `numpy.ndarray` Excess error estimate Examples -------- >>> excess_error(n_on=10, n_off=20, alpha=0.1) 3.1937438845342623... >>> excess_error(n_on=4, n_off=9, alpha=0.5) 2.5 """ n_on = np.asanyarray(n_on, dtype=np.float64) n_off = np.asanyarray(n_off, dtype=np.float64) alpha = np.asanyarray(alpha, dtype=np.float64) variance = n_on + (alpha ** 2) * n_off return np.sqrt(variance)
[docs]def significance(n_on, mu_bkg, method="lima", n_on_min=1): r"""Compute significance for an observed number of counts and known background. The default ``method="lima"`` gives the significance estimate corresponding to equation (17) from the Li & Ma paper [1]_ in the limiting of known background :math:`\mu_{bkg} = \alpha \times n_{off}` with :math:`\alpha \to 0`. It is given by the following formula: .. math:: S_{lima} = \left[ 2 n_{on} \log \left( \frac{n_{on}}{\mu_{bkg}} \right) - n_{on} + \mu_{bkg} \right] ^ {1/2} For ``method="simple"``, the significance estimate is given by: .. math:: S_{simple} = (n_{on} - \mu_{bkg}) / \sqrt{\mu_{bkg}} Parameters ---------- n_on : array_like Observed number of counts mu_bkg : array_like Known background level method : {"lima", "simple"} Method for significance estimation n_on_min : float Minimum ``n_on`` (return ``NaN`` for smaller values) Returns ------- significance : `~numpy.ndarray` Significance estimate References ---------- .. [1] Li and Ma, "Analysis methods for results in gamma-ray astronomy", `Link <https://ui.adsabs.harvard.edu/abs/1983ApJ...272..317L>`_ See Also -------- excess, significance_on_off Examples -------- >>> significance(n_on=10, mu_bkg=2, method='lima') 4.0235256 >>> significance(n_on=10, mu_bkg=2, method='simple') 5.65685425 """ n_on = np.asanyarray(n_on, dtype=np.float64) mu_bkg = np.asanyarray(mu_bkg, dtype=np.float64) if method == "simple": func = _significance_simple elif method == "lima": func = _significance_lima elif method == "direct": func = _significance_direct else: raise ValueError("Invalid method: {}".format(method)) # For low `n_on` values, don't try to compute a significance and return `NaN`. n_on = np.atleast_1d(n_on) mu_bkg = np.atleast_1d(mu_bkg) mask = n_on >= n_on_min s = np.ones_like(n_on) * np.nan s[mask] = func(n_on[mask], mu_bkg[mask]) return s
def _significance_simple(n_on, mu_bkg): # TODO: check this formula against ??? # Is this the limit from the on/off case for alpha -> 0? excess = n_on - mu_bkg bkg_err = np.sqrt(mu_bkg) return excess / bkg_err def _significance_lima(n_on, mu_bkg): sign = np.sign(n_on - mu_bkg) val = np.sqrt(2) * np.sqrt(n_on * np.log(n_on / mu_bkg) - n_on + mu_bkg) return sign * val
[docs]def significance_on_off(n_on, n_off, alpha, method="lima"): r"""Compute significance of an on-off observation. The default ``method="lima"`` gives the significance estimate corresponding to equation (17) from the Li & Ma paper [1]_. For ``method="simple"``, the significance estimate is given by Equation (5) from the Li & Ma paper [1]_. It is somewhat biased, but has the advantage of being analytically invertible, which is useful for sensitivity computations. .. math:: S_{simple} = \mu_{excess} / \Delta\mu_{excess} \mu_{excess} = n_{on} - \alpha n_{off} \Delta\mu_{excess} = \sqrt{n_{on} + \alpha ^ 2 n_{off}} Parameters ---------- n_on : array_like Observed number of counts in the on region n_off : array_like Observed number of counts in the off region alpha : array_like On / off region exposure ratio for background events method : {"lima", "simple"} Method for significance estimation Returns ------- significance : `~numpy.ndarray` Significance estimate References ---------- .. [1] Li and Ma, "Analysis methods for results in gamma-ray astronomy", `Link <https://ui.adsabs.harvard.edu/abs/1983ApJ...272..317L>`_ See Also -------- significance, excess_matching_significance_on_off Examples -------- >>> significance_on_off(n_on=10, n_off=20, alpha=0.1, method='lima') 3.6850322319420274 >>> significance_on_off(n_on=10, n_off=20, alpha=0.1, method='simple') 2.5048971643405982 """ n_on = np.asanyarray(n_on, dtype=np.float64) n_off = np.asanyarray(n_off, dtype=np.float64) alpha = np.asanyarray(alpha, dtype=np.float64) with np.errstate(invalid="ignore", divide="ignore"): if method == "simple": return _significance_simple_on_off(n_on, n_off, alpha) elif method == "lima": return _significance_lima_on_off(n_on, n_off, alpha) elif method == "direct": return _significance_direct_on_off(n_on, n_off, alpha) else: raise ValueError("Invalid method: {}".format(method))
def _significance_simple_on_off(n_on, n_off, alpha): """Compute significance with the simple Equation (5) from Li & Ma.""" excess_ = excess(n_on, n_off, alpha) excess_error_ = excess_error(n_on, n_off, alpha) return excess_ / excess_error_ def _significance_lima_on_off(n_on, n_off, alpha): r"""Compute significance with the Li & Ma formula (17).""" sign = np.sign(excess(n_on, n_off, alpha)) tt = (alpha + 1) / (n_on + n_off) ll = n_on * np.log(n_on * tt / alpha) mm = n_off * np.log(n_off * tt) val = np.sqrt(np.abs(2 * (ll + mm))) return sign * val def _significance_direct(n_on, mu_bkg): """Compute significance directly via Poisson probability. Reference: TODO (is this ever used?) """ # Compute tail probability to see n_on or more counts # Note that we're using ``k = n_on - 1`` to get the probability # for n_on included or more, because `poisson.sf(k)` returns the # probability for more than k, with k excluded # For `n_on = 0` this returns ` probability = poisson.sf(n_on - 1, mu_bkg) # Convert probability to a significance return norm.isf(probability) def _significance_direct_on_off(n_on, n_off, alpha): """Compute significance directly via Poisson probability. Reference: https://ui.adsabs.harvard.edu/abs/1993NIMPA.328..570A You can use this method for small n_on < 10. In this case the Li & Ma formula isn't correct any more. """ f = np.math.factorial # Not vectorised, only works for scalar, integer inputs n_on = int(n_on) n_off = int(n_off) # Compute tail probability to see n_on or more counts probability = 1 for n in range(0, n_on): term_1 = alpha ** n / (1 + alpha) ** (n_off + n + 1) term_2 = f(n_off + n) / (f(n) * f(n_off)) probability -= term_1 * term_2 # Convert probability to a significance return norm.isf(probability)
[docs]def excess_ul_helene(excess, excess_error, significance): """Compute excess upper limit using the Helene method. Reference: https://ui.adsabs.harvard.edu/abs/1984NIMPA.228..120H Parameters ---------- excess : float Signal excess excess_error : float Gaussian excess error For on / off measurement, use this function to compute it: `~gammapy.stats.excess_error`. significance : float Confidence level significance for the excess upper limit. Returns ------- excess_ul : float Upper limit for the excess """ conf_level1 = significance_to_probability_normal(significance) if excess_error <= 0: raise ValueError("Non-positive excess_error: {}".format(excess_error)) if excess >= 0.0: zeta = excess / excess_error value = zeta / np.sqrt(2.0) integral = (1.0 + erf(value)) / 2.0 integral2 = 1.0 - conf_level1 * integral value_old = value value_new = value_old + 0.01 if integral > integral2: value_new = 0.0 integral = (1.0 + erf(value_new)) / 2.0 else: zeta = -excess / excess_error value = zeta / np.sqrt(2.0) integral = 1 - (1.0 + erf(value)) / 2.0 integral2 = 1.0 - conf_level1 * integral value_old = value value_new = value_old + 0.01 integral = (1.0 + erf(value_new)) / 2.0 # The 1st Loop is for Speed & 2nd For Precision while integral < integral2: value_old = value_new value_new = value_new + 0.01 integral = (1.0 + erf(value_new)) / 2.0 value_new = value_old + 0.0000001 integral = (1.0 + erf(value_new)) / 2.0 while integral < integral2: value_new = value_new + 0.0000001 integral = (1.0 + erf(value_new)) / 2.0 value_new = value_new * np.sqrt(2.0) if excess >= 0.0: conf_limit = (value_new + zeta) * excess_error else: conf_limit = (value_new - zeta) * excess_error return conf_limit
[docs]def excess_matching_significance(mu_bkg, significance, method="lima"): r"""Compute excess matching a given significance. This function is the inverse of `significance`. Parameters ---------- mu_bkg : array_like Known background level significance : array_like Significance method : {'lima', 'simple'} Select method Returns ------- excess : `numpy.ndarray` Excess See Also -------- significance, excess_matching_significance_on_off Examples -------- >>> excess_matching_significance(mu_bkg=0.2, significance=5, method='lima') TODO >>> excess_matching_significance(mu_bkg=0.2, significance=5, method='simple') TODO """ mu_bkg = np.asanyarray(mu_bkg, dtype=np.float64) significance = np.asanyarray(significance, dtype=np.float64) if method == "simple": return _excess_matching_significance_simple(mu_bkg, significance) elif method == "lima": return _excess_matching_significance_lima(mu_bkg, significance) else: raise ValueError("Invalid method: {}".format(method))
[docs]def excess_matching_significance_on_off(n_off, alpha, significance, method="lima"): r"""Compute sensitivity of an on-off observation. This function is the inverse of `significance_on_off`. Parameters ---------- n_off : array_like Observed number of counts in the off region alpha : array_like On / off region exposure ratio for background events significance : array_like Desired significance level method : {'lima', 'simple'} Which method? Returns ------- excess : `numpy.ndarray` Excess See Also -------- significance_on_off, excess_matching_significance Examples -------- >>> excess_matching_significance_on_off(n_off=20,alpha=0.1,significance=5,method='lima') 12.038 >>> excess_matching_significance_on_off(n_off=20,alpha=0.1,significance=5,method='simple') 27.034 >>> excess_matching_significance_on_off(n_off=20,alpha=0.1,significance=0,method='lima') 2.307301461e-09 >>> excess_matching_significance_on_off(n_off=20,alpha=0.1,significance=0,method='simple') 0.0 >>> excess_matching_significance_on_off(n_off=20,alpha=0.1,significance=-10,method='lima') nan >>> excess_matching_significance_on_off(n_off=20,alpha=0.1,significance=-10,method='simple') nan """ n_off = np.asanyarray(n_off, dtype=np.float64) alpha = np.asanyarray(alpha, dtype=np.float64) significance = np.asanyarray(significance, dtype=np.float64) if method == "simple": return _excess_matching_significance_on_off_simple(n_off, alpha, significance) elif method == "lima": return _excess_matching_significance_on_off_lima(n_off, alpha, significance) else: raise ValueError("Invalid method: {}".format(method))
def _excess_matching_significance_simple(mu_bkg, significance): return significance * np.sqrt(mu_bkg) def _excess_matching_significance_on_off_simple(n_off, alpha, significance): # TODO: can these equations be simplified? significance2 = significance ** 2 determinant = significance2 + 4 * n_off * alpha * (1 + alpha) temp = significance2 + 2 * n_off * alpha n_on = 0.5 * (temp + significance * np.sqrt(np.abs(determinant))) return n_on - background(n_off, alpha) # This is mostly a copy & paste from _excess_matching_significance_on_off_lima # TODO: simplify this, or avoid code duplication? # Looking at the formula for significance_lima_on_off, I don't think # it can be analytically inverted because the n_on appears inside and outside the log # So probably root finding is still needed here. def _excess_matching_significance_lima(mu_bkg, significance): # Significance not well-defined for n_on < 0 # Return Nan if given significance can't be reached s0 = _significance_lima(n_on=1e-5, mu_bkg=mu_bkg) if s0 >= significance: return np.nan def target_significance(n_on): if n_on >= 0: return _significance_lima(n_on, mu_bkg) - significance else: # This high value is to tell the optimizer to stay n_on >= 0 return 1e10 excess_guess = _excess_matching_significance_simple(mu_bkg, significance) n_on_guess = excess_guess + mu_bkg # solver options to control robustness / accuracy / speed opts = dict(factor=0.1) n_on = fsolve(target_significance, n_on_guess, **opts) return n_on - mu_bkg def _excess_matching_significance_on_off_lima(n_off, alpha, significance): # Significance not well-defined for n_on < 0 # Return Nan if given significance can't be reached s0 = _significance_lima_on_off(n_on=1e-5, n_off=n_off, alpha=alpha) if s0 >= significance: return np.nan def target_significance(n_on): if n_on >= 0: return _significance_lima_on_off(n_on, n_off, alpha) - significance else: # This high value is to tell the optimizer to stay n_on >= 0 return 1e10 excess_guess = _excess_matching_significance_on_off_simple( n_off, alpha, significance ) n_on_guess = excess_guess + background(n_off, alpha) # solver options to control robustness / accuracy / speed opts = dict(factor=0.1) n_on = fsolve(target_significance, n_on_guess, **opts) return n_on - background(n_off, alpha) _excess_matching_significance_lima = np.vectorize(_excess_matching_significance_lima) _excess_matching_significance_on_off_lima = np.vectorize( _excess_matching_significance_on_off_lima )