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 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 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" )