# LogParabola¶

class gammapy.spectrum.models.LogParabola(amplitude='1e-12 cm-2 s-1 TeV-1', reference='10 TeV', alpha=2, beta=1)[source]

Spectral log parabola model.

$\phi(E) = \phi_0 \left( \frac{E}{E_0} \right) ^ { - \alpha - \beta \log{ \left( \frac{E}{E_0} \right) } }$

Note that $$log$$ refers to the natural logarithm. This is consistent with the Fermi Science Tools and ctools. The Sherpa package, however, uses $$log_{10}$$. If you have parametrization based on $$log_{10}$$ you can use the from_log10() method.

Parameters: amplitude : Quantity $$\phi_0$$ reference : Quantity $$E_0$$ alpha : Quantity $$\alpha$$ beta : Quantity $$\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()


Attributes Summary

 alpha amplitude beta e_peak Spectral energy distribution peak energy (Quantity). parameters Parameters (Parameters) reference

Methods Summary

 __call__(self, energy) Call evaluate method of derived classes copy(self) A deep copy. energy_flux(self, emin, emax, \*\*kwargs) Compute energy flux in given energy range. energy_flux_error(self, emin, emax, \*\*kwargs) Compute energy flux in given energy range with error propagation. evaluate(energy, amplitude, reference, …) Evaluate the model (static function). evaluate_error(self, energy) Evaluate spectral model with error propagation. from_dict(val) Create from dict. from_log10(amplitude, reference, alpha, beta) Construct LogParabola from $$log_{10}$$ parametrization integral(self, emin, emax, \*\*kwargs) Integrate spectral model numerically. integral_error(self, emin, emax, \*\*kwargs) Integrate spectral model numerically with error propagation. inverse(self, value[, emin, emax]) Return energy for a given function value of the spectral model. plot(self, energy_range[, ax, energy_unit, …]) Plot spectral model curve. plot_error(self, energy_range[, ax, …]) Plot spectral model error band. spectral_index(self, energy[, epsilon]) Compute spectral index at given energy. to_dict(self) Convert to dict.

Attributes Documentation

alpha
amplitude
beta
e_peak

Spectral energy distribution peak energy (Quantity).

This is the peak in E^2 x dN/dE and is given by:

$E_{Peak} = E_{0} \exp{ (2 - \alpha) / (2 * \beta)}$
parameters

Parameters (Parameters)

reference

Methods Documentation

__call__(self, energy)

Call evaluate method of derived classes

copy(self)

A deep copy.

energy_flux(self, emin, emax, **kwargs)

Compute energy flux in given energy range.

$G(E_{min}, E_{max}) = \int_{E_{min}}^{E_{max}} E \phi(E) dE$
Parameters: emin, emax : Quantity Lower and upper bound of integration range. **kwargs : dict Keyword arguments passed to func:integrate_spectrum
energy_flux_error(self, emin, emax, **kwargs)

Compute energy flux in given energy range with error propagation.

$G(E_{min}, E_{max}) = \int_{E_{min}}^{E_{max}} E \phi(E) dE$
Parameters: emin, emax : Quantity Lower bound of integration range. **kwargs : dict Keyword arguments passed to integrate_spectrum() energy_flux, energy_flux_error : tuple of Quantity Tuple of energy flux and energy flux error.
static evaluate(energy, amplitude, reference, alpha, beta)[source]

Evaluate the model (static function).

evaluate_error(self, energy)

Evaluate spectral model with error propagation.

Parameters: energy : Quantity Energy at which to evaluate flux, flux_error : tuple of Quantity Tuple of flux and flux error.
classmethod from_dict(val)

Create from dict.

classmethod from_log10(amplitude, reference, alpha, beta)[source]

Construct LogParabola from $$log_{10}$$ parametrization

integral(self, emin, emax, **kwargs)

Integrate spectral model numerically.

$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 : Quantity Lower and upper bound of integration range. **kwargs : dict Keyword arguments passed to integrate_spectrum()
integral_error(self, emin, emax, **kwargs)

Integrate spectral model numerically with error propagation.

Parameters: emin, emax : Quantity Lower adn upper bound of integration range. **kwargs : dict Keyword arguments passed to func:integrate_spectrum integral, integral_error : tuple of Quantity Tuple of integral flux and integral flux error.
inverse(self, value, emin=<Quantity 0.1 TeV>, emax=<Quantity 100. TeV>)

Return energy for a given function value of the spectral model.

Calls the scipy.optimize.brentq numerical root finding method.

Parameters: value : Quantity Function value of the spectral model. emin : Quantity Lower bracket value in case solution is not unique. emax : Quantity Upper bracket value in case solution is not unique. energy : Quantity Energies at which the model has the given value.
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 : Axes, optional Axis energy_range : Quantity Plot range energy_unit : str, Unit, optional Unit of the energy axis flux_unit : str, 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 ax : Axes, optional Axis
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 : Axes, optional Axis energy_range : Quantity Plot range energy_unit : str, Unit, optional Unit of the energy axis flux_unit : str, 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 ax : Axes, optional Axis
spectral_index(self, energy, epsilon=1e-05)

Compute spectral index at given energy.

Parameters: energy : Quantity Energy at which to estimate the index epsilon : float Fractional energy increment to use for determining the spectral index. index : float Estimated spectral index.
to_dict(self)

Convert to dict.