def make_test_psfmap(size, shape="gauss"):
psf = fake_psf3d(size, shape)
aeff2d = fake_aeff2d()
pointing = SkyCoord(0, 0, unit="deg")
energy_axis = MapAxis(nodes=[0.2, 0.7, 1.5, 2.0, 10.0],
unit="TeV",
name="energy")
rad_axis = MapAxis.from_nodes(nodes=np.linspace(0.0, 0.6, 50),
unit="deg",
name="theta")
geom = WcsGeom.create(skydir=pointing,
binsz=0.2,
width=5,
axes=[rad_axis, energy_axis])
exposure_geom = WcsGeom.create(skydir=pointing,
binsz=0.2,
width=5,
axes=[energy_axis])
exposure_map = make_map_exposure_true_energy(pointing, "1 h", aeff2d,
exposure_geom)
return make_psf_map(psf, pointing, geom, 3 * u.deg, exposure_map)
def make_edisp_map_test():
etrue = [0.2, 0.7, 1.5, 2.0, 10.0] * u.TeV
migra = np.linspace(0.0, 3.0, 51)
offsets = np.array((0.0, 1.0, 2.0, 3.0)) * u.deg
pointing = SkyCoord(0, 0, unit="deg")
energy_axis = MapAxis(
nodes=[0.2, 0.7, 1.5, 2.0, 10.0],
unit="TeV",
name="energy",
node_type="edges",
interp="log",
)
migra_axis = MapAxis(nodes=np.linspace(0.0, 3.0, 51),
unit="",
name="migra")
edisp2d = EnergyDispersion2D.from_gauss(etrue, migra, 0.0, 0.2, offsets)
geom = WcsGeom.create(skydir=pointing,
binsz=1.0,
width=5.0,
axes=[migra_axis, energy_axis])
aeff2d = fake_aeff2d()
exposure_geom = geom.squash(axis="migra")
exposure_map = make_map_exposure_true_energy(pointing, "1 h", aeff2d,
exposure_geom)
return make_edisp_map(edisp2d, pointing, geom, exposure_map)
def make_psf_map_obs(geom, obs):
exposure_map = make_map_exposure_true_energy(
geom=geom.squash(axis="theta"),
pointing=obs.pointing_radec,
aeff=obs.aeff,
livetime=obs.observation_live_time_duration)
psf_map = make_psf_map(geom=geom,
psf=obs.psf,
pointing=obs.pointing_radec,
exposure_map=exposure_map)
return psf_map
def get_exposure(geom_etrue):
filename = (
"$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits"
)
aeff = EffectiveAreaTable2D.read(filename, hdu="EFFECTIVE AREA")
exposure_map = make_map_exposure_true_energy(
pointing=SkyCoord(1, 0.5, unit="deg", frame="galactic"),
livetime="1 hour",
aeff=aeff,
geom=geom_etrue,
)
return exposure_map
def main():
# Define some parameters
pointing = SkyCoord(1, 0.5, unit='deg', frame='galactic')
livetime = 1 * u.hour
offset_max = 3 * u.deg
offset = Angle('2 deg')
irfs = get_irfs()
geom = get_geom()
sky_model = get_sky_model()
# Let's get started ...
exposure_map = make_map_exposure_true_energy(
pointing=pointing, livetime=livetime, aeff=irfs['aeff'],
ref_geom=geom, offset_max=offset_max,
)
exposure_map.write('exposure.fits')
evaluator = SkyModelMapEvaluator(sky_model, exposure_map)
# Accessing and saving a lot of the following maps is for debugging.
# Just for a simulation one doesn't need to store all these things.
dnde = evaluator.compute_dnde()
WcsNDMap(geom, dnde).write('dnde.fits')
flux = evaluator.compute_flux()
WcsNDMap(geom, flux).write('flux.fits')
npred = evaluator.compute_npred()
WcsNDMap(geom, npred).write('npred.fits')
# TODO: Apply PSF convolution
psf = irfs['psf'].to_energy_dependent_table_psf(theta=offset)
# kernels = irfs['psf'].kernels(npred_cube_simple)
# npred_cube_convolved = npred_cube_simple.convolve(kernels)
# TODO: optionally apply EDISP
edisp = irfs['edisp'].to_energy_dispersion(offset=offset)
# TODO: add background
# Compute counts as a Poisson fluctuation
counts = np.random.poisson(npred)
WcsNDMap(geom, counts).write('counts.fits')
# In[ ]:
# Define some observation parameters
# We read in the pointing info from one of the 1dc event list files as an example
pointing = FixedPointingInfo.read(
"$GAMMAPY_DATA/cta-1dc/data/baseline/gps/gps_baseline_110380.fits")
livetime = 1 * u.hour
offset_max = 2 * u.deg
offset = Angle("2 deg")
# In[ ]:
exposure = make_map_exposure_true_energy(pointing=pointing.radec,
livetime=livetime,
aeff=irfs["aeff"],
geom=geom)
exposure.slice_by_idx({
"energy": 3
}).plot(add_cbar=True)
# In[ ]:
background = make_map_background_irf(pointing=pointing,
ontime=livetime,
bkg=irfs["bkg"],
geom=geom)
background.slice_by_idx({
"energy": 3
}).plot(add_cbar=True)
def simulate_dataset(
skymodel,
geom,
pointing,
irfs,
livetime=1 * u.h,
offset=0 * u.deg,
max_radius=0.8 * u.deg,
random_state="random-seed",
):
"""Simulate a 3D dataset.
Simulate a source defined with a sky model for a given pointing,
geometry and irfs for a given exposure time.
This will return a dataset object which includes the counts cube,
the exposure cube, the psf cube, the background model and the sky model.
Parameters
----------
skymodel : `~gammapy.modeling.models.SkyModel`
Background model map
geom : `~gammapy.maps.WcsGeom`
Geometry object for the observation
pointing : `~astropy.coordinates.SkyCoord`
Pointing position
irfs : dict
Irfs used for simulating the observation
livetime : `~astropy.units.Quantity`
Livetime exposure of the simulated observation
offset : `~astropy.units.Quantity`
Offset from the center of the pointing position.
This is used for the PSF and Edisp estimation
max_radius : `~astropy.coordinates.Angle`
The maximum radius of the PSF kernel.
random_state: {int, 'random-seed', 'global-rng', `~numpy.random.RandomState`}
Defines random number generator initialisation.
Returns
-------
dataset : `~gammapy.cube.MapDataset`
A dataset of the simulated observation.
"""
background = make_map_background_irf(
pointing=pointing, ontime=livetime, bkg=irfs["bkg"], geom=geom
)
background_model = BackgroundModel(background)
psf = irfs["psf"].to_energy_dependent_table_psf(theta=offset)
psf_kernel = PSFKernel.from_table_psf(psf, geom, max_radius=max_radius)
exposure = make_map_exposure_true_energy(
pointing=pointing, livetime=livetime, aeff=irfs["aeff"], geom=geom
)
if "edisp" in irfs:
energy = geom.axes[0].edges
edisp = irfs["edisp"].to_energy_dispersion(offset, e_reco=energy, e_true=energy)
else:
edisp = None
dataset = MapDataset(
model=skymodel,
exposure=exposure,
background_model=background_model,
psf=psf_kernel,
edisp=edisp,
)
npred_map = dataset.npred()
rng = get_random_state(random_state)
counts = rng.poisson(npred_map.data)
dataset.counts = WcsNDMap(geom, counts)
return dataset
compound_model = sky_model_1 + sky_model_2
# Define map geometry
axis = MapAxis.from_edges(np.logspace(-1.0, 1.0, 10), unit="TeV")
geom = WcsGeom.create(
skydir=(0, 0), binsz=0.02, width=(2, 2), coordsys="GAL", axes=[axis]
)
# Define some observation parameters
# we are not simulating many pointings / observations
pointing = SkyCoord(0.2, 0.5, unit="deg", frame="galactic")
livetime = 20 * u.hour
exposure_map = make_map_exposure_true_energy(
pointing=pointing, livetime=livetime, aeff=aeff, geom=geom
)
evaluator = MapEvaluator(model=compound_model, exposure=exposure_map)
npred = evaluator.compute_npred()
npred_map = WcsNDMap(geom, npred)
fig, ax, cbar = npred_map.sum_over_axes().plot(add_cbar=True)
ax.scatter(
[lon_0_1, lon_0_2, pointing.galactic.l.degree],
[lat_0_1, lat_0_2, pointing.galactic.b.degree],
transform=ax.get_transform("galactic"),
marker="+",
color="cyan",
models = sky_model_1 + sky_model_2
# Define map geometry
axis = MapAxis.from_edges(np.logspace(-1.0, 1.0, 10), unit="TeV")
geom = WcsGeom.create(
skydir=(0, 0), binsz=0.02, width=(2, 2), coordsys="GAL", axes=[axis]
)
# Define some observation parameters
# we are not simulating many pointings / observations
pointing = SkyCoord(0.2, 0.5, unit="deg", frame="galactic")
livetime = 20 * u.hour
exposure_map = make_map_exposure_true_energy(
pointing=pointing, livetime=livetime, aeff=aeff, geom=geom
)
evaluator = MapEvaluator(model=models, exposure=exposure_map)
npred = evaluator.compute_npred()
npred_map = WcsNDMap(geom, npred)
fig, ax, cbar = npred_map.sum_over_axes().plot(add_cbar=True)
ax.scatter(
[lon_0_1, lon_0_2, pointing.galactic.l.degree],
[lat_0_1, lat_0_2, pointing.galactic.b.degree],
transform=ax.get_transform("galactic"),
marker="+",
color="cyan",
