def test_lightcurve_estimator_spectrum_datasets():
# Doing a LC on one hour bin
datasets = get_spectrum_datasets()
time_intervals = [
Time(["2010-01-01T00:00:00", "2010-01-01T01:00:00"]),
Time(["2010-01-01T01:00:00", "2010-01-01T02:00:00"]),
]
estimator = LightCurveEstimator(
energy_range=[1, 100] * u.TeV, norm_n_values=3, time_intervals=time_intervals
)
lightcurve = estimator.run(datasets)
assert_allclose(lightcurve.table["time_min"], [55197.0, 55197.041667])
assert_allclose(lightcurve.table["time_max"], [55197.041667, 55197.083333])
assert_allclose(lightcurve.table["e_ref"], [10, 10])
assert_allclose(lightcurve.table["e_min"], [1, 1])
assert_allclose(lightcurve.table["e_max"], [100, 100])
assert_allclose(lightcurve.table["ref_dnde"], [1e-14, 1e-14])
assert_allclose(lightcurve.table["ref_flux"], [9.9e-13, 9.9e-13])
assert_allclose(lightcurve.table["ref_eflux"], [4.60517e-12, 4.60517e-12])
assert_allclose(lightcurve.table["ref_e2dnde"], [1e-12, 1e-12])
assert_allclose(lightcurve.table["stat"], [23.302288, 22.457766], rtol=1e-5)
assert_allclose(lightcurve.table["norm"], [0.988107, 0.948108], rtol=1e-2)
assert_allclose(lightcurve.table["norm_err"], [0.04493, 0.041469], rtol=1e-2)
assert_allclose(lightcurve.table["counts"], [2281, 2222])
assert_allclose(lightcurve.table["norm_errp"], [0.044252, 0.043771], rtol=1e-2)
assert_allclose(lightcurve.table["norm_errn"], [0.04374, 0.043521], rtol=1e-2)
assert_allclose(lightcurve.table["norm_ul"], [1.077213, 1.036237], rtol=1e-2)
assert_allclose(lightcurve.table["sqrt_ts"], [26.773925, 25.796426], rtol=1e-2)
assert_allclose(lightcurve.table["ts"], [716.843084, 665.455601], rtol=1e-2)
assert_allclose(lightcurve.table[0]["norm_scan"], [0.2, 1.0, 5.0])
assert_allclose(
lightcurve.table[0]["stat_scan"],
[444.426957, 23.375417, 3945.382802],
rtol=1e-5,
)
def test_lightcurve_estimator_spectrum_datasets_withmaskfit():
# Doing a LC on one hour bin
datasets = get_spectrum_datasets()
time_intervals = [
Time(["2010-01-01T00:00:00", "2010-01-01T01:00:00"]),
Time(["2010-01-01T01:00:00", "2010-01-01T02:00:00"]),
]
e_min_fit = 1 * u.TeV
e_max_fit = 3 * u.TeV
for dataset in datasets:
geom = dataset.counts.geom
data = geom.energy_mask(emin=e_min_fit, emax=e_max_fit)
dataset.mask_fit = RegionNDMap.from_geom(geom, data=data, dtype=bool)
steps = ["err", "counts", "ts", "norm-scan"]
estimator = LightCurveEstimator(datasets,
norm_n_values=3,
time_intervals=time_intervals)
lightcurve = estimator.run(e_ref=10 * u.TeV,
e_min=1 * u.TeV,
e_max=100 * u.TeV,
steps=steps)
assert_allclose(lightcurve.table["time_min"], [55197.0, 55197.041667])
assert_allclose(lightcurve.table["time_max"], [55197.041667, 55197.083333])
assert_allclose(lightcurve.table["stat"], [6.60304, 0.421047], rtol=1e-3)
assert_allclose(lightcurve.table["norm"], [0.885082, 0.967022], rtol=1e-3)
def get_light_curve(self):
"""Calculate light curve for a specific model component."""
lc_settings = self.config.light_curve
log.info("Computing light curve.")
energy_edges = self._make_energy_axis(lc_settings.energy_edges).edges
if lc_settings.time_intervals.start is None or lc_settings.time_intervals.stop is None:
log.info(
"Time intervals not defined. Extract light curve on datasets GTIs."
)
time_intervals = None
else:
time_intervals = [
(t1, t2) for t1, t2 in zip(lc_settings.time_intervals.start,
lc_settings.time_intervals.stop)
]
light_curve_estimator = LightCurveEstimator(
time_intervals=time_intervals,
energy_edges=energy_edges,
source=lc_settings.source,
fit=self.fit,
**lc_settings.parameters,
)
lc = light_curve_estimator.run(datasets=self.datasets)
self.light_curve = lc
log.info("\n{}".format(
self.light_curve.to_table(format="lightcurve", sed_type="flux")))
def test_lightcurve_estimator_spectrum_datasets_withmaskfit():
# Doing a LC on one hour bin
datasets = get_spectrum_datasets()
time_intervals = [
Time(["2010-01-01T00:00:00", "2010-01-01T01:00:00"]),
Time(["2010-01-01T01:00:00", "2010-01-01T02:00:00"]),
]
e_min_fit = 1 * u.TeV
e_max_fit = 3 * u.TeV
for dataset in datasets:
geom = dataset.counts.geom
data = geom.energy_mask(emin=e_min_fit, emax=e_max_fit)
dataset.mask_fit = RegionNDMap.from_geom(geom, data=data, dtype=bool)
selection = ["scan"]
estimator = LightCurveEstimator(
e_edges=[1, 30] * u.TeV,
norm_n_values=3,
time_intervals=time_intervals,
selection_optional=selection,
)
lightcurve = estimator.run(datasets)
assert_allclose(lightcurve.table["time_min"], [55197.0, 55197.041667])
assert_allclose(lightcurve.table["time_max"], [55197.041667, 55197.083333])
assert_allclose(lightcurve.table["stat"], [6.603043, 0.421051], rtol=1e-3)
assert_allclose(lightcurve.table["norm"], [0.885124, 0.967054], rtol=1e-3)
def test_lightcurve_estimator_spectrum_datasets_largerbin():
# Test all dataset in a single LC bin, here two hours
datasets = get_spectrum_datasets()
time_intervals = [Time(["2010-01-01T00:00:00", "2010-01-01T02:00:00"])]
estimator = LightCurveEstimator(datasets,
norm_n_values=3,
time_intervals=time_intervals)
steps = ["err", "counts", "ts", "norm-scan"]
lightcurve = estimator.run(e_ref=10 * u.TeV,
e_min=1 * u.TeV,
e_max=100 * u.TeV,
steps=steps)
assert_allclose(lightcurve.table["time_min"], [55197.0])
assert_allclose(lightcurve.table["time_max"], [55197.083333])
assert_allclose(lightcurve.table["e_ref"], [10])
assert_allclose(lightcurve.table["e_min"], [1])
assert_allclose(lightcurve.table["e_max"], [100])
assert_allclose(lightcurve.table["ref_dnde"], [1e-14])
assert_allclose(lightcurve.table["ref_flux"], [9.9e-13])
assert_allclose(lightcurve.table["ref_eflux"], [4.60517e-12])
assert_allclose(lightcurve.table["ref_e2dnde"], [1e-12])
assert_allclose(lightcurve.table["stat"], [46.177981], rtol=1e-5)
assert_allclose(lightcurve.table["norm"], [0.968049], rtol=1e-5)
assert_allclose(lightcurve.table["norm_err"], [0.030982], rtol=1e-3)
assert_allclose(lightcurve.table["ts"], [1381.880757], rtol=1e-4)
def test_lightcurve_estimator_fit_options():
# Doing a LC on one hour bin
datasets = get_spectrum_datasets()
time_intervals = [
Time(["2010-01-01T00:00:00", "2010-01-01T01:00:00"]),
Time(["2010-01-01T01:00:00", "2010-01-01T02:00:00"]),
]
energy_edges = [1, 30] * u.TeV
estimator = LightCurveEstimator(
energy_edges=energy_edges,
norm_n_values=3,
time_intervals=time_intervals,
selection_optional="all",
backend="minuit",
optimize_opts=dict(tol=0.2, strategy=1),
)
fpe = estimator._flux_poins_estimator(energy_edges)
assert_allclose(fpe.optimize_opts["tol"], 0.2)
flux_estimator = fpe._flux_estimator(1 * u.TeV, 30 * u.TeV)
assert_allclose(flux_estimator.optimize_opts["tol"], 0.2)
param_estimator = flux_estimator._parameter_estimator
assert_allclose(param_estimator.optimize_opts["tol"], 0.2)
param_estimator.fit(datasets).run()
assert_allclose(param_estimator._fit.minuit.tol, 0.2)
def test_lightcurve_estimator_spectrum_datasets_with_mask_fit():
# Doing a LC on one hour bin
datasets = get_spectrum_datasets()
time_intervals = [
Time(["2010-01-01T00:00:00", "2010-01-01T01:00:00"]),
Time(["2010-01-01T01:00:00", "2010-01-01T02:00:00"]),
]
energy_min_fit = 1 * u.TeV
energy_max_fit = 3 * u.TeV
for dataset in datasets:
geom = dataset.counts.geom
dataset.mask_fit = geom.energy_mask(energy_min=energy_min_fit,
energy_max=energy_max_fit)
selection = ["scan"]
estimator = LightCurveEstimator(
energy_edges=[1, 30] * u.TeV,
norm_n_values=3,
time_intervals=time_intervals,
selection_optional=selection,
)
lightcurve = estimator.run(datasets)
table = lightcurve.to_table(format="lightcurve")
assert_allclose(table["time_min"], [55197.0, 55197.041667])
assert_allclose(table["time_max"], [55197.041667, 55197.083333])
assert_allclose(table["stat"], [[6.603043], [0.421051]], rtol=1e-3)
assert_allclose(table["norm"], [[0.885124], [0.967054]], rtol=1e-3)
def test_lightcurve_estimator_spectrum_datasets_largerbin():
# Test all dataset in a single LC bin, here two hours
datasets = get_spectrum_datasets()
time_intervals = [Time(["2010-01-01T00:00:00", "2010-01-01T02:00:00"])]
estimator = LightCurveEstimator(
energy_edges=[1, 30] * u.TeV,
norm_n_values=3,
time_intervals=time_intervals,
selection_optional=["scan"],
)
lightcurve = estimator.run(datasets)
table = lightcurve.to_table(format="lightcurve")
assert_allclose(table["time_min"], [55197.0])
assert_allclose(table["time_max"], [55197.083333])
assert_allclose(table["e_ref"][0], [5.623413])
assert_allclose(table["e_min"][0], [1])
assert_allclose(table["e_max"][0], [31.622777])
assert_allclose(table["ref_dnde"][0], [3.162278e-14], rtol=1e-5)
assert_allclose(table["ref_flux"][0], [9.683772e-13], rtol=1e-5)
assert_allclose(table["ref_eflux"][0], [3.453878e-12], rtol=1e-5)
assert_allclose(table["stat"][0], [34.219808], rtol=1e-5)
assert_allclose(table["norm"][0], [0.909646], rtol=1e-5)
assert_allclose(table["norm_err"][0], [0.040874], rtol=1e-3)
assert_allclose(table["ts"][0], [742.939324], rtol=1e-4)
def get_lc(datasets):
spatial_model1 = GaussianSpatialModel(lon_0="0.2 deg",
lat_0="0.1 deg",
sigma="0.3 deg",
frame="galactic")
spatial_model1.parameters["lon_0"].frozen = True
spatial_model1.parameters["lat_0"].frozen = True
spatial_model1.parameters["sigma"].frozen = True
spectral_model1 = PowerLawSpectralModel(index=3,
amplitude="1e-11 cm-2 s-1 TeV-1",
reference="1 TeV")
model_fit = SkyModel(
spatial_model=spatial_model1,
spectral_model=spectral_model1,
name="model_fit",
)
for dataset in datasets:
dataset.models = [
model_fit,
FoVBackgroundModel(dataset_name=dataset.name)
]
lc_maker = LightCurveEstimator(energy_edges=[1.0, 10.0] * u.TeV,
source="model_fit",
reoptimize=False)
lc = lc_maker.run(datasets)
print(lc.to_table(format="lightcurve", sed_type="flux")["flux"])
def perform_analysis(type, observations, target_position, time_intervals):
log.info(f"Dataset creation in {type}.")
if type == "1d":
datasets = create_datasets_1d(observations, target_position)
else:
datasets = create_datasets_3d(observations, target_position)
log.info("Assign model on the datasets.")
if type == "1d":
sky_model = define_model_1d()
for dataset in datasets:
dataset.models = sky_model
elif type == "3d":
sky_model = define_model_3d(target_position)
for dataset in datasets:
dataset.models = [dataset.background_model, sky_model]
log.info(f"Run LightCurveEstimator in {type}.")
lc_maker = LightCurveEstimator(energy_edges=[0.7, 20.0] * u.TeV,
source="pks2155",
time_intervals=time_intervals)
lc = lc_maker.run(datasets)
log.info("Export results.")
filename = make_path("results")
filename.mkdir(exist_ok=True)
path = filename / f"lightcurve_{type}.fits"
log.info(f"Writing {path}")
lc.write(path, format="lightcurve", overwrite=True)
def main(config_path, models_path, output, reference):
config = AnalysisConfig.read(config_path)
analysis = Analysis(config)
log.info(config)
analysis.get_observations()
log.info(analysis)
log.info(dir(analysis))
log.info(analysis.datasets)
log.info(analysis.datasets[0].counts)
analysis.get_datasets()
analysis.read_models(models_path)
# stacked fit and flux estimation
analysis.run_fit()
analysis.get_flux_points()
# Plot flux points
ax_sed, ax_residuals = analysis.flux_points.plot_fit()
if reference:
plot_kwargs = {
"energy_range": [
analysis.config.flux_points.energy.min,
analysis.config.flux_points.energy.max,
],
"energy_power": 2,
"flux_unit": "erg-1 cm-2 s-1",
}
create_crab_spectral_model(reference).plot(
**plot_kwargs, ax=ax_sed, label="Crab reference"
)
ax_sed.legend()
ax_sed.set_ylim(1e-12, 1e-9)
base_out = Path(output)
ax_sed.get_figure().savefig(base_out.with_suffix(".pdf").as_posix())
plt.clf()
analysis.models.write(base_out.with_suffix(".yaml").as_posix(), overwrite=True)
analysis.flux_points.write(
base_out.with_suffix(".fits").as_posix(), overwrite=True
)
ax_excess = analysis.datasets["stacked"].plot_excess()
ax_excess.get_figure().savefig(base_out.with_suffix(".excess.pdf").as_posix())
plt.clf()
config.datasets.stack = False
analysis.get_observations()
analysis.get_datasets()
analysis.read_models(models_path)
lc_maker_low = LightCurveEstimator(
energy_edges=[.2, 5] * u.TeV, source=config.flux_points.source, reoptimize=False
)
lc_low = lc_maker_low.run(analysis.datasets)
ax_lc = lc_low.plot(marker="o", label="1D")
ax_lc.get_figure().savefig(base_out.with_suffix(".lc.pdf").as_posix())
plt.clf()
def test_lightcurve_estimator_spectrum_datasets_default():
# Test default time interval: each time interval is equal to the gti of each dataset, here one hour
datasets = get_spectrum_datasets()
estimator = LightCurveEstimator(energy_range=[1, 100] * u.TeV,
norm_n_values=3)
steps = ["err", "counts", "ts", "norm-scan"]
lightcurve = estimator.run(datasets, steps=steps)
assert_allclose(lightcurve.table["time_min"], [55197.0, 55197.041667])
assert_allclose(lightcurve.table["time_max"], [55197.041667, 55197.083333])
assert_allclose(lightcurve.table["norm"], [0.988107, 0.948108], rtol=1e-3)
def test_lightcurve_estimator_spectrum_datasets():
# Doing a LC on one hour bin
datasets = get_spectrum_datasets()
time_intervals = [
Time(["2010-01-01T00:00:00", "2010-01-01T01:00:00"]),
Time(["2010-01-01T01:00:00", "2010-01-01T02:00:00"]),
]
estimator = LightCurveEstimator(
energy_edges=[1, 30] * u.TeV,
norm_n_values=3,
time_intervals=time_intervals,
selection_optional="all",
)
lightcurve = estimator.run(datasets)
assert_allclose(lightcurve.table["time_min"], [55197.0, 55197.041667])
assert_allclose(lightcurve.table["time_max"], [55197.041667, 55197.083333])
assert_allclose(lightcurve.table["e_ref"], [[5.623413], [5.623413]])
assert_allclose(lightcurve.table["e_min"], [[1], [1]])
assert_allclose(lightcurve.table["e_max"], [[31.622777], [31.622777]])
assert_allclose(lightcurve.table["ref_dnde"],
[[3.162278e-14], [3.162278e-14]],
rtol=1e-5)
assert_allclose(lightcurve.table["ref_flux"],
[[9.683772e-13], [9.683772e-13]],
rtol=1e-5)
assert_allclose(lightcurve.table["ref_eflux"],
[[3.453878e-12], [3.453878e-12]],
rtol=1e-5)
assert_allclose(lightcurve.table["ref_e2dnde"], [[1e-12], [1e-12]],
rtol=1e-5)
assert_allclose(lightcurve.table["stat"], [[16.824042], [17.391981]],
rtol=1e-5)
assert_allclose(lightcurve.table["norm"], [[0.911963], [0.9069318]],
rtol=1e-2)
assert_allclose(lightcurve.table["norm_err"], [[0.057769], [0.057835]],
rtol=1e-2)
assert_allclose(lightcurve.table["counts"], [[791], [784]])
assert_allclose(lightcurve.table["norm_errp"], [[0.058398], [0.058416]],
rtol=1e-2)
assert_allclose(lightcurve.table["norm_errn"], [[0.057144], [0.057259]],
rtol=1e-2)
assert_allclose(lightcurve.table["norm_ul"], [[1.029989], [1.025061]],
rtol=1e-2)
assert_allclose(lightcurve.table["sqrt_ts"], [[19.384781], [19.161769]],
rtol=1e-2)
assert_allclose(lightcurve.table["ts"], [[375.769735], [367.173374]],
rtol=1e-2)
assert_allclose(lightcurve.table[0]["norm_scan"], [[0.2, 1.0, 5.0]])
assert_allclose(
lightcurve.table[0]["stat_scan"],
[[224.058304, 19.074405, 2063.75636]],
rtol=1e-5,
)
def get_lc(datasets):
spectral_model = PowerLawSpectralModel(
index=3, amplitude="1e-11 cm-2 s-1 TeV-1", reference="1 TeV"
)
model_fit = SkyModel(spectral_model=spectral_model, name="model-fit",)
for dataset in datasets:
dataset.models = model_fit
lc_maker_1d = LightCurveEstimator(
e_edges=[1.0, 10.0] * u.TeV, source="model-fit", reoptimize=False
)
lc_1d = lc_maker_1d.run(datasets)
def test_lightcurve_estimator_spectrum_datasets_default():
# Test default time interval: each time interval is equal to the gti of each dataset, here one hour
datasets = get_spectrum_datasets()
selection = ["scan"]
estimator = LightCurveEstimator(e_edges=[1, 30] * u.TeV,
norm_n_values=3,
selection_optional=selection)
lightcurve = estimator.run(datasets)
assert_allclose(lightcurve.table["time_min"], [55197.0, 55197.041667])
assert_allclose(lightcurve.table["time_max"], [55197.041667, 55197.083333])
assert_allclose(lightcurve.table["norm"], [0.911963, 0.906931], rtol=1e-3)
def test_lightcurve_estimator_spectrum_datasets():
# Doing a LC on one hour bin
datasets = get_spectrum_datasets()
time_intervals = [
Time(["2010-01-01T00:00:00", "2010-01-01T01:00:00"]),
Time(["2010-01-01T01:00:00", "2010-01-01T02:00:00"]),
]
estimator = LightCurveEstimator(
energy_edges=[1, 30] * u.TeV,
norm_n_values=3,
time_intervals=time_intervals,
selection_optional="all",
)
lightcurve = estimator.run(datasets)
table = lightcurve.to_table(format="lightcurve")
assert_allclose(table["time_min"], [55197.0, 55197.041667])
assert_allclose(table["time_max"], [55197.041667, 55197.083333])
assert_allclose(table["e_ref"], [[5.623413], [5.623413]])
assert_allclose(table["e_min"], [[1], [1]])
assert_allclose(table["e_max"], [[31.622777], [31.622777]])
assert_allclose(
table["ref_dnde"], [[3.162278e-14], [3.162278e-14]], rtol=1e-5
)
assert_allclose(
table["ref_flux"], [[9.683772e-13], [9.683772e-13]], rtol=1e-5
)
assert_allclose(
table["ref_eflux"], [[3.453878e-12], [3.453878e-12]], rtol=1e-5
)
assert_allclose(table["stat"], [[16.824042], [17.391981]], rtol=1e-5)
assert_allclose(table["norm"], [[0.911963], [0.9069318]], rtol=1e-2)
assert_allclose(table["norm_err"], [[0.057769], [0.057835]], rtol=1e-2)
assert_allclose(table["counts"], [[[791, np.nan]], [[np.nan, 784]]])
assert_allclose(table["norm_errp"], [[0.058398], [0.058416]], rtol=1e-2)
assert_allclose(table["norm_errn"], [[0.057144], [0.057259]], rtol=1e-2)
assert_allclose(table["norm_ul"], [[1.029989], [1.025061]], rtol=1e-2)
assert_allclose(table["sqrt_ts"], [[19.384781], [19.161769]], rtol=1e-2)
assert_allclose(table["ts"], [[375.769735], [367.173374]], rtol=1e-2)
assert_allclose(table[0]["norm_scan"], [[0.2, 1.0, 5.0]])
assert_allclose(
table[0]["stat_scan"], [[224.058304, 19.074405, 2063.75636]], rtol=1e-5,
)
# TODO: fix reference model I/O
fp = FluxPoints.from_table(
table=table, format="lightcurve", reference_model=PowerLawSpectralModel()
)
assert fp.norm.geom.axes.names == ["energy", "time"]
assert fp.counts.geom.axes.names == ["dataset", "energy", "time"]
assert fp.stat_scan.geom.axes.names == ["norm", "energy", "time"]
def test_lightcurve_estimator_spectrum_datasets_timeoverlaped():
# Check that it returns a ValueError if the time intervals overlapped
datasets = get_spectrum_datasets()
time_intervals = [
Time(["2010-01-01T00:00:00", "2010-01-01T01:30:00"]),
Time(["2010-01-01T01:00:00", "2010-01-01T02:00:00"]),
]
with pytest.raises(ValueError) as excinfo:
estimator = LightCurveEstimator(norm_n_values=3,
time_intervals=time_intervals)
estimator.run(datasets)
msg = "LightCurveEstimator requires non-overlapping time bins."
assert str(excinfo.value) == msg
def test_group_datasets_in_time_interval_outflows():
datasets = get_spectrum_datasets()
# Check Overflow
time_intervals = [
Time(["2010-01-01T00:00:00", "2010-01-01T00:55:00"]),
Time(["2010-01-01T01:00:00", "2010-01-01T02:00:00"]),
]
estimator = LightCurveEstimator(energy_range=[1, 10] * u.TeV,
norm_n_values=3,
time_intervals=time_intervals)
steps = ["err", "counts", "ts", "norm-scan"]
estimator.run(datasets, steps=steps)
assert estimator.group_table_info["Bin_type"][0] == "Overflow"
# Check underflow
time_intervals = [
Time(["2010-01-01T00:05:00", "2010-01-01T01:00:00"]),
Time(["2010-01-01T01:00:00", "2010-01-01T02:00:00"]),
]
estimator = LightCurveEstimator(energy_range=[1, 10] * u.TeV,
norm_n_values=3,
time_intervals=time_intervals)
steps = ["err", "counts", "ts", "norm-scan"]
estimator.run(datasets, steps=steps)
assert estimator.group_table_info["Bin_type"][0] == "Underflow"
def test_lightcurve_estimator_spectrum_datasets_emptybin():
# Test all dataset in a single LC bin, here two hours
datasets = get_spectrum_datasets()
time_intervals = [Time(["2010-01-01T00:00:00", "2010-01-01T02:00:00"]),
Time(["2010-02-01T00:00:00", "2010-02-01T02:00:00"])]
estimator = LightCurveEstimator(
energy_edges=[1, 30] * u.TeV,
norm_n_values=3,
time_intervals=time_intervals,
selection_optional=["scan"],
)
lightcurve = estimator.run(datasets)
table = lightcurve.to_table(format="lightcurve")
assert_allclose(table["time_min"], [55197.0])
assert_allclose(table["time_max"], [55197.083333])
def test_lightcurve_estimator_spectrum_datasets_gti_not_include_in_time_intervals(
):
# Check that it returns a ValueError if the time intervals are smaller than the dataset GTI.
datasets = get_spectrum_datasets()
time_intervals = [
Time(["2010-01-01T00:00:00", "2010-01-01T00:05:00"]),
Time(["2010-01-01T01:00:00", "2010-01-01T01:05:00"]),
]
estimator = LightCurveEstimator(energy_range=[1, 100] * u.TeV,
norm_n_values=3,
time_intervals=time_intervals)
with pytest.raises(ValueError) as excinfo:
steps = ["err", "counts", "ts", "norm-scan"]
estimator.run(datasets, steps=steps)
msg = "LightCurveEstimator: No datasets in time intervals"
assert str(excinfo.value) == msg
def test_lightcurve_estimator_spectrum_datasets_notordered():
# Test that if the time intervals given are not ordered in time, it is first ordered correctly and then
# compute as expected
datasets = get_spectrum_datasets()
time_intervals = [
Time(["2010-01-01T01:00:00", "2010-01-01T02:00:00"]),
Time(["2010-01-01T00:00:00", "2010-01-01T01:00:00"]),
]
estimator = LightCurveEstimator(energy_range=[1, 100] * u.TeV,
norm_n_values=3,
time_intervals=time_intervals)
steps = ["err", "counts", "ts", "norm-scan"]
lightcurve = estimator.run(datasets, steps=steps)
assert_allclose(lightcurve.table["time_min"], [55197.0, 55197.041667])
assert_allclose(lightcurve.table["time_max"], [55197.041667, 55197.083333])
assert_allclose(lightcurve.table["norm"], [0.988107, 0.948108], rtol=1e-3)
def test_lightcurve_estimator_spectrum_datasets_gti_not_include_in_time_intervals():
# Check that it returns a ValueError if the time intervals are smaller than the dataset GTI.
datasets = get_spectrum_datasets()
time_intervals = [
Time(["2010-01-01T00:00:00", "2010-01-01T00:05:00"]),
Time(["2010-01-01T01:00:00", "2010-01-01T01:05:00"]),
]
estimator = LightCurveEstimator(
energy_edges=[1, 30] * u.TeV,
norm_n_values=3,
time_intervals=time_intervals,
selection_optional=["scan"],
)
with pytest.raises(ValueError) as excinfo:
estimator.run(datasets)
msg = "LightCurveEstimator: No datasets in time intervals"
assert str(excinfo.value) == msg
def test_lightcurve_estimator_spectrum_datasets_notordered():
# Test that if the time intervals given are not ordered in time, it is first ordered correctly and then
# compute as expected
datasets = get_spectrum_datasets()
time_intervals = [
Time(["2010-01-01T01:00:00", "2010-01-01T02:00:00"]),
Time(["2010-01-01T00:00:00", "2010-01-01T01:00:00"]),
]
estimator = LightCurveEstimator(
e_edges=[1, 100] * u.TeV,
norm_n_values=3,
time_intervals=time_intervals,
selection_optional=["scan"],
)
lightcurve = estimator.run(datasets)
assert_allclose(lightcurve.table["time_min"], [55197.0, 55197.041667])
assert_allclose(lightcurve.table["time_max"], [55197.041667, 55197.083333])
assert_allclose(lightcurve.table["norm"], [0.911963, 0.906931], rtol=1e-3)
def test_group_datasets_in_time_interval():
# Doing a LC on one hour bin
datasets = get_spectrum_datasets()
time_intervals = [
Time(["2010-01-01T00:00:00", "2010-01-01T01:00:00"]),
Time(["2010-01-01T01:00:00", "2010-01-01T02:00:00"]),
]
estimator = LightCurveEstimator(energy_range=[1, 10] * u.TeV,
norm_n_values=3,
time_intervals=time_intervals)
steps = ["err", "counts", "ts", "norm-scan"]
estimator.run(datasets, steps=steps)
assert len(estimator.group_table_info) == 2
assert estimator.group_table_info["Name"][0] == "dataset_1"
assert_allclose(estimator.group_table_info["Tstart"],
[55197.0, 55197.04166666667])
assert_allclose(estimator.group_table_info["Tstop"],
[55197.04166666667, 55197.083333333336])
assert_allclose(estimator.group_table_info["Group_ID"], [0, 1])
def test_lightcurve_estimator_map_datasets():
datasets = get_map_datasets()
time_intervals = [
Time(["2010-01-01T00:00:00", "2010-01-01T01:00:00"]),
Time(["2010-01-01T01:00:00", "2010-01-01T02:00:00"]),
]
estimator = LightCurveEstimator(
energy_edges=[1, 100] * u.TeV,
source="test_source",
time_intervals=time_intervals,
selection_optional=["scan"],
)
lightcurve = estimator.run(datasets)
table = lightcurve.to_table(format="lightcurve")
assert_allclose(table["time_min"], [55197.0, 55197.041667])
assert_allclose(table["time_max"], [55197.041667, 55197.083333])
assert_allclose(table["e_ref"], [[10.857111], [10.857111]])
assert_allclose(table["e_min"], [[1.178769], [1.178769]], rtol=1e-5)
assert_allclose(table["e_max"], [[100], [100]])
assert_allclose(
table["ref_dnde"], [[8.483429e-14], [8.483429e-14]], rtol=1e-5
)
assert_allclose(
table["ref_flux"], [[8.383429e-12], [8.383429e-12]], rtol=1e-5
)
assert_allclose(
table["ref_eflux"], [[4.4407e-11], [4.4407e-11]], rtol=1e-5
)
assert_allclose(table["stat"], [[9402.778975], [9517.750207]], rtol=1e-2)
assert_allclose(table["norm"], [[0.971592], [0.963286]], rtol=1e-2)
assert_allclose(table["norm_err"], [[0.044643], [0.044475]], rtol=1e-2)
assert_allclose(table["sqrt_ts"], [[35.880361], [35.636547]], rtol=1e-2)
assert_allclose(table["ts"], [[1287.4003], [1269.963491]], rtol=1e-2)
datasets = get_map_datasets()
time_intervals2 = [Time(["2010-01-01T00:00:00", "2010-01-01T02:00:00"])]
estimator2 = LightCurveEstimator(
energy_edges=[1, 100] * u.TeV,
source="test_source",
time_intervals=time_intervals2,
selection_optional=["scan"],
)
lightcurve2 = estimator2.run(datasets)
table = lightcurve2.to_table(format="lightcurve")
assert_allclose(table["time_min"][0], [55197.0])
assert_allclose(table["time_max"][0], [55197.083333])
assert_allclose(table["e_ref"][0], [10.857111], rtol=1e-5)
assert_allclose(table["e_min"][0], [1.178769], rtol=1e-5)
assert_allclose(table["e_max"][0], [100])
assert_allclose(table["ref_dnde"][0], [8.483429e-14], rtol=1e-5)
assert_allclose(table["ref_flux"][0], [8.383429e-12], rtol=1e-5)
assert_allclose(table["ref_eflux"][0], [4.4407e-11], rtol=1e-5)
assert_allclose(table["stat"][0], [18920.54651], rtol=1e-2)
assert_allclose(table["norm"][0], [0.967438], rtol=1e-2)
assert_allclose(table["norm_err"][0], [0.031508], rtol=1e-2)
assert_allclose(table["counts"][0], [[2205, 2220]])
assert_allclose(table["ts"][0], [2557.346464], rtol=1e-2)
def test_lightcurve_estimator_map_datasets():
datasets = get_map_datasets()
time_intervals = [
Time(["2010-01-01T00:00:00", "2010-01-01T01:00:00"]),
Time(["2010-01-01T01:00:00", "2010-01-01T02:00:00"]),
]
estimator = LightCurveEstimator(
energy_range=[1, 100] * u.TeV,
source="test_source",
time_intervals=time_intervals,
)
steps = ["err", "counts", "ts", "norm-scan"]
lightcurve = estimator.run(datasets, steps=steps)
assert_allclose(lightcurve.table["time_min"], [55197.0, 55197.041667])
assert_allclose(lightcurve.table["time_max"], [55197.041667, 55197.083333])
assert_allclose(lightcurve.table["e_ref"], [10, 10])
assert_allclose(lightcurve.table["e_min"], [1, 1])
assert_allclose(lightcurve.table["e_max"], [100, 100])
assert_allclose(lightcurve.table["ref_dnde"], [1e-13, 1e-13])
assert_allclose(lightcurve.table["ref_flux"], [9.9e-12, 9.9e-12])
assert_allclose(lightcurve.table["ref_eflux"], [4.60517e-11, 4.60517e-11])
assert_allclose(lightcurve.table["ref_e2dnde"], [1e-11, 1e-11])
assert_allclose(lightcurve.table["stat"], [-87412.393367, -89856.129206],
rtol=1e-2)
assert_allclose(lightcurve.table["norm"], [0.972535, 0.995933], rtol=1e-2)
assert_allclose(lightcurve.table["norm_err"], [0.037293, 0.037806],
rtol=1e-2)
assert_allclose(lightcurve.table["sqrt_ts"], [39.568557, 39.934953],
rtol=1e-2)
assert_allclose(lightcurve.table["ts"], [1565.670741, 1594.800492],
rtol=1e-2)
datasets = get_map_datasets()
time_intervals2 = [Time(["2010-01-01T00:00:00", "2010-01-01T02:00:00"])]
estimator2 = LightCurveEstimator(
energy_range=[1, 100] * u.TeV,
source="test_source",
time_intervals=time_intervals2,
)
lightcurve2 = estimator2.run(datasets)
assert_allclose(lightcurve2.table["time_min"], [55197.0])
assert_allclose(lightcurve2.table["time_max"], [55197.083333])
assert_allclose(lightcurve2.table["e_ref"], [10])
assert_allclose(lightcurve2.table["e_min"], [1])
assert_allclose(lightcurve2.table["e_max"], [100])
assert_allclose(lightcurve2.table["ref_dnde"], [1e-13])
assert_allclose(lightcurve2.table["ref_flux"], [9.9e-12])
assert_allclose(lightcurve2.table["ref_eflux"], [4.60517e-11])
assert_allclose(lightcurve2.table["ref_e2dnde"], [1e-11])
assert_allclose(lightcurve2.table["stat"], [-177267.775615], rtol=1e-2)
assert_allclose(lightcurve2.table["norm"], [0.983672], rtol=1e-2)
assert_allclose(lightcurve2.table["norm_err"], [0.026545], rtol=1e-2)
assert_allclose(lightcurve.table["counts"], [46816, 47399])
assert_allclose(lightcurve2.table["ts"], [3160.275], rtol=1e-2)
def test_lightcurve_estimator_map_datasets():
datasets = get_map_datasets()
time_intervals = [
Time(["2010-01-01T00:00:00", "2010-01-01T01:00:00"]),
Time(["2010-01-01T01:00:00", "2010-01-01T02:00:00"]),
]
estimator = LightCurveEstimator(datasets,
source="source",
time_intervals=time_intervals)
steps = ["err", "counts", "ts", "norm-scan"]
lightcurve = estimator.run(e_ref=10 * u.TeV,
e_min=1 * u.TeV,
e_max=100 * u.TeV,
steps=steps)
assert_allclose(lightcurve.table["time_min"], [55197.0, 55197.041667])
assert_allclose(lightcurve.table["time_max"], [55197.041667, 55197.083333])
assert_allclose(lightcurve.table["e_ref"], [10, 10])
assert_allclose(lightcurve.table["e_min"], [1, 1])
assert_allclose(lightcurve.table["e_max"], [100, 100])
assert_allclose(lightcurve.table["ref_dnde"], [1e-13, 1e-13])
assert_allclose(lightcurve.table["ref_flux"], [9.9e-12, 9.9e-12])
assert_allclose(lightcurve.table["ref_eflux"], [4.60517e-11, 4.60517e-11])
assert_allclose(lightcurve.table["ref_e2dnde"], [1e-11, 1e-11])
assert_allclose(lightcurve.table["stat"], [-87412.393367, -89856.129206],
rtol=1e-5)
assert_allclose(lightcurve.table["norm_err"], [0.042259, 0.043614],
rtol=1e-3)
assert_allclose(lightcurve.table["sqrt_ts"], [38.527512, 39.489968],
rtol=1e-4)
assert_allclose(lightcurve.table["ts"], [1484.369159, 1559.457547],
rtol=1e-4)
datasets = get_map_datasets()
time_intervals2 = [Time(["2010-01-01T00:00:00", "2010-01-01T02:00:00"])]
estimator2 = LightCurveEstimator(datasets,
source="source",
time_intervals=time_intervals2)
lightcurve2 = estimator2.run(e_ref=10 * u.TeV,
e_min=1 * u.TeV,
e_max=100 * u.TeV)
assert_allclose(lightcurve2.table["time_min"], [55197.0])
assert_allclose(lightcurve2.table["time_max"], [55197.083333])
assert_allclose(lightcurve2.table["e_ref"], [10])
assert_allclose(lightcurve2.table["e_min"], [1])
assert_allclose(lightcurve2.table["e_max"], [100])
assert_allclose(lightcurve2.table["ref_dnde"], [1e-13])
assert_allclose(lightcurve2.table["ref_flux"], [9.9e-12])
assert_allclose(lightcurve2.table["ref_eflux"], [4.60517e-11])
assert_allclose(lightcurve2.table["ref_e2dnde"], [1e-11])
assert_allclose(lightcurve2.table["stat"], [-177267.775615], rtol=1e-5)
assert_allclose(lightcurve2.table["norm_err"], [0.030358], rtol=1e-3)
assert_allclose(lightcurve.table["counts"], [46794, 47388])
assert_allclose(lightcurve2.table["ts"], [3042.893291], rtol=1e-4)
def test_lightcurve_estimator_fit_options():
# Doing a LC on one hour bin
datasets = get_spectrum_datasets()
time_intervals = [
Time(["2010-01-01T00:00:00", "2010-01-01T01:00:00"]),
Time(["2010-01-01T01:00:00", "2010-01-01T02:00:00"]),
]
energy_edges = [1, 30] * u.TeV
estimator = LightCurveEstimator(
energy_edges=energy_edges,
norm_n_values=3,
time_intervals=time_intervals,
selection_optional="all",
fit=Fit(backend="minuit", optimize_opts=dict(tol=0.2, strategy=1)),
)
assert_allclose(estimator.fit.optimize_opts["tol"], 0.2)
estimator.fit.run(datasets=datasets)
assert_allclose(estimator.fit.minuit.tol, 0.2)
def test_lightcurve_estimator_spectrum_datasets_2_energy_bins():
# Doing a LC on one hour bin
datasets = get_spectrum_datasets()
time_intervals = [
Time(["2010-01-01T00:00:00", "2010-01-01T01:00:00"]),
Time(["2010-01-01T01:00:00", "2010-01-01T02:00:00"]),
]
estimator = LightCurveEstimator(
energy_edges=[1, 5, 30] * u.TeV,
norm_n_values=3,
time_intervals=time_intervals,
selection_optional="all",
)
lightcurve = estimator.run(datasets)
table = lightcurve.to_table(format="lightcurve")
assert_allclose(table["time_min"], [55197.0, 55197.041667])
assert_allclose(table["time_max"], [55197.041667, 55197.083333])
assert_allclose(table["e_ref"],
[[2.238721, 12.589254], [2.238721, 12.589254]])
assert_allclose(table["e_min"], [[1, 5.011872], [1, 5.011872]])
assert_allclose(table["e_max"],
[[5.011872, 31.622777], [5.011872, 31.622777]])
assert_allclose(
table["ref_dnde"],
[[1.995262e-13, 6.309573e-15], [1.995262e-13, 6.309573e-15]],
rtol=1e-5,
)
assert_allclose(
table["stat"],
[[8.234951, 8.30321], [2.037205, 15.300507]],
rtol=1e-5,
)
assert_allclose(
table["norm"],
[[0.894723, 0.967419], [0.914283, 0.882351]],
rtol=1e-2,
)
assert_allclose(
table["norm_err"],
[[0.065905, 0.121288], [0.06601, 0.119457]],
rtol=1e-2,
)
assert_allclose(
table["counts"],
[[[669.0, np.nan], [122.0, np.nan]], [[np.nan, 667.0], [np.nan, 117.0]]
],
)
assert_allclose(
table["norm_errp"],
[[0.06664, 0.124741], [0.066815, 0.122832]],
rtol=1e-2,
)
assert_allclose(
table["norm_errn"],
[[0.065176, 0.117904], [0.065212, 0.116169]],
rtol=1e-2,
)
assert_allclose(
table["norm_ul"],
[[1.029476, 1.224117], [1.049283, 1.134874]],
rtol=1e-2,
)
assert_allclose(
table["sqrt_ts"],
[[16.233236, 10.608376], [16.609784, 9.557339]],
rtol=1e-2,
)
assert_allclose(table[0]["norm_scan"], [[0.2, 1.0, 5.0], [0.2, 1.0, 5.0]])
assert_allclose(
table[0]["stat_scan"],
[[153.880281, 10.701492, 1649.609684],
[70.178023, 8.372913, 414.146676]],
rtol=1e-5,
)
# those quantities are currently not part of the table so we test separately
npred = lightcurve.npred.data.squeeze()
assert_allclose(
npred,
[[[669.36, np.nan], [121.66, np.nan]],
[[np.nan, 664.41], [np.nan, 115.09]]],
rtol=1e-3,
)
npred_excess_err = lightcurve.npred_excess_err.data.squeeze()
assert_allclose(
npred_excess_err,
[[[26.80, np.nan], [11.31, np.nan]], [[np.nan, 26.85], [np.nan, 11.14]]
],
rtol=1e-3,
)
npred_excess_errp = lightcurve.npred_excess_errp.data.squeeze()
assert_allclose(
npred_excess_errp,
[[[27.11, np.nan], [11.63, np.nan]], [[np.nan, 27.15], [np.nan, 11.46]]
],
rtol=1e-3,
)
npred_excess_errn = lightcurve.npred_excess_errn.data.squeeze()
assert_allclose(
npred_excess_errn,
[[[26.50, np.nan], [11.00, np.nan]], [[np.nan, 26.54], [np.nan, 10.84]]
],
rtol=1e-3,
)
npred_excess_ul = lightcurve.npred_excess_ul.data.squeeze()
assert_allclose(
npred_excess_ul,
[[[418.68, np.nan], [114.19, np.nan]],
[[np.nan, 426.74], [np.nan, 105.86]]],
rtol=1e-3,
)
fp = FluxPoints.from_table(table=table,
format="lightcurve",
reference_model=PowerLawSpectralModel())
assert fp.norm.geom.axes.names == ["energy", "time"]
assert fp.counts.geom.axes.names == ["dataset", "energy", "time"]
assert fp.stat_scan.geom.axes.names == ["norm", "energy", "time"]
def test_lightcurve_estimator_spectrum_datasets_2_energy_bins():
# Doing a LC on one hour bin
datasets = get_spectrum_datasets()
time_intervals = [
Time(["2010-01-01T00:00:00", "2010-01-01T01:00:00"]),
Time(["2010-01-01T01:00:00", "2010-01-01T02:00:00"]),
]
estimator = LightCurveEstimator(energy_edges=[1, 5, 30] * u.TeV,
norm_n_values=3,
time_intervals=time_intervals)
lightcurve = estimator.run(datasets)
assert_allclose(lightcurve.table["time_min"], [55197.0, 55197.041667])
assert_allclose(lightcurve.table["time_max"], [55197.041667, 55197.083333])
assert_allclose(lightcurve.table["e_ref"],
[[2.238721, 12.589254], [2.238721, 12.589254]])
assert_allclose(lightcurve.table["e_min"], [[1, 5.011872], [1, 5.011872]])
assert_allclose(lightcurve.table["e_max"],
[[5.011872, 31.622777], [5.011872, 31.622777]])
assert_allclose(
lightcurve.table["ref_dnde"],
[[1.995262e-13, 6.309573e-15], [1.995262e-13, 6.309573e-15]],
rtol=1e-5,
)
assert_allclose(
lightcurve.table["stat"],
[[8.234951, 8.30321], [2.037205, 15.300507]],
rtol=1e-5,
)
assert_allclose(
lightcurve.table["norm"],
[[0.894723, 0.967419], [0.914283, 0.882351]],
rtol=1e-2,
)
assert_allclose(
lightcurve.table["norm_err"],
[[0.065905, 0.121288], [0.06601, 0.119457]],
rtol=1e-2,
)
assert_allclose(lightcurve.table["counts"],
[[669.0, 122.0], [667.0, 117.0]])
assert_allclose(
lightcurve.table["norm_errp"],
[[0.06664, 0.124741], [0.066815, 0.122832]],
rtol=1e-2,
)
assert_allclose(
lightcurve.table["norm_errn"],
[[0.065176, 0.117904], [0.065212, 0.116169]],
rtol=1e-2,
)
assert_allclose(
lightcurve.table["norm_ul"],
[[1.029476, 1.224117], [1.049283, 1.134874]],
rtol=1e-2,
)
assert_allclose(
lightcurve.table["sqrt_ts"],
[[16.233236, 10.608376], [16.609784, 9.557339]],
rtol=1e-2,
)
assert_allclose(lightcurve.table[0]["norm_scan"],
[[0.2, 1.0, 5.0], [0.2, 1.0, 5.0]])
assert_allclose(
lightcurve.table[0]["stat_scan"],
[[153.880281, 10.701492, 1649.609684],
[70.178023, 8.372913, 414.146676]],
rtol=1e-5,
)
