PowerLawSpectralModel¶

class gammapy.modeling.models.PowerLawSpectralModel(index=2.0, amplitude='1e-12 cm-2 s-1 TeV-1', reference='1 TeV')[source]¶

Bases: gammapy.modeling.models.SpectralModel

Spectral power-law model.

\[\phi(E) = \phi_0 \cdot \left( \frac{E}{E_0} \right)^{-\Gamma}\]

Parameters:	index : `Quantity` \(\Gamma\) amplitude : `Quantity` \(\phi_0\) reference : `Quantity` \(E_0\)

Examples

This is how to plot the default PowerLawSpectralModel model:

from astropy import units as u
from gammapy.modeling.models import PowerLawSpectralModel

pwl = PowerLawSpectralModel()
pwl.plot(energy_range=[0.1, 100] * u.TeV)
plt.show()

Attributes Summary

`amplitude`
`index`
`parameters`	Parameters (`Parameters`)
`pivot_energy`	The decorrelation energy is defined as:
`reference`
`tag`

Methods Summary

`__call__`(self, energy)	Call self as a function.
`copy`(self)	A deep copy.
`create`(tag, \args, \\*kwargs)	Create a model instance.
`energy_flux`(self, emin, emax)	Compute energy flux in given energy range analytically.
`energy_flux_error`(self, emin, emax, \\kwargs)	Compute energy flux in given energy range analytically with error propagation.
`evaluate`(energy, index, amplitude, reference)	Evaluate the model (static function).
`evaluate_energy_flux`(emin, emax, index, …)	Evaluate the energy flux (static function)
`evaluate_error`(self, energy)	Evaluate spectral model with error propagation.
`evaluate_integral`(emin, emax, index, …)	Evaluate the model integral (static function).
`from_dict`(data)
`integral`(self, emin, emax, \\kwargs)	Integrate power law analytically.
`integral_error`(self, emin, emax, \\kwargs)	Integrate power law analytically with error propagation.
`inverse`(self, value)	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)

Attributes Documentation

amplitude¶

index¶

parameters¶: Parameters (Parameters)

pivot_energy¶

The decorrelation energy is defined as:

\[E_D = E_0 * \exp{cov(\phi_0, \Gamma) / (\phi_0 \Delta \Gamma^2)}\]

Formula (1) in https://arxiv.org/pdf/0910.4881.pdf

reference¶

tag = 'PowerLawSpectralModel'¶

Methods Documentation

__call__(self, energy)¶: Call self as a function.

copy(self)¶: A deep copy.

static create(tag, *args, **kwargs)¶

Create a model instance.

Examples

>>> from gammapy.modeling import Model
>>> spectral_model = Model.create("PowerLaw2SpectralModel", amplitude="1e-10 cm-2 s-1", index=3)
>>> type(spectral_model)
gammapy.modeling.models.spectral.PowerLaw2SpectralModel

energy_flux(self, emin, emax)[source]¶

Compute energy flux in given energy range analytically.

\[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 : `Quantity` Lower and upper bound of integration range.

energy_flux_error(self, emin, emax, **kwargs)[source]¶

Compute energy flux in given energy range analytically with error propagation.

Parameters:	emin, emax : `Quantity` Lower and upper bound of integration range.
Returns:	energy_flux, energy_flux_error : tuple of `Quantity` Tuple of energy flux and energy flux error.

static evaluate(energy, index, amplitude, reference)[source]¶: Evaluate the model (static function).

static evaluate_energy_flux(emin, emax, index, amplitude, reference)[source]¶: Evaluate the energy flux (static function)

evaluate_error(self, energy)¶

Evaluate spectral model with error propagation.

Parameters:	energy : `Quantity` Energy at which to evaluate
Returns:	flux, flux_error : tuple of `Quantity` Tuple of flux and flux error.

static evaluate_integral(emin, emax, index, amplitude, reference)[source]¶: Evaluate the model integral (static function).

classmethod from_dict(data)¶

integral(self, emin, emax, **kwargs)[source]¶

Integrate power law analytically.

\[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 : `Quantity` Lower and upper bound of integration range

integral_error(self, emin, emax, **kwargs)[source]¶

Integrate power law analytically with error propagation.

Parameters:	emin, emax : `Quantity` Lower and upper bound of integration range.
Returns:	integral, integral_error : tuple of `Quantity` Tuple of integral flux and integral flux error.

inverse(self, value)[source]¶

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

Parameters:	value : `Quantity` Function value of the spectral model.

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.modeling.models import ExpCutoffPowerLawSpectralModel
from astropy import units as u

pwl = ExpCutoffPowerLawSpectralModel()
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
Returns:	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

Returns:

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.
Returns:	index : float Estimated spectral index.

to_dict(self)¶