def observations_magic():
observations = [
Observation.read(
"$GAMMAPY_DATA/magic/rad_max/data/magic_dl3_run_05029747.fits"),
Observation.read(
"$GAMMAPY_DATA/magic/rad_max/data/magic_dl3_run_05029748.fits"),
]
return observations
def observations_magic_rad_max():
observations = [
Observation.read(
"$GAMMAPY_DATA/magic/rad_max/data/20131004_05029747_DL3_CrabNebula-W0.40+035.fits"
),
Observation.read(
"$GAMMAPY_DATA/magic/rad_max/data/20131004_05029748_DL3_CrabNebula-W0.40+215.fits"
),
]
return observations
def test_mde_run_switchoff(dataset, models):
irfs = load_cta_irfs(
"$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits"
)
livetime = 1.0 * u.hr
pointing = SkyCoord(0, 0, unit="deg", frame="galactic")
obs = Observation.create(obs_id=1001,
pointing=pointing,
livetime=livetime,
irfs=irfs)
dataset.models = models
dataset.psf = None
dataset.edisp = None
dataset.background = None
sampler = MapDatasetEventSampler(random_state=0)
events = sampler.run(dataset=dataset, observation=obs)
assert len(events.table) == 88
assert_allclose(events.table["ENERGY"][0], 2.751205, rtol=1e-5)
assert_allclose(events.table["RA"][0], 266.559566, rtol=1e-5)
assert_allclose(events.table["DEC"][0], -28.742429, rtol=1e-5)
meta = events.table.meta
assert meta["RA_PNT"] == 266.4049882865447
assert meta["ONTIME"] == 3600.0
assert meta["OBS_ID"] == 1001
assert meta["RADECSYS"] == "icrs"
def test_mde_run(dataset):
irfs = load_cta_irfs(
"$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits"
)
livetime = 10.0 * u.hr
pointing = SkyCoord(0, 0, unit="deg", frame="galactic")
obs = Observation.create(obs_id=1001,
pointing=pointing,
livetime=livetime,
irfs=irfs)
sampler = MapDatasetEventSampler(random_state=0)
events = sampler.run(dataset=dataset, observation=obs)
dataset_bkg = dataset.copy()
dataset_bkg.models = dataset_bkg.models[1]
events_bkg = sampler.run(dataset=dataset_bkg, observation=obs)
assert len(events.table) == 2422
assert_allclose(events.table["ENERGY"][0], 1.56446303986587, rtol=1e-5)
assert_allclose(events.table["RA"][0], 268.8180057255861, rtol=1e-5)
assert_allclose(events.table["DEC"][0], -28.45051813404372, rtol=1e-5)
assert len(events_bkg.table) == 12
assert_allclose(events_bkg.table["ENERGY"][0], 1.377619454, rtol=1e-5)
assert_allclose(events_bkg.table["RA"][0], 265.09135019, rtol=1e-5)
assert_allclose(events_bkg.table["DEC"][0], -30.631115659801, rtol=1e-5)
assert_allclose(events_bkg.table["MC_ID"][0], 0, rtol=1e-5)
meta = events.table.meta
assert meta["RA_PNT"] == 266.4049882865447
assert meta["ONTIME"] == 36000.0
assert meta["OBS_ID"] == 1001
assert meta["RADECSYS"] == "icrs"
def test_events_datastore(tmp_path, dataset, models):
irfs = load_cta_irfs(
"$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits"
)
livetime = 10.0 * u.hr
pointing = SkyCoord(0, 0, unit="deg", frame="galactic")
obs = Observation.create(
obs_id=1001,
pointing=pointing,
livetime=livetime,
irfs=irfs,
location=LOCATION,
)
dataset.models = models
sampler = MapDatasetEventSampler(random_state=0)
events = sampler.run(dataset=dataset, observation=obs)
primary_hdu = fits.PrimaryHDU()
hdu_evt = fits.BinTableHDU(events.table)
hdu_gti = fits.BinTableHDU(dataset.gti.table, name="GTI")
hdu_all = fits.HDUList([primary_hdu, hdu_evt, hdu_gti])
hdu_all.writeto(str(tmp_path / "events.fits"))
DataStore.from_events_files([str(tmp_path / "events.fits")])
def prepare_dataset_simple(filename_dataset):
"""Prepare dataset for a given skymodel."""
log.info(f"Reading {IRF_FILE}")
irfs = load_cta_irfs(IRF_FILE)
edisp_gauss = EnergyDispersion2D.from_gauss(
e_true=ENERGY_AXIS_TRUE.edges,
migra=MIGRA_AXIS.edges,
sigma=0.1,
bias=0,
offset=[0, 2, 4, 6, 8] * u.deg,
)
irfs["edisp"] = edisp_gauss
# irfs["aeff"].data.data = np.ones_like(irfs["aeff"].data.data) * 1e6
observation = Observation.create(
obs_id=1001, pointing=POINTING, livetime=LIVETIME, irfs=irfs
)
empty = MapDataset.create(
WCS_GEOM, energy_axis_true=ENERGY_AXIS_TRUE, migra_axis=MIGRA_AXIS
)
# maker = MapDatasetMaker(selection=["exposure", "edisp"])
# maker = MapDatasetMaker(selection=["exposure", "edisp", "background"])
maker = MapDatasetMaker(selection=["exposure", "edisp", "psf", "background"])
dataset = maker.run(empty, observation)
filename_dataset.parent.mkdir(exist_ok=True, parents=True)
log.info(f"Writing {filename_dataset}")
dataset.write(filename_dataset, overwrite=True)
def test_mde_sample_weak_src(dataset, models):
irfs = load_cta_irfs(
"$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits"
)
livetime = 10.0 * u.hr
pointing = SkyCoord(0, 0, unit="deg", frame="galactic")
obs = Observation.create(
obs_id=1001,
pointing=pointing,
livetime=livetime,
irfs=irfs,
location=LOCATION,
)
models[0].parameters["amplitude"].value = 1e-25
dataset.models = models
sampler = MapDatasetEventSampler(random_state=0)
events = sampler.run(dataset=dataset, observation=obs)
assert len(events.table) == 18
assert_allclose(len(np.where(events.table["MC_ID"] == 0)[0]),
len(events.table),
rtol=1e-5)
def simulate_single(self,
pointing,
models=None,
empty=None,
random_state="random-seed"):
obs = Observation.create(pointing=pointing,
livetime=self.livetime,
irfs=self.get_irf())
maker = MapDatasetMaker(
selection=["exposure", "background", "psf", "edisp"])
maker_safe_mask = SafeMaskMaker(methods=["offset-max"],
offset_max=2.0 * u.deg)
dataset = maker.run(empty, obs)
dataset = maker_safe_mask.run(dataset, obs)
dataset.models = Models([models])
#fluctuate the background - gaussian fluctuations
bkg_factor = np.random.normal(self.mean_bkg, self.sigma_bkg)
while bkg_factor < 0.0:
bkg_factor = np.random.normal(self.mean_bkg, self.sigma_bkg)
dataset.background.data = bkg_factor * dataset.background.data
self.bkg_norms.append(bkg_factor)
#Poission fluctuate source + background
dataset.fake()
dataset.models = None #remove the model on the dataset
dataset.background.data /= bkg_factor # restore the old background
return dataset
def empty_dataset(source_pos_radec, map_geom, e_reco_binning, livetime,
irf_file, offset):
source_pos_ra = source_pos_radec["ra"]
source_pos_dec = source_pos_radec["dec"]
source = SkyCoord(source_pos_ra,
source_pos_dec,
unit="deg",
frame="icrs")
e_reco_min = u.Quantity(e_reco_binning["e_reco_min"]).to("TeV")
e_reco_min = e_reco_min.value
e_reco_max = u.Quantity(e_reco_binning["e_reco_max"]).to("TeV")
e_reco_max = e_reco_max.value
n_e_reco = e_reco_binning["n_e_reco"]
energy_axis = MapAxis.from_edges(np.logspace(
np.log10(e_reco_min), np.log10(e_reco_max), n_e_reco),
unit="TeV",
name="energy",
interp="log")
geom = WcsGeom.create(
skydir=source,
binsz=u.Quantity(map_geom["binsize"]).to("deg").value,
width=(u.Quantity(map_geom["width"]).to("deg").value,
u.Quantity(map_geom["width"]).to("deg").value),
frame="icrs",
axes=[energy_axis])
energy_axis_true = MapAxis.from_edges(np.logspace(
np.log10(e_reco_min), np.log10(e_reco_max), n_e_reco),
unit="TeV",
name="energy",
interp="log")
pointing = SkyCoord(u.Quantity(source_pos_ra).to("deg"),
u.Quantity(source_pos_dec).to("deg") + offset,
frame="icrs",
unit="deg")
irfs = load_cta_irfs(irf_file)
obs = Observation.create(pointing=pointing,
livetime=livetime,
irfs=irfs)
empty = MapDataset.create(geom, energy_axis_true=energy_axis_true)
maker = MapDatasetMaker(
selection=["exposure", "background", "psf", "edisp"])
maker_safe_mask = SafeMaskMaker(
methods=["offset-max"],
offset_max=u.quantity.Quantity(map_geom["width"]) +
1.0 * u.deg)
dataset = maker.run(empty, obs)
dataset = maker_safe_mask.run(dataset, obs)
return dataset
def __init__(self, lambda_true: u.quantity.Quantity, index_true: float,
normalization_true: u.quantity.Quantity,
livetime: u.quantity.Quantity, pointing_galactic: dict,
e_reco_binning: dict, on_region_radius: str, irf_file: str):
normalization_true = normalization_true.to("cm-2 s-1 TeV-1")
self.lambda_true = lambda_true
self.index_true = index_true
self.normalization_true = normalization_true
pointing_l = pointing_galactic["pointing_l"]
pointing_b = pointing_galactic["pointing_b"]
pointing = SkyCoord(pointing_l,
pointing_b,
unit="deg",
frame="galactic")
e_reco_min = u.Quantity(e_reco_binning["e_reco_min"]).to("TeV").value
e_reco_max = u.Quantity(e_reco_binning["e_reco_max"]).to("TeV").value
n_e_reco = e_reco_binning["n_e_reco"]
self.energy_axis = np.logspace(np.log10(e_reco_min),
np.log10(e_reco_max), n_e_reco) * u.TeV
on_region_radius = Angle(on_region_radius)
self.on_region = CircleSkyRegion(center=pointing,
radius=on_region_radius)
irfs = load_cta_irfs(irf_file)
self.obs = Observation.create(pointing=pointing,
livetime=livetime,
irfs=irfs)
def test_observation_write(tmp_path):
obs = Observation.read(
"$GAMMAPY_DATA/hess-dl3-dr1/data/hess_dl3_dr1_obs_id_023523.fits.gz")
path = tmp_path / "obs.fits.gz"
obs.write(path)
obs_read = obs.read(path)
assert obs_read.events is not None
assert obs_read.gti is not None
assert obs_read.aeff is not None
assert obs_read.edisp is not None
assert obs_read.bkg is not None
assert obs_read.rad_max is None
# unsupported format
with pytest.raises(ValueError):
obs.write(tmp_path / "foo.fits.gz", format="cool-new-format")
# no irfs
path = tmp_path / "obs_no_irfs.fits.gz"
obs.write(path, include_irfs=False)
obs_read = obs.read(path)
assert obs_read.events is not None
assert obs_read.gti is not None
assert obs_read.aeff is None
assert obs_read.edisp is None
assert obs_read.bkg is None
assert obs_read.rad_max is None
def simulate_map_dataset(random_state=0, name=None):
irfs = load_cta_irfs(
"$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits"
)
skydir = SkyCoord("0 deg", "0 deg", frame="galactic")
edges = np.logspace(-1, 2, 15) * u.TeV
energy_axis = MapAxis.from_edges(edges=edges, name="energy", interp="log")
geom = WcsGeom.create(
skydir=skydir, width=(4, 4), binsz=0.1, axes=[energy_axis], frame="galactic"
)
gauss = GaussianSpatialModel(
lon_0="0 deg", lat_0="0 deg", sigma="0.4 deg", frame="galactic"
)
pwl = PowerLawSpectralModel(amplitude="1e-11 cm-2 s-1 TeV-1")
skymodel = SkyModel(spatial_model=gauss, spectral_model=pwl, name="source")
obs = Observation.create(pointing=skydir, livetime=1 * u.h, irfs=irfs)
empty = MapDataset.create(geom, name=name)
maker = MapDatasetMaker(selection=["exposure", "background", "psf", "edisp"])
dataset = maker.run(empty, obs)
dataset.models.append(skymodel)
dataset.fake(random_state=random_state)
return dataset
def test_observation_cta_1dc():
ontime = 5.0 * u.hr
pointing = SkyCoord(0, 0, unit="deg", frame="galactic")
irfs = load_cta_irfs(
"$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits"
)
t_ref = Time('2020-01-01T00:00:00')
tstart = 20 * u.hour
location = EarthLocation(lon="-70d18m58.84s",
lat="-24d41m0.34s",
height="2000m")
obs = Observation.create(
pointing,
irfs=irfs,
deadtime_fraction=0.1,
tstart=tstart,
tstop=tstart + ontime,
reference_time=t_ref,
location=location,
)
assert_skycoord_allclose(obs.pointing_radec, pointing.icrs)
assert_allclose(obs.observation_live_time_duration, 0.9 * ontime)
assert_allclose(obs.target_radec.ra, np.nan)
assert not np.isnan(obs.pointing_zen)
assert_allclose(obs.muoneff, 1)
def test_observation_read_single_file_fixed_rad_max():
"""check that for a point-like observation without the RAD_MAX_2D table
a RadMax2D object is generated from the RAD_MAX keyword"""
obs = Observation.read(
"$GAMMAPY_DATA/joint-crab/dl3/magic/run_05029748_DL3.fits")
assert obs.rad_max is not None
assert obs.rad_max.quantity.shape == (1, 1)
assert u.allclose(obs.rad_max.quantity, 0.1414213 * u.deg)
def simulate():
irfs = load_cta_irfs(
"$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits"
)
# Reconstructed and true energy axis
center = SkyCoord(0.0, 0.0, unit="deg", frame="galactic")
energy_axis = MapAxis.from_edges(
np.logspace(-0.5, 1.0, 10), unit="TeV", name="energy", interp="log",
)
energy_axis_true = MapAxis.from_edges(
np.logspace(-1.2, 2.0, 31), unit="TeV", name="energy_true", interp="log",
)
on_region_radius = Angle("0.11 deg")
on_region = CircleSkyRegion(center=center, radius=on_region_radius)
pointing = SkyCoord(0.5, 0.5, unit="deg", frame="galactic")
spectral_model = PowerLawSpectralModel(
index=3, amplitude="1e-11 cm-2 s-1 TeV-1", reference="1 TeV"
)
temporal_model = ExpDecayTemporalModel(t0="6 h", t_ref=gti_t0.mjd * u.d)
model_simu = SkyModel(
spectral_model=spectral_model, temporal_model=temporal_model, name="model-simu",
)
lvtm = np.ones(N_OBS) * 1.0 * u.hr
tstart = 1.0 * u.hr
datasets = []
for i in range(N_OBS):
obs = Observation.create(
pointing=pointing,
livetime=lvtm[i],
tstart=tstart,
irfs=irfs,
reference_time=gti_t0,
)
empty = SpectrumDataset.create(
e_reco=energy_axis,
e_true=energy_axis_true,
region=on_region,
name=f"dataset_{i}",
)
maker = SpectrumDatasetMaker(selection=["aeff", "background", "edisp"])
dataset = maker.run(empty, obs)
dataset.models = model_simu
dataset.fake()
datasets.append(dataset)
tstart = tstart + 2.0 * u.hr
return datasets
def test_observation():
livetime = 5.0 * u.hr
pointing = SkyCoord(0, 0, unit="deg", frame="galactic")
irfs = load_cta_irfs(
"$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits"
)
obs = Observation.create(pointing,
livetime=livetime,
irfs=irfs,
deadtime_fraction=0.1)
assert_skycoord_allclose(obs.pointing_radec, pointing.icrs)
assert_allclose(obs.observation_live_time_duration, 0.9 * livetime)
def test_observation_read_single_file():
"""read event list and irf components from the same DL3 files"""
obs = Observation.read(
"$GAMMAPY_DATA/hess-dl3-dr1/data/hess_dl3_dr1_obs_id_020136.fits.gz")
energy = Quantity(1, "TeV")
offset = Quantity(0.5, "deg")
val = obs.aeff.evaluate(energy_true=energy, offset=offset)
assert obs.obs_id == 20136
assert len(obs.events.energy) == 11243
assert obs.available_irfs == ["aeff", "edisp", "psf", "bkg"]
assert_allclose(val.value, 273372.44851054, rtol=1e-5)
assert val.unit == "m2"
def test_irf_alpha_config(dataset, models):
irfs = load_cta_irfs(
"$GAMMAPY_DATA/cta-caldb/Prod5-South-20deg-AverageAz-14MSTs37SSTs.180000s-v0.1.fits.gz"
)
livetime = 1.0 * u.hr
pointing = SkyCoord(0, 0, unit="deg", frame="galactic")
obs = Observation.create(obs_id=1001,
pointing=pointing,
livetime=livetime,
irfs=irfs)
dataset.models = models
sampler = MapDatasetEventSampler(random_state=0)
events = sampler.run(dataset=dataset, observation=obs)
assert events is not None
def prepare_dataset(filename_dataset):
"""Prepare dataset for a given skymodel."""
log.info(f"Reading {IRF_FILE}")
irfs = load_cta_irfs(IRF_FILE)
observation = Observation.create(
obs_id=1001, pointing=POINTING, livetime=LIVETIME, irfs=irfs
)
empty = MapDataset.create(
WCS_GEOM, energy_axis_true=ENERGY_AXIS_TRUE, migra_axis=MIGRA_AXIS
)
maker = MapDatasetMaker(selection=["exposure", "background", "psf", "edisp"])
dataset = maker.run(empty, observation)
filename_dataset.parent.mkdir(exist_ok=True, parents=True)
log.info(f"Writing {filename_dataset}")
dataset.write(filename_dataset, overwrite=True)
def test_event_det_coords(dataset):
irfs = load_cta_irfs(
"$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits"
)
livetime = 1.0 * u.hr
pointing = SkyCoord(0, 0, unit="deg", frame="galactic")
obs = Observation.create(
obs_id=1001, pointing=pointing, livetime=livetime, irfs=irfs
)
sampler = MapDatasetEventSampler(random_state=0)
events = sampler.run(dataset=dataset, observation=obs)
assert len(events.table) == 374
assert_allclose(events.table["DETX"][0], -2.44563584, rtol=1e-5)
assert events.table["DETX"].unit == "deg"
assert_allclose(events.table["DETY"][0], 0.01414569, rtol=1e-5)
assert events.table["DETY"].unit == "deg"
def simulate_events(filename_model, filename_dataset, dataset, obs_id):
"""Simulate events for a given model and dataset.
Parameters
----------
filename_model : str
Filename of the model definition.
filename_dataset : str
Filename of the dataset to use for simulation.
nobs : int
Number of obervations to simulate.
"""
log.info(f"Reading {IRF_FILE}")
irfs = load_cta_irfs(IRF_FILE)
# log.info(f"Reading {filename_dataset}")
# dataset = MapDataset.read(filename_dataset)
log.info(f"Reading {filename_model}")
models = Models.read(filename_model)
# dataset.models = models
dataset.models.extend(models)
sampler = MapDatasetEventSampler(random_state=0)
# obs_id = np.arange(nobs)
# with multiprocessing.Pool(processes=core) as pool:
# args1 = zip(obs_id, repeat(POINTING), repeat(LIVETIME), repeat(irfs),
# repeat(dataset), repeat(filename_dataset), repeat(filename_model))
# pool.starmap(simulate_parallel, args1)
# for obs_id in np.arange(nobs):
observation = Observation.create(obs_id=obs_id,
pointing=POINTING,
livetime=LIVETIME,
irfs=irfs)
events = sampler.run(dataset, observation)
path = get_filename_events(filename_dataset, filename_model, obs_id)
log.info(f"Writing {path}")
path.parent.mkdir(exist_ok=True, parents=True)
events.table.write(str(path), overwrite=True)
def test_dataset_maker_spectrum_global_rad_max():
"""test the energy-dependent spectrum extraction"""
observation = Observation.read('$GAMMAPY_DATA/joint-crab/dl3/magic/run_05029748_DL3.fits')
maker = SpectrumDatasetMaker(
containment_correction=False, selection=["counts", "exposure", "edisp"]
)
dataset = maker.run(get_spectrumdataset_rad_max("spec"), observation)
finder = WobbleRegionsFinder(n_off_regions=3)
bkg_maker = ReflectedRegionsBackgroundMaker(region_finder=finder)
dataset_on_off = bkg_maker.run(dataset, observation)
counts = dataset_on_off.counts
counts_off = dataset_on_off.counts_off
assert counts.unit == ""
assert counts_off.unit == ""
assert_allclose(counts.data.sum(), 437, rtol=1e-5)
assert_allclose(counts_off.data.sum(), 273, rtol=1e-5)
def test_observation_read():
"""read event list and irf components from different DL3 files"""
obs = Observation.read(
event_file=
"$GAMMAPY_DATA/hess-dl3-dr1/data/hess_dl3_dr1_obs_id_020136.fits.gz",
irf_file=
"$GAMMAPY_DATA/hess-dl3-dr1/data/hess_dl3_dr1_obs_id_020137.fits.gz",
)
energy = Quantity(1, "TeV")
offset = Quantity(0.5, "deg")
val = obs.aeff.evaluate(energy_true=energy, offset=offset)
assert obs.obs_id == 20136
assert len(obs.events.energy) == 11243
assert obs.available_hdus == [
"events", "gti", "aeff", "edisp", "psf", "bkg"
]
assert_allclose(val.value, 278000.54120855, rtol=1e-5)
assert val.unit == "m2"
def setup_class(self):
table = Table()
table["RA"] = [0.0, 0.0, 0.0, 0.0, 10.0] * u.deg
table["DEC"] = [0.0, 0.05, 0.9, 10.0, 10.0] * u.deg
table["ENERGY"] = [1.0, 1.0, 1.5, 1.5, 10.0] * u.TeV
table["OFFSET"] = [0.1, 0.1, 0.5, 1.0, 1.5] * u.deg
table.meta["RA_PNT"] = 0 * u.deg
table.meta["DEC_PNT"] = 0.5 * u.deg
meta_obs = dict()
meta_obs["RA_PNT"] = 0 * u.deg
meta_obs["DEC_PNT"] = 0.5 * u.deg
meta_obs["DEADC"] = 1
meta = time_ref_to_dict("2010-01-01")
gti_table = Table({"START": [1], "STOP": [3]}, meta=meta)
gti = GTI(gti_table)
self.observation = Observation(
events=EventList(table), obs_info=meta_obs, gti=gti
)
def setup_class(self):
self.observations = []
for sign in [-1, 1]:
events = Table()
events["RA"] = [0.0, 0.0, 0.0, 0.0, 10.0] * u.deg
events["DEC"] = sign * ([0.0, 0.05, 0.9, 10.0, 10.0] * u.deg)
events["ENERGY"] = [1.0, 1.0, 1.5, 1.5, 10.0] * u.TeV
events["OFFSET"] = [0.1, 0.1, 0.5, 1.0, 1.5] * u.deg
obs_info = dict(
RA_PNT=0 * u.deg,
DEC_PNT=sign * 0.5 * u.deg,
DEADC=1,
)
events.meta.update(obs_info)
meta = time_ref_to_dict("2010-01-01")
gti_table = Table({"START": [1], "STOP": [3]}, meta=meta)
gti = GTI(gti_table)
self.observations.append(Observation(
events=EventList(events), obs_info=obs_info, gti=gti
))
def test_observation_peek(data_store, caplog):
obs = Observation.read(
"$GAMMAPY_DATA/hess-dl3-dr1/data/hess_dl3_dr1_obs_id_023523.fits.gz")
with mpl_plot_check():
obs.peek()
obs.bkg = None
with mpl_plot_check():
obs.peek()
assert "WARNING" in [record.levelname for record in caplog.records]
message = "No background model found for obs 23523."
assert message in [record.message for record in caplog.records]
obs.psf = None
with mpl_plot_check():
obs.peek()
assert "WARNING" in [record.levelname for record in caplog.records]
message = "No PSF found for obs 23523."
assert message in [record.message for record in caplog.records]
def simulate_events(filename_model, filename_dataset, nobs):
"""Simulate events for a given model and dataset.
Parameters
----------
filename_model : str
Filename of the model definition.
filename_dataset : str
Filename of the dataset to use for simulation.
nobs : int
Number of obervations to simulate.
"""
log.info(f"Reading {IRF_FILE}")
irfs = load_cta_irfs(IRF_FILE)
log.info(f"Reading {filename_dataset}")
dataset = MapDataset.read(filename_dataset)
log.info(f"Reading {filename_model}")
models = Models.read(filename_model)
models.append(FoVBackgroundModel(dataset_name=dataset.name))
dataset.models = models
# dataset.models.extend(models)
sampler = MapDatasetEventSampler(random_state=0)
for obs_id in np.arange(nobs):
observation = Observation.create(
obs_id=obs_id, pointing=POINTING, livetime=LIVETIME, irfs=irfs
)
events = sampler.run(dataset, observation)
path = get_filename_events(filename_dataset, filename_model, obs_id)
log.info(f"Writing {path}")
path.parent.mkdir(exist_ok=True, parents=True)
events.table.write(str(path), overwrite=True)
def test_mde_run(dataset):
irfs = load_cta_irfs(
"$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits"
)
livetime = 1.0 * u.hr
pointing = SkyCoord(0, 0, unit="deg", frame="galactic")
obs = Observation.create(obs_id=1001,
pointing=pointing,
livetime=livetime,
irfs=irfs)
sampler = MapDatasetEventSampler(random_state=0)
events = sampler.run(dataset=dataset, observation=obs)
dataset_bkg = dataset.copy()
dataset_bkg.models = dataset_bkg.models[1]
events_bkg = sampler.run(dataset=dataset_bkg, observation=obs)
assert len(events.table) == 374
assert_allclose(events.table["ENERGY"][0], 4.09979515940, rtol=1e-5)
assert_allclose(events.table["RA"][0], 263.611383742, rtol=1e-5)
assert_allclose(events.table["DEC"][0], -28.89318805, rtol=1e-5)
assert len(events_bkg.table) == 10
assert_allclose(events_bkg.table["ENERGY"][0], 2.84808850102, rtol=1e-5)
assert_allclose(events_bkg.table["RA"][0], 266.6138405848, rtol=1e-5)
assert_allclose(events_bkg.table["DEC"][0], -29.0489180785, rtol=1e-5)
assert_allclose(events_bkg.table["MC_ID"][0], 0, rtol=1e-5)
meta = events.table.meta
assert meta["RA_PNT"] == 266.4049882865447
assert meta["ONTIME"] == 3600.0
assert meta["OBS_ID"] == 1001
assert meta["RADECSYS"] == "icrs"
assert meta["ALT_PNT"] == "20.000"
assert meta["AZ_PNT"] == "0.000"
def test_create_dl3_energy_dependent_cuts(
temp_dir_observed_files, observed_dl2_file
):
"""
Generating an DL3 file from a test DL2 files and test IRF file, using
energy dependent cuts. Here the previously created IRF is used.
"""
from lstchain.tools.lstchain_create_dl3_file import DataReductionFITSWriter
from gammapy.data import Observation
irf_file = temp_dir_observed_files / "pnt_irf.fits.gz"
dl2_name = observed_dl2_file.name
observed_dl3_file = temp_dir_observed_files / dl2_name.replace('dl2', 'dl3')
observed_dl3_file = observed_dl3_file.with_suffix(".fits")
assert (
run_tool(
DataReductionFITSWriter(),
argv=[
f"--input-dl2={observed_dl2_file}",
f"--output-dl3-path={temp_dir_observed_files}",
f"--input-irf={irf_file}",
"--source-name=Crab",
"--source-ra=83.633deg",
"--source-dec=22.01deg",
"--overwrite",
],
cwd=temp_dir_observed_files,
)
== 0
)
assert Observation.read(
event_file=observed_dl3_file, irf_file=irf_file
).obs_id == 2008
def generate_dataset(Eflux,
flux,
Erange=None,
tstart=Time('2000-01-01 02:00:00', scale='utc'),
tobs=100 * u.s,
irf_file=None,
alpha=1 / 5,
name=None,
fake=True,
onoff=True,
seed='random-seed',
debug=False):
"""
Generate a dataset from a list of energies and flux points either as
a SpectrumDataset or a SpectrumDatasetOnOff
Note :
- in SpectrumDataset, the backgound counts are assumed precisely know and
are not fluctuated.
- in SpectrumDatasetOnOff, the background counts (off counts) are
fluctuated from the IRF known values.
Parameters
----------
Eflux : Quantity
Energies at which the flux is given.
flux : Quantity
Flux corresponding to the given energies.
Erange : List, optional
The energy boundaries within which the flux is defined, if not over all
energies. The default is None.
tstart : Time object, optional
Start date of the dataset.
The default is Time('2000-01-01 02:00:00',scale='utc').
tobs : Quantity, optional
Duration of the observation. The default is 100*u.s.
irf_file : String, optional
The IRf file name. The default is None.
alpha : Float, optional
The on over off surface ratio for the On-Off analysis.
The default is 1/5.
name : String, optional
The dataset name, also used to name tthe spectrum. The default is None.
fake : Boolean, optional
If True, the dataset counts are fluctuated. The default is True.
onoff : Boolean, optional
If True, use SpectrumDatasetOnOff, otherwise SpectrumDataSet.
The default is True.
seed : String, optional
The seed for the randome generator; If an integer will generate the
same random series at each run. The default is 'random-seed'.
debug: Boolean
If True, let's talk a bit. The default is False.
Returns
-------
ds : Dataset object
The dataset.
"""
random_state = get_random_state(seed)
### Define on region
on_pointing = SkyCoord(ra=0 * u.deg, dec=0 * u.deg,
frame="icrs") # Observing region
on_region = CircleSkyRegion(center=on_pointing, radius=0.5 * u.deg)
# Define energy axis (see spectrum analysis notebook)
# edges for SpectrumDataset - all dataset should have the same axes
# Note that linear spacing is clearly problematic for powerlaw fluxes
# Axes can also be defined using MapAxis
unit = u.GeV
E1v = min(Eflux).to(unit).value
E2v = max(Eflux).to(unit).value
# ereco = np.logspace(np.log10(1.1*E1v), np.log10(0.9*E2v), 20) * unit
# ereco_axis = MapAxis.from_edges(ereco.to("TeV").value,
# unit="TeV",
# name="energy",
# interp="log")
ereco_axis = MapAxis.from_energy_bounds(1.1 * E1v * unit,
0.9 * E2v * unit,
nbin=4,
per_decade=True,
name="energy")
# etrue = np.logspace(np.log10( E1v), np.log10( E2v), 50) * unit
# etrue_axis = MapAxis.from_edges(etrue.to("TeV").value,
# unit="TeV",
# name="energy_true",
# interp="log")
etrue_axis = MapAxis.from_energy_bounds(E1v * unit,
E2v * unit,
nbin=4,
per_decade=True,
name="energy_true")
if (debug):
print("Dataset ", name)
print("Etrue : ", etrue_axis.edges)
print("Ereco : ", ereco_axis.edges)
# Load IRF
irf = load_cta_irfs(irf_file)
spec = TemplateSpectralModel(energy=Eflux,
values=flux,
interp_kwargs={"values_scale": "log"})
model = SkyModel(spectral_model=spec, name="Spec" + str(name))
obs = Observation.create(obs_id=1,
pointing=on_pointing,
livetime=tobs,
irfs=irf,
deadtime_fraction=0,
reference_time=tstart)
ds_empty = SpectrumDataset.create(
e_reco=ereco_axis, # Ereco.edges,
e_true=etrue_axis, #Etrue.edges,
region=on_region,
name=name)
maker = SpectrumDatasetMaker(containment_correction=False,
selection=["exposure", "background", "edisp"])
ds = maker.run(ds_empty, obs)
ds.models = model
mask = ds.mask_safe.geom.energy_mask(energy_min=Erange[0],
energy_max=Erange[1])
mask = mask & ds.mask_safe.data
ds.mask_safe = RegionNDMap(ds.mask_safe.geom, data=mask)
ds.fake(random_state=random_state) # Fake is mandatory ?
# Transform SpectrumDataset into SpectrumDatasetOnOff if needed
if (onoff):
ds = SpectrumDatasetOnOff.from_spectrum_dataset(dataset=ds,
acceptance=1,
acceptance_off=1 /
alpha)
print("Transformed in ONOFF")
if fake:
print(" Fluctuations : seed = ", seed)
if (onoff):
ds.fake(npred_background=ds.npred_background())
else:
ds.fake(random_state=random_state)
print("ds.energy_range = ", ds.energy_range)
return ds
