def setup(self):
ra = [0., 0., 0., 10.]*u.deg
dec = [0.,0.9, 10., 10.]*u.deg
energy = [1.,1.5, 1.5, 10.]*u.TeV
evt_table = Table([ra,dec,energy], names=['RA','DEC','ENERGY'])
self.evt_list = EventListBase(evt_table)
center = SkyCoord(0.,0., frame='icrs', unit='deg')
self.on_region = CircleSkyRegion(center,radius=1.0*u.deg)
def _spectrum_extraction(self):
"""Run all steps for the spectrum extraction."""
region = self.settings["datasets"]["geom"]["region"]
log.info("Reducing spectrum datasets.")
on_lon = Angle(region["center"][0])
on_lat = Angle(region["center"][1])
on_center = SkyCoord(on_lon, on_lat, frame=region["frame"])
on_region = CircleSkyRegion(on_center, Angle(region["radius"]))
maker_config = {}
if "containment_correction" in self.settings["datasets"]:
maker_config["containment_correction"] = self.settings["datasets"][
"containment_correction"
]
params = self.settings["datasets"]["geom"]["axes"][0]
e_reco = MapAxis.from_bounds(**params).edges
maker_config["e_reco"] = e_reco
# TODO: remove hard-coded e_true and make it configurable
maker_config["e_true"] = np.logspace(-2, 2.5, 109) * u.TeV
maker_config["region"] = on_region
dataset_maker = SpectrumDatasetMaker(**maker_config)
bkg_maker_config = {}
background = self.settings["datasets"]["background"]
if "exclusion_mask" in background:
map_hdu = {}
filename = background["exclusion_mask"]["filename"]
if "hdu" in background["exclusion_mask"]:
map_hdu = {"hdu": background["exclusion_mask"]["hdu"]}
exclusion_region = Map.read(filename, **map_hdu)
bkg_maker_config["exclusion_mask"] = exclusion_region
if background["background_estimator"] == "reflected":
reflected_bkg_maker = ReflectedRegionsBackgroundMaker(**bkg_maker_config)
else:
# TODO: raise error?
log.info("Background estimation only for reflected regions method.")
safe_mask_maker = SafeMaskMaker(methods=["aeff-default", "aeff-max"])
datasets = []
for obs in self.observations:
selection = ["counts", "aeff", "edisp"]
dataset = dataset_maker.run(obs, selection=selection)
dataset = reflected_bkg_maker.run(dataset, obs)
dataset = safe_mask_maker.run(dataset, obs)
datasets.append(dataset)
self.datasets = Datasets(datasets)
if self.settings["datasets"]["stack-datasets"]:
stacked = self.datasets.stack_reduce()
stacked.name = "stacked"
self.datasets = Datasets([stacked])
def simulate():
irfs = load_cta_irfs(
"$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits"
)
# Reconstructed and true energy axis
center = SkyCoord(0.0, 0.0, unit="deg", frame="galactic")
energy_axis = MapAxis.from_edges(
np.logspace(-0.5, 1.0, 10), unit="TeV", name="energy", interp="log",
)
energy_axis_true = MapAxis.from_edges(
np.logspace(-1.2, 2.0, 31), unit="TeV", name="energy_true", interp="log",
)
on_region_radius = Angle("0.11 deg")
on_region = CircleSkyRegion(center=center, radius=on_region_radius)
pointing = SkyCoord(0.5, 0.5, unit="deg", frame="galactic")
spectral_model = PowerLawSpectralModel(
index=3, amplitude="1e-11 cm-2 s-1 TeV-1", reference="1 TeV"
)
temporal_model = ExpDecayTemporalModel(t0="6 h", t_ref=gti_t0.mjd * u.d)
model_simu = SkyModel(
spectral_model=spectral_model, temporal_model=temporal_model, name="model-simu",
)
lvtm = np.ones(N_OBS) * 1.0 * u.hr
tstart = 1.0 * u.hr
datasets = []
for i in range(N_OBS):
obs = Observation.create(
pointing=pointing,
livetime=lvtm[i],
tstart=tstart,
irfs=irfs,
reference_time=gti_t0,
)
empty = SpectrumDataset.create(
e_reco=energy_axis,
e_true=energy_axis_true,
region=on_region,
name=f"dataset_{i}",
)
maker = SpectrumDatasetMaker(selection=["aeff", "background", "edisp"])
dataset = maker.run(empty, obs)
dataset.models = model_simu
dataset.fake()
datasets.append(dataset)
tstart = tstart + 2.0 * u.hr
return datasets
def estimate_reflected(self, EXCLUSION_FILE, size):
#just extracts the reflected background
on_size=0.11 * u.deg #0.11 for point source cuts...
allsky_mask = SkyImage.read(EXCLUSION_FILE)
exclusion_mask = allsky_mask.cutout(position=self.obspos,size=size)
on_region=CircleSkyRegion(self.obspos,on_size)
background_estimator = ReflectedRegionsBackgroundEstimator(obs_list=self.obslist, on_region=on_region, exclusion_mask = exclusion_mask)
background_estimator.run()
return background_estimator.result[0]
def write_region(cls, coords, filename, **kwargs):
try:
iter(coords)
except TypeError as te:
raise Exception('Coords must be iterable')
circles = []
for coord in coords:
center = utils.get_skycoord(coord)
rad = utils.get_angle(coord['rad'])
circles.append(CircleSkyRegion(center=center, radius=rad, visual=kwargs))
write_ds9(circles, filename)
def test_xmatch_query_with_cone_area(self, xmatch):
try:
table = xmatch.query(cat1='vizier:II/311/wise',
cat2='vizier:II/246/out',
max_distance=5 * arcsec,
area=CircleSkyRegion(center=SkyCoord(
10, 10, unit='deg', frame='icrs'),
radius=12 * arcmin))
except ReadTimeout:
pytest.xfail("xmatch query timed out.")
assert len(table) == 185
def test_field_l_param(self, field_l):
center = coordinates.SkyCoord(ra=10.8, dec=32.2, unit="deg")
radius = coordinates.Angle(1.5, unit="deg")
cone_region = CircleSkyRegion(center, radius)
table = cds.query_region(region=cone_region,
fields=field_l,
get_query_payload=False)
assert isinstance(table, Table)
assert set(table.colnames).issubset(set(field_l))
def test_region(self):
pos = SkyCoord(81, 21, unit='deg', frame='icrs')
radius = Angle(1, 'deg')
circ = CircleSkyRegion(pos, radius)
idx = circ.contains(self.events.radec)
table = self.events.table[idx]
assert_allclose(table[4]['RA'], 81, rtol=1)
assert_allclose(table[2]['DEC'], 21, rtol=1)
assert len(table) == 5
def test_integrate_geom():
center = SkyCoord("0d", "0d", frame="icrs")
model = GaussianSpatialModel(lon="0d", lat="0d", sigma=0.1 * u.deg, frame="icrs")
radius_large = 1 * u.deg
circle_large = CircleSkyRegion(center, radius_large)
radius_small = 0.1 * u.deg
circle_small = CircleSkyRegion(center, radius_small)
geom_large, geom_small = (
RegionGeom(region=circle_large, binsz_wcs="0.01deg"),
RegionGeom(region=circle_small, binsz_wcs="0.01deg"),
)
integral_large, integral_small = (
model.integrate_geom(geom_large).data,
model.integrate_geom(geom_small).data,
)
assert_allclose(integral_large[0], 1, rtol=0.01)
assert_allclose(integral_small[0], 0.3953, rtol=0.01)
def test_cone_search_spatial_request(RA, DEC, RADIUS):
center = coordinates.SkyCoord(ra=RA, dec=DEC, unit="deg")
radius = coordinates.Angle(RADIUS, unit="deg")
cone_region = CircleSkyRegion(center=center, radius=radius)
request_payload = cds.query_region(region=cone_region,
get_query_payload=True,
intersect='overlaps')
assert (request_payload['DEC'] == str(DEC)) and \
(request_payload['RA'] == str(RA)) and \
(request_payload['SR'] == str(RADIUS))
def test_intersect_param(intersect):
center = coordinates.SkyCoord(ra=10.8, dec=32.2, unit="deg")
radius = coordinates.Angle(1.5, unit="deg")
cone_region = CircleSkyRegion(center, radius)
request_payload = cds.query_region(region=cone_region,
intersect=intersect,
get_query_payload=True)
if intersect == 'encloses':
assert request_payload['intersect'] == 'enclosed'
else:
assert request_payload['intersect'] == intersect
def _gaia_galex_xmatch(cats, ra, dec, radius):
galex = cats['II/312/ais']
coord = SkyCoord(ra=ra * u.deg, dec=dec * u.deg, frame='icrs')
region = CircleSkyRegion(coord, radius=radius)
xm = XMatch.query(cat1='vizier:I/345/gaia2',
cat2=galex,
colRA2='RAJ2000',
colDec2='DEJ2000',
area=region,
max_distance=radius)
xm.sort('angDist')
return xm
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.63308, dec=22.01450, unit="deg")
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
on_region_radius = Angle("0.11 deg")
on_region = CircleSkyRegion(center=target_position,
radius=on_region_radius)
dataset_maker = SpectrumDatasetMaker(containment_correction=True,
selection=["counts", "aeff", "edisp"])
empty = SpectrumDatasetOnOff.create(region=on_region,
e_reco=e_reco,
e_true=e_true)
bkg_maker = ReflectedRegionsBackgroundMaker()
safe_mask_masker = SafeMaskMaker(methods=["aeff-max"], aeff_percent=10)
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
model = spectral_model.copy()
model.name = "crab"
datasets_1d = []
for observation in observations:
dataset = dataset_maker.run(dataset=empty.copy(),
observation=observation)
dataset_on_off = bkg_maker.run(dataset, observation)
dataset_on_off = safe_mask_masker.run(dataset_on_off, observation)
datasets_1d.append(dataset_on_off)
for dataset in datasets_1d:
model = spectral_model.copy()
model.name = "crab"
dataset.model = model
return datasets_1d
def evaluation_region(self):
"""Evaluation region"""
if hasattr(self, "to_region"):
return self.to_region()
elif self.evaluation_radius is not None:
return CircleSkyRegion(
center=self.position,
radius=self.evaluation_radius,
)
else:
return None
def _gaia_mermilliod_xmatch(cats, ra, dec, radius):
mermilliod = cats['II/168/ubvmeans']
coord = SkyCoord(ra=ra * u.deg, dec=dec * u.deg, frame='icrs')
region = CircleSkyRegion(coord, radius=radius)
xm = XMatch.query(cat1='vizier:I/345/gaia2',
cat2=mermilliod,
colRA2='_RA',
colDec2='_DE',
area=region,
max_distance=radius)
xm.sort('angDist')
return xm
def _gaia_hauck_xmatch(cats, ra, dec, radius):
mermilliod = cats['J/A+A/580/A23/catalog']
coord = SkyCoord(ra=ra * u.deg, dec=dec * u.deg, frame='icrs')
region = CircleSkyRegion(coord, radius=radius)
xm = XMatch.query(cat1='vizier:I/345/gaia2',
cat2=mermilliod,
colRA2='_RA.icrs',
colDec2='_DE.icrs',
area=region,
max_distance=radius)
xm.sort('angDist')
return xm
def exclusion_mask():
exclusion_region = CircleSkyRegion(
center=SkyCoord(183.604, -8.708, unit="deg", frame="galactic"),
radius=0.5 * u.deg,
)
skydir = SkyCoord(ra=83.63, dec=22.01, unit="deg", frame="icrs")
geom = WcsGeom.create(
npix=(150, 150), binsz=0.05, skydir=skydir, proj="TAN", frame="icrs"
)
return ~geom.region_mask([exclusion_region])
def make_mask(datasets,
source_pos,
source_radius=0.3*u.deg):
# Make the exclusion mask
geom = datasets[0].counts.geom
energy_axis = datasets[0].counts.geom.axes["energy"]
geom_image = geom.to_image().to_cube([energy_axis.squash()])
regions = CircleSkyRegion(center=source_pos, radius=source_radius)
exclusion_mask = Map.from_geom(geom_image)
exclusion_mask.data = geom_image.region_mask([regions], inside=False)
return exclusion_mask
def test_find_reflected_regions(mask):
pos = SkyCoord(80.2, 23.5, unit='deg', frame='icrs')
radius = Angle(0.4, 'deg')
region = CircleSkyRegion(pos, radius)
center = SkyCoord(83.2, 22.7, unit='deg', frame='icrs')
regions = find_reflected_regions(region,
center,
mask,
min_distance_input=Angle('0 deg'))
assert (len(regions)) == 20
assert_quantity_allclose(regions[3].center.icrs.ra,
Angle('81.752 deg'),
rtol=1e-2)
def test_make_region_mask():
from regions import CircleSkyRegion
geom = WcsGeom.create(npix=(3, 3), binsz=2, proj='CAR', coordsys='GAL')
m = WcsNDMap(geom)
region = CircleSkyRegion(SkyCoord(0, 0, unit='deg', frame='galactic'),
1.0 * u.deg)
maskmap = m.make_region_mask(region)
assert maskmap.data.dtype == bool
assert np.sum(maskmap.data) == 1
maskmap = m.make_region_mask(region, inside=False)
assert np.sum(maskmap.data) == 8
def test_EventList_region():
filename = gammapy_extra.filename(
'test_datasets/unbundled/hess/run_0023037_hard_eventlist.fits.gz')
event_list = EventList.read(filename, hdu='EVENTS')
pos = SkyCoord(81, 21, unit='deg', frame='icrs')
radius = Angle(1, 'deg')
circ = CircleSkyRegion(pos, radius)
idx = circ.contains(event_list.radec)
filtered_list = event_list[idx]
assert_allclose(filtered_list[4]['RA'], 81, rtol=1)
assert_allclose(filtered_list[2]['DEC'], 21, rtol=1)
assert len(filtered_list) == 5
def test_hpx_geom_region_mask():
geom = HpxGeom.create(nside=256, region="DISK(0.,0.,5.)")
circle = CircleSkyRegion(center=SkyCoord("0d", "0d"), radius=3 * u.deg)
mask = geom.region_mask(circle)
assert_allclose(mask.data.sum(), 534)
assert mask.geom.nside == 256
solid_angle = (mask.data * geom.solid_angle()).sum()
assert_allclose(solid_angle,
2 * np.pi * (1 - np.cos(3 * u.deg)) * u.sr,
rtol=0.01)
def test_fov_bkg_maker_mask_fit_handling(obs_dataset, exclusion_mask):
fov_bkg_maker = FoVBackgroundMaker(method="scale", exclusion_mask=exclusion_mask)
test_dataset = obs_dataset.copy(name="test-fov")
region = CircleSkyRegion(obs_dataset._geom.center_skydir, Angle(0.4, "deg"))
mask_fit = obs_dataset._geom.region_mask(regions=[region])
test_dataset.mask_fit = mask_fit
dataset = fov_bkg_maker.run(test_dataset)
assert np.all(test_dataset.mask_fit == mask_fit) == True
model = dataset.models[f"{dataset.name}-bkg"].spectral_model
assert_allclose(model.norm.value, 0.9975, rtol=1e-3)
assert_allclose(model.norm.error, 0.1115, rtol=1e-3)
assert_allclose(model.tilt.value, 0.0, rtol=1e-2)
def setup_class(self):
table = Table()
table["RA"] = [0.0, 0.0, 0.0, 10.0] * u.deg
table["DEC"] = [0.0, 0.9, 10.0, 10.0] * u.deg
table["ENERGY"] = [1.0, 1.5, 1.5, 10.0] * u.TeV
table["OFFSET"] = [0.1, 0.5, 1.0, 1.5] * u.deg
self.events = EventListBase(table)
center1 = SkyCoord(0.0, 0.0, frame="icrs", unit="deg")
on_region1 = CircleSkyRegion(center1, radius=1.0 * u.deg)
center2 = SkyCoord(0.0, 10.0, frame="icrs", unit="deg")
on_region2 = RectangleSkyRegion(center2, width=0.5 * u.deg, height=0.3 * u.deg)
self.on_regions = [on_region1, on_region2]
def setup(self):
ra = [0.0, 0.0, 0.0, 10.0] * u.deg
dec = [0.0, 0.9, 10.0, 10.0] * u.deg
energy = [1.0, 1.5, 1.5, 10.0] * u.TeV
evt_table = Table([ra, dec, energy], names=["RA", "DEC", "ENERGY"])
self.evt_list = EventListBase(evt_table)
center1 = SkyCoord(0.0, 0.0, frame="icrs", unit="deg")
on_region1 = CircleSkyRegion(center1, radius=1.0 * u.deg)
center2 = SkyCoord(0.0, 10.0, frame="icrs", unit="deg")
on_region2 = RectangleSkyRegion(center2,
width=0.5 * u.deg,
height=0.3 * u.deg)
self.on_regions = [on_region1, on_region2]
def test_integrate_geom():
model = GaussianSpatialModel(lon="0d", lat="0d", sigma=0.1 * u.deg, frame="icrs")
spectral_model = PowerLawSpectralModel(amplitude="1e-11 cm-2 s-1 TeV-1")
sky_model = SkyModel(spectral_model=spectral_model, spatial_model=model)
center = SkyCoord("0d", "0d", frame="icrs")
radius = 0.3 * u.deg
square = CircleSkyRegion(center, radius)
axis = MapAxis.from_energy_bounds("1 TeV", "10 TeV", nbin=3, name="energy_true")
geom = RegionGeom(region=square, axes=[axis], binsz_wcs="0.01deg")
integral = sky_model.integrate_geom(geom).data
assert_allclose(integral / 1e-12, [[[5.299]], [[2.460]], [[1.142]]], rtol=1e-3)
def test_hpx_map_to_region_nd_map():
axis = MapAxis.from_energy_bounds("10 GeV", "2 TeV", nbin=10)
m = HpxNDMap.create(nside=128, axes=[axis])
m.data += 1
circle = CircleSkyRegion(center=SkyCoord("0d", "0d"), radius=10 * u.deg)
spec = m.to_region_nd_map(region=circle)
assert_allclose(spec.data.sum(), 14660)
spec_mean = m.to_region_nd_map(region=circle, func=np.mean)
assert_allclose(spec_mean.data, 1)
spec_interp = m.to_region_nd_map(region=circle.center, func=np.mean)
assert_allclose(spec_interp.data, 1)
def get_spectrumdataset(name):
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)
energy_axis = MapAxis.from_energy_bounds(
0.1, 40, nbin=15, per_decade=True, unit="TeV", name="energy"
)
energy_axis_true = MapAxis.from_energy_bounds(
0.05, 100, nbin=20, per_decade=True, unit="TeV", name="energy_true"
)
geom = RegionGeom.create(region=on_region, axes=[energy_axis])
return SpectrumDataset.create(
geom=geom, energy_axis_true=energy_axis_true, name=name
)
def _spectrum_extraction(self):
"""Run all steps for the spectrum extraction."""
region = self.settings["datasets"]["geom"]["region"]
log.info("Reducing spectrum datasets.")
on_lon = Angle(region["center"][0])
on_lat = Angle(region["center"][1])
on_center = SkyCoord(on_lon, on_lat, frame=region["frame"])
on_region = CircleSkyRegion(on_center, Angle(region["radius"]))
background_params = {"on_region": on_region}
background = self.settings["datasets"]["background"]
if "exclusion_mask" in background:
map_hdu = {}
filename = background["exclusion_mask"]["filename"]
if "hdu" in background["exclusion_mask"]:
map_hdu = {"hdu": background["exclusion_mask"]["hdu"]}
exclusion_region = Map.read(filename, **map_hdu)
background_params["exclusion_mask"] = exclusion_region
if background["background_estimator"] == "reflected":
self.background_estimator = ReflectedRegionsBackgroundEstimator(
observations=self.observations, **background_params
)
self.background_estimator.run()
else:
# TODO: raise error?
log.info("Background estimation only for reflected regions method.")
extraction_params = {}
if "containment_correction" in self.settings["datasets"]:
extraction_params["containment_correction"] = self.settings["datasets"][
"containment_correction"
]
params = self.settings["datasets"]["geom"]["axes"][0]
e_reco = MapAxis.from_bounds(**params).edges
extraction_params["e_reco"] = e_reco
extraction_params["e_true"] = None
self.extraction = SpectrumExtraction(
observations=self.observations,
bkg_estimate=self.background_estimator.result,
**extraction_params,
)
self.extraction.run()
self.datasets = Datasets(self.extraction.spectrum_observations)
if self.settings["datasets"]["stack-datasets"]:
stacked = self.datasets.stack_reduce()
stacked.name = "stacked"
self.datasets = Datasets([stacked])
def test_contributes(models):
center_sky = SkyCoord(3, 4, unit="deg", frame="galactic")
circle_sky_12 = CircleSkyRegion(center=center_sky, radius=1 * u.deg)
axis = MapAxis.from_edges(np.logspace(-1, 1, 3), unit=u.TeV, name="energy")
geom = WcsGeom.create(skydir=(3, 4), npix=(5, 4), frame="galactic", axes=[axis])
mask = geom.region_mask([circle_sky_12])
spatial_model = GaussianSpatialModel(
lon_0="0 deg", lat_0="0 deg", sigma="0.9 deg", frame="galactic"
)
assert spatial_model.evaluation_region.height == 2 * spatial_model.evaluation_radius
model4 = SkyModel(
spatial_model=spatial_model,
spectral_model=PowerLawSpectralModel(),
name="source-4",
)
assert model4.contributes(mask, margin=0 * u.deg)
