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