def test_validation_checks():
config = AnalysisConfig()
analysis = Analysis(config)
analysis.settings["observations"]["datastore"] = "other"
with pytest.raises(FileNotFoundError):
analysis.get_observations()
config = AnalysisConfig.from_template("1d")
analysis = Analysis(config)
assert analysis.get_flux_points() is False
assert analysis.run_fit() is False
assert analysis.set_model() is False
assert analysis.get_datasets() is False
analysis.get_observations()
analysis.settings["datasets"]["dataset-type"] = "not assigned"
assert analysis.get_datasets() is False
analysis.settings["datasets"]["dataset-type"] = "SpectrumDatasetOnOff"
analysis.get_observations()
analysis.get_datasets()
model_str = Path(MODEL_FILE).read_text()
analysis.set_model(model=model_str)
assert isinstance(analysis.model, SkyModels) is True
assert analysis.set_model() is False
analysis.run_fit()
del analysis.settings["flux-points"]
assert analysis.get_flux_points() is False
def test_analysis_1d_stacked():
cfg = """
datasets:
geom:
axes:
energy_true: {min: 0.03 TeV, max: 100 TeV, nbins: 50}
background:
method: reflected
"""
config = get_example_config("1d")
analysis = Analysis(config)
analysis.update_config(cfg)
analysis.config.datasets.stack = True
analysis.get_observations()
analysis.get_datasets()
analysis.read_models(MODEL_FILE_1D)
analysis.run_fit()
assert len(analysis.datasets) == 1
assert_allclose(analysis.datasets["stacked"].counts.data.sum(), 184)
pars = analysis.fit_result.parameters
assert_allclose(pars["index"].value, 2.76913, rtol=1e-2)
assert_allclose(pars["amplitude"].value, 5.496388e-11, rtol=1e-2)
def test_analysis_1d():
cfg = """
observations:
datastore: $GAMMAPY_DATA/hess-dl3-dr1
obs_ids: [23523, 23526]
obs_time: {
start: [J2004.92654346, J2004.92658453, J2004.92663655],
stop: [J2004.92658453, J2004.92663655, J2004.92670773]
}
datasets:
type: 1d
background:
method: reflected
geom:
axes:
energy_true: {min: 0.01 TeV, max: 300 TeV, nbins: 109}
on_region: {frame: icrs, lon: 83.633 deg, lat: 22.014 deg, radius: 0.11 deg}
safe_mask:
methods: [aeff-default, edisp-bias]
parameters: {bias_percent: 10.0}
containment_correction: false
flux_points:
energy: {min: 1 TeV, max: 50 TeV, nbins: 4}
light_curve:
energy_edges: {min: 1 TeV, max: 50 TeV, nbins: 1}
time_intervals: {
start: [J2004.92654346, J2004.92658453, J2004.92663655],
stop: [J2004.92658453, J2004.92663655, J2004.92670773]
}
"""
config = get_example_config("1d")
analysis = Analysis(config)
analysis.update_config(cfg)
analysis.get_observations()
analysis.get_datasets()
analysis.read_models(MODEL_FILE_1D)
analysis.run_fit()
analysis.get_flux_points()
analysis.get_light_curve()
assert len(analysis.datasets) == 3
table = analysis.flux_points.data.to_table(sed_type="dnde")
assert len(table) == 4
dnde = table["dnde"].quantity
assert dnde.unit == "cm-2 s-1 TeV-1"
assert_allclose(dnde[0].value, 8.116854e-12, rtol=1e-2)
assert_allclose(dnde[2].value, 3.444475e-14, rtol=1e-2)
axis = analysis.light_curve.geom.axes["time"]
assert axis.nbin == 3
assert_allclose(axis.time_min.mjd, [53343.92, 53343.935, 53343.954])
flux = analysis.light_curve.flux.data[:, :, 0, 0]
assert_allclose(flux, [[1.688954e-11], [2.347870e-11], [1.604152e-11]],
rtol=1e-4)
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_usage_errors():
config = get_example_config("1d")
analysis = Analysis(config)
with pytest.raises(RuntimeError):
analysis.get_datasets()
with pytest.raises(RuntimeError):
analysis.read_models(MODEL_FILE)
with pytest.raises(RuntimeError):
analysis.run_fit()
with pytest.raises(RuntimeError):
analysis.get_flux_points()
def run_analysis(estimate):
"""Run analysis from observation selection to model fitting."""
config = AnalysisConfig.read(f"{estimate}/config.yaml")
analysis = Analysis(config)
analysis.get_observations()
analysis.get_datasets()
models = Models.read(f"{estimate}/models.yaml")
analysis.set_models(models)
analysis.run_fit()
return analysis
def run_3d(name):
"""Run 3D analysis for one source."""
logging.info(f"run3d: {name}")
mode = "3d"
config_file = f"config{mode}.yaml"
target_config_file = f"targets.yaml"
model_file = f"model{mode}_{name}.yaml"
outdir = f"results/{name}"
config = target_config3d(config_file, target_config_file, name)
analysis = Analysis(config)
analysis.get_observations()
conf = config.settings["observations"]["filters"][0]
nb, lon, lat, rad = (
len(analysis.observations.ids),
conf["lon"],
conf["lat"],
conf["radius"],
)
logging.info(f"{nb} observations found in {rad} around {lon}, {lat} ")
analysis.get_datasets()
# test
plt.figure(figsize=(5, 5))
analysis.datasets["stacked"].counts.sum_over_axes().plot(add_cbar=True)
plt.savefig(f"{outdir}/{name}_{mode}_counts.png", bbox_inches="tight")
analysis.set_model(filename=model_file)
logging.info(analysis.model)
analysis.run_fit()
logging.info(analysis.fit_result.parameters.to_table())
analysis.fit_result.parameters.to_table().write(
f"{outdir}/{name}_{mode}_bestfit.dat", format="ascii", overwrite=True)
analysis.get_flux_points(source=f"{name}")
analysis.flux_points.write(f"{outdir}/{name}_{mode}_fluxpoints.fits")
plt.figure(figsize=(5, 5))
analysis.datasets["stacked"].counts.sum_over_axes().plot(add_cbar=True)
plt.savefig(f"{outdir}/{name}_{mode}_counts.png", bbox_inches="tight")
plt.figure(figsize=(5, 5))
analysis.datasets["stacked"].plot_residuals(method="diff/sqrt(model)",
vmin=-0.5,
vmax=0.5)
plt.savefig(f"{outdir}/{name}_{mode}_residuals.png", bbox_inches="tight")
plt.figure(figsize=(8, 5))
ax_sed, ax_residuals = analysis.flux_points.peek()
plt.savefig(f"{outdir}/{name}_{mode}_fluxpoints.png", bbox_inches="tight")
def test_analysis_1d_stacked():
config = AnalysisConfig.from_template("1d")
analysis = Analysis(config)
analysis.settings["datasets"]["stack-datasets"] = True
analysis.get_observations()
analysis.get_datasets()
analysis.set_model(filename=MODEL_FILE)
analysis.run_fit()
assert len(analysis.datasets) == 1
assert_allclose(analysis.datasets["stacked"].counts.data.sum(), 404)
pars = analysis.fit_result.parameters
assert_allclose(pars["index"].value, 2.689559, rtol=1e-3)
assert_allclose(pars["amplitude"].value, 2.81629e-11, rtol=1e-3)
def test_analysis_1d(config_analysis_data):
config = AnalysisConfig.from_template("1d")
analysis = Analysis(config)
analysis.config.update_settings(config_analysis_data)
analysis.get_observations()
analysis.get_datasets()
analysis.set_model(filename=MODEL_FILE)
analysis.run_fit()
analysis.get_flux_points()
assert len(analysis.datasets) == 2
assert len(analysis.flux_points.data.table) == 4
dnde = analysis.flux_points.data.table["dnde"].quantity
assert dnde.unit == "cm-2 s-1 TeV-1"
assert_allclose(dnde[0].value, 8.03604e-12, rtol=1e-2)
assert_allclose(dnde[-1].value, 4.780021e-21, rtol=1e-2)
def test_usage_errors():
config = get_example_config("1d")
analysis = Analysis(config)
with pytest.raises(RuntimeError):
analysis.get_datasets()
with pytest.raises(RuntimeError):
analysis.read_datasets()
with pytest.raises(RuntimeError):
analysis.write_datasets()
with pytest.raises(TypeError):
analysis.read_models()
with pytest.raises(RuntimeError):
analysis.write_models()
with pytest.raises(RuntimeError):
analysis.run_fit()
with pytest.raises(RuntimeError):
analysis.get_flux_points()
with pytest.raises(ValidationError):
analysis.config.datasets.type = "None"
def analysis_3d_data_reduction(target):
log.info(f"analysis_3d_data_reduction: {target}")
opts = yaml.safe_load(open("targets.yaml"))[target]
txt = Path("config_template.yaml").read_text()
txt = txt.format_map(opts)
config = AnalysisConfig.from_yaml(txt)
analysis = Analysis(config)
analysis.get_observations()
log.info("Running data reduction")
analysis.get_datasets()
# TODO: write datasets and separate fitting to next function
# Not implemented in Gammapy yet, coming very soon.
log.info("Running fit ...")
analysis.read_models(f"{target}/model_3d.yaml")
logging.info(analysis.models)
analysis.run_fit()
logging.info(analysis.fit_result.parameters.to_table())
path = f"{target}/{target}_3d_bestfit.rst"
log.info(f"Writing {path}")
analysis.fit_result.parameters.to_table().write(path,
format="ascii.rst",
overwrite=True)
# analysis.get_flux_points(source=f"{target}")
# path = f"{target}/{target}_3d_fluxpoints.fits"
# log.info(f"Writing {path}")
# analysis.flux_points.write(path, overwrite=True)
analysis.get_flux_points(source=f"{target}")
path = f"{target}/{target}_3d_fluxpoints.ecsv"
log.info(f"Writing {path}")
keys = [
"e_ref", "e_min", "e_max", "dnde", "dnde_errp", "dnde_errn", "is_ul"
]
analysis.flux_points.data.table_formatted[keys].write(path,
format="ascii.ecsv",
overwrite=True)
return analysis # will write to disk when possible
def test_analysis_3d():
config = AnalysisConfig.from_template("3d")
analysis = Analysis(config)
analysis.get_observations()
analysis.get_datasets()
analysis.set_model(filename=MODEL_FILE)
analysis.datasets["stacked"].background_model.tilt.frozen = False
analysis.run_fit()
analysis.get_flux_points()
assert len(analysis.datasets) == 1
assert len(analysis.fit_result.parameters) == 8
res = analysis.fit_result.parameters
assert res[3].unit == "cm-2 s-1 TeV-1"
assert len(analysis.flux_points.data.table) == 2
dnde = analysis.flux_points.data.table["dnde"].quantity
assert_allclose(dnde[0].value, 1.182768e-11, rtol=1e-1)
assert_allclose(dnde[-1].value, 4.051367e-13, rtol=1e-1)
assert_allclose(res["index"].value, 2.76607, rtol=1e-1)
assert_allclose(res["tilt"].value, -0.143204, rtol=1e-1)
def test_analysis_3d():
config = get_example_config("3d")
analysis = Analysis(config)
analysis.get_observations()
analysis.get_datasets()
analysis.read_models(MODEL_FILE)
analysis.datasets["stacked"].background_model.spectral_model.tilt.frozen = False
analysis.run_fit()
analysis.get_flux_points()
assert len(analysis.datasets) == 1
assert len(analysis.fit_result.parameters) == 8
res = analysis.fit_result.parameters
assert res["amplitude"].unit == "cm-2 s-1 TeV-1"
assert len(analysis.flux_points.data.table) == 2
dnde = analysis.flux_points.data.table["dnde"].quantity
assert_allclose(dnde[0].value, 1.376879e-11, rtol=1e-2)
assert_allclose(dnde[-1].value, 2.691466e-13, rtol=1e-2)
assert_allclose(res["index"].value, 3.097613, rtol=1e-2)
assert_allclose(res["tilt"].value, -0.207792, rtol=1e-2)
def test_analysis_1d_stacked_no_fit_range():
cfg = """
observations:
datastore: $GAMMAPY_DATA/hess-dl3-dr1
obs_cone: {frame: icrs, lon: 83.633 deg, lat: 22.014 deg, radius: 5 deg}
obs_ids: [23592, 23559]
datasets:
type: 1d
stack: false
geom:
axes:
energy: {min: 0.01 TeV, max: 100 TeV, nbins: 73}
energy_true: {min: 0.03 TeV, max: 100 TeV, nbins: 50}
on_region: {frame: icrs, lon: 83.633 deg, lat: 22.014 deg, radius: 0.1 deg}
containment_correction: true
background:
method: reflected
"""
config = AnalysisConfig.from_yaml(cfg)
analysis = Analysis(config)
analysis.update_config(cfg)
analysis.config.datasets.stack = True
analysis.get_observations()
analysis.get_datasets()
analysis.read_models(MODEL_FILE_1D)
analysis.run_fit()
with pytest.raises(ValueError):
analysis.get_excess_map()
assert len(analysis.datasets) == 1
assert_allclose(analysis.datasets["stacked"].counts.data.sum(), 184)
pars = analysis.models.parameters
assert_allclose(analysis.datasets[0].mask_fit.data, True)
assert_allclose(pars["index"].value, 2.76913, rtol=1e-2)
assert_allclose(pars["amplitude"].value, 5.479729e-11, rtol=1e-2)
def test_analysis_1d():
cfg = """
observations:
datastore: $GAMMAPY_DATA/hess-dl3-dr1
obs_ids: [23523, 23526]
datasets:
type: 1d
background:
method: reflected
geom:
axes:
energy_true: {min: 0.01 TeV, max: 300 TeV, nbins: 109}
on_region: {frame: icrs, lon: 83.633 deg, lat: 22.014 deg, radius: 0.11 deg}
safe_mask:
methods: [aeff-default, edisp-bias]
parameters: {bias_percent: 10.0}
containment_correction: false
flux_points:
energy: {min: 1 TeV, max: 50 TeV, nbins: 4}
"""
config = get_example_config("1d")
analysis = Analysis(config)
analysis.update_config(cfg)
analysis.get_observations()
analysis.get_datasets()
analysis.read_models(MODEL_FILE_1D)
analysis.run_fit()
analysis.get_flux_points()
assert len(analysis.datasets) == 2
assert len(analysis.flux_points.data.table) == 4
dnde = analysis.flux_points.data.table["dnde"].quantity
assert dnde.unit == "cm-2 s-1 TeV-1"
assert_allclose(dnde[0].value, 8.116854e-12, rtol=1e-2)
assert_allclose(dnde[2].value, 3.547128e-14, rtol=1e-2)
value: 1.0
unit: TeV
frozen: true
"""
# Now we set the model on the analysis object:
# In[ ]:
analysis.set_models(model_config)
# Finally we run the fit:
# In[ ]:
analysis.run_fit()
# In[ ]:
print(analysis.fit_result)
# This is how we can write the model back to file again:
# In[ ]:
filename = path / "model-best-fit.yaml"
analysis.models.write(filename, overwrite=True)
# In[ ]:
get_ipython().system('cat analysis_1/model-best-fit.yaml')
def run_analysis_3d(target_dict):
"""Run 3D analysis for the selected target"""
tag = target_dict["tag"]
name = target_dict["name"]
log.info(f"running 3d analysis, {tag}")
path_res = Path(tag + "/results/")
ra = target_dict["ra"]
dec = target_dict["dec"]
e_decorr = target_dict["e_decorr"]
config_str = f"""
general:
logging:
level: INFO
outdir: .
observations:
datastore: $GAMMAPY_DATA/hess-dl3-dr1/
filters:
- filter_type: par_value
value_param: {name}
variable: TARGET_NAME
datasets:
dataset-type: MapDataset
stack-datasets: true
offset-max: 2.5 deg
geom:
skydir: [{ra}, {dec}]
width: [5, 5]
binsz: 0.02
coordsys: CEL
proj: TAN
axes:
- name: energy
hi_bnd: 100
lo_bnd: 0.1
nbin: 24
interp: log
node_type: edges
unit: TeV
energy-axis-true:
name: energy
hi_bnd: 100
lo_bnd: 0.1
nbin: 72
interp: log
node_type: edges
unit: TeV
"""
print(config_str)
config = AnalysisConfig(config_str)
# Observation selection
analysis = Analysis(config)
analysis.get_observations()
if DEBUG is True:
analysis.observations.list = [analysis.observations.list[0]]
# Data reduction
analysis.get_datasets()
# Set runwise energy threshold. See reference paper, section 5.1.1.
for dataset in analysis.datasets:
# energy threshold given by the 10% edisp criterium
e_thr_bias = dataset.edisp.get_bias_energy(0.1)
# energy at which the background peaks
background_model = dataset.background_model
bkg_spectrum = background_model.map.get_spectrum()
peak = bkg_spectrum.data.max()
idx = list(bkg_spectrum.data).index(peak)
e_thr_bkg = bkg_spectrum.energy.center[idx]
esafe = max(e_thr_bias, e_thr_bkg)
dataset.mask_fit = dataset.counts.geom.energy_mask(emin=esafe)
# Model fitting
spatial_model = target_dict["spatial_model"]
model_config = f"""
components:
- name: {tag}
type: SkyModel
spatial:
type: {spatial_model}
frame: icrs
parameters:
- name: lon_0
value: {ra}
unit: deg
- name: lat_0
value: {dec}
unit: deg
spectral:
type: PowerLawSpectralModel
parameters:
- name: amplitude
value: 1.0e-12
unit: cm-2 s-1 TeV-1
- name: index
value: 2.0
unit: ''
- name: reference
value: {e_decorr}
unit: TeV
frozen: true
"""
model_npars = 5
if spatial_model == "DiskSpatialModel":
model_config = yaml.load(model_config)
parameters = model_config["components"][0]["spatial"]["parameters"]
parameters.append(
{
"name": "r_0",
"value": 0.2,
"unit": "deg",
"frozen": False
}
)
parameters.append(
{
"name": "e",
"value": 0.8,
"unit": "",
"frozen": False
}
)
parameters.append(
{
"name": "phi",
"value": 150,
"unit": "deg",
"frozen": False
}
)
parameters.append(
{
"name": "edge",
"value": 0.01,
"unit": "deg",
"frozen": True
}
)
model_npars += 4
analysis.set_model(model=model_config)
for dataset in analysis.datasets:
dataset.background_model.norm.frozen = False
analysis.run_fit()
parameters = analysis.model.parameters
parameters.covariance = analysis.fit_result.parameters.covariance[0:model_npars, 0:model_npars]
write_fit_summary(parameters, str(path_res / "results-summary-fit-3d.yaml"))
# Flux points
# TODO: This is a workaround to re-optimize the bkg in each energy bin. Add has to be added to the Analysis class
datasets = analysis.datasets.copy()
for dataset in datasets:
for par in dataset.parameters:
if par is not dataset.background_model.norm:
par.frozen = True
reoptimize = True if DEBUG is False else False
fpe = FluxPointsEstimator(
datasets=datasets, e_edges=FLUXP_EDGES, source=tag, reoptimize=reoptimize
)
flux_points = fpe.run()
flux_points.table["is_ul"] = flux_points.table["ts"] < 4
keys = ["e_ref", "e_min", "e_max", "dnde", "dnde_errp", "dnde_errn"]
flux_points.table_formatted[keys].write(
path_res / "flux-points-3d.ecsv", format="ascii.ecsv"
)
def run_analysis(method, target_dict, debug, skip_flux_points):
"""If the method is "1d", runs joint spectral analysis for the selected target. If
instead it is "3d", runs stacked 3D analysis."""
tag = target_dict["tag"]
log.info(f"Running {method} analysis, {tag}")
path_res = Path(tag + "/results/")
log.info("Reading config")
txt = Path(f"config_{method}.yaml").read_text()
txt = txt.format_map(target_dict)
config = AnalysisConfig.from_yaml(txt)
if debug:
config.observations.obs_ids = [target_dict["debug_run"]]
config.flux_points.energy.nbins = 1
if method == "3d":
config.datasets.geom.axes.energy_true.nbins = 10
analysis = Analysis(config)
log.info("Running observations selection")
analysis.get_observations()
log.info(f"Running data reduction")
analysis.get_datasets()
log.info(f"Setting the model")
txt = Path("model_config.yaml").read_text()
txt = txt.format_map(target_dict)
analysis.set_models(txt)
if method == "3d":
analysis.datasets[
0].background_model.spectral_model.norm.frozen = False
analysis.datasets[
0].background_model.spectral_model.tilt.frozen = False
# Impose min and max values to ensure position does not diverge
delta = 1.5
lon = analysis.models[0].spatial_model.lon_0.value
lat = analysis.models[0].spatial_model.lat_0.value
analysis.models[0].spatial_model.lat_0.min = lat - delta
analysis.models[0].spatial_model.lat_0.max = lat + delta
analysis.models[0].spatial_model.lon_0.min = lon - delta
analysis.models[0].spatial_model.lon_0.max = lon + delta
if target_dict["spatial_model"] == "DiskSpatialModel":
analysis.models[0].spatial_model.e.frozen = False
analysis.models[0].spatial_model.phi.frozen = False
analysis.models[0].spatial_model.r_0.value = 0.3
log.info(f"Running fit ...")
analysis.run_fit(optimize_opts={"print_level": 3})
# TODO: This is a workaround. Set covariance automatically
log.info(f"Writing {path_res}")
write_fit_summary(analysis.models[0].parameters,
str(path_res / f"result-{method}.yaml"))
if not skip_flux_points:
log.info(f"Running flux points estimation")
# Freeze all parameters except the backround norm
if method == "3d":
dataset = analysis.datasets[0]
for parameter in dataset.models.parameters:
if parameter is not dataset.background_model.spectral_model.norm:
parameter.frozen = True
analysis.get_flux_points()
flux_points = analysis.flux_points.data
flux_points.table["is_ul"] = flux_points.table["ts"] < 4
keys = [
"e_ref",
"e_min",
"e_max",
"dnde",
"dnde_errp",
"dnde_errn",
"is_ul",
"dnde_ul",
]
log.info(f"Writing {path_res}")
flux_points.table_formatted[keys].write(path_res /
f"flux-points-{method}.ecsv",
format="ascii.ecsv")
def run_analysis(method, target_dict, debug):
"""If the method is "1d", runs joint spectral analysis for the selected target. If
instead it is "3d", runs stacked 3D analysis."""
tag = target_dict["tag"]
log.info(f"Running {method} analysis, {tag}")
path_res = Path(tag + "/results/")
log.info("Reading config")
txt = Path(f"config_{method}.yaml").read_text()
txt = txt.format_map(target_dict)
config = AnalysisConfig.from_yaml(txt)
if debug:
config.observations.obs_ids = [target_dict["debug_run"]]
config.flux_points.energy.nbins = 1
if method == "3d":
config.datasets.geom.axes.energy_true.nbins = 10
analysis = Analysis(config)
log.info("Running observations selection")
analysis.get_observations()
log.info(f"Running data reduction")
analysis.get_datasets()
# TODO: This is a workaround. We should somehow apply the safe mask (run by run) from the HLI
from gammapy.cube import SafeMaskMaker
datasets = []
maker_safe_mask = SafeMaskMaker(methods=["edisp-bias", "bkg-peak"],
bias_percent=10)
for dataset in analysis.datasets:
dataset = maker_safe_mask.run(dataset)
datasets.append(dataset)
analysis.datasets = datasets
log.info(f"Setting the model")
txt = Path("model_config.yaml").read_text()
txt = txt.format_map(target_dict)
log.info(txt)
analysis.set_models(txt)
if method == "3d" and target_dict["spatial_model"] == "DiskSpatialModel":
analysis.models[0].spatial_model.e.frozen = False
analysis.models[0].spatial_model.phi.frozen = False
analysis.models[0].spatial_model.r_0.value = 0.3
log.info(f"Running fit ...")
analysis.run_fit()
# TODO: This is a workaround. Set covariance automatically
results = analysis.fit_result
names = ["spectral_model", "spatial_model"]
for name in names:
if name == "spatial_model" and method == "1d":
continue
model = getattr(analysis.models[0], name)
model.parameters.covariance = results.parameters.get_subcovariance(
model.parameters.names)
log.info(f"Writing {path_res}")
write_fit_summary(analysis.models[0].parameters,
str(path_res / f"results-summary-fit-{method}.yaml"))
log.info(f"Running flux points estimation")
# TODO: For the 3D analysis, re-optimize the background norm in each energy
# bin. For now, this is not possible from the HLI.
analysis.get_flux_points(source=tag)
flux_points = analysis.flux_points.data
flux_points.table["is_ul"] = flux_points.table["ts"] < 4
keys = [
"e_ref",
"e_min",
"e_max",
"dnde",
"dnde_errp",
"dnde_errn",
"is_ul",
"dnde_ul",
]
log.info(f"Writing {path_res}")
flux_points.table_formatted[keys].write(path_res /
f"flux-points-{method}.ecsv",
format="ascii.ecsv")
def run_analyses(targets):
log.info("Run small source extension check.")
info = {}
targets = list(AVAILABLE_TARGETS) if targets == "all-targets" else [
targets
]
for target in targets:
t = time.time()
config = AnalysisConfig.read(f"configs/config_{target}.yaml")
analysis = Analysis(config)
analysis.get_observations()
info["data_preparation"] = time.time() - t
t = time.time()
analysis.get_datasets()
info["data_reduction"] = time.time() - t
models = Models.read(f"models/model_{target}.yaml")
point_models = Models(define_model_pointlike(models[0]))
analysis.set_models(point_models)
t = time.time()
analysis.run_fit()
info["point_model_fitting"] = time.time() - t
log.info(f"\n{point_models.to_parameters_table()}")
log.info("Fitting extended gaussian source.")
analysis.datasets.models = []
analysis.set_models(models)
t = time.time()
analysis.run_fit()
info["gauss_model_fitting"] = time.time() - t
log.info(analysis.fit_result)
log.info(f"\n{models.to_parameters_table()}")
log.info("Extract size error, UL and stat profile.")
t = time.time()
analysis.models[0].spatial_model.lon_0.frozen = True
analysis.models[0].spatial_model.lat_0.frozen = True
analysis.models[0].spectral_model.index.frozen = True
size_est = ExtensionEstimator(
source=models[0].name,
energy_edges=[0.2, 10.0] * u.TeV,
selection_optional=["errn-errp", "ul", "scan"],
size_min="0.08 deg",
size_max="0.12 deg",
size_n_values=20,
reoptimize=True)
res = size_est.run(analysis.datasets)
info["estimator"] = time.time() - t
t = time.time()
log.info(res)
plot_profile(res[0], target)
Path(f"bench_{target}.yaml").write_text(
yaml.dump(info, sort_keys=False, indent=4))
analysis.models.to_parameters_table().write(
f"results/{target}_results.ecsv", overwrite=True)
