def test_spectral_model(self, ref):
model = self.cat[ref["idx"]].spectral_model
dnde, dnde_err = model.evaluate_error(100 * u.GeV)
assert isinstance(model, ref["spec_type"])
assert_quantity_allclose(dnde, ref["dnde"])
assert_quantity_allclose(dnde_err, ref["dnde_err"])
def test_evaluate(self):
x = np.linspace(-100, 20, 5)
y = np.linspace(-2, 2, 7)
x, y = np.meshgrid(x, y)
coords = SkyCoord(x, y, unit="deg", frame="galactic")
image = self.model.evaluate(coords)
desired = 1.223962643740966 * u.Unit("cm-2 s-1 sr-1")
assert_quantity_allclose(image.sum(), desired)
def test_primary_flux():
with pytest.raises(ValueError):
PrimaryFlux(channel="Spam", mDM=1 * u.TeV)
primflux = PrimaryFlux(channel="W", mDM=1 * u.TeV)
actual = primflux.table_model(500 * u.GeV)
desired = 9.328234e-05 / u.GeV
assert_quantity_allclose(actual, desired)
def test_spectral_model(self, ref):
model = self.cat[ref["idx"]].spectral_model
e_ref = model.reference.quantity
dnde, dnde_err = model.evaluate_error(e_ref)
assert isinstance(model, ref["spec_type"])
assert_quantity_allclose(dnde, ref["dnde"], rtol=1e-4)
assert_quantity_allclose(dnde_err, ref["dnde_err"], rtol=1e-4)
def test_x_edges_lon(checkerboard_image):
x_edges = Angle(np.linspace(-0.1, 0.1, 6), "deg")
p = ImageProfileEstimator(x_edges=x_edges, axis="lon", method="sum")
profile = p.run(checkerboard_image)
desired = 12 * np.ones(5) * u.Unit("cm-2 s-1")
assert_quantity_allclose(profile.profile, desired)
def test_pwl_pivot_energy():
pwl = PowerLaw(amplitude="5.35510540e-11 TeV-1 cm-1 s-1")
pwl.parameters.covariance = np.array(
[[0.0318377 ** 2, 6.56889442e-14, 0], [6.56889442e-14, 0, 0], [0, 0, 0]]
)
assert_quantity_allclose(pwl.pivot_energy, 3.3540034240210987 * u.TeV)
def test_trapz_loglog():
energy = Quantity([1, 10], "TeV")
pwl = PowerLawSpectralModel(index=2.3)
ref = pwl.integral(emin=energy[0], emax=energy[1])
val = trapz_loglog(pwl(energy), energy)
assert_quantity_allclose(val, ref)
def test_normalize(cosine_profile):
normalized = cosine_profile.normalize(mode="integral")
profile = normalized.profile
assert_quantity_allclose(profile.sum(), 1 * u.Unit("cm-2 s-1"))
normalized = cosine_profile.normalize(mode="peak")
profile = normalized.profile
assert_quantity_allclose(profile.max(), 1 * u.Unit("cm-2 s-1"))
def test_data(self):
d = self.source.data
assert isinstance(d, OrderedDict)
assert isinstance(d["RA"], Quantity)
assert_quantity_allclose(d["RA"], Quantity(43.3, "deg"))
assert isinstance(d["DEC"], Quantity)
assert_quantity_allclose(d["DEC"], Quantity(2, "deg"))
def test_4FGL_DR3():
cat = SourceCatalog4FGL("$GAMMAPY_DATA/catalogs/fermi/gll_psc_v28.fit.gz")
source = cat["4FGL J0534.5+2200"]
model = source.spectral_model()
fp = source.flux_points
not_ul = ~fp.is_ul.data.squeeze()
fp_dnde = fp.dnde.quantity.squeeze()[not_ul]
model_dnde = model(fp.energy_ref[not_ul])
assert_quantity_allclose(model_dnde, fp_dnde, rtol=0.07)
def test_smooth(cosine_profile, kernel):
# smoothing should preserve the mean
desired_mean = cosine_profile.profile.mean()
smoothed = cosine_profile.smooth(kernel, radius=3)
assert_quantity_allclose(smoothed.profile.mean(), desired_mean)
# smoothing should decrease errors
assert smoothed.profile_err.mean() < cosine_profile.profile_err.mean()
def test_spectral_model_err(self, gammacat, ref):
source = gammacat[ref["name"]]
spectral_model = source.spectral_model()
e_min, e_max, e_inf = [1, 10, 1e10] * u.TeV
dnde, dnde_err = spectral_model.evaluate_error(e_min)
assert_quantity_allclose(dnde, ref["dnde_1TeV"], rtol=1e-3)
assert_quantity_allclose(dnde_err, ref["dnde_1TeV_err"], rtol=1e-3)
def test_measure_curve_of_growth(gaussian_image):
"""Test measure_curve_of_growth function"""
position = SkyCoord(0, 0, frame="galactic", unit="deg")
radius_max = 0.6 * u.deg
radius, containment = measure_curve_of_growth(gaussian_image, position, radius_max)
sigma = 0.2 * u.deg
containment_ana = u.Quantity(
1 - np.exp(-0.5 * (radius / sigma) ** 2).value, "cm-2 s-1"
)
assert_quantity_allclose(containment, containment_ana, rtol=0.1)
def test_radial_profile_sum(checkerboard_image):
center = SkyCoord(0, 0, unit="deg", frame="galactic")
p = ImageProfileEstimator(axis="radial", method="sum", center=center)
profile = p.run(checkerboard_image)
desired = [4.0, 8.0, 20.0, 12.0, 12.0] * u.Unit("cm-2 s-1")
assert_quantity_allclose(profile.profile, desired)
with pytest.raises(ValueError):
ImageProfileEstimator(axis="radial")
def test_pwl_pivot_energy():
pwl = PowerLawSpectralModel(amplitude="5.35510540e-11 cm-2 s-1 TeV-1")
pwl.covariance = [
[0.0318377 ** 2, 6.56889442e-14, 0],
[6.56889442e-14, 0, 0],
[0, 0, 0],
]
assert_quantity_allclose(pwl.pivot_energy, 3.3540034240210987 * u.TeV)
def test_flux_points(self):
# test flux point on PKS 2155-304
src = self.cat["1FHL J0153.1+7515"]
flux_points = src.flux_points
actual = flux_points.table["flux"]
desired = [5.523017e-11, 0, 0] * u.Unit("cm-2 s-1")
assert_quantity_allclose(actual, desired)
actual = flux_points.table["flux_ul"]
desired = [np.nan, 4.163177e-11, 2.599397e-11] * u.Unit("cm-2 s-1")
assert_quantity_allclose(actual, desired, rtol=1e-5)
def test_flux_points(self):
# test flux point on PKS 2155-304
src = self.cat["PKS 2155-304"]
flux_points = src.flux_points
actual = flux_points.table["flux"]
desired = [2.866363e-10, 6.118736e-11, 3.257970e-16] * u.Unit("cm-2 s-1")
assert_quantity_allclose(actual, desired)
actual = flux_points.table["flux_ul"]
desired = [np.nan, np.nan, 1.294092e-11] * u.Unit("cm-2 s-1")
assert_quantity_allclose(actual, desired, rtol=1e-3)
def test_dmfluxmap(jfact):
emin = 0.1 * u.TeV
emax = 10 * u.TeV
massDM = 1 * u.TeV
channel = "W"
diff_flux = DMAnnihilation(mass=massDM, channel=channel)
int_flux = (jfact *
diff_flux.integral(emin=emin, emax=emax)).to("cm-2 s-1")
actual = int_flux[5, 5]
desired = 1.94839226e-12 / u.cm**2 / u.s
assert_quantity_allclose(actual, desired, rtol=1e-5)
def test_integrate_spectrum():
"""
Test numerical integration against analytical solution.
"""
emin = Quantity(1, "TeV")
emax = Quantity(10, "TeV")
pwl = PowerLaw(index=2.3)
ref = pwl.integral(emin=emin, emax=emax)
val = integrate_spectrum(pwl, emin, emax)
assert_quantity_allclose(val, ref)
def test_to_from_dict():
spectrum = TEST_MODELS[0]
model = spectrum["model"]
model_dict = model.to_dict()
new_model = SpectralModel.from_dict(model_dict)
assert isinstance(new_model, PowerLaw)
actual = [par.value for par in new_model.parameters]
desired = [par.value for par in model.parameters]
assert_quantity_allclose(actual, desired)
def test_compute_energy_threshold(self, spectrum_dataset_crab_fine,
observations_hess_dl3):
maker = SpectrumDatasetMaker(containment_correction=True)
safe_mask_maker = SafeMaskMaker(methods=["aeff-max"], aeff_percent=10)
obs = observations_hess_dl3[0]
dataset = maker.run(spectrum_dataset_crab_fine, obs)
dataset = safe_mask_maker.run(dataset, obs)
actual = dataset.energy_range[0]
assert_quantity_allclose(actual, 0.8799225 * u.TeV, rtol=1e-3)
def test_compute_flux_points_dnde_fermi():
"""
Test compute_flux_points_dnde on fermi source.
"""
fermi_3fgl = SourceCatalog3FGL()
source = fermi_3fgl["3FGL J0835.3-4510"]
flux_points = source.flux_points.to_sed_type(
"dnde", model=source.spectral_model(), method="log_center", pwl_approx=True
)
for column in ["dnde", "dnde_errn", "dnde_errp", "dnde_ul"]:
actual = flux_points.table["e2" + column].quantity
desired = flux_points.table[column].quantity * flux_points.e_ref ** 2
assert_quantity_allclose(actual[:-1], desired[:-1], rtol=1e-1)
def test_compute_energy_threshold(self,
spectrum_dataset_maker_crab_fine_bins,
observations_hess_dl3):
safe_mask_maker = SafeMaskMaker(methods=["aeff-max"], aeff_percent=10)
obs = observations_hess_dl3[0]
spectrum_dataset_maker_crab_fine_bins.containment_correction = True
dataset = spectrum_dataset_maker_crab_fine_bins.run(
obs, selection=["counts", "aeff", "edisp"])
dataset = safe_mask_maker.run(dataset, obs)
actual = dataset.energy_range[0]
assert_quantity_allclose(actual, 0.8799225 * u.TeV, rtol=1e-3)
def test_dmfluxmap(jfact):
energy_min = 0.1 * u.TeV
energy_max = 10 * u.TeV
massDM = 1 * u.TeV
channel = "W"
diff_flux = DarkMatterAnnihilationSpectralModel(mass=massDM,
channel=channel)
int_flux = (jfact * diff_flux.integral(
energy_min=energy_min, energy_max=energy_max)).to("cm-2 s-1")
actual = int_flux[5, 5]
desired = 1.9483e-12 / u.cm**2 / u.s
assert_quantity_allclose(actual, desired, rtol=1e-3)
def test_to_from_dict():
spectrum = TEST_MODELS[0]
model = spectrum["model"]
model_dict = model.to_dict()
model_class = SPECTRAL_MODEL_REGISTRY.get_cls(model_dict["type"])
new_model = model_class.from_dict(model_dict)
assert isinstance(new_model, PowerLawSpectralModel)
actual = [par.value for par in new_model.parameters]
desired = [par.value for par in model.parameters]
assert_quantity_allclose(actual, desired)
def test_compute_flux_points_dnde_fermi():
"""
Test compute_flux_points_dnde on fermi source.
"""
fermi_3fgl = SourceCatalog3FGL()
source = fermi_3fgl["3FGL J0835.3-4510"]
flux_points = source.flux_points
table = source.flux_points_table
for column in ["e2dnde", "e2dnde_errn", "e2dnde_errp", "e2dnde_ul"]:
actual = table[column].quantity
desired = getattr(flux_points, column).quantity.squeeze()
assert_quantity_allclose(actual[:-1], desired[:-1], rtol=0.05)
def test(aeff):
assert aeff.axes["energy_true"].nbin == 96
assert aeff.axes["offset"].nbin == 6
assert aeff.data.shape == (96, 6)
assert aeff.axes["energy_true"].unit == "TeV"
assert aeff.axes["offset"].unit == "deg"
assert aeff.unit == "m2"
assert_quantity_allclose(aeff.meta["HI_THRES"], 100, rtol=1e-3)
assert_quantity_allclose(aeff.meta["LO_THRES"], 0.870964, rtol=1e-3)
test_val = aeff.evaluate(energy_true="14 TeV", offset="0.2 deg")
assert_allclose(test_val.value, 683177.5, rtol=1e-3)
def test_synchrotron(self):
import naima
particle_distribution = naima.models.LogParabola(
amplitude=2e33 / u.eV, e_0=10 * u.TeV, alpha=1.3, beta=0.5
)
radiative_model = naima.radiative.Synchrotron(particle_distribution, B=2 * u.G)
model = NaimaSpectralModel(radiative_model)
for p in model.parameters:
assert p._type == "spectral"
val_at_2TeV = 1.0565840392550432e-24 * u.Unit("cm-2 s-1 TeV-1")
integral_1_10TeV = 4.449186e-13 * u.Unit("cm-2 s-1")
eflux_1_10TeV = 4.594121e-13 * u.Unit("TeV cm-2 s-1")
value = model(self.energy)
assert_quantity_allclose(value, val_at_2TeV)
assert_quantity_allclose(
model.integral(energy_min=self.energy_min, energy_max=self.energy_max),
integral_1_10TeV,
rtol=1e-5,
)
assert_quantity_allclose(
model.energy_flux(energy_min=self.energy_min, energy_max=self.energy_max),
eflux_1_10TeV,
rtol=1e-5,
)
val = model(self.e_array)
assert val.shape == self.e_array.shape
model.B.value = 3 # update B
val_at_2TeV = 5.1985064062296e-16 * u.Unit("cm-2 s-1 TeV-1")
value = model(self.energy)
assert_quantity_allclose(value, val_at_2TeV)
def test_to_from_dict_compound():
spectrum = TEST_MODELS[-2]
model = spectrum["model"]
assert spectrum["name"] == "compound6"
model_dict = model.to_dict()
assert model_dict["spectral"]["operator"] == "add"
model_class = SPECTRAL_MODEL_REGISTRY.get_cls(model_dict["spectral"]["type"])
new_model = model_class.from_dict(model_dict)
assert isinstance(new_model, CompoundSpectralModel)
actual = [par.value for par in new_model.parameters]
desired = [par.value for par in model.parameters]
assert_quantity_allclose(actual, desired)
def test_find_reflected_regions(exclusion_mask, on_region, pointing_pos, nreg1,
reg3_ra, nreg2, nreg3):
pointing = pointing_pos
finder = ReflectedRegionsFinder(min_distance_input="0 deg", )
regions, _ = finder.run(
center=pointing,
region=on_region,
exclusion_mask=exclusion_mask,
)
assert len(regions) == nreg1
assert_quantity_allclose(regions[3].center.icrs.ra, reg3_ra, rtol=1e-2)
# Test without exclusion
regions, _ = finder.run(center=pointing, region=on_region)
assert len(regions) == nreg2
# Test with too small exclusion
small_mask = exclusion_mask.cutout(pointing, Angle("0.1 deg"))
regions, _ = finder.run(
center=pointing,
region=on_region,
exclusion_mask=small_mask,
)
assert len(regions) == nreg3
# Test with maximum number of regions
finder.max_region_number = 5
regions, _ = finder.run(
center=pointing,
region=on_region,
exclusion_mask=small_mask,
)
assert len(regions) == 5
# Test with an other type of region
on_ellipse_annulus = EllipseAnnulusSkyRegion(
center=on_region.center.galactic,
inner_width=0.1 * u.deg,
outer_width=0.2 * u.deg,
inner_height=0.3 * u.deg,
outer_height=0.6 * u.deg,
angle=130 * u.deg,
)
regions, _ = finder.run(
region=on_ellipse_annulus,
center=pointing,
exclusion_mask=small_mask,
)
assert len(regions) == 5
