def reference_model_default(self):
"""Reference model default (`SkyModel`) """
return SkyModel(PowerLawSpectralModel(index=2))
def data_prep():
data_store = DataStore.from_dir("$GAMMAPY_DATA/hess-dl3-dr1/")
OBS_ID = 23523
obs_ids = OBS_ID * np.ones(N_OBS)
observations = data_store.get_observations(obs_ids)
target_position = SkyCoord(ra=83.63, dec=22.01, unit="deg", frame="icrs")
on_region_radius = Angle("0.11 deg")
on_region = CircleSkyRegion(center=target_position,
radius=on_region_radius)
exclusion_region = CircleSkyRegion(
center=SkyCoord(183.604, -8.708, unit="deg", frame="galactic"),
radius=0.5 * u.deg,
)
skydir = target_position.galactic
exclusion_mask = Map.create(npix=(150, 150),
binsz=0.05,
skydir=skydir,
proj="TAN",
frame="galactic")
mask = exclusion_mask.geom.region_mask([exclusion_region], inside=False)
exclusion_mask.data = mask
e_reco = MapAxis.from_bounds(0.1, 40, nbin=40, interp="log",
unit="TeV").edges
e_true = MapAxis.from_bounds(0.05, 100, nbin=200, interp="log",
unit="TeV").edges
empty = SpectrumDatasetOnOff.create(
region=on_region,
e_reco=e_reco,
e_true=e_true,
)
dataset_maker = SpectrumDatasetMaker(containment_correction=True,
selection=["counts", "aeff", "edisp"])
bkg_maker = ReflectedRegionsBackgroundMaker(exclusion_mask=exclusion_mask)
safe_mask_masker = SafeMaskMaker(methods=["aeff-max"], aeff_percent=10)
spectral_model = PowerLawSpectralModel(index=2,
amplitude=2e-11 *
u.Unit("cm-2 s-1 TeV-1"),
reference=1 * u.TeV)
spatial_model = PointSpatialModel(lon_0=target_position.ra,
lat_0=target_position.dec,
frame="icrs")
spatial_model.lon_0.frozen = True
spatial_model.lat_0.frozen = True
sky_model = SkyModel(spatial_model=spatial_model,
spectral_model=spectral_model,
name="")
# Data preparation
datasets = []
for idx, observation in enumerate(observations):
dataset = empty.copy(name=f"dataset{idx}")
dataset = dataset_maker.run(dataset=dataset, observation=observation)
dataset_on_off = bkg_maker.run(dataset, observation)
dataset_on_off = safe_mask_masker.run(dataset_on_off, observation)
dataset_on_off.models = sky_model
datasets.append(dataset_on_off)
return Datasets(datasets)
def run_region(self, kr, lon, lat, radius):
# TODO: for now we have to read/create the allsky maps each in each job
# because we can't pickle <functools._lru_cache_wrapper object
# send this back to init when fixed
log.info(f"ROI {kr}: loading data")
# exposure
exposure_hpx = Map.read(
"$GAMMAPY_DATA/fermi_3fhl/fermi_3fhl_exposure_cube_hpx.fits.gz")
exposure_hpx.unit = "cm2 s"
# iem
iem_filepath = BASE_PATH / "data" / "gll_iem_v06_extrapolated.fits"
iem_fermi_extra = Map.read(iem_filepath)
# norm=1.1, tilt=0.03 see paper appendix A
model_iem = SkyModel(
PowerLawNormSpectralModel(norm=1.1, tilt=0.03),
TemplateSpatialModel(iem_fermi_extra, normalize=False),
name="iem_extrapolated",
)
# ROI
roi_time = time()
ROI_pos = SkyCoord(lon, lat, frame="galactic", unit="deg")
width = 2 * (radius + self.psf_margin)
# Counts
counts = Map.create(
skydir=ROI_pos,
width=width,
proj="CAR",
frame="galactic",
binsz=1 / 8.0,
axes=[self.energy_axis],
dtype=float,
)
counts.fill_by_coord({
"skycoord": self.events.radec,
"energy": self.events.energy
})
axis = MapAxis.from_nodes(counts.geom.axes[0].center,
name="energy_true",
unit="GeV",
interp="log")
wcs = counts.geom.wcs
geom = WcsGeom(wcs=wcs, npix=counts.geom.npix, axes=[axis])
coords = geom.get_coord()
# expo
data = exposure_hpx.interp_by_coord(coords)
exposure = WcsNDMap(geom, data, unit=exposure_hpx.unit, dtype=float)
# read PSF
psf_kernel = PSFKernel.from_table_psf(self.psf,
geom,
max_radius=self.psf_margin *
u.deg)
# Energy Dispersion
e_true = exposure.geom.axes[0].edges
e_reco = counts.geom.axes[0].edges
edisp = EDispKernel.from_diagonal_response(e_true=e_true,
e_reco=e_reco)
# fit mask
if coords["lon"].min() < 90 * u.deg and coords["lon"].max(
) > 270 * u.deg:
coords["lon"][coords["lon"].value > 180] -= 360 * u.deg
mask = (
(coords["lon"] >= coords["lon"].min() + self.psf_margin * u.deg)
& (coords["lon"] <= coords["lon"].max() - self.psf_margin * u.deg)
& (coords["lat"] >= coords["lat"].min() + self.psf_margin * u.deg)
& (coords["lat"] <= coords["lat"].max() - self.psf_margin * u.deg))
mask_fermi = WcsNDMap(counts.geom, mask)
log.info(f"ROI {kr}: pre-computing diffuse")
# IEM
eval_iem = MapEvaluator(model=model_iem,
exposure=exposure,
psf=psf_kernel,
edisp=edisp)
bkg_iem = eval_iem.compute_npred()
# ISO
eval_iso = MapEvaluator(model=self.model_iso,
exposure=exposure,
edisp=edisp)
bkg_iso = eval_iso.compute_npred()
# merge iem and iso, only one local normalization is fitted
dataset_name = "3FHL_ROI_num" + str(kr)
background_total = bkg_iem + bkg_iso
background_model = BackgroundModel(background_total,
name="bkg_iem+iso",
datasets_names=[dataset_name])
background_model.parameters["norm"].min = 0.0
# Sources model
in_roi = self.FHL3.positions.galactic.contained_by(wcs)
FHL3_roi = []
for ks in range(len(self.FHL3.table)):
if in_roi[ks] == True:
model = self.FHL3[ks].sky_model()
model.spatial_model.parameters.freeze_all() # freeze spatial
model.spectral_model.parameters["amplitude"].min = 0.0
if isinstance(model.spectral_model, PowerLawSpectralModel):
model.spectral_model.parameters["index"].min = 0.1
model.spectral_model.parameters["index"].max = 10.0
else:
model.spectral_model.parameters["alpha"].min = 0.1
model.spectral_model.parameters["alpha"].max = 10.0
FHL3_roi.append(model)
model_total = Models([background_model] + FHL3_roi)
# Dataset
dataset = MapDataset(
models=model_total,
counts=counts,
exposure=exposure,
psf=psf_kernel,
edisp=edisp,
mask_fit=mask_fermi,
name=dataset_name,
)
cat_stat = dataset.stat_sum()
datasets = Datasets([dataset])
log.info(f"ROI {kr}: running fit")
fit = Fit(datasets)
results = fit.run(**self.optimize_opts)
print("ROI_num", str(kr), "\n", results)
fit_stat = datasets.stat_sum()
if results.message != "Optimization failed.":
datasets.write(path=Path(self.resdir),
prefix=dataset.name,
overwrite=True)
np.savez(
self.resdir / f"3FHL_ROI_num{kr}_fit_infos.npz",
message=results.message,
stat=[cat_stat, fit_stat],
)
exec_time = time() - roi_time
print("ROI", kr, " time (s): ", exec_time)
log.info(f"ROI {kr}: running flux points")
for model in FHL3_roi:
if (self.FHL3[model.name].data["ROI_num"] == kr
and self.FHL3[model.name].data["Signif_Avg"] >=
self.sig_cut):
flux_points = FluxPointsEstimator(
e_edges=self.El_flux,
source=model.name,
n_sigma_ul=2,
).run(datasets=datasets)
filename = self.resdir / f"{model.name}_flux_points.fits"
flux_points.write(filename, overwrite=True)
exec_time = time() - roi_time - exec_time
print("ROI", kr, " Flux points time (s): ", exec_time)
# In[ ]:
model_diffuse = SkyDiffuseCube(diffuse_galactic, name="diffuse")
eval_diffuse = MapEvaluator(model=model_diffuse,
exposure=exposure,
psf=psf_kernel,
edisp=edisp)
background_gal = eval_diffuse.compute_npred()
background_gal.sum_over_axes().plot()
print("Background counts from Galactic diffuse: ", background_gal.data.sum())
# In[ ]:
model_iso = SkyModel(ConstantSpatialModel(), diffuse_iso, name="diffuse-iso")
eval_iso = MapEvaluator(model=model_iso, exposure=exposure, edisp=edisp)
background_iso = eval_iso.compute_npred()
background_iso.sum_over_axes().plot(add_cbar=True)
print("Background counts from isotropic diffuse: ", background_iso.data.sum())
# In[ ]:
background_total = background_iso + background_gal
# ## Excess and flux
#
# Let's compute an excess and flux image, by subtracting the background, and summing over the energy axis.
def make_example_2():
spatial = GaussianSpatialModel(lon_0="0 deg", lat_0="0 deg", sigma="1 deg")
model = SkyModel(PowerLawSpectralModel(), spatial)
models = Models([model])
models.write(DATA_PATH / "example2.yaml")
plt.plot(lons, profile / profile.max(), alpha=0.5)
plt.xlabel("Radius (deg)")
plt.ylabel("Profile (A.U.)")
edge_min, edge_max = r_0 * (1 - edge_width / 2.), r_0 * (1 + edge_width / 2.)
with quantity_support():
plt.vlines([edge_min, edge_max], 0, 1, linestyles=["--"], color="k")
plt.annotate("", xy=(edge_min, 0.5), xytext=(edge_min + r_0 * edge_width, 0.5),
arrowprops=dict(arrowstyle="<->", lw=2))
plt.text(0.2, 0.53, "Edge width", ha="center", size=12)
margin = 0.02 * u.deg
plt.hlines([0.95], edge_min - margin, edge_min + margin, linestyles=["-"], color="k")
plt.text(edge_min + margin, 0.95, "95%", size=12, va="center")
plt.hlines([0.05], edge_max - margin, edge_max + margin, linestyles=["-"], color="k")
plt.text(edge_max - margin, 0.05, "5%", size=12, va="center", ha="right")
plt.show()
# %%
# YAML representation
# -------------------
# Here is an example YAML file using the model:
pwl = PowerLawSpectralModel()
gauss = DiskSpatialModel()
model = SkyModel(spectral_model=pwl, spatial_model=gauss, name="pwl-disk-model")
models = Models([model])
print(models.to_yaml())
def test_sky_model_create():
m = SkyModel.create("pl", "point", name="my-source")
assert isinstance(m.spatial_model, PointSpatialModel)
assert isinstance(m.spectral_model, PowerLawSpectralModel)
assert m.name == "my-source"
.. _LightCurve-temporal-model:
LightCurve Temporal Model
=========================
This model parametrises a lightCurve time model.
"""
from gammapy.modeling.models import LightCurveTemplateTemporalModel, SkyModel, Models
from astropy.time import Time
time_range = [Time("59100", format="mjd"), Time("59365", format="mjd")]
path = "$GAMMAPY_DATA/tests/models/light_curve/lightcrv_PKSB1222+216.fits"
light_curve_model = LightCurveTemplateTemporalModel.read(path)
light_curve_model.plot(time_range)
# %%
# YAML representation
# -------------------
# Here is an example YAML file using the model:
from gammapy.modeling.models import PowerLawSpectralModel
model = SkyModel(spectral_model=PowerLawSpectralModel(),
temporal_model=light_curve_model,
name="light_curve_model")
models = Models([model])
print(models.to_yaml())
# %%
# Example plot
# ------------
# Here is an example plot of the model:
from astropy import units as u
import matplotlib.pyplot as plt
from gammapy.modeling.models import Models, SkyModel, SmoothBrokenPowerLawSpectralModel
energy_range = [0.1, 100] * u.TeV
model = SmoothBrokenPowerLawSpectralModel(
index1=1.5,
index2=2.5,
amplitude="1e-12 TeV-1 cm-2 s-1",
ebreak="1 TeV",
reference="1 TeV",
beta=1,
)
model.plot(energy_range)
plt.grid(which="both")
# %%
# YAML representation
# -------------------
# Here is an example YAML file using the model:
model = SkyModel(spectral_model=model, name="smooth-broken-power-law-model")
models = Models([model])
print(models.to_yaml())
\phi(E) = \frac{N_0}{\sigma \sqrt{2\pi}} \exp{ \frac{- \left( E-\bar{E} \right)^2 }{2 \sigma^2} }
"""
# %%
# Example plot
# ------------
# Here is an example plot of the model:
from astropy import units as u
import matplotlib.pyplot as plt
from gammapy.modeling.models import GaussianSpectralModel, Models, SkyModel
energy_range = [0.1, 100] * u.TeV
model = GaussianSpectralModel(norm="1e-2 cm-2 s-1",
mean=2 * u.TeV,
sigma=0.2 * u.TeV)
model.plot(energy_range)
plt.grid(which="both")
plt.ylim(1e-24, 1e-1)
# %%
# YAML representation
# -------------------
# Here is an example YAML file using the model:
model = SkyModel(spectral_model=model, name="gaussian-model")
models = Models([model])
print(models.to_yaml())
# Define the source model - Use a pointsource + integrated power law model to directly get flux
spatial_model = PointSpatialModel(lon_0=target_position.ra,
lat_0=target_position.dec,
frame="icrs")
spectral_model = PowerLawSpectralModel(
index=2.6,
amplitude=2.0e-11 * u.Unit("1 / (cm2 s TeV)"),
reference=1 * u.TeV,
)
spectral_model.parameters["index"].frozen = False
sky_model = SkyModel(spatial_model=spatial_model,
spectral_model=spectral_model,
name="")
sky_model.parameters["lon_0"].frozen = True
sky_model.parameters["lat_0"].frozen = True
# ### Make the map datasets
#
# The following function is in charge of the MapDataset production. It will later be fully covered in the data reduction chain
# In[ ]:
# psf_kernel and MapMaker for each segment
def make_map_dataset(observations,
target_pos,
geom,
from astropy import units as u
from astropy.time import Time
import matplotlib.pyplot as plt
from gammapy.modeling.models import (
Models,
PowerLawSpectralModel,
PowerLawTemporalModel,
SkyModel,
)
time_range = [Time.now(), Time.now() + 2 * u.d]
pl_model = PowerLawTemporalModel(alpha=-2.0,
t_ref=(time_range[0].mjd - 0.1) * u.d)
pl_model.plot(time_range)
plt.grid(which="both")
plt.yscale("log")
# %%
# YAML representation
# -------------------
# Here is an example YAML file using the model:
model = SkyModel(
spectral_model=PowerLawSpectralModel(),
temporal_model=pl_model,
name="powerlaw-model",
)
models = Models([model])
print(models.to_yaml())
lon_0=lon_0_1 * u.deg, lat_0=lat_0_1 * u.deg, sigma="0.3 deg", frame="galactic"
)
spatial_model_2 = GaussianSpatialModel(
lon_0=lon_0_2 * u.deg, lat_0=lat_0_2 * u.deg, sigma="0.2 deg", frame="galactic"
)
spectral_model_1 = PowerLawSpectralModel(
index=3, amplitude="1e-11 cm-2 s-1 TeV-1", reference="1 TeV"
)
spectral_model_2 = PowerLawSpectralModel(
index=3, amplitude="1e-11 cm-2 s-1 TeV-1", reference="1 TeV"
)
sky_model_1 = SkyModel(
spatial_model=spatial_model_1, spectral_model=spectral_model_1, name="source-1"
)
sky_model_2 = SkyModel(
spatial_model=spatial_model_2, spectral_model=spectral_model_2, name="source-2"
)
models = sky_model_1 + sky_model_2
# Define map geometry
axis = MapAxis.from_edges(np.logspace(-1.0, 1.0, 10), unit="TeV", name="energy")
geom = WcsGeom.create(
skydir=(0, 0), binsz=0.02, width=(2, 2), coordsys="GAL", axes=[axis]
)
def from_maps(cls,
maps,
sed_type=None,
reference_model=None,
gti=None,
meta=None):
"""Create FluxMaps from a dictionary of maps.
Parameters
----------
maps : `Maps`
Maps object containing the input maps.
sed_type : str
SED type of the input maps. Default is `Likelihood`
reference_model : `~gammapy.modeling.models.SkyModel`, optional
Reference model to use for conversions. Default in None.
If None, a model consisting of a point source with a power
law spectrum of index 2 is assumed.
gti : `~gammapy.data.GTI`
Maps GTI information. Default is None.
meta : `dict`
Meta dict.
Returns
-------
flux_maps : `~gammapy.estimators.FluxMaps`
Flux maps object.
"""
if sed_type is None:
sed_type = cls._guess_sed_type(maps.keys())
if sed_type is None:
raise ValueError("Specifying the sed type is required")
cls._validate_data(data=maps, sed_type=sed_type)
if sed_type == "likelihood":
return cls(data=maps,
reference_model=reference_model,
gti=gti,
meta=meta)
if reference_model is None:
log.warning(
"No reference model set for FluxMaps. Assuming point source with E^-2 spectrum."
)
reference_model = cls.reference_model_default
elif isinstance(reference_model, SpectralModel):
reference_model = SkyModel(reference_model)
map_ref = maps[sed_type]
energy_axis = map_ref.geom.axes["energy"]
with np.errstate(invalid="ignore", divide="ignore"):
fluxes = reference_model.spectral_model.reference_fluxes(
energy_axis=energy_axis)
# TODO: handle reshaping in MapAxis
factor = fluxes[f"ref_{sed_type}"].to(map_ref.unit)[cls._expand_slice]
data = dict()
data["norm"] = map_ref / factor
for key in OPTIONAL_QUANTITIES[sed_type]:
if key in maps:
norm_type = key.replace(sed_type, "norm")
data[norm_type] = maps[key] / factor
# We add the remaining maps
for key in OPTIONAL_QUANTITIES_COMMON:
if key in maps:
data[key] = maps[key]
return cls(data=data,
reference_model=reference_model,
gti=gti,
meta=meta)
# ------------
# Here is an example plot of the model:
from astropy import units as u
import matplotlib.pyplot as plt
from gammapy.modeling.models import (
Models,
PiecewiseNormSpectralModel,
PowerLawSpectralModel,
SkyModel,
)
energy_range = [0.1, 100] * u.TeV
model = PiecewiseNormSpectralModel(
energy=[0.1, 1, 3, 10, 30, 100] * u.TeV,
norms=[1, 3, 8, 10, 8, 2],
)
model.plot(energy_range, flux_unit="")
plt.grid(which="both")
# %%
# YAML representation
# -------------------
# Here is an example YAML file using the model:
model = model * PowerLawSpectralModel()
model = SkyModel(spectral_model=model, name="piecewise-norm-model")
models = Models([model])
print(models.to_yaml())
def data_prep():
data_store = DataStore.from_dir("$GAMMAPY_DATA/hess-dl3-dr1/")
OBS_ID = 23523
obs_ids = OBS_ID * np.ones(N_OBS)
observations = data_store.get_observations(obs_ids)
time_intervals = [(obs.tstart, obs.tstop) for obs in observations]
target_position = SkyCoord(ra=83.63308, dec=22.01450, unit="deg")
emin, emax = [0.7, 10] * u.TeV
energy_axis = MapAxis.from_bounds(emin.value,
emax.value,
10,
unit="TeV",
name="energy",
interp="log")
geom = WcsGeom.create(
skydir=target_position,
binsz=0.02,
width=(2, 2),
coordsys="CEL",
proj="CAR",
axes=[energy_axis],
)
energy_axis_true = MapAxis.from_bounds(0.1,
20,
20,
unit="TeV",
name="energy",
interp="log")
offset_max = 2 * u.deg
datasets = []
maker = MapDatasetMaker(offset_max=offset_max)
safe_mask_maker = SafeMaskMaker(methods=["offset-max"],
offset_max=offset_max)
for time_interval in time_intervals:
observations = observations.select_time(time_interval)
# Proceed with further analysis only if there are observations
# in the selected time window
if len(observations) == 0:
log.warning(f"No observations in time interval: {time_interval}")
continue
stacked = MapDataset.create(geom=geom,
energy_axis_true=energy_axis_true)
for obs in observations:
dataset = maker.run(stacked, obs)
dataset = safe_mask_maker.run(dataset, obs)
stacked.stack(dataset)
stacked.edisp = stacked.edisp.get_energy_dispersion(
position=target_position, e_reco=energy_axis.edges)
stacked.psf = stacked.psf.get_psf_kernel(position=target_position,
geom=stacked.exposure.geom,
max_radius="0.3 deg")
datasets.append(stacked)
spatial_model = PointSpatialModel(lon_0=target_position.ra,
lat_0=target_position.dec,
frame="icrs")
spatial_model.lon_0.frozen = True
spatial_model.lat_0.frozen = True
spectral_model = PowerLawSpectralModel(index=2.6,
amplitude=2.0e-11 *
u.Unit("1 / (cm2 s TeV)"),
reference=1 * u.TeV)
spectral_model.index.frozen = False
sky_model = SkyModel(spatial_model=spatial_model,
spectral_model=spectral_model,
name="")
for dataset in datasets:
model = sky_model.copy(name="crab")
dataset.model = model
return datasets
"""
# %%
# Example plot
# ------------
# Here is an example plot of the model:
from astropy import units as u
import matplotlib.pyplot as plt
from gammapy.modeling.models import ExpCutoffPowerLawSpectralModel, Models, SkyModel
energy_range = [0.1, 100] * u.TeV
model = ExpCutoffPowerLawSpectralModel(
amplitude=1e-12 * u.Unit("cm-2 s-1 TeV-1"),
index=2,
lambda_=0.1 * u.Unit("TeV-1"),
reference=1 * u.TeV,
)
model.plot(energy_range)
plt.grid(which="both")
# %%
# YAML representation
# -------------------
# Here is an example YAML file using the model:
model = SkyModel(spectral_model=model, name="exp-cutoff-power-law-model")
models = Models([model])
print(models.to_yaml())
mDM = 40000 * u.Unit("GeV")
channel = "b"
xsection = 1e-26 * u.Unit("cm3 s-1")
redshift = 0
RATIO = 2.71
# **Define 3D Sky Model**
DarkMatterAnnihilationSpectralModel.THERMAL_RELIC_CROSS_SECTION = xsection
flux_model = DarkMatterAnnihilationSpectralModel(mass=mDM,
channel=channel,
jfactor=JFAC)
spatial_model = TemplateSpatialModel.read(jfactor_filename)
sky_model = SkyModel(spatial_model=spatial_model,
spectral_model=flux_model,
name="model-simu")
bkg_model = FoVBackgroundModel(dataset_name="dataset-simu")
models = Models([sky_model, bkg_model])
# ## Declare observation values
pointing = src_pos
livetime = 100 * u.hour
offset = 2.0 * u.deg
#offset = 0.5 * u.deg
# Create an in-memory observation
obs = Observation.create(pointing=pointing, livetime=livetime, irfs=irfs)
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 (
ExpDecayTemporalModel,
Models,
PowerLawSpectralModel,
SkyModel,
)
t0 = "5 h"
t_ref = Time("2020-10-01")
time_range = [t_ref, t_ref + 1 * u.d]
expdecay_model = ExpDecayTemporalModel(t_ref=t_ref.mjd * u.d, t0=t0)
expdecay_model.plot(time_range)
plt.grid(which="both")
model = SkyModel(
spectral_model=PowerLawSpectralModel(),
temporal_model=expdecay_model,
name="expdecay_model",
)
models = Models([model])
print(models.to_yaml())
def make_prof(self, sp_datasets):
""" Utility to make the profile in each region
Parameters
----------
sp_datasets : `~gammapy.datasets.MapDatasets` of `~gammapy.datasets.SpectrumDataset` or \
`~gammapy.datasets.SpectrumDatasetOnOff`
the dataset to use for profile extraction
Returns
--------
results : list of dictionary
the list of results (list of keys: x_min, x_ref, x_max, alpha, counts, background, excess, ts, sqrt_ts, \
err, errn, errp, ul, exposure, solid_angle)
"""
results = []
distance = self._get_projected_distance()
for index, spds in enumerate(sp_datasets):
old_model = None
if spds.models is not None:
old_model = spds.models
spds.models = SkyModel(spectral_model=self.spectrum)
e_reco = spds.counts.geom.axes["energy"].edges
# ToDo: When the function to_spectrum_dataset will manage the masks, use the following line
# mask = spds.mask if spds.mask is not None else slice(None)
mask = slice(None)
if isinstance(spds, SpectrumDatasetOnOff):
stats = WStatCountsStatistic(
spds.counts.data[mask][:, 0, 0],
spds.counts_off.data[mask][:, 0, 0],
spds.alpha.data[mask][:, 0, 0],
)
else:
stats = CashCountsStatistic(
spds.counts.data[mask][:, 0, 0],
spds.background_model.evaluate().data[mask][:, 0, 0],
)
result = {
"x_min": distance.edges[index],
"x_max": distance.edges[index + 1],
"x_ref": distance.center[index],
"energy_edge": e_reco,
}
if isinstance(spds, SpectrumDatasetOnOff):
result["alpha"] = stats.alpha
result.update(
{
"counts": stats.n_on,
"background": stats.background,
"excess": stats.excess,
}
)
result["ts"] = stats.delta_ts
result["sqrt_ts"] = stats.significance
result["err"] = stats.error * self.n_sigma
if "errn-errp" in self.selection_optional:
result["errn"] = stats.compute_errn(self.n_sigma)
result["errp"] = stats.compute_errp(self.n_sigma)
if "ul" in self.selection_optional:
result["ul"] = stats.compute_upper_limit(self.n_sigma_ul)
npred = spds.npred().data[mask][:, 0, 0]
e_reco_lo = e_reco[:-1]
e_reco_hi = e_reco[1:]
flux = (
stats.excess
/ npred
* spds.models[0].spectral_model.integral(e_reco_lo, e_reco_hi).value
)
result["flux"] = flux
result["flux_err"] = stats.error / stats.excess * flux
if "errn-errp" in self.selection_optional:
result["flux_errn"] = np.abs(result["errn"]) / stats.excess * flux
result["flux_errp"] = result["errp"] / stats.excess * flux
if "ul" in self.selection_optional:
result["flux_ul"] = result["ul"] / stats.excess * flux
solid_angle = spds.counts.geom.solid_angle()
result["solid_angle"] = (
np.full(result["counts"].shape, solid_angle.to_value("sr")) * u.sr
)
results.append(result)
if old_model is not None:
spds.models = old_model
return results
# ------------
# 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())
from astropy import units as u
import matplotlib.pyplot as plt
from gammapy.modeling.models import (
Models,
SkyModel,
SuperExpCutoffPowerLaw4FGLSpectralModel,
)
energy_range = [0.1, 100] * u.TeV
model = SuperExpCutoffPowerLaw4FGLSpectralModel(
index_1=1,
index_2=2,
amplitude="1e-12 TeV-1 cm-2 s-1",
reference="1 TeV",
expfactor=1e-2,
)
model.plot(energy_range)
plt.grid(which="both")
plt.ylim(1e-24, 1e-10)
# %%
# YAML representation
# -------------------
# Here is an example YAML file using the model:
model = SkyModel(spectral_model=model,
name="super-exp-cutoff-power-law-4fgl-model")
models = Models([model])
print(models.to_yaml())
def test_plot_fit(self):
dataset = self.dataset.copy()
dataset.models = SkyModel(spectral_model=PowerLawSpectralModel())
with mpl_plot_check():
dataset.plot_fit()
def reference_model():
return SkyModel(spatial_model=PointSpatialModel(),
spectral_model=PowerLawSpectralModel(index=2))
def make_datasets_example():
# Define which data to use and print some information
energy_axis = MapAxis.from_edges(
np.logspace(-1.0, 1.0, 4), unit="TeV", name="energy", interp="log"
)
geom0 = WcsGeom.create(
skydir=(0, 0),
binsz=0.1,
width=(1, 1),
frame="galactic",
proj="CAR",
axes=[energy_axis],
)
geom1 = WcsGeom.create(
skydir=(1, 0),
binsz=0.1,
width=(1, 1),
frame="galactic",
proj="CAR",
axes=[energy_axis],
)
geoms = [geom0, geom1]
sources_coords = [(0, 0), (0.9, 0.1)]
names = ["gc", "g09"]
models = []
for idx, (lon, lat) in enumerate(sources_coords):
spatial_model = PointSpatialModel(
lon_0=lon * u.deg, lat_0=lat * u.deg, frame="galactic"
)
spectral_model = ExpCutoffPowerLawSpectralModel(
index=2 * u.Unit(""),
amplitude=3e-12 * u.Unit("cm-2 s-1 TeV-1"),
reference=1.0 * u.TeV,
lambda_=0.1 / u.TeV,
)
model_ecpl = SkyModel(
spatial_model=spatial_model, spectral_model=spectral_model, name=names[idx]
)
models.append(model_ecpl)
# test to link a spectral parameter
params0 = models[0].spectral_model.parameters
params1 = models[1].spectral_model.parameters
params0.link("reference", params1["reference"])
# update the sky model
models[0].parameters.link("reference", params1["reference"])
obs_ids = [110380, 111140, 111159]
data_store = DataStore.from_dir("$GAMMAPY_DATA/cta-1dc/index/gps/")
diffuse_model = SkyDiffuseCube.read(
"$GAMMAPY_DATA/fermi_3fhl/gll_iem_v06_cutout.fits"
)
datasets_list = []
for idx, geom in enumerate(geoms):
observations = data_store.get_observations(obs_ids)
stacked = MapDataset.create(geom=geom)
stacked.background_model.name = "background_irf_" + names[idx]
maker = MapDatasetMaker(offset_max=4.0 * u.deg)
for obs in observations:
dataset = maker.run(stacked, obs)
stacked.stack(dataset)
stacked.psf = stacked.psf.get_psf_kernel(
position=geom.center_skydir, geom=geom, max_radius="0.3 deg"
)
stacked.name = names[idx]
stacked.models = models[idx] + diffuse_model
datasets_list.append(stacked)
datasets = Datasets(datasets_list)
dataset0 = datasets[0]
print("dataset0")
print("counts sum : ", dataset0.counts.data.sum())
print("expo sum : ", dataset0.exposure.data.sum())
print("bkg0 sum : ", dataset0.background_model.evaluate().data.sum())
datasets.write("$GAMMAPY_DATA/tests/models", prefix="gc_example_", overwrite=True)
def logpar_reference_model():
logpar = LogParabolaSpectralModel(amplitude="2e-12 cm-2s-1TeV-1",
alpha=1.5,
beta=0.5)
return SkyModel(spatial_model=PointSpatialModel(), spectral_model=logpar)
def test_fov_bkg_maker_with_source_model(obs_dataset, exclusion_mask, caplog):
test_dataset = obs_dataset.copy(name="test-fov")
# crab model
spatial_model = PointSpatialModel(lon_0="83.619deg",
lat_0="22.024deg",
frame="icrs")
spectral_model = PowerLawSpectralModel(
index=2.6, amplitude="4.5906e-11 cm-2 s-1 TeV-1", reference="1 TeV")
model = SkyModel(spatial_model=spatial_model,
spectral_model=spectral_model,
name="test-source")
bkg_model = FoVBackgroundModel(dataset_name="test-fov")
test_dataset.models = [model, bkg_model]
# pre-fit both source and background to get reference model
Fit().run(test_dataset)
bkg_model_spec = test_dataset.models[
f"{test_dataset.name}-bkg"].spectral_model
norm_ref = 0.897
assert not bkg_model_spec.norm.frozen
assert_allclose(bkg_model_spec.norm.value, norm_ref, rtol=1e-4)
assert_allclose(bkg_model_spec.tilt.value, 0.0, rtol=1e-4)
# apply scale method with pre-fitted source model and no exclusion_mask
bkg_model_spec.norm.value = 1
fov_bkg_maker = FoVBackgroundMaker(method="scale", exclusion_mask=None)
dataset = fov_bkg_maker.run(test_dataset)
bkg_model_spec = test_dataset.models[f"{dataset.name}-bkg"].spectral_model
assert_allclose(bkg_model_spec.norm.value, norm_ref, rtol=1e-4)
assert_allclose(bkg_model_spec.tilt.value, 0.0, rtol=1e-4)
# apply fit method with pre-fitted source model and no exlusion mask
bkg_model_spec.norm.value = 1
fov_bkg_maker = FoVBackgroundMaker(method="fit", exclusion_mask=None)
dataset = fov_bkg_maker.run(test_dataset)
bkg_model_spec = test_dataset.models[f"{dataset.name}-bkg"].spectral_model
assert_allclose(bkg_model_spec.norm.value, norm_ref, rtol=1e-4)
assert_allclose(bkg_model_spec.tilt.value, 0.0, rtol=1e-4)
# apply scale method with pre-fitted source model and exclusion_mask
bkg_model_spec.norm.value = 1
fov_bkg_maker = FoVBackgroundMaker(method="scale",
exclusion_mask=exclusion_mask)
dataset = fov_bkg_maker.run(test_dataset)
bkg_model_spec = test_dataset.models[f"{dataset.name}-bkg"].spectral_model
assert_allclose(bkg_model_spec.norm.value, 0.830779, rtol=1e-4)
assert_allclose(bkg_model_spec.tilt.value, 0.0, rtol=1e-4)
# apply fit method with pre-fitted source model and exlusion mask
bkg_model_spec.norm.value = 1
fov_bkg_maker = FoVBackgroundMaker(method="fit",
exclusion_mask=exclusion_mask)
dataset = fov_bkg_maker.run(test_dataset)
bkg_model_spec = test_dataset.models[f"{dataset.name}-bkg"].spectral_model
assert_allclose(bkg_model_spec.norm.value, 0.830779, rtol=1e-4)
assert_allclose(bkg_model_spec.tilt.value, 0.0, rtol=1e-4)
# Here we check that source parameters are correctly thawed after fit.
assert not dataset.models.parameters["index"].frozen
assert not dataset.models.parameters["lon_0"].frozen
# test
model.spectral_model.amplitude.value *= 1e5
fov_bkg_maker = FoVBackgroundMaker(method="scale")
dataset = fov_bkg_maker.run(test_dataset)
assert "WARNING" in [_.levelname for _ in caplog.records]
message1 = "FoVBackgroundMaker failed. Negative residuals counts for test-fov. Setting mask to False."
assert message1 in [_.message for _ in caplog.records]
# Spectral model corresponding to PKS 2155-304 (quiescent state)
index = 3.53
amplitude = 1.81 * 1e-12 * u.Unit("cm-2 s-1 TeV-1")
reference = 1 * u.TeV
pwl = PowerLawSpectralModel(index=index,
amplitude=amplitude,
reference=reference)
# The power-law model is multiplied by the EBL norm spectral model
redshift = 0.117
absorption = EBLAbsorptionNormSpectralModel.read_builtin("dominguez",
redshift=redshift)
model = pwl * absorption
energy_bounds = [0.1, 100] * u.TeV
plt.figure()
model.plot(energy_bounds)
plt.grid(which="both")
plt.ylim(1e-24, 1e-8)
# %%
# YAML representation
# -------------------
# Here is an example YAML file using the model:
model = SkyModel(spectral_model=model, name="absorbed-model")
models = Models([model])
print(models.to_yaml())
def sky_model(self):
"""Source sky model (`~gammapy.modeling.models.SkyModel`)."""
spatial_model = self.spatial_model
spectral_model = self.spectral_model
return SkyModel(spatial_model, spectral_model, name=self.name)
=======================
This model takes a constant value along the spectral range.
.. math:: \phi(E) = k
"""
# %%
# Example plot
# ------------
# Here is an example plot of the model:
from astropy import units as u
import matplotlib.pyplot as plt
from gammapy.modeling.models import ConstantSpectralModel, Models, SkyModel
energy_range = [0.1, 100] * u.TeV
model = ConstantSpectralModel(const="1 / (cm2 s TeV)")
model.plot(energy_range)
plt.grid(which="both")
# %%
# YAML representation
# -------------------
# Here is an example YAML file using the model:
model = SkyModel(spectral_model=model, name="constant-model")
models = Models([model])
print(models.to_yaml())
