# Licensed under a 3-clause BSD style license - see LICENSE.rst
"""Spectral models for Gammapy."""
import operator
import numpy as np
from scipy.optimize import brentq
import astropy.units as u
from astropy.table import Table
from ..utils.energy import EnergyBounds
from ..utils.nddata import NDDataArray, BinnedDataAxis
from ..utils.scripts import make_path
from ..utils.fitting import Parameter, Parameters, Model
from ..utils.interpolation import ScaledRegularGridInterpolator
from .utils import integrate_spectrum
__all__ = [
"SpectralModel",
"ConstantModel",
"CompoundSpectralModel",
"PowerLaw",
"PowerLaw2",
"ExponentialCutoffPowerLaw",
"ExponentialCutoffPowerLaw3FGL",
"PLSuperExpCutoff3FGL",
"LogParabola",
"TableModel",
"AbsorbedSpectralModel",
"Absorption",
]
[docs]class SpectralModel(Model):
"""Spectral model base class.
Derived classes should store their parameters as
`~gammapy.utils.modeling.Parameters`
See for example return pardict of
`~gammapy.spectrum.models.PowerLaw`.
"""
[docs] def __call__(self, energy):
"""Call evaluate method of derived classes"""
kwargs = dict()
for par in self.parameters.parameters:
quantity = par.quantity
if quantity.unit.physical_type == "energy":
quantity = quantity.to(energy.unit)
kwargs[par.name] = quantity
return self.evaluate(energy, **kwargs)
def __mul__(self, model):
if not isinstance(model, SpectralModel):
model = ConstantModel(const=model)
return CompoundSpectralModel(self, model, operator.mul)
def __rmul__(self, model):
# This is needed to support e.g. 5 * model
return self.__mul__(model)
def __add__(self, model):
if not isinstance(model, SpectralModel):
model = ConstantModel(const=model)
return CompoundSpectralModel(self, model, operator.add)
def __radd__(self, model):
return self.__add__(model)
def __sub__(self, model):
if not isinstance(model, SpectralModel):
model = ConstantModel(const=model)
return CompoundSpectralModel(self, model, operator.sub)
def __rsub__(self, model):
return self.__sub__(model)
def __truediv__(self, model):
if not isinstance(model, SpectralModel):
model = ConstantModel(const=model)
return CompoundSpectralModel(self, model, operator.truediv)
def __rtruediv__(self, model):
return self.__div__(model)
def _parse_uarray(self, uarray):
from uncertainties import unumpy
values = unumpy.nominal_values(uarray)
errors = unumpy.std_devs(uarray)
return values, errors
def _convert_energy(self, energy):
if "reference" in self.parameters.names:
return energy.to(self.parameters["reference"].unit)
elif "emin" in self.parameters.names:
return energy.to(self.parameters["emin"].unit)
else:
return energy
[docs] def evaluate_error(self, energy):
"""Evaluate spectral model with error propagation.
Parameters
----------
energy : `~astropy.units.Quantity`
Energy at which to evaluate
Returns
-------
flux, flux_error : tuple of `~astropy.units.Quantity`
Tuple of flux and flux error.
"""
energy = self._convert_energy(energy)
unit = self(energy).unit
upars = self.parameters._ufloats
uarray = self.evaluate(energy.value, **upars)
return self._parse_uarray(uarray) * unit
[docs] def integral(self, emin, emax, **kwargs):
r"""Integrate spectral model numerically.
.. math::
F(E_{min}, E_{max}) = \int_{E_{min}}^{E_{max}} \phi(E) dE
If array input for ``emin`` and ``emax`` is given you have to set
``intervals=True`` if you want the integral in each energy bin.
Parameters
----------
emin, emax : `~astropy.units.Quantity`
Lower and upper bound of integration range.
**kwargs : dict
Keyword arguments passed to :func:`~gammapy.spectrum.integrate_spectrum`
"""
return integrate_spectrum(self, emin, emax, **kwargs)
[docs] def integral_error(self, emin, emax, **kwargs):
"""Integrate spectral model numerically with error propagation.
Parameters
----------
emin, emax : `~astropy.units.Quantity`
Lower adn upper bound of integration range.
**kwargs : dict
Keyword arguments passed to func:`~gammapy.spectrum.integrate_spectrum`
Returns
-------
integral, integral_error : tuple of `~astropy.units.Quantity`
Tuple of integral flux and integral flux error.
"""
emin = self._convert_energy(emin)
emax = self._convert_energy(emax)
unit = self.integral(emin, emax, **kwargs).unit
upars = self.parameters._ufloats
def f(x):
return self.evaluate(x, **upars)
uarray = integrate_spectrum(f, emin.value, emax.value, **kwargs)
return self._parse_uarray(uarray) * unit
[docs] def energy_flux(self, emin, emax, **kwargs):
r"""Compute energy flux in given energy range.
.. math::
G(E_{min}, E_{max}) = \int_{E_{min}}^{E_{max}} E \phi(E) dE
Parameters
----------
emin, emax : `~astropy.units.Quantity`
Lower and upper bound of integration range.
**kwargs : dict
Keyword arguments passed to func:`~gammapy.spectrum.integrate_spectrum`
"""
def f(x):
return x * self(x)
return integrate_spectrum(f, emin, emax, **kwargs)
[docs] def energy_flux_error(self, emin, emax, **kwargs):
r"""Compute energy flux in given energy range with error propagation.
.. math::
G(E_{min}, E_{max}) = \int_{E_{min}}^{E_{max}} E \phi(E) dE
Parameters
----------
emin, emax : `~astropy.units.Quantity`
Lower bound of integration range.
**kwargs : dict
Keyword arguments passed to :func:`~gammapy.spectrum.integrate_spectrum`
Returns
-------
energy_flux, energy_flux_error : tuple of `~astropy.units.Quantity`
Tuple of energy flux and energy flux error.
"""
emin = self._convert_energy(emin)
emax = self._convert_energy(emax)
unit = self.energy_flux(emin, emax, **kwargs).unit
upars = self.parameters._ufloats
def f(x):
return x * self.evaluate(x, **upars)
uarray = integrate_spectrum(f, emin.value, emax.value, **kwargs)
return self._parse_uarray(uarray) * unit
[docs] def to_dict(self):
"""Convert to dict."""
retval = self.parameters.to_dict()
retval["name"] = self.__class__.__name__
return retval
[docs] @classmethod
def from_dict(cls, val):
"""Create from dict."""
val_copy = val.copy()
classname = val_copy.pop("name")
parameters = Parameters.from_dict(val_copy)
model = globals()[classname]()
model.parameters = parameters
model.parameters.covariance = parameters.covariance
return model
[docs] def plot(
self,
energy_range,
ax=None,
energy_unit="TeV",
flux_unit="cm-2 s-1 TeV-1",
energy_power=0,
n_points=100,
**kwargs
):
"""Plot spectral model curve.
kwargs are forwarded to `matplotlib.pyplot.plot`
By default a log-log scaling of the axes is used, if you want to change
the y axis scaling to linear you can use::
from gammapy.spectrum.models import ExponentialCutoffPowerLaw
from astropy import units as u
pwl = ExponentialCutoffPowerLaw()
ax = pwl.plot(energy_range=(0.1, 100) * u.TeV)
ax.set_yscale('linear')
Parameters
----------
ax : `~matplotlib.axes.Axes`, optional
Axis
energy_range : `~astropy.units.Quantity`
Plot range
energy_unit : str, `~astropy.units.Unit`, optional
Unit of the energy axis
flux_unit : str, `~astropy.units.Unit`, optional
Unit of the flux axis
energy_power : int, optional
Power of energy to multiply flux axis with
n_points : int, optional
Number of evaluation nodes
Returns
-------
ax : `~matplotlib.axes.Axes`, optional
Axis
"""
import matplotlib.pyplot as plt
ax = plt.gca() if ax is None else ax
emin, emax = energy_range
energy = EnergyBounds.equal_log_spacing(emin, emax, n_points, energy_unit)
# evaluate model
flux = self(energy).to(flux_unit)
y = self._plot_scale_flux(energy, flux, energy_power)
ax.plot(energy.value, y.value, **kwargs)
self._plot_format_ax(ax, energy, y, energy_power)
return ax
[docs] def plot_error(
self,
energy_range,
ax=None,
energy_unit="TeV",
flux_unit="cm-2 s-1 TeV-1",
energy_power=0,
n_points=100,
**kwargs
):
"""Plot spectral model error band.
.. note::
This method calls ``ax.set_yscale("log", nonposy='clip')`` and
``ax.set_xscale("log", nonposx='clip')`` to create a log-log representation.
The additional argument ``nonposx='clip'`` avoids artefacts in the plot,
when the error band extends to negative values (see also
https://github.com/matplotlib/matplotlib/issues/8623).
When you call ``plt.loglog()`` or ``plt.semilogy()`` explicitely in your
plotting code and the error band extends to negative values, it is not
shown correctly. To circumvent this issue also use
``plt.loglog(nonposx='clip', nonposy='clip')``
or ``plt.semilogy(nonposy='clip')``.
Parameters
----------
ax : `~matplotlib.axes.Axes`, optional
Axis
energy_range : `~astropy.units.Quantity`
Plot range
energy_unit : str, `~astropy.units.Unit`, optional
Unit of the energy axis
flux_unit : str, `~astropy.units.Unit`, optional
Unit of the flux axis
energy_power : int, optional
Power of energy to multiply flux axis with
n_points : int, optional
Number of evaluation nodes
**kwargs : dict
Keyword arguments forwarded to `matplotlib.pyplot.fill_between`
Returns
-------
ax : `~matplotlib.axes.Axes`, optional
Axis
"""
import matplotlib.pyplot as plt
ax = plt.gca() if ax is None else ax
kwargs.setdefault("facecolor", "black")
kwargs.setdefault("alpha", 0.2)
kwargs.setdefault("linewidth", 0)
emin, emax = energy_range
energy = EnergyBounds.equal_log_spacing(emin, emax, n_points, energy_unit)
flux, flux_err = self.evaluate_error(energy).to(flux_unit)
y_lo = self._plot_scale_flux(energy, flux - flux_err, energy_power)
y_hi = self._plot_scale_flux(energy, flux + flux_err, energy_power)
where = (energy >= energy_range[0]) & (energy <= energy_range[1])
ax.fill_between(energy.value, y_lo.value, y_hi.value, where=where, **kwargs)
self._plot_format_ax(ax, energy, y_lo, energy_power)
return ax
@staticmethod
def _plot_format_ax(ax, energy, y, energy_power):
ax.set_xlabel("Energy [{}]".format(energy.unit))
if energy_power > 0:
ax.set_ylabel("E{} * Flux [{}]".format(energy_power, y.unit))
else:
ax.set_ylabel("Flux [{}]".format(y.unit))
ax.set_xscale("log", nonposx="clip")
ax.set_yscale("log", nonposy="clip")
@staticmethod
def _plot_scale_flux(energy, flux, energy_power):
try:
eunit = [_ for _ in flux.unit.bases if _.physical_type == "energy"][0]
except IndexError:
eunit = energy.unit
y = flux * np.power(energy, energy_power)
return y.to(flux.unit * eunit ** energy_power)
[docs] def spectral_index(self, energy, epsilon=1e-5):
"""Compute spectral index at given energy.
Parameters
----------
energy : `~astropy.units.Quantity`
Energy at which to estimate the index
epsilon : float
Fractional energy increment to use for determining the spectral index.
Returns
-------
index : float
Estimated spectral index.
"""
f1 = self(energy)
f2 = self(energy * (1 + epsilon))
return np.log(f1 / f2) / np.log(1 + epsilon)
[docs] def inverse(self, value, emin=0.1 * u.TeV, emax=100 * u.TeV):
"""Return energy for a given function value of the spectral model.
Calls the `scipy.optimize.brentq` numerical root finding method.
Parameters
----------
value : `~astropy.units.Quantity`
Function value of the spectral model.
emin : `~astropy.units.Quantity`
Lower bracket value in case solution is not unique.
emax : `~astropy.units.Quantity`
Upper bracket value in case solution is not unique.
Returns
-------
energy : `~astropy.units.Quantity`
Energies at which the model has the given ``value``.
"""
eunit = "TeV"
energies = []
for val in np.atleast_1d(value):
def f(x):
# scale by 1e12 to achieve better precision
energy = u.Quantity(x, eunit, copy=False)
y = self(energy).to_value(value.unit)
return 1e12 * (y - val.value)
energy = brentq(f, emin.to_value(eunit), emax.to_value(eunit))
energies.append(energy)
return u.Quantity(energies, eunit, copy=False)
[docs]class ConstantModel(SpectralModel):
r"""Constant model
.. math::
\phi(E) = k
Parameters
----------
const : `~astropy.units.Quantity`
:math:`k`
"""
__slots__ = ["const"]
def __init__(self, const):
self.const = Parameter("const", const)
super().__init__([self.const])
[docs] @staticmethod
def evaluate(energy, const):
"""Evaluate the model (static function)."""
return np.ones(np.atleast_1d(energy).shape) * const
[docs]class CompoundSpectralModel(SpectralModel):
"""Represents the algebraic combination of two
`~gammapy.spectrum.models.SpectralModel`
"""
def __init__(self, model1, model2, operator):
self.model1 = model1
self.model2 = model2
self.operator = operator
parameters = (
self.model1.parameters.parameters + self.model2.parameters.parameters
)
super().__init__(parameters)
# TODO: Think about how to deal with covariance matrix
def __str__(self):
ss = self.__class__.__name__
ss += "\n Component 1 : {}".format(self.model1)
ss += "\n Component 2 : {}".format(self.model2)
ss += "\n Operator : {}".format(self.operator)
return ss
[docs] def __call__(self, energy):
val1 = self.model1(energy)
val2 = self.model2(energy)
return self.operator(val1, val2)
[docs] def to_dict(self):
retval = dict()
retval["model1"] = self.model1.to_dict()
retval["model2"] = self.model2.to_dict()
retval["operator"] = self.operator
[docs]class PowerLaw(SpectralModel):
r"""Spectral power-law model.
.. math::
\phi(E) = \phi_0 \cdot \left( \frac{E}{E_0} \right)^{-\Gamma}
Parameters
----------
index : `~astropy.units.Quantity`
:math:`\Gamma`
amplitude : `~astropy.units.Quantity`
:math:`\phi_0`
reference : `~astropy.units.Quantity`
:math:`E_0`
Examples
--------
This is how to plot the default `PowerLaw` model::
from astropy import units as u
from gammapy.spectrum.models import PowerLaw
pwl = PowerLaw()
pwl.plot(energy_range=[0.1, 100] * u.TeV)
plt.show()
"""
__slots__ = ["index", "amplitude", "reference"]
def __init__(self, index=2.0, amplitude="1e-12 cm-2 s-1 TeV-1", reference="1 TeV"):
self.index = Parameter("index", index)
self.amplitude = Parameter("amplitude", amplitude)
self.reference = Parameter("reference", reference, frozen=True)
super().__init__([self.index, self.amplitude, self.reference])
[docs] @staticmethod
def evaluate(energy, index, amplitude, reference):
"""Evaluate the model (static function)."""
return amplitude * np.power((energy / reference), -index)
[docs] def integral(self, emin, emax, **kwargs):
r"""Integrate power law analytically.
.. math::
F(E_{min}, E_{max}) = \int_{E_{min}}^{E_{max}}\phi(E)dE = \left.
\phi_0 \frac{E_0}{-\Gamma + 1} \left( \frac{E}{E_0} \right)^{-\Gamma + 1}
\right \vert _{E_{min}}^{E_{max}}
Parameters
----------
emin, emax : `~astropy.units.Quantity`
Lower and upper bound of integration range
"""
# kwargs are passed to this function but not used
# this is to get a consistent API with SpectralModel.integral()
pars = self.parameters
if np.isclose(pars["index"].value, 1):
e_unit = emin.unit
prefactor = pars["amplitude"].quantity * pars["reference"].quantity.to(
e_unit
)
upper = np.log(emax.to_value(e_unit))
lower = np.log(emin.to_value(e_unit))
else:
val = -1 * pars["index"].value + 1
prefactor = pars["amplitude"].quantity * pars["reference"].quantity / val
upper = np.power((emax / pars["reference"].quantity), val)
lower = np.power((emin / pars["reference"].quantity), val)
return prefactor * (upper - lower)
[docs] def integral_error(self, emin, emax, **kwargs):
r"""Integrate power law analytically with error propagation.
Parameters
----------
emin, emax : `~astropy.units.Quantity`
Lower and upper bound of integration range.
Returns
-------
integral, integral_error : tuple of `~astropy.units.Quantity`
Tuple of integral flux and integral flux error.
"""
# kwargs are passed to this function but not used
# this is to get a consistent API with SpectralModel.integral()
emin = self._convert_energy(emin)
emax = self._convert_energy(emax)
unit = self.integral(emin, emax, **kwargs).unit
upars = self.parameters._ufloats
if np.isclose(upars["index"].nominal_value, 1):
prefactor = upars["amplitude"] * upars["reference"]
upper = np.log(emax.value)
lower = np.log(emin.value)
else:
val = -1 * upars["index"] + 1
prefactor = upars["amplitude"] * upars["reference"] / val
upper = np.power((emax.value / upars["reference"]), val)
lower = np.power((emin.value / upars["reference"]), val)
uarray = prefactor * (upper - lower)
return self._parse_uarray(uarray) * unit
[docs] def energy_flux(self, emin, emax):
r"""Compute energy flux in given energy range analytically.
.. math::
G(E_{min}, E_{max}) = \int_{E_{min}}^{E_{max}}E \phi(E)dE = \left.
\phi_0 \frac{E_0^2}{-\Gamma + 2} \left( \frac{E}{E_0} \right)^{-\Gamma + 2}
\right \vert _{E_{min}}^{E_{max}}
Parameters
----------
emin, emax : `~astropy.units.Quantity`
Lower and upper bound of integration range.
"""
pars = self.parameters
val = -1 * pars["index"].value + 2
if np.isclose(val, 0):
# see https://www.wolframalpha.com/input/?i=a+*+x+*+(x%2Fb)+%5E+(-2)
# for reference
temp = pars["amplitude"].quantity * pars["reference"].quantity ** 2
return temp * np.log(emax / emin)
else:
prefactor = (
pars["amplitude"].quantity * pars["reference"].quantity ** 2 / val
)
upper = (emax / pars["reference"].quantity) ** val
lower = (emin / pars["reference"].quantity) ** val
return prefactor * (upper - lower)
[docs] def energy_flux_error(self, emin, emax, **kwargs):
r"""Compute energy flux in given energy range analytically with error propagation.
Parameters
----------
emin, emax : `~astropy.units.Quantity`
Lower and upper bound of integration range.
Returns
-------
energy_flux, energy_flux_error : tuple of `~astropy.units.Quantity`
Tuple of energy flux and energy flux error.
"""
emin = self._convert_energy(emin)
emax = self._convert_energy(emax)
unit = self.energy_flux(emin, emax, **kwargs).unit
upars = self.parameters._ufloats
val = -1 * upars["index"] + 2
if np.isclose(val.nominal_value, 0):
# see https://www.wolframalpha.com/input/?i=a+*+x+*+(x%2Fb)+%5E+(-2)
# for reference
temp = upars["amplitude"] * upars["reference"] ** 2
uarray = temp * np.log(emax.value / emin.value)
else:
prefactor = upars["amplitude"] * upars["reference"] ** 2 / val
upper = (emax.value / upars["reference"]) ** val
lower = (emin.value / upars["reference"]) ** val
uarray = prefactor * (upper - lower)
return self._parse_uarray(uarray) * unit
[docs] def inverse(self, value):
"""Return energy for a given function value of the spectral model.
Parameters
----------
value : `~astropy.units.Quantity`
Function value of the spectral model.
"""
p = self.parameters
base = value / p["amplitude"].quantity
return p["reference"].quantity * np.power(base, -1.0 / p["index"].value)
[docs]class PowerLaw2(SpectralModel):
r"""Spectral power-law model with integral as amplitude parameter.
See also: https://fermi.gsfc.nasa.gov/ssc/data/analysis/scitools/source_models.html
.. math::
\phi(E) = F_0 \cdot \frac{\Gamma + 1}{E_{0, max}^{-\Gamma + 1}
- E_{0, min}^{-\Gamma + 1}} \cdot E^{-\Gamma}
Parameters
----------
index : `~astropy.units.Quantity`
Spectral index :math:`\Gamma`
amplitude : `~astropy.units.Quantity`
Integral flux :math:`F_0`.
emin : `~astropy.units.Quantity`
Lower energy limit :math:`E_{0, min}`.
emax : `~astropy.units.Quantity`
Upper energy limit :math:`E_{0, max}`.
Examples
--------
This is how to plot the default `PowerLaw2` model::
from astropy import units as u
from gammapy.spectrum.models import PowerLaw2
pwl2 = PowerLaw2()
pwl2.plot(energy_range=[0.1, 100] * u.TeV)
plt.show()
"""
__slots__ = ["index", "amplitude", "emin", "emax"]
def __init__(
self, amplitude="1e-12 cm-2 s-1", index=2, emin="0.1 TeV", emax="100 TeV"
):
self.amplitude = Parameter("amplitude", amplitude)
self.index = Parameter("index", index)
self.emin = Parameter("emin", emin, frozen=True)
self.emax = Parameter("emax", emax, frozen=True)
super().__init__([self.index, self.amplitude, self.emin, self.emax])
[docs] @staticmethod
def evaluate(energy, amplitude, index, emin, emax):
"""Evaluate the model (static function)."""
top = -index + 1
# to get the energies dimensionless we use a modified formula
bottom = emax - emin * (emin / emax) ** (-index)
return amplitude * (top / bottom) * np.power(energy / emax, -index)
[docs] def integral(self, emin, emax, **kwargs):
r"""Integrate power law analytically.
.. math::
F(E_{min}, E_{max}) = F_0 \cdot \frac{E_{max}^{\Gamma + 1} \
- E_{min}^{\Gamma + 1}}{E_{0, max}^{\Gamma + 1} \
- E_{0, min}^{\Gamma + 1}}
Parameters
----------
emin, emax : `~astropy.units.Quantity`
Lower and upper bound of integration range.
"""
pars = self.parameters
temp1 = np.power(emax, -pars["index"].value + 1)
temp2 = np.power(emin, -pars["index"].value + 1)
top = temp1 - temp2
temp1 = np.power(pars["emax"].quantity, -pars["index"].value + 1)
temp2 = np.power(pars["emin"].quantity, -pars["index"].value + 1)
bottom = temp1 - temp2
return pars["amplitude"].quantity * top / bottom
[docs] def integral_error(self, emin, emax, **kwargs):
r"""Integrate power law analytically with error propagation.
Parameters
----------
emin, emax : `~astropy.units.Quantity`
Lower and upper bound of integration range.
Returns
-------
integral, integral_error : tuple of `~astropy.units.Quantity`
Tuple of integral flux and integral flux error.
"""
emin = self._convert_energy(emin)
emax = self._convert_energy(emax)
unit = self.integral(emin, emax, **kwargs).unit
upars = self.parameters._ufloats
temp1 = np.power(emax.value, -upars["index"] + 1)
temp2 = np.power(emin.value, -upars["index"] + 1)
top = temp1 - temp2
temp1 = np.power(upars["emax"], -upars["index"] + 1)
temp2 = np.power(upars["emin"], -upars["index"] + 1)
bottom = temp1 - temp2
uarray = upars["amplitude"] * top / bottom
return self._parse_uarray(uarray) * unit
[docs] def inverse(self, value):
"""Return energy for a given function value of the spectral model.
Parameters
----------
value : `~astropy.units.Quantity`
Function value of the spectral model.
"""
p = self.parameters
amplitude, index, emin, emax = (
p["amplitude"].quantity,
p["index"].value,
p["emin"].quantity,
p["emax"].quantity,
)
# to get the energies dimensionless we use a modified formula
top = -index + 1
bottom = emax - emin * (emin / emax) ** (-index)
term = (bottom / top) * (value / amplitude)
return np.power(term.to_value(""), -1.0 / index) * emax
[docs]class ExponentialCutoffPowerLaw(SpectralModel):
r"""Spectral exponential cutoff power-law model.
.. math::
\phi(E) = \phi_0 \cdot \left(\frac{E}{E_0}\right)^{-\Gamma} \exp(-\lambda E)
Parameters
----------
index : `~astropy.units.Quantity`
:math:`\Gamma`
amplitude : `~astropy.units.Quantity`
:math:`\phi_0`
reference : `~astropy.units.Quantity`
:math:`E_0`
lambda_ : `~astropy.units.Quantity`
:math:`\lambda`
Examples
--------
This is how to plot the default `ExponentialCutoffPowerLaw` model::
from astropy import units as u
from gammapy.spectrum.models import ExponentialCutoffPowerLaw
ecpl = ExponentialCutoffPowerLaw()
ecpl.plot(energy_range=[0.1, 100] * u.TeV)
plt.show()
"""
__slots__ = ["index", "amplitude", "reference", "lambda_"]
def __init__(
self,
index=1.5,
amplitude="1e-12 cm-2 s-1 TeV-1",
reference="1 TeV",
lambda_="0.1 TeV-1",
):
self.index = Parameter("index", index)
self.amplitude = Parameter("amplitude", amplitude)
self.reference = Parameter("reference", reference, frozen=True)
self.lambda_ = Parameter("lambda_", lambda_)
super().__init__([self.index, self.amplitude, self.reference, self.lambda_])
[docs] @staticmethod
def evaluate(energy, index, amplitude, reference, lambda_):
"""Evaluate the model (static function)."""
pwl = amplitude * (energy / reference) ** (-index)
try:
cutoff = np.exp(-energy * lambda_)
except AttributeError:
from uncertainties.unumpy import exp
cutoff = exp(-energy * lambda_)
return pwl * cutoff
@property
def e_peak(self):
r"""Spectral energy distribution peak energy (`~astropy.utils.Quantity`).
This is the peak in E^2 x dN/dE and is given by:
.. math::
E_{Peak} = (2 - \Gamma) / \lambda
"""
p = self.parameters
reference = p["reference"].quantity
index = p["index"].quantity
lambda_ = p["lambda_"].quantity
if index >= 2:
return np.nan * reference.unit
else:
return (2 - index) / lambda_
[docs]class ExponentialCutoffPowerLaw3FGL(SpectralModel):
r"""Spectral exponential cutoff power-law model used for 3FGL.
Note that the parametrization is different from `ExponentialCutoffPowerLaw`:
.. math::
\phi(E) = \phi_0 \cdot \left(\frac{E}{E_0}\right)^{-\Gamma}
\exp \left( \frac{E_0 - E}{E_{C}} \right)
Parameters
----------
index : `~astropy.units.Quantity`
:math:`\Gamma`
amplitude : `~astropy.units.Quantity`
:math:`\phi_0`
reference : `~astropy.units.Quantity`
:math:`E_0`
ecut : `~astropy.units.Quantity`
:math:`E_{C}`
Examples
--------
This is how to plot the default `ExponentialCutoffPowerLaw3FGL` model::
from astropy import units as u
from gammapy.spectrum.models import ExponentialCutoffPowerLaw3FGL
ecpl_3fgl = ExponentialCutoffPowerLaw3FGL()
ecpl_3fgl.plot(energy_range=[0.1, 100] * u.TeV)
plt.show()
"""
__slots__ = ["index", "amplitude", "reference", "ecut"]
def __init__(
self,
index=1.5,
amplitude="1e-12 cm-2 s-1 TeV-1",
reference="1 TeV",
ecut="10 TeV",
):
self.index = Parameter("index", index)
self.amplitude = Parameter("amplitude", amplitude)
self.reference = Parameter("reference", reference, frozen=True)
self.ecut = Parameter("ecut", ecut)
super().__init__([self.index, self.amplitude, self.reference, self.ecut])
[docs] @staticmethod
def evaluate(energy, index, amplitude, reference, ecut):
"""Evaluate the model (static function)."""
pwl = amplitude * (energy / reference) ** (-index)
try:
cutoff = np.exp((reference - energy) / ecut)
except AttributeError:
from uncertainties.unumpy import exp
cutoff = exp((reference - energy) / ecut)
return pwl * cutoff
[docs]class PLSuperExpCutoff3FGL(SpectralModel):
r"""Spectral super exponential cutoff power-law model used for 3FGL.
.. math::
\phi(E) = \phi_0 \cdot \left(\frac{E}{E_0}\right)^{-\Gamma_1}
\exp \left( \left(\frac{E_0}{E_{C}} \right)^{\Gamma_2} -
\left(\frac{E}{E_{C}} \right)^{\Gamma_2}
\right)
Parameters
----------
index_1 : `~astropy.units.Quantity`
:math:`\Gamma_1`
index_2 : `~astropy.units.Quantity`
:math:`\Gamma_2`
amplitude : `~astropy.units.Quantity`
:math:`\phi_0`
reference : `~astropy.units.Quantity`
:math:`E_0`
ecut : `~astropy.units.Quantity`
:math:`E_{C}`
Examples
--------
This is how to plot the default `PLSuperExpCutoff3FGL` model::
from astropy import units as u
from gammapy.spectrum.models import PLSuperExpCutoff3FGL
secpl_3fgl = PLSuperExpCutoff3FGL()
secpl_3fgl.plot(energy_range=[0.1, 100] * u.TeV)
plt.show()
"""
__slots__ = ["index_1", "index_2", "amplitude", "reference", "ecut"]
def __init__(
self,
index_1=1.5,
index_2=2,
amplitude="1e-12 cm-2 s-1 TeV-1",
reference="1 TeV",
ecut="10 TeV",
):
self.index_1 = Parameter("index_1", index_1)
self.index_2 = Parameter("index_2", index_2)
self.amplitude = Parameter("amplitude", amplitude)
self.reference = Parameter("reference", reference, frozen=True)
self.ecut = Parameter("ecut", ecut)
super().__init__(
[self.index_1, self.index_2, self.amplitude, self.reference, self.ecut]
)
[docs] @staticmethod
def evaluate(energy, amplitude, reference, ecut, index_1, index_2):
"""Evaluate the model (static function)."""
pwl = amplitude * (energy / reference) ** (-index_1)
try:
cutoff = np.exp((reference / ecut) ** index_2 - (energy / ecut) ** index_2)
except AttributeError:
from uncertainties.unumpy import exp
cutoff = exp((reference / ecut) ** index_2 - (energy / ecut) ** index_2)
return pwl * cutoff
[docs]class LogParabola(SpectralModel):
r"""Spectral log parabola model.
.. math::
\phi(E) = \phi_0 \left( \frac{E}{E_0} \right) ^ {
- \alpha - \beta \log{ \left( \frac{E}{E_0} \right) }
}
Note that :math:`log` refers to the natural logarithm. This is consistent
with the `Fermi Science Tools
<https://fermi.gsfc.nasa.gov/ssc/data/analysis/scitools/source_models.html>`_
and `ctools
<http://cta.irap.omp.eu/ctools-devel/users/user_manual/getting_started/models.html#log-parabola>`_.
The `Sherpa <http://cxc.harvard.edu/sherpa/ahelp/logparabola.html_
package>`_ package, however, uses :math:`log_{10}`. If you have
parametrization based on :math:`log_{10}` you can use the
:func:`~gammapy.spectrum.models.LogParabola.from_log10` method.
Parameters
----------
amplitude : `~astropy.units.Quantity`
:math:`\phi_0`
reference : `~astropy.units.Quantity`
:math:`E_0`
alpha : `~astropy.units.Quantity`
:math:`\alpha`
beta : `~astropy.units.Quantity`
:math:`\beta`
Examples
--------
This is how to plot the default `LogParabola` model::
from astropy import units as u
from gammapy.spectrum.models import LogParabola
log_parabola = LogParabola()
log_parabola.plot(energy_range=[0.1, 100] * u.TeV)
plt.show()
"""
__slots__ = ["amplitude", "reference", "alpha", "beta"]
def __init__(
self, amplitude="1e-12 cm-2 s-1 TeV-1", reference="10 TeV", alpha=2, beta=1
):
self.amplitude = Parameter("amplitude", amplitude)
self.reference = Parameter("reference", reference, frozen=True)
self.alpha = Parameter("alpha", alpha)
self.beta = Parameter("beta", beta)
super().__init__([self.amplitude, self.reference, self.alpha, self.beta])
[docs] @classmethod
def from_log10(cls, amplitude, reference, alpha, beta):
"""Construct LogParabola from :math:`log_{10}` parametrization"""
beta_ = beta / np.log(10)
return cls(amplitude=amplitude, reference=reference, alpha=alpha, beta=beta_)
[docs] @staticmethod
def evaluate(energy, amplitude, reference, alpha, beta):
"""Evaluate the model (static function)."""
try:
xx = (energy / reference).to("")
exponent = -alpha - beta * np.log(xx)
except AttributeError:
from uncertainties.unumpy import log
xx = energy / reference
exponent = -alpha - beta * log(xx)
return amplitude * np.power(xx, exponent)
@property
def e_peak(self):
r"""Spectral energy distribution peak energy (`~astropy.units.Quantity`).
This is the peak in E^2 x dN/dE and is given by:
.. math::
E_{Peak} = E_{0} \exp{ (2 - \alpha) / (2 * \beta)}
"""
p = self.parameters
reference = p["reference"].quantity
alpha = p["alpha"].quantity
beta = p["beta"].quantity
return reference * np.exp((2 - alpha) / (2 * beta))
[docs]class TableModel(SpectralModel):
"""A model generated from a table of energy and value arrays.
the units returned will be the units of the values array provided at
initialization. The model will return values interpolated in
log-space, returning 0 for energies outside of the limits of the provided
energy array.
Class implementation follows closely what has been done in
`naima.models.TableModel`
Parameters
----------
energy : `~astropy.units.Quantity` array
Array of energies at which the model values are given
values : array
Array with the values of the model at energies ``energy``.
norm : float
Model scale that is multiplied to the supplied arrays. Defaults to 1.
values_scale : {'log', 'lin', 'sqrt'}
Interpolation scaling applied to values. If the values vary over many magnitudes
a 'log' scaling is recommended.
interp_kwargs : dict
Interpolation keyword arguments pass to `scipy.interpolate.interp1d`.
By default all values outside the interpolation range are set to zero.
If you want to apply linear extrapolation you can pass `interp_kwargs={'fill_value':
'extrapolate', 'kind': 'linear'}`
meta : dict, optional
Meta information, meta['filename'] will be used for serialization
"""
__slots__ = ["energy", "values", "norm", "meta", "_evaluate"]
def __init__(
self, energy, values, norm=1, values_scale="log", interp_kwargs=None, meta=None
):
self.norm = Parameter("norm", norm, unit="")
self.energy = energy
self.values = values
self.meta = dict() if meta is None else meta
interp_kwargs = interp_kwargs or {}
interp_kwargs.setdefault("values_scale", "log")
interp_kwargs.setdefault("points_scale", ("log",))
self._evaluate = ScaledRegularGridInterpolator(
points=(energy,), values=values, **interp_kwargs
)
super().__init__([self.norm])
[docs] @classmethod
def read_xspec_model(cls, filename, param, **kwargs):
"""Read XSPEC table model
The input is a table containing absorbed values from a XSPEC model as a
function of energy.
TODO: Format of the file should be described and discussed in
https://gamma-astro-data-formats.readthedocs.io/en/latest/index.html
Parameters
----------
filename : str
File containing the XSPEC model
param : float
Model parameter value
Examples
--------
Fill table from an EBL model (Franceschini, 2008)
>>> from gammapy.spectrum.models import TableModel
>>> filename = '$GAMMAPY_DATA/ebl/ebl_franceschini.fits.gz'
>>> table_model = TableModel.read_xspec_model(filename=filename, param=0.3)
"""
filename = str(make_path(filename))
# Check if parameter value is in range
table_param = Table.read(filename, hdu="PARAMETERS")
param_min = table_param["MINIMUM"]
param_max = table_param["MAXIMUM"]
if param < param_min or param > param_max:
err = "Parameter out of range, param={}, param_min={}, param_max={}".format(
param, param_min, param_max
)
raise ValueError(err)
# Get energy values
table_energy = Table.read(filename, hdu="ENERGIES")
energy_lo = table_energy["ENERG_LO"]
energy_hi = table_energy["ENERG_HI"]
# Hack while format is not fixed, energy values are in keV
energy_bounds = EnergyBounds.from_lower_and_upper_bounds(
lower=energy_lo, upper=energy_hi, unit=u.keV
)
energy = energy_bounds.log_centers
# Get spectrum values (no interpolation, take closest value for param)
table_spectra = Table.read(filename, hdu="SPECTRA")
idx = np.abs(table_spectra["PARAMVAL"] - param).argmin()
values = u.Quantity(table_spectra[idx][1], "", copy=False) # no dimension
kwargs.setdefault("values_scale", "lin")
return cls(energy=energy, values=values, **kwargs)
[docs] @classmethod
def read_fermi_isotropic_model(cls, filename, **kwargs):
"""Read Fermi isotropic diffuse model
see `LAT Background models <https://fermi.gsfc.nasa.gov/ssc/data/access/lat/BackgroundModels.html>`_
Parameters
----------
filename : str
filename
"""
filename = str(make_path(filename))
vals = np.loadtxt(filename)
energy = u.Quantity(vals[:, 0], "MeV", copy=False)
values = u.Quantity(vals[:, 1], "MeV-1 s-1 cm-2 sr-1", copy=False)
return cls(energy=energy, values=values, **kwargs)
[docs] def evaluate(self, energy, norm):
"""Evaluate the model (static function)."""
values = self._evaluate((energy,), clip=True)
return norm * values
class ScaleModel(SpectralModel):
"""Wrapper to scale another spectral model by a norm factor.
Parameters
----------
model : `SpectralModel`
Spectral model to wrap.
norm : float
Multiplicative norm factor for the model value.
"""
__slots__ = ["norm", "model"]
def __init__(self, model, norm=1):
self.norm = Parameter("norm", norm, unit="")
self.model = model
params = []
params.append(getattr(self, "norm"))
super().__init__(params)
def evaluate(self, energy, norm):
return norm * self.model(energy)
[docs]class Absorption:
r"""Gamma-ray absorption models.
Parameters
----------
energy_lo, energy_hi : `~astropy.units.Quantity`
Lower and upper bin edges of energy axis
param_lo, param_hi : `~astropy.units.Quantity`
Lower and upper bin edges of parameter axis
data : `~astropy.units.Quantity`
Model value
Examples
--------
Create and plot EBL absorption models for a redshift of 0.5:
.. plot::
:include-source:
import matplotlib.pyplot as plt
import astropy.units as u
from gammapy.spectrum.models import Absorption
# Load tables for z=0.5
redshift = 0.5
dominguez = Absorption.read_builtin('dominguez').table_model(redshift)
franceschini = Absorption.read_builtin('franceschini').table_model(redshift)
finke = Absorption.read_builtin('finke').table_model(redshift)
# start customised plot
energy_range = [0.08, 3] * u.TeV
ax = plt.gca()
opts = dict(energy_range=energy_range, energy_unit='TeV', ax=ax, flux_unit='')
franceschini.plot(label='Franceschini 2008', **opts)
finke.plot(label='Finke 2010', **opts)
dominguez.plot(label='Dominguez 2011', **opts)
# tune plot
ax.set_ylabel(r'Absorption coefficient [$\exp{(-\tau(E))}$]')
ax.set_xlim(energy_range.value) # we get ride of units
ax.set_ylim([1.e-4, 2.])
ax.set_yscale('log')
ax.set_title('EBL models (z=' + str(redshift) + ')')
plt.grid(which='both')
plt.legend(loc='best') # legend
# show plot
plt.show()
"""
__slots__ = ["energy_lo", "energy_hi", "param_lo", "param_hi", "data"]
def __init__(self, energy_lo, energy_hi, param_lo, param_hi, data):
axes = [
BinnedDataAxis(
param_lo, param_hi, interpolation_mode="linear", name="parameter"
),
BinnedDataAxis(
energy_lo, energy_hi, interpolation_mode="log", name="energy"
),
]
self.data = NDDataArray(axes=axes, data=data)
self.data.default_interp_kwargs["fill_value"] = None
[docs] @classmethod
def read(cls, filename):
"""Build object from an XSPEC model.
Todo: Format of XSPEC binary files should be referenced at https://gamma-astro-data-formats.readthedocs.io/en/latest/
Parameters
----------
filename : str
File containing the model.
"""
# Create EBL data array
filename = str(make_path(filename))
table_param = Table.read(filename, hdu="PARAMETERS")
par_min = table_param["MINIMUM"]
par_max = table_param["MAXIMUM"]
par_array = table_param[0]["VALUE"]
par_delta = np.diff(par_array) * 0.5
param_lo, param_hi = par_array, par_array # initialisation
param_lo[0] = par_min - par_delta[0]
param_lo[1:] -= par_delta
param_hi[:-1] += par_delta
param_hi[-1] = par_max
# Get energy values
table_energy = Table.read(filename, hdu="ENERGIES")
energy_lo = u.Quantity(
table_energy["ENERG_LO"], "keV", copy=False
) # unit not stored in file
energy_hi = u.Quantity(
table_energy["ENERG_HI"], "keV", copy=False
) # unit not stored in file
# Get spectrum values
table_spectra = Table.read(filename, hdu="SPECTRA")
data = table_spectra["INTPSPEC"].data
return cls(
energy_lo=energy_lo,
energy_hi=energy_hi,
param_lo=param_lo,
param_hi=param_hi,
data=data,
)
[docs] @classmethod
def read_builtin(cls, name):
"""Read one of the built-in absorption models.
Parameters
----------
name : {'franceschini', 'dominguez', 'finke'}
name of one of the available model in gammapy-data
References
----------
.. [1] Franceschini et al., "Extragalactic optical-infrared background radiation, its time evolution and the cosmic photon-photon opacity",
`Link <http://adsabs.harvard.edu/abs/2008A%26A...487..837F>`__
.. [2] Dominguez et al., " Extragalactic background light inferred from AEGIS galaxy-SED-type fractions"
`Link <http://adsabs.harvard.edu/abs/2011MNRAS.410.2556D>`__
.. [3] Finke et al., "Modeling the Extragalactic Background Light from Stars and Dust"
`Link <http://adsabs.harvard.edu/abs/2010ApJ...712..238F>`__
"""
models = dict()
models["franceschini"] = "$GAMMAPY_DATA/ebl/ebl_franceschini.fits.gz"
models["dominguez"] = "$GAMMAPY_DATA/ebl/ebl_dominguez11.fits.gz"
models["finke"] = "$GAMMAPY_DATA/ebl/frd_abs.fits.gz"
return cls.read(models[name])
[docs] def table_model(self, parameter, unit="TeV"):
"""Table model for a given parameter (`~gammapy.spectrum.models.TableModel`).
Parameters
----------
parameter : float
Parameter value.
unit : str, (optional)
desired value for energy axis
"""
energy_axis = self.data.axes[1]
energy = (energy_axis.log_center()).to(unit)
values = self.evaluate(energy=energy, parameter=parameter)
return TableModel(energy=energy, values=values, values_scale="lin")
[docs] def evaluate(self, energy, parameter):
"""Evaluate model for energy and parameter value."""
return self.data.evaluate(energy=energy, parameter=parameter)
[docs]class AbsorbedSpectralModel(SpectralModel):
"""Spectral model with EBL absorption.
Parameters
----------
spectral_model : `~gammapy.spectrum.models.SpectralModel`
Spectral model.
absorption : `~gammapy.spectrum.models.Absorption`
Absorption model.
parameter : float
parameter value for absorption model
parameter_name : str, optional
parameter name
"""
__slots__ = ["spectral_model", "absorption", "parameter", "parameter_name"]
def __init__(
self, spectral_model, absorption, parameter, parameter_name="redshift"
):
self.spectral_model = spectral_model
self.absorption = absorption
self.parameter = parameter
self.parameter_name = parameter_name
# initialise list parameters from spectral model
param_list = []
for param in spectral_model.parameters.parameters:
param_list.append(param)
# Add parameter to the list
min_ = self.absorption.data.axes[0].lo[0]
max_ = self.absorption.data.axes[0].lo[-1]
par = Parameter(parameter_name, parameter, min=min_, max=max_, frozen=True)
param_list.append(par)
self._parameters = Parameters(param_list)
[docs] def evaluate(self, energy, **kwargs):
"""Evaluate the model at a given energy."""
# assign redshift value and remove it from dictionnary
# since it does not belong to the spectral model
parameter = kwargs[self.parameter_name]
del kwargs[self.parameter_name]
flux = self.spectral_model.evaluate(energy=energy, **kwargs)
absorption = self.absorption.evaluate(energy=energy, parameter=parameter)
return flux * absorption