def test_constant_temporal_model_integral():
temporal_model = ConstantTemporalModel()
start = [1, 3, 5] * u.day
stop = [2, 3.5, 6] * u.day
gti = GTI.create(start, stop)
val = temporal_model.integral(gti.time_start, gti.time_stop)
assert len(val) == 3
assert_allclose(np.sum(val), 1.0, rtol=1e-5)
def test_constant_temporal_model_sample():
temporal_model = ConstantTemporalModel(norm=10.0)
t_ref = "2010-01-01T00:00:00"
t_min = "2010-01-01T00:00:00"
t_max = "2010-01-01T08:00:00"
sampler = temporal_model.sample_time(n_events=2,
t_min=t_min,
t_max=t_max,
random_state=0)
sampler = u.Quantity((sampler - Time(t_ref)).sec, "s")
assert len(sampler) == 2
assert_allclose(sampler.value, [15805.82891311, 20597.45375153], rtol=1e-5)
def sample_background(self, dataset):
"""Sample background
Parameters
----------
dataset : `~gammapy.datasets.MapDataset`
Map dataset
Returns
-------
events : `gammapy.data.EventList`
Background events
"""
background = dataset.npred_background()
temporal_model = ConstantTemporalModel()
table = self._sample_coord_time(background, temporal_model, dataset.gti)
table["MC_ID"] = 0
table["ENERGY"] = table["ENERGY_TRUE"]
table["RA"] = table["RA_TRUE"]
table["DEC"] = table["DEC_TRUE"]
return EventList(table)
def sample_background(self, dataset):
"""Sample background
Parameters
----------
dataset : `~gammapy.cube.MapDataset`
Map dataset
Returns
-------
events : `gammapy.data.EventList`
Background events
"""
background = dataset.background_model.evaluate()
temporal_model = ConstantTemporalModel()
table = self._sample_coord_time(background, temporal_model,
dataset.gti)
table["MC_ID"] = 0
table.rename_column("ENERGY_TRUE", "ENERGY")
table.rename_column("RA_TRUE", "RA")
table.rename_column("DEC_TRUE", "DEC")
return EventList(table)
def spectrum_dataset():
name = "test"
energy = np.logspace(-1, 1, 31) * u.TeV
livetime = 100 * u.s
pwl = PowerLawSpectralModel(
index=2.1, amplitude="1e5 cm-2 s-1 TeV-1", reference="0.1 TeV",
)
temp_mod = ConstantTemporalModel()
model = SkyModel(spectral_model=pwl, temporal_model=temp_mod, name="test-source")
axis = MapAxis.from_edges(energy, interp="log", name="energy")
axis_true = MapAxis.from_edges(energy, interp="log", name="energy_true")
background = RegionNDMap.create(region="icrs;circle(0, 0, 0.1)", axes=[axis])
models = Models([model])
exposure = RegionNDMap.create(region="icrs;circle(0, 0, 0.1)", axes=[axis_true])
exposure.quantity = u.Quantity("1 cm2") * livetime
bkg_rate = np.ones(30) / u.s
background.quantity = bkg_rate * livetime
start = [1, 3, 5] * u.day
stop = [2, 3.5, 6] * u.day
t_ref = Time(55555, format="mjd")
gti = GTI.create(start, stop, reference_time=t_ref)
dataset = SpectrumDataset(
models=models, exposure=exposure, background=background, name=name, gti=gti,
)
dataset.fake(random_state=23)
return dataset
def sample_sources(self, dataset):
"""Sample source model components.
Parameters
----------
dataset : `~gammapy.cube.MapDataset`
Map dataset.
Returns
-------
events : `~gammapy.data.EventList`
Event list
"""
events_all = []
for idx, evaluator in enumerate(dataset._evaluators):
evaluator = copy.deepcopy(evaluator)
evaluator.edisp = None
evaluator.psf = None
npred = evaluator.compute_npred()
temporal_model = ConstantTemporalModel()
table = self._sample_coord_time(npred, temporal_model, dataset.gti)
table["MC_ID"] = idx + 1
events_all.append(EventList(table))
return EventList.stack(events_all)
def sample_sources(self, dataset):
"""Sample source model components.
Parameters
----------
dataset : `~gammapy.cube.MapDataset`
Map dataset.
Returns
-------
events : `~gammapy.data.EventList`
Event list
"""
events_all = []
for idx, model in enumerate(dataset.models):
if isinstance(model, BackgroundModel):
continue
evaluator = dataset.evaluators.get(model.name)
evaluator = copy.deepcopy(evaluator)
evaluator.model.apply_irf["psf"] = False
evaluator.model.apply_irf["edisp"] = False
npred = evaluator.compute_npred()
temporal_model = ConstantTemporalModel()
table = self._sample_coord_time(npred, temporal_model, dataset.gti)
table["MC_ID"] = idx + 1
events_all.append(EventList(table))
return EventList.stack(events_all)
def sample_sources(self, dataset):
"""Sample source model components.
Parameters
----------
dataset : `~gammapy.cube.MapDataset`
Map dataset.
Returns
-------
events : `~gammapy.data.EventList`
Event list
"""
events_all = []
for idx, model in enumerate(dataset.models):
if isinstance(model, BackgroundModel):
continue
evaluator = dataset.evaluators.get(model.name)
evaluator = copy.deepcopy(evaluator)
evaluator.model.apply_irf["psf"] = False
evaluator.model.apply_irf["edisp"] = False
npred = evaluator.compute_npred()
if hasattr(model, "temporal_model"):
if getattr(model, "temporal_model") is None:
temporal_model = ConstantTemporalModel()
else:
temporal_model = model.temporal_model
else:
temporal_model = ConstantTemporalModel()
table = self._sample_coord_time(npred, temporal_model, dataset.gti)
if len(table) > 0:
table["MC_ID"] = idx + 1
else:
mcid = table.Column(name="MC_ID", length=0, dtype=int)
table.add_column(mcid)
events_all.append(EventList(table))
return EventList.stack(events_all)
def sky_model():
spatial_model = GaussianSpatialModel(
lon_0="3 deg", lat_0="4 deg", sigma="3 deg", frame="galactic"
)
spectral_model = PowerLawSpectralModel(
index=2, amplitude="1e-11 cm-2 s-1 TeV-1", reference="1 TeV"
)
temporal_model = ConstantTemporalModel()
return SkyModel(
spatial_model=spatial_model,
spectral_model=spectral_model,
temporal_model=temporal_model,
name="source-1",
)
def sample_sources(self, dataset):
"""Sample source model components.
Parameters
----------
dataset : `~gammapy.datasets.MapDataset`
Map dataset.
Returns
-------
events : `~gammapy.data.EventList`
Event list
"""
events_all = []
for idx, evaluator in enumerate(dataset.evaluators.values()):
if evaluator.needs_update:
evaluator.update(
dataset.exposure,
dataset.psf,
dataset.edisp,
dataset._geom,
dataset.mask,
)
flux = evaluator.compute_flux()
npred = evaluator.apply_exposure(flux)
if evaluator.model.temporal_model is None:
temporal_model = ConstantTemporalModel()
else:
temporal_model = evaluator.model.temporal_model
table = self._sample_coord_time(npred, temporal_model, dataset.gti)
if len(table) > 0:
table["MC_ID"] = idx + 1
else:
mcid = table.Column(name="MC_ID", length=0, dtype=int)
table.add_column(mcid)
events_all.append(EventList(table))
return EventList.from_stack(events_all)
def sample_sources(self, dataset):
"""Sample source model components.
Parameters
----------
dataset : `~gammapy.datasets.MapDataset`
Map dataset.
Returns
-------
events : `~gammapy.data.EventList`
Event list
"""
events_all = []
for idx, model in enumerate(dataset.models):
if isinstance(model, BackgroundModel):
continue
evaluator = dataset.evaluators.get(model)
flux = evaluator.compute_flux()
npred = evaluator.apply_exposure(flux)
if model.temporal_model is None:
temporal_model = ConstantTemporalModel()
else:
temporal_model = model.temporal_model
table = self._sample_coord_time(npred, temporal_model, dataset.gti)
if len(table) > 0:
table["MC_ID"] = idx + 1
else:
mcid = table.Column(name="MC_ID", length=0, dtype=int)
table.add_column(mcid)
events_all.append(EventList(table))
return EventList.from_stack(events_all)
# ------------
# Here is an example plot of the model:
from astropy import units as u
from astropy.time import Time
import matplotlib.pyplot as plt
# %%
# YAML representation
# -------------------
# Here is an example YAML file using the model:
from gammapy.modeling.models import (
ConstantTemporalModel,
Models,
PowerLawSpectralModel,
SkyModel,
)
time_range = [Time.now(), Time.now() + 1 * u.d]
constant_model = ConstantTemporalModel(const=1)
constant_model.plot(time_range)
plt.grid(which="both")
model = SkyModel(
spectral_model=PowerLawSpectralModel(),
temporal_model=constant_model,
name="constant-model",
)
models = Models([model])
print(models.to_yaml())
def test_constant_temporal_model_evaluate_norm_at_time():
temporal_model = ConstantTemporalModel(norm=10.0)
val = temporal_model.evaluate_norm_at_time(46300)
assert_allclose(val, 10.0, rtol=1e-5)
def test_constant_temporal_model_evaluate():
temporal_model = ConstantTemporalModel()
t = Time(46300, format="mjd")
val = temporal_model(t)
assert_allclose(val, 1.0, rtol=1e-5)
def test_plot_constant_model():
time_range = [Time.now(), Time.now() + 1 * u.d]
constant_model = ConstantTemporalModel(const=1)
with mpl_plot_check():
constant_model.plot(time_range)
def test_time_sampling(tmp_path):
time = np.arange(0, 10, 0.06) * u.hour
table = Table()
table["TIME"] = time
table["NORM"] = rate(time)
table.meta = dict(MJDREFI=55197.0, MJDREFF=0, TIMEUNIT="hour")
temporal_model = LightCurveTemplateTemporalModel(table)
filename = str(make_path(tmp_path / "tmp.fits"))
temporal_model.write(path=filename)
model_read = temporal_model.read(filename)
assert temporal_model.filename == filename
assert model_read.filename == filename
assert_allclose(model_read.table["TIME"].quantity.value, time.value)
t_ref = "2010-01-01T00:00:00"
t_min = "2010-01-01T00:00:00"
t_max = "2010-01-01T08:00:00"
sampler = temporal_model.sample_time(n_events=2,
t_min=t_min,
t_max=t_max,
random_state=0,
t_delta="10 min")
sampler = u.Quantity((sampler - Time(t_ref)).sec, "s")
assert len(sampler) == 2
assert_allclose(sampler.value, [12661.65802564, 7826.92991], rtol=1e-5)
table = Table()
table["TIME"] = time
table["NORM"] = np.ones(len(time))
table.meta = dict(MJDREFI=55197.0, MJDREFF=0, TIMEUNIT="hour")
temporal_model_uniform = LightCurveTemplateTemporalModel(table)
sampler_uniform = temporal_model_uniform.sample_time(n_events=2,
t_min=t_min,
t_max=t_max,
random_state=0,
t_delta="10 min")
sampler_uniform = u.Quantity((sampler_uniform - Time(t_ref)).sec, "s")
assert len(sampler_uniform) == 2
assert_allclose(sampler_uniform.value, [1261.65802564, 6026.9299098],
rtol=1e-5)
temporal_model = ConstantTemporalModel()
sampler_costant = temporal_model.sample_time(n_events=2,
t_min=t_min,
t_max=t_max,
random_state=0)
sampler_costant = u.Quantity((sampler_costant - Time(t_ref)).sec, "s")
assert len(sampler_costant) == 2
assert_allclose(sampler_costant.value, [4330.10377559, 3334.04566256],
rtol=1e-5)
temporal_model = ExpDecayTemporalModel(t_ref=Time(t_ref).mjd * u.d)
sampler_expo = temporal_model.sample_time(n_events=2,
t_min=t_min,
t_max=t_max,
random_state=0)
sampler_expo = u.Quantity((sampler_expo.mjd - Time(t_ref).mjd), "d")
assert sampler_expo.unit == u.d
assert_allclose(sampler_expo.to("s").value, [11824.1055276, 7273.04658336],
rtol=1e-8)
