def test_wrong_units():
energy_axis_true = MapAxis.from_energy_bounds(
"1 TeV", "10 TeV", nbin=10, name="energy_true"
)
offset_axis = MapAxis.from_bounds(0 * u.deg, 2 * u.deg, nbin=2, name='offset')
wrong_unit = u.TeV
data = np.ones((energy_axis_true.nbin, offset_axis.nbin)) * wrong_unit
area_test = EffectiveAreaTable2D(axes=[energy_axis_true, offset_axis])
with pytest.raises(ValueError) as error:
EffectiveAreaTable2D(data=data, axes=[energy_axis_true, offset_axis])
assert error.match(f"Error: {wrong_unit} is not an allowed unit. {area_test.tag} requires {area_test.default_unit} data quantities.")
def get_irfs(config, filename):
'''Get IRFs from file.
Parameters
----------
config : `dict`
Configuration dictionary.
filename : fits file
IRFs file
Returns
-------
irfs : `dict`
IRFs dictionary.
'''
offset = Angle(config['selection']['offset_fov'] * u.deg)
psf_fov = EnergyDependentMultiGaussPSF.read(filename, hdu='POINT SPREAD FUNCTION')
psf = psf_fov.to_energy_dependent_table_psf(theta=offset)
print(' psf', psf)
aeff = EffectiveAreaTable2D.read(filename, hdu='EFFECTIVE AREA')
edisp_fov = EnergyDispersion2D.read(filename, hdu='ENERGY DISPERSION')
table = fits.open('irf_file.fits')['BACKGROUND']
table.columns.change_name(str('BGD'), str('Bgd'))
table.header['TUNIT7'] = '1 / (MeV s sr)'
bkg = Background3D.read(filename, hdu='BACKGROUND')
irfs = dict(psf=psf, aeff=aeff, edisp=edisp_fov, bkg=bkg, offset=offset)
return irfs
def get_irfs():
filename = '$GAMMAPY_EXTRA/datasets/cta-1dc/caldb/data/cta//1dc/bcf/South_z20_50h/irf_file.fits'
psf = EnergyDependentMultiGaussPSF.read(filename, hdu='POINT SPREAD FUNCTION')
aeff = EffectiveAreaTable2D.read(filename, hdu='EFFECTIVE AREA')
edisp = EnergyDispersion2D.read(filename, hdu='ENERGY DISPERSION')
bkg = Background3D.read(filename, hdu='BACKGROUND')
return dict(psf=psf, aeff=aeff, edisp=edisp, bkg=bkg)
def create_effective_area_table_2d(
effective_area,
true_energy_bins,
fov_offset_bins,
):
'''
Create a ``gammapy.irf.EffectiveAreaTable2D`` from pyirf outputs.
Parameters
----------
effective_area: astropy.units.Quantity[area]
Effective area array, must have shape (n_energy_bins, n_fov_offset_bins)
true_energy_bins: astropy.units.Quantity[energy]
Bin edges in true energy
fov_offset_bins: astropy.units.Quantity[angle]
Bin edges in the field of view offset.
For Point-Like IRFs, only giving a single bin is appropriate.
Returns
-------
gammapy.irf.EffectiveAreaTable2D
'''
offset_axis = _create_offset_axis(fov_offset_bins)
energy_axis_true = _create_energy_axis_true(true_energy_bins)
return EffectiveAreaTable2D(
energy_axis_true=energy_axis_true,
offset_axis=offset_axis,
data=effective_area,
)
def read(cls, filename):
"""Read from a FITS file.
Parameters
----------
filename : `str`
File containing the IRFs
"""
filename = str(make_path(filename))
hdu_list = fits.open(filename)
aeff = EffectiveAreaTable2D.read(filename, hdu='EFFECTIVE AREA')
bkg = Background3D.read(filename, hdu='BACKGROUND')
edisp = EnergyDispersion2D.read(filename, hdu='ENERGY DISPERSION')
psf = EnergyDependentMultiGaussPSF.read(filename, hdu='POINT SPREAD FUNCTION')
if 'SENSITIVITY' in hdu_list:
sensi = SensitivityTable.read(filename, hdu='SENSITIVITY')
else:
sensi = None
return cls(
aeff=aeff,
bkg=bkg,
edisp=edisp,
psf=psf,
ref_sensi=sensi,
)
def read(cls, filename):
"""Read from a FITS file.
Parameters
----------
filename : `str`
File containing the IRFs
"""
filename = str(make_path(filename))
hdu_list = fits.open(filename)
aeff = EffectiveAreaTable2D.read(filename, hdu='EFFECTIVE AREA')
bkg = Background3D.read(filename, hdu='BACKGROUND')
edisp = EnergyDispersion2D.read(filename, hdu='ENERGY DISPERSION')
psf = EnergyDependentMultiGaussPSF.read(filename,
hdu='POINT SPREAD FUNCTION')
if 'SENSITIVITY' in hdu_list:
sensi = SensitivityTable.read(filename, hdu='SENSITIVITY')
else:
sensi = None
return cls(
aeff=aeff,
bkg=bkg,
edisp=edisp,
psf=psf,
ref_sensi=sensi,
)
def test_from_parametrization():
# Log center of this is 100 GeV
area_ref = 1.65469579e07 * u.cm ** 2
axis = MapAxis.from_energy_edges([80, 125] * u.GeV, name="energy_true")
area = EffectiveAreaTable2D.from_parametrization(axis, "HESS")
assert_allclose(area.quantity, area_ref)
assert area.unit == area_ref.unit
# Log center of this is 0.1, 2 TeV
area_ref = [1.65469579e07, 1.46451957e09] * u.cm * u.cm
axis = MapAxis.from_energy_edges([0.08, 0.125, 32] * u.TeV, name="energy_true")
area = EffectiveAreaTable2D.from_parametrization(axis, "HESS")
assert_allclose(area.quantity[:, 0], area_ref)
assert area.unit == area_ref.unit
def test_aeff2d_pointlike():
filename = "$GAMMAPY_DATA/joint-crab/dl3/magic/run_05029748_DL3.fits"
aeff = EffectiveAreaTable2D.read(filename)
hdu = aeff.to_table_hdu()
assert aeff.is_pointlike
assert hdu.header["HDUCLAS3"] == "POINT-LIKE"
def check_aeff(label):
irf_file = '1dc/1dc/caldb/data/cta/1dc/bcf/' + label + '/irf_file.fits'
log.info(f'Reading {irf_file}')
aeff = EffectiveAreaTable2D.read(irf_file, hdu='EFFECTIVE AREA')
aeff.peek()
filename = 'checks/irfs/' + label + '_aeff.png'
log.info(f'Writing {filename}')
plt.savefig(filename)
def get_irfs():
"""Load CTA IRFs"""
filename = "$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits"
psf = EnergyDependentMultiGaussPSF.read(filename,
hdu="POINT SPREAD FUNCTION")
aeff = EffectiveAreaTable2D.read(filename, hdu="EFFECTIVE AREA")
edisp = EnergyDispersion2D.read(filename, hdu="ENERGY DISPERSION")
bkg = Background3D.read(filename, hdu="BACKGROUND")
return dict(psf=psf, aeff=aeff, edisp=edisp, bkg=bkg)
def setup(self):
self.energy_lo = np.logspace(0, 1, 10)[:-1] * u.TeV
self.energy_hi = np.logspace(0, 1, 10)[1:] * u.TeV
self.energy_axis_true = MapAxis.from_energy_bounds("1 TeV",
"10 TeV",
nbin=9,
name="energy_true")
self.offset_lo = np.linspace(0, 1, 4)[:-1] * u.deg
self.offset_hi = np.linspace(0, 1, 4)[1:] * u.deg
self.offset_axis = MapAxis.from_bounds(0,
1,
nbin=3,
unit="deg",
name="offset",
node_type="edges")
self.migra_lo = np.linspace(0, 3, 4)[:-1]
self.migra_hi = np.linspace(0, 3, 4)[1:]
self.migra_axis = MapAxis.from_bounds(0,
3,
nbin=3,
name="migra",
node_type="edges")
self.fov_lon_lo = np.linspace(-6, 6, 11)[:-1] * u.deg
self.fov_lon_hi = np.linspace(-6, 6, 11)[1:] * u.deg
self.fov_lon_axis = MapAxis.from_bounds(-6, 6, nbin=10, name="fov_lon")
self.fov_lat_lo = np.linspace(-6, 6, 11)[:-1] * u.deg
self.fov_lat_hi = np.linspace(-6, 6, 11)[1:] * u.deg
self.fov_lat_axis = MapAxis.from_bounds(-6, 6, nbin=10, name="fov_lat")
self.aeff_data = np.random.rand(9, 3) * u.cm * u.cm
self.edisp_data = np.random.rand(9, 3, 3)
self.bkg_data = np.random.rand(9, 10, 10) / u.MeV / u.s / u.sr
self.aeff = EffectiveAreaTable2D(
axes=[self.energy_axis_true, self.offset_axis],
data=self.aeff_data.value,
unit=self.aeff_data.unit,
)
self.edisp = EnergyDispersion2D(
axes=[
self.energy_axis_true,
self.migra_axis,
self.offset_axis,
],
data=self.edisp_data,
)
axes = [
self.energy_axis_true.copy(name="energy"),
self.fov_lon_axis,
self.fov_lat_axis,
]
self.bkg = Background3D(axes=axes,
data=self.bkg_data.value,
unit=self.bkg_data.unit)
def fake_aeff2d(area=1e6 * u.m ** 2):
energy_axis_true = MapAxis.from_energy_bounds(
"0.1 TeV", "10 TeV", nbin=4, name="energy_true"
)
offset_axis = MapAxis.from_edges([0.0, 1.0, 2.0, 3.0] * u.deg, name="offset")
return EffectiveAreaTable2D(
axes=[energy_axis_true, offset_axis], data=area.value, unit=area.unit
)
def test_to_table_is_pointlike():
energy_axis = MapAxis.from_energy_bounds('1 TeV', '10 TeV',
nbin=3, name='energy_true')
offset_axis = MapAxis.from_bounds(0 * u.deg, 2 * u.deg,
nbin=2, name='offset')
aeff = EffectiveAreaTable2D(data=np.ones((3, 2)) * u.m**2,
axes=[energy_axis, offset_axis])
hdu = aeff.to_table_hdu()
assert "is_pointlike" not in hdu.header
def simulate_spectrum_dataset(model, random_state=0):
energy_edges = np.logspace(-0.5, 1.5, 21) * u.TeV
energy_axis = MapAxis.from_edges(energy_edges, interp="log", name="energy")
energy_axis_true = energy_axis.copy(name="energy_true")
aeff = EffectiveAreaTable2D.from_parametrization(
energy_axis_true=energy_axis_true)
bkg_model = SkyModel(
spectral_model=PowerLawSpectralModel(index=2.5,
amplitude="1e-12 cm-2 s-1 TeV-1"),
name="background",
)
bkg_model.spectral_model.amplitude.frozen = True
bkg_model.spectral_model.index.frozen = True
geom = RegionGeom.create(region="icrs;circle(0, 0, 0.1)",
axes=[energy_axis])
acceptance = RegionNDMap.from_geom(geom=geom, data=1)
edisp = EDispKernelMap.from_diagonal_response(
energy_axis=energy_axis,
energy_axis_true=energy_axis_true,
geom=geom,
)
geom_true = RegionGeom.create(region="icrs;circle(0, 0, 0.1)",
axes=[energy_axis_true])
exposure = make_map_exposure_true_energy(pointing=SkyCoord("0d", "0d"),
aeff=aeff,
livetime=100 * u.h,
geom=geom_true)
mask_safe = RegionNDMap.from_geom(geom=geom, dtype=bool)
mask_safe.data += True
acceptance_off = RegionNDMap.from_geom(geom=geom, data=5)
dataset = SpectrumDatasetOnOff(
name="test_onoff",
exposure=exposure,
acceptance=acceptance,
acceptance_off=acceptance_off,
edisp=edisp,
mask_safe=mask_safe,
)
dataset.models = bkg_model
bkg_npred = dataset.npred_signal()
dataset.models = model
dataset.fake(
random_state=random_state,
npred_background=bkg_npred,
)
return dataset
def test_effective_area2d_gammapy(aeff2d_hdus):
'''Test our effective area is readable by gammapy'''
from gammapy.irf import EffectiveAreaTable2D
area, hdus = aeff2d_hdus
for hdu in hdus:
with tempfile.NamedTemporaryFile(suffix='.fits') as f:
fits.HDUList([fits.PrimaryHDU(), hdu]).writeto(f.name)
# test reading with gammapy works
aeff2d = EffectiveAreaTable2D.read(f.name)
assert u.allclose(area, aeff2d.data.data, atol=1e-16 * u.m**2)
def test_to_table():
energy_axis_true = MapAxis.from_energy_bounds(
"1 TeV", "10 TeV", nbin=10, name="energy_true"
)
offset_axis = MapAxis.from_bounds(0, 1, nbin=4, name="offset", unit="deg")
aeff = EffectiveAreaTable2D(
axes=[energy_axis_true, offset_axis], data=1, unit="cm2"
)
hdu = aeff.to_table_hdu()
assert_equal(hdu.data["ENERG_LO"][0], aeff.axes["energy_true"].edges[:-1].value)
assert hdu.header["TUNIT1"] == aeff.axes["energy_true"].unit
def get_exposure(geom_etrue):
filename = (
"$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits"
)
aeff = EffectiveAreaTable2D.read(filename, hdu="EFFECTIVE AREA")
exposure_map = make_map_exposure_true_energy(
pointing=SkyCoord(1, 0.5, unit="deg", frame="galactic"),
livetime=1 * u.hr,
aeff=aeff,
geom=geom_etrue,
)
return exposure_map
def fake_aeff2d(area=1e6 * u.m ** 2):
offsets = np.array((0.0, 1.0, 2.0, 3.0)) * u.deg
energy_axis_true = MapAxis.from_energy_bounds(
"0.1 TeV", "10 TeV", nbin=4, name="energy_true"
)
offset_axis = MapAxis.from_edges(offsets, name="offset")
aeff_values = np.ones((4, 3)) * area
return EffectiveAreaTable2D(
energy_axis_true=energy_axis_true, offset_axis=offset_axis, data=aeff_values,
)
def test_wrong_axis_order():
energy_axis_true = MapAxis.from_energy_bounds(
"1 TeV", "10 TeV", nbin=10, name="energy_true"
)
offset = np.linspace(0, 1, 4) * u.deg
offset_axis = MapAxis.from_nodes(offset, name="offset")
data = np.ones(shape=(offset_axis.nbin, energy_axis_true.nbin))
with pytest.raises(ValueError):
EffectiveAreaTable2D(
axes=[energy_axis_true, offset_axis], data=data, unit="cm2"
)
def test_wrong_axis_order():
energy_axis_true = MapAxis.from_energy_bounds(
"1 TeV", "10 TeV", nbin=10, name="energy_true"
)
offset = np.linspace(0, 1, 4) * u.deg
offset_axis = MapAxis.from_nodes(offset, name="offset")
data = np.ones(shape=(offset_axis.nbin, energy_axis_true.nbin)) * u.cm ** 2
with pytest.raises(AssertionError):
EffectiveAreaTable2D(
energy_axis_true=energy_axis_true, offset_axis=offset_axis, data=data,
)
def fake_aeff2d(area=1e6 * u.m**2):
offsets = np.array((0.0, 1.0, 2.0, 3.0)) * u.deg
energy = np.logspace(-1, 1, 5) * u.TeV
energy_lo = energy[:-1]
energy_hi = energy[1:]
aeff_values = np.ones((4, 3)) * area
return EffectiveAreaTable2D(
energy_lo,
energy_hi,
offset_lo=offsets[:-1],
offset_hi=offsets[1:],
data=aeff_values,
)
def load_irf(self):
filename = os.path.join(self.outdir, "irf.fits.gz")
with fits.open(filename, memmap=False) as hdulist:
aeff = EffectiveAreaTable2D.from_hdulist(hdulist=hdulist)
edisp = EnergyDispersion2D.read(filename, hdu="ENERGY DISPERSION")
bkg_fits_table = hdulist["BACKGROUND"]
bkg_table = Table.read(bkg_fits_table)
energy_lo = bkg_table["ENERG_LO"].quantity
energy_hi = bkg_table["ENERG_HI"].quantity
bkg = bkg_table["BGD"].quantity
axes = [
BinnedDataAxis(energy_lo,
energy_hi,
interpolation_mode="log",
name="energy")
]
bkg = BkgData(data=NDDataArray(axes=axes, data=bkg))
# Create rmf with appropriate dimensions (e_reco->bkg, e_true->area)
e_reco_min = bkg.energy.lo[0]
e_reco_max = bkg.energy.hi[-1]
e_reco_bin = bkg.energy.nbins
e_reco_axis = EnergyBounds.equal_log_spacing(e_reco_min, e_reco_max,
e_reco_bin, "TeV")
e_true_min = aeff.data.axes[0].lo[0]
e_true_max = aeff.data.axes[0].hi[-1]
e_true_bin = len(aeff.data.axes[0].bins) - 1
e_true_axis = EnergyBounds.equal_log_spacing(e_true_min, e_true_max,
e_true_bin, "TeV")
# Fake offset...
rmf = edisp.to_energy_dispersion(offset=0.5 * u.deg,
e_reco=e_reco_axis,
e_true=e_true_axis)
# This is required because in gammapy v0.8
# gammapy.spectrum.utils.integrate_model
# calls the attribute aeff.energy which is an attribute of
# EffectiveAreaTable and not of EffectiveAreaTable2D
# WARNING the angle is not important, but only because we started with
# on-axis data! TO UPDATE
aeff = aeff.to_effective_area_table(Angle("1d"))
self.irf = Irf(bkg=bkg, aeff=aeff, rmf=rmf)
def load(self):
"""Load HDU as appropriate class.
TODO: this should probably go via an extensible registry.
"""
hdu_class = self.hdu_class
filename = self.path()
hdu = self.hdu_name
if hdu_class == "events":
from gammapy.data import EventList
return EventList.read(filename, hdu=hdu)
elif hdu_class == "gti":
from gammapy.data import GTI
return GTI.read(filename, hdu=hdu)
elif hdu_class == "aeff_2d":
from gammapy.irf import EffectiveAreaTable2D
return EffectiveAreaTable2D.read(filename, hdu=hdu)
elif hdu_class == "edisp_2d":
from gammapy.irf import EnergyDispersion2D
return EnergyDispersion2D.read(filename, hdu=hdu)
elif hdu_class == "psf_table":
from gammapy.irf import PSF3D
return PSF3D.read(filename, hdu=hdu)
elif hdu_class == "psf_3gauss":
from gammapy.irf import EnergyDependentMultiGaussPSF
return EnergyDependentMultiGaussPSF.read(filename, hdu=hdu)
elif hdu_class == "psf_king":
from gammapy.irf import PSFKing
return PSFKing.read(filename, hdu=hdu)
elif hdu_class == "bkg_2d":
from gammapy.irf import Background2D
return Background2D.read(filename, hdu=hdu)
elif hdu_class == "bkg_3d":
from gammapy.irf import Background3D
return Background3D.read(filename, hdu=hdu)
else:
raise ValueError(f"Invalid hdu_class: {hdu_class}")
def test_writeread(self, tmp_path):
path = tmp_path / "tmp.fits"
fits.HDUList([
fits.PrimaryHDU(),
self.aeff.to_table_hdu(),
self.edisp.to_table_hdu(),
self.bkg.to_table_hdu(),
]).writeto(path)
read_aeff = EffectiveAreaTable2D.read(path, hdu="EFFECTIVE AREA")
assert_allclose(read_aeff.data.data, self.aeff_data)
read_edisp = EnergyDispersion2D.read(path, hdu="ENERGY DISPERSION")
assert_allclose(read_edisp.data.data, self.edisp_data)
read_bkg = Background3D.read(path, hdu="BACKGROUND")
assert_allclose(read_bkg.data.data, self.bkg_data)
def get_irfs(config):
filename = '$GAMMAPY_EXTRA/datasets/cta-1dc/caldb/data/cta//1dc/bcf/South_z20_50h/irf_file.fits'
offset = Angle(config['selection']['offset_fov'] * u.deg)
psf_fov = EnergyDependentMultiGaussPSF.read(filename, hdu='POINT SPREAD FUNCTION')
psf = psf_fov.to_energy_dependent_table_psf(theta=offset)
print(' psf', psf)
aeff = EffectiveAreaTable2D.read(filename, hdu='EFFECTIVE AREA')
edisp_fov = EnergyDispersion2D.read(filename, hdu='ENERGY DISPERSION')
edisp = edisp_fov.to_energy_dispersion(offset=offset)
# TODO: read background once it's working!
# bkg = Background3D.read(filename, hdu='BACKGROUND')
return dict(psf=psf, aeff=aeff, edisp=edisp)
def test_write():
energy_axis_true = MapAxis.from_energy_bounds(
"1 TeV", "10 TeV", nbin=10, name="energy_true"
)
offset = np.linspace(0, 1, 4) * u.deg
offset_axis = MapAxis.from_nodes(offset, name="offset")
data = np.ones(shape=(energy_axis_true.nbin, offset_axis.nbin)) * u.cm ** 2
aeff = EffectiveAreaTable2D(
energy_axis_true=energy_axis_true, offset_axis=offset_axis, data=data,
)
hdu = aeff.to_table_hdu()
assert_equal(
hdu.data["ENERG_LO"][0], aeff.data.axes["energy_true"].edges[:-1].value
)
assert hdu.header["TUNIT1"] == aeff.data.axes["energy_true"].unit
def get_irfs(config):
filename = '$GAMMAPY_EXTRA/datasets/cta-1dc/caldb/data/cta//1dc/bcf/South_z20_50h/irf_file.fits'
offset = Angle(config['selection']['offset_fov'] * u.deg)
psf_fov = EnergyDependentMultiGaussPSF.read(filename,
hdu='POINT SPREAD FUNCTION')
psf = psf_fov.to_energy_dependent_table_psf(theta=offset)
print(' psf', psf)
aeff = EffectiveAreaTable2D.read(filename, hdu='EFFECTIVE AREA')
edisp_fov = EnergyDispersion2D.read(filename, hdu='ENERGY DISPERSION')
edisp = edisp_fov.to_energy_dispersion(offset=offset)
# TODO: read background once it's working!
# bkg = Background3D.read(filename, hdu='BACKGROUND')
return dict(psf=psf, aeff=aeff, edisp=edisp)
def test_writeread(self, tmpdir):
filename = str(tmpdir / "testirf.fits")
fits.HDUList([
fits.PrimaryHDU(),
self.aeff.to_fits(),
self.edisp.to_fits(),
self.bkg.to_fits(),
]).writeto(filename)
read_aeff = EffectiveAreaTable2D.read(filename=filename,
hdu="EFFECTIVE AREA")
assert_allclose(read_aeff.data.data, self.aeff_data)
read_edisp = EnergyDispersion2D.read(filename=filename,
hdu="ENERGY DISPERSION")
assert_allclose(read_edisp.data.data, self.edisp_data)
read_bkg = Background3D.read(filename=filename, hdu="BACKGROUND")
assert_allclose(read_bkg.data.data, self.bkg_data)
def test_rad_max_from_irf():
e_bins = 3
o_bins = 2
energy_axis = MapAxis.from_energy_bounds(1 * u.TeV,
10 * u.TeV,
nbin=e_bins,
name='energy_true')
offset_axis = MapAxis.from_bounds(0 * u.deg,
3 * u.deg,
nbin=o_bins,
name='offset')
aeff = EffectiveAreaTable2D(
data=u.Quantity(np.ones((e_bins, o_bins)), u.m**2, copy=False),
axes=[energy_axis, offset_axis],
is_pointlike=True,
)
with pytest.raises(ValueError):
# not a point-like IRF
RadMax2D.from_irf(aeff)
with pytest.raises(ValueError):
# missing rad_max
RadMax2D.from_irf(aeff)
aeff.meta['RAD_MAX'] = '0.2 deg'
with pytest.raises(ValueError):
# invalid format
RadMax2D.from_irf(aeff)
aeff.meta['RAD_MAX'] = 0.2
rad_max = RadMax2D.from_irf(aeff)
assert rad_max.axes['energy'].nbin == 1
assert rad_max.axes['offset'].nbin == 1
assert rad_max.axes['energy'].edges[0] == aeff.axes['energy_true'].edges[0]
assert rad_max.axes['energy'].edges[1] == aeff.axes['energy_true'].edges[
-1]
assert rad_max.axes['offset'].edges[0] == aeff.axes['offset'].edges[0]
assert rad_max.axes['offset'].edges[1] == aeff.axes['offset'].edges[-1]
assert rad_max.quantity.shape == (1, 1)
assert rad_max.quantity[0, 0] == 0.2 * u.deg
def test_write():
energy = np.logspace(0, 1, 11) * u.TeV
energy_lo = energy[:-1]
energy_hi = energy[1:]
offset = np.linspace(0, 1, 4) * u.deg
offset_lo = offset[:-1]
offset_hi = offset[1:]
data = np.ones(shape=(len(energy_lo), len(offset_lo))) * u.cm * u.cm
aeff = EffectiveAreaTable2D(
energy_lo=energy_lo,
energy_hi=energy_hi,
offset_lo=offset_lo,
offset_hi=offset_hi,
data=data,
)
hdu = aeff.to_fits()
assert_equal(hdu.data["ENERG_LO"][0],
aeff.data.axis("energy").edges[:-1].value)
assert hdu.header["TUNIT1"] == aeff.data.axis("energy").unit
def test_effective_area_2d_to_gadf():
from gammapy.irf import EffectiveAreaTable2D
from gammapy.maps import MapAxis
energy_axis = MapAxis.from_energy_bounds(1 * u.TeV,
10 * u.TeV,
nbin=3,
name='energy_true')
offset_axis = MapAxis.from_bounds(0 * u.deg,
2 * u.deg,
nbin=2,
name='offset')
data = np.ones((energy_axis.nbin, offset_axis.nbin)) * u.m**2
aeff = EffectiveAreaTable2D(data=data, axes=[energy_axis, offset_axis])
hdu = aeff.to_table_hdu(format='gadf-dl3')
columns = {column.name for column in hdu.columns}
mandatory_columns = {
'ENERG_LO',
'ENERG_HI',
'THETA_LO',
'THETA_HI',
'EFFAREA',
}
missing = mandatory_columns.difference(columns)
assert len(missing) == 0, f'GADF HDU missing required column(s) {missing}'
header = hdu.header
assert header['HDUCLASS'] == 'GADF'
assert header[
'HDUDOC'] == 'https://github.com/open-gamma-ray-astro/gamma-astro-data-formats'
assert header['HDUVERS'] == '0.2'
assert header['HDUCLAS1'] == 'RESPONSE'
assert header['HDUCLAS2'] == 'EFF_AREA'
assert header['HDUCLAS3'] == 'FULL-ENCLOSURE'
assert header['HDUCLAS4'] == 'AEFF_2D'
assert header['EXTNAME'] == 'EFFECTIVE AREA'
def test_effective_area2d():
'''Test our effective area is readable by gammapy'''
pytest.importorskip('gammapy')
from pyirf.io import create_aeff2d_hdu
from gammapy.irf import EffectiveAreaTable2D
e_bins = np.geomspace(0.1, 100, 31) * u.TeV
fov_bins = [0, 1, 2, 3] * u.deg
area = np.full((30, 3), 1e6) * u.m**2
for point_like in [True, False]:
with tempfile.NamedTemporaryFile(suffix='.fits') as f:
hdu = create_aeff2d_hdu(area,
e_bins,
fov_bins,
point_like=point_like)
fits.HDUList([fits.PrimaryHDU(), hdu]).writeto(f.name)
# test reading with gammapy works
aeff2d = EffectiveAreaTable2D.read(f.name)
assert u.allclose(area, aeff2d.data.data, atol=1e-16 * u.m**2)
from astropy import units as u
from gammapy.utils.fits import get_hdu
from gammapy.irf import EffectiveAreaTable2D
import matplotlib.pyplot as plt
irf_path = 'perf_prod2/South_5h/irf_file.fits.gz'
table_hdu_area = get_hdu(irf_path + '[EFFECTIVE AREA]')
table_area = Table(table_hdu_area.data)
# Needed fix
table_area['ENERG_LO'].unit = u.TeV
table_area['ENERG_HI'].unit = u.TeV
table_area['THETA_LO'].unit = u.deg
table_area['THETA_HI'].unit = u.deg
table_area['EFFAREA'].unit = u.m * u.m
table_area['EFFAREA_RECO'].unit = u.m * u.m
# End
eff_area_2d = EffectiveAreaTable2D.from_table(table_area)
eff_area = eff_area_2d.to_effective_area_table(offset=0.5 * u.deg)
plt.figure('AREA')
ax = eff_area.plot()
ax.set_yscale('log')
plt.show(block=False)
import matplotlib.pyplot as plt
import numpy as np
import astropy.units as u
from astropy.coordinates import SkyCoord
from gammapy.irf import EffectiveAreaTable2D
from gammapy.maps import WcsGeom, MapAxis, WcsNDMap
from gammapy.spectrum.models import PowerLaw
from gammapy.image.models import SkyGaussian
from gammapy.utils.random import get_random_state
from gammapy.cube import make_map_exposure_true_energy, MapFit, MapEvaluator
from gammapy.cube.models import SkyModel
filename = "$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits"
aeff = EffectiveAreaTable2D.read(filename, hdu="EFFECTIVE AREA")
# Define sky model to simulate the data
lon_0_1 = 0.2
lon_0_2 = 0.4
lat_0_1 = 0.1
lat_0_2 = 0.6
spatial_model_1 = SkyGaussian(
lon_0=lon_0_1 * u.deg, lat_0=lat_0_1 * u.deg, sigma="0.3 deg"
)
spatial_model_2 = SkyGaussian(
lon_0=lon_0_2 * u.deg, lat_0=lat_0_2 * u.deg, sigma="0.2 deg"
)
spectral_model_1 = PowerLaw(
index=3, amplitude="1e-11 cm-2 s-1 TeV-1", reference="1 TeV"
)
