def EBLabsorbed(self, tab, model, debug=False):
"""
Return the EBL-absorbed model.
Absorption data are either obtained from the Gammapy datasets or form
external proprietary files.
Parameters
----------
tab : TemplateSpectralModel
A flux versus energy as an interpolated table.
model : String
An EBL model name among those available.
debug : Boolean, optional
If True let's talk a bit. The default is False.
Returns
-------
attflux : TemplateSpectralModel
An attenuated flux versus energy as an interpolated table.
"""
attflux = tab
if (model == "gilmore"):
from ebl import EBL_from_file
eblabs = EBL_from_file("EBL/data/ebl_gilmore12-10GeV.dat")
attflux.values = tab.values * eblabs(self.Eval, self.z)
if debug: print(" EBL : Gilmore")
elif model != None and model != 'in-file':
eblabs = EBLAbsorptionNormSpectralModel.read_builtin(
model, redshift=self.z)
attflux = tab * eblabs
if debug: print(" EBL : ", model)
return attflux
def test_absorbed_extrapolate():
ebl_model = "dominguez"
z = 0.0001
alpha_norm = 1
absorption = EBLAbsorptionNormSpectralModel.read_builtin(ebl_model)
values = absorption.evaluate(1 * u.TeV, z, alpha_norm)
assert_allclose(values, 1)
def test_absorption():
# absorption values for given redshift
redshift = 0.117
absorption = EBLAbsorptionNormSpectralModel.read_builtin("dominguez",
redshift=redshift)
# Spectral model corresponding to PKS 2155-304 (quiescent state)
index = 3.53
amplitude = 1.81 * 1e-12 * u.Unit("cm-2 s-1 TeV-1")
reference = 1 * u.TeV
pwl = PowerLawSpectralModel(index=index,
amplitude=amplitude,
reference=reference)
# EBL + PWL model
model = pwl * absorption
desired = u.Quantity(5.140765e-13, "TeV-1 s-1 cm-2")
assert_quantity_allclose(model(1 * u.TeV), desired, rtol=1e-3)
assert model.model2.alpha_norm.value == 1.0
# EBL + PWL model: test if norm of EBL=0: it mean model =pwl
model.parameters["alpha_norm"].value = 0
assert_quantity_allclose(model(1 * u.TeV), pwl(1 * u.TeV), rtol=1e-3)
# EBL + PWL model: Test with a norm different of 1
absorption = EBLAbsorptionNormSpectralModel.read_builtin("dominguez",
redshift=redshift,
alpha_norm=1.5)
model = pwl * absorption
desired = u.Quantity(2.739695e-13, "TeV-1 s-1 cm-2")
assert model.model2.alpha_norm.value == 1.5
assert_quantity_allclose(model(1 * u.TeV), desired, rtol=1e-3)
# Test error propagation
model.model1.amplitude.error = 0.1 * model.model1.amplitude.value
dnde, dnde_err = model.evaluate_error(1 * u.TeV)
assert_allclose(dnde_err / dnde, 0.1)
def test_absorption_io(tmp_path):
dominguez = EBLAbsorptionNormSpectralModel.read_builtin("dominguez",
redshift=0.5)
assert len(dominguez.parameters) == 2
model_dict = dominguez.to_dict()
parnames = [_["name"] for _ in model_dict["parameters"]]
assert parnames == [
"alpha_norm",
"redshift",
]
new_model = EBLAbsorptionNormSpectralModel.from_dict(model_dict)
assert new_model.redshift.value == 0.5
assert new_model.alpha_norm.name == "alpha_norm"
assert new_model.alpha_norm.value == 1
assert_allclose(new_model.energy, dominguez.energy)
assert_allclose(new_model.param, dominguez.param)
assert len(new_model.parameters) == 2
model = EBLAbsorptionNormSpectralModel(
u.Quantity(range(3), "keV"),
u.Quantity(range(2), ""),
u.Quantity(np.ones((2, 3)), ""),
redshift=0.5,
alpha_norm=1,
)
model_dict = model.to_dict()
new_model = EBLAbsorptionNormSpectralModel.from_dict(model_dict)
assert_allclose(new_model.energy, model.energy)
assert_allclose(new_model.param, model.param)
assert_allclose(new_model.data, model.data)
write_yaml(model_dict, tmp_path / "tmp.yaml")
read_yaml(tmp_path / "tmp.yaml")
# Here is an example plot of the model:
from astropy import units as u
import matplotlib.pyplot as plt
from gammapy.modeling.models import (
EBLAbsorptionNormSpectralModel,
Models,
PowerLawSpectralModel,
SkyModel,
)
# Here we illustrate how to create and plot EBL absorption models for a redshift of 0.5
# sphinx_gallery_thumbnail_number = 1
redshift = 0.5
dominguez = EBLAbsorptionNormSpectralModel.read_builtin("dominguez",
redshift=redshift)
franceschini = EBLAbsorptionNormSpectralModel.read_builtin("franceschini",
redshift=redshift)
finke = EBLAbsorptionNormSpectralModel.read_builtin("finke", redshift=redshift)
plt.figure()
energy_bounds = [0.08, 3] * u.TeV
opts = dict(energy_bounds=energy_bounds, xunits=u.TeV)
franceschini.plot(label="Franceschini 2008", **opts)
finke.plot(label="Finke 2010", **opts)
dominguez.plot(label="Dominguez 2011", **opts)
plt.ylabel(r"Absorption coefficient [$\exp{(-\tau(E))}$]")
plt.xlim(energy_bounds.value)
plt.ylim(1e-4, 2)
plt.title(f"EBL models (z={redshift})")