def test_absorption(): # absorption values for given redshift redshift = 0.117 absorption = Absorption.read_builtin("dominguez") # 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) # EBL + PWL model model = AbsorbedSpectralModel(spectral_model=pwl, absorption=absorption, parameter=redshift) desired = u.Quantity(5.140765e-13, "TeV-1 s-1 cm-2") assert_quantity_allclose(model(1 * u.TeV), desired, rtol=1e-3) assert model.alpha_norm.value == 1.0 # EBL + PWL model: test if norm of EBL=0: it mean model =pwl model = AbsorbedSpectralModel(spectral_model=pwl, absorption=absorption, alpha_norm=0, parameter=redshift) assert_quantity_allclose(model(1 * u.TeV), pwl(1 * u.TeV), rtol=1e-3) # EBL + PWL model: Test with a norm different of 1 model = AbsorbedSpectralModel(spectral_model=pwl, absorption=absorption, alpha_norm=1.5, parameter=redshift) desired = u.Quantity(2.739695e-13, "TeV-1 s-1 cm-2") assert model.alpha_norm.value == 1.5 assert_quantity_allclose(model(1 * u.TeV), desired, rtol=1e-3) # Test error propagation model.spectral_model.parameters.set_error( amplitude=0.1 * model.spectral_model.amplitude.value) dnde, dnde_err = model.evaluate_error(1 * u.TeV) assert_allclose(dnde_err / dnde, 0.1)
def fake_dataset(): axis = MapAxis.from_energy_bounds(0.1, 10, 5, unit="TeV", name="energy") axis_true = MapAxis.from_energy_bounds(0.05, 20, 10, unit="TeV", name="energy_true") geom = WcsGeom.create(npix=50, binsz=0.02, axes=[axis]) dataset = MapDataset.create(geom) dataset.psf = PSFMap.from_gauss(axis_true, sigma="0.05 deg") dataset.mask_safe += np.ones(dataset.data_shape, dtype=bool) dataset.background += 1 dataset.exposure += 1e12 * u.cm ** 2 * u.s spatial_model = PointSpatialModel() spectral_model = PowerLawSpectralModel(amplitude="1e-10 cm-2s-1TeV-1", index=2) model = SkyModel( spatial_model=spatial_model, spectral_model=spectral_model, name="source" ) dataset.models = [model] dataset.fake(random_state=42) return dataset
def spectrum_dataset(): name = "test" energy = np.logspace(-1, 1, 31) * u.TeV livetime = 100 * u.s pwl = PowerLawSpectralModel( index=2.1, amplitude="1e5 cm-2 s-1 TeV-1", reference="0.1 TeV", ) temp_mod = ConstantTemporalModel() model = SkyModel(spectral_model=pwl, temporal_model=temp_mod, name="test-source") axis = MapAxis.from_edges(energy, interp="log", name="energy") axis_true = MapAxis.from_edges(energy, interp="log", name="energy_true") background = RegionNDMap.create(region="icrs;circle(0, 0, 0.1)", axes=[axis]) models = Models([model]) exposure = RegionNDMap.create(region="icrs;circle(0, 0, 0.1)", axes=[axis_true]) exposure.quantity = u.Quantity("1 cm2") * livetime bkg_rate = np.ones(30) / u.s background.quantity = bkg_rate * livetime start = [1, 3, 5] * u.day stop = [2, 3.5, 6] * u.day t_ref = Time(55555, format="mjd") gti = GTI.create(start, stop, reference_time=t_ref) dataset = SpectrumDataset( models=models, exposure=exposure, background=background, name=name, gti=gti, ) dataset.fake(random_state=23) return dataset
def test_flux_estimator_compound_model(): pl = PowerLawSpectralModel() pl.amplitude.min = 1e-15 pl.amplitude.max = 1e-10 pln = PowerLawNormSpectralModel() pln.norm.value = 0.1 pln.norm.frozen = True spectral_model = pl * pln model = SkyModel(spectral_model=spectral_model, name="test") estimator = FluxEstimator(source="test", selection_optional=[], reoptimize=True) scale_model = estimator.get_scale_model(Models([model])) assert_allclose(scale_model.norm.min, 1e-3) assert_allclose(scale_model.norm.max, 1e2)
def test_table_properties(self, table_flux_estimate): model = PowerLawSpectralModel(amplitude="1e-10 cm-2s-1TeV-1", index=2) fe = FluxEstimate(data=table_flux_estimate, spectral_model=model) assert fe.dnde.unit == u.Unit("cm-2s-1TeV-1") assert_allclose(fe.dnde.value, [1e-9, 1e-11]) assert_allclose(fe.dnde_err.value, [1e-10, 1e-12]) assert_allclose(fe.dnde_errn.value, [2e-10, 2e-12]) assert_allclose(fe.dnde_errp.value, [1.5e-10, 1.5e-12]) assert_allclose(fe.dnde_ul.value, [2e-9, 2e-11]) assert fe.e2dnde.unit == u.Unit("TeV cm-2s-1") assert_allclose(fe.e2dnde.value, [1e-10, 1e-10]) assert fe.flux.unit == u.Unit("cm-2s-1") assert_allclose(fe.flux.value, [9e-10, 9e-11]) assert fe.eflux.unit == u.Unit("TeV cm-2s-1") assert_allclose(fe.eflux.value, [2.302585e-10, 2.302585e-10])
def simulate_spectrum_dataset(model, random_state=0): energy_edges = np.logspace(-0.5, 1.5, 21) * u.TeV energy_axis = MapAxis.from_edges(energy_edges, interp="log", name="energy") aeff = EffectiveAreaTable.from_parametrization( energy=energy_edges).to_region_map() bkg_model = SkyModel( spectral_model=PowerLawSpectralModel(index=2.5, amplitude="1e-12 cm-2 s-1 TeV-1"), name="background", ) bkg_model.spectral_model.amplitude.frozen = True bkg_model.spectral_model.index.frozen = True geom = RegionGeom(region=None, axes=[energy_axis]) acceptance = RegionNDMap.from_geom(geom=geom, data=1) edisp = EDispKernelMap.from_diagonal_response( energy_axis=energy_axis, energy_axis_true=energy_axis.copy(name="energy_true"), geom=geom, ) livetime = 100 * u.h exposure = aeff * livetime mask_safe = RegionNDMap.from_geom(geom=geom, dtype=bool) mask_safe.data += True dataset = SpectrumDatasetOnOff(name="test_onoff", exposure=exposure, acceptance=acceptance, acceptance_off=5, edisp=edisp, mask_safe=mask_safe) dataset.models = bkg_model bkg_npred = dataset.npred_signal() dataset.models = model dataset.fake( random_state=random_state, npred_background=bkg_npred, ) return dataset
def test_model_plot(): pars, errs = {}, {} pars["amplitude"] = 1e-12 * u.Unit("TeV-1 cm-2 s-1") pars["reference"] = 1 * u.Unit("TeV") pars["index"] = 2 * u.Unit("") errs["amplitude"] = 0.1e-12 * u.Unit("TeV-1 cm-2 s-1") pwl = PowerLawSpectralModel(**pars) pwl.parameters.set_parameter_errors(errs) with mpl_plot_check(): pwl.plot((1 * u.TeV, 10 * u.TeV)) with mpl_plot_check(): pwl.plot_error((1 * u.TeV, 10 * u.TeV))
def simulate_map_dataset(random_state=0, name=None): irfs = load_cta_irfs( "$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits" ) skydir = SkyCoord("0 deg", "0 deg", frame="galactic") energy_edges = np.logspace(-1, 2, 15) * u.TeV energy_axis = MapAxis.from_edges(edges=energy_edges, name="energy", interp="log") geom = WcsGeom.create(skydir=skydir, width=(4, 4), binsz=0.1, axes=[energy_axis], frame="galactic") gauss = GaussianSpatialModel(lon_0="0 deg", lat_0="0 deg", sigma="0.4 deg", frame="galactic") pwl = PowerLawSpectralModel(amplitude="1e-11 cm-2 s-1 TeV-1") skymodel = SkyModel(spatial_model=gauss, spectral_model=pwl, name="source") obs = Observation.create( pointing=skydir, livetime=1 * u.h, irfs=irfs, location=EarthLocation(lon="-70d18m58.84s", lat="-24d41m0.34s", height="2000m"), ) empty = MapDataset.create(geom, name=name) maker = MapDatasetMaker( selection=["exposure", "background", "psf", "edisp"]) dataset = maker.run(empty, obs) bkg_model = FoVBackgroundModel(dataset_name=dataset.name) dataset.models = [bkg_model, skymodel] dataset.fake(random_state=random_state) return dataset
def trapz_loglog(y, x, axis=-1): """Integrate using the composite trapezoidal rule in log-log space. Integrate `y` (`x`) along given axis in loglog space. Parameters ---------- y : array_like Input array to integrate. x : array_like, optional Independent variable to integrate over. axis : int, optional Specify the axis. Returns ------- trapz : float Definite integral as approximated by trapezoidal rule in loglog space. """ from gammapy.modeling.models import PowerLawSpectralModel as pl # see https://stackoverflow.com/a/56840428 x, y = np.moveaxis(x, axis, 0), np.moveaxis(y, axis, 0) energy_min, energy_max = x[:-1], x[1:] vals_energy_min, vals_energy_max = y[:-1], y[1:] # log scale has the build-in zero clipping log = LogScale() with np.errstate(invalid="ignore", divide="ignore"): index = -log(vals_energy_min / vals_energy_max) / log(energy_min / energy_max) index[np.isnan(index)] = np.inf return pl.evaluate_integral( energy_min=energy_min, energy_max=energy_max, index=index, reference=energy_min, amplitude=vals_energy_min, )
def table_psf_in_energy_band(self, energy_band, spectrum=None, n_bins=11, **kwargs): """Average PSF in a given energy band. Expected counts in sub energy bands given the given exposure and spectrum are used as weights. Parameters ---------- energy_band : `~astropy.units.Quantity` Energy band spectrum : `~gammapy.modeling.models.SpectralModel` Spectral model used for weighting the PSF. Default is a power law with index=2. n_bins : int Number of energy points in the energy band, used to compute the weigthed PSF. Returns ------- psf : `TablePSF` Table PSF """ from gammapy.modeling.models import PowerLawSpectralModel, TemplateSpectralModel if spectrum is None: spectrum = PowerLawSpectralModel() exposure = TemplateSpectralModel(self.energy, self.exposure) e_min, e_max = energy_band energy = MapAxis.from_energy_bounds(e_min, e_max, n_bins).edges weights = spectrum(energy) * exposure(energy) weights /= weights.sum() psf_value = self.evaluate(energy=energy) psf_value_weighted = weights[:, np.newaxis] * psf_value return TablePSF(self.rad, psf_value_weighted.sum(axis=0), **kwargs)
def test_table_properties(region_map_flux_estimate): model = SkyModel(PowerLawSpectralModel(amplitude="1e-10 cm-2s-1TeV-1", index=2)) fe = FluxMaps(data=region_map_flux_estimate, reference_model=model) assert fe.dnde.unit == u.Unit("cm-2s-1TeV-1") assert_allclose(fe.dnde.data.flat, [1e-9, 1e-11]) assert_allclose(fe.dnde_err.data.flat, [1e-10, 1e-12]) assert_allclose(fe.dnde_errn.data.flat, [2e-10, 2e-12]) assert_allclose(fe.dnde_errp.data.flat, [1.5e-10, 1.5e-12]) assert_allclose(fe.dnde_ul.data.flat, [2e-9, 2e-11]) assert fe.e2dnde.unit == u.Unit("TeV cm-2s-1") assert_allclose(fe.e2dnde.data.flat, [1e-10, 1e-10]) assert fe.flux.unit == u.Unit("cm-2s-1") assert_allclose(fe.flux.data.flat, [9e-10, 9e-11]) assert fe.eflux.unit == u.Unit("TeV cm-2s-1") assert_allclose(fe.eflux.data.flat, [2.302585e-10, 2.302585e-10])
def test_compute_ts_map(input_dataset): """Minimal test of compute_ts_image""" spatial_model = GaussianSpatialModel(sigma="0.1 deg") spectral_model = PowerLawSpectralModel(index=2) model = SkyModel(spatial_model=spatial_model, spectral_model=spectral_model) ts_estimator = TSMapEstimator( model=model, threshold=1, kernel_width="1 deg", selection_optional=[] ) result = ts_estimator.run(input_dataset) assert_allclose(result["ts"].data[99, 99], 1704.23, rtol=1e-2) assert_allclose(result["niter"].data[99, 99], 8) assert_allclose(result["flux"].data[99, 99], 1.02e-09, rtol=1e-2) assert_allclose(result["flux_err"].data[99, 99], 3.84e-11, rtol=1e-2) assert result["flux"].unit == u.Unit("cm-2s-1") assert result["flux_err"].unit == u.Unit("cm-2s-1") # Check mask is correctly taken into account assert np.isnan(result["ts"].data[30, 40])
def __init__( self, regions, e_edges=None, spectrum=None, n_sigma=1.0, n_sigma_ul=3.0, selection_optional="all", ): self.regions = regions self.n_sigma = n_sigma self.n_sigma_ul = n_sigma_ul self.e_edges = u.Quantity(e_edges) if e_edges is not None else None if spectrum is None: spectrum = PowerLawSpectralModel() self.spectrum = spectrum self.selection_optional = selection_optional
def test_compute_ts_map_psf(fermi_dataset): spatial_model = PointSpatialModel() spectral_model = PowerLawSpectralModel(amplitude="1e-22 cm-2 s-1 keV-1") model = SkyModel(spatial_model=spatial_model, spectral_model=spectral_model) estimator = TSMapEstimator(model=model, kernel_width="1 deg", selection_optional="all") result = estimator.run(fermi_dataset) assert_allclose(result["ts"].data[0, 29, 29], 833.38, atol=0.1) assert_allclose(result["niter"].data[0, 29, 29], 7) assert_allclose(result["flux"].data[0, 29, 29], 1.34984e-09, rtol=1e-3) assert_allclose(result["flux_err"].data[0, 29, 29], 7.93751176e-11, rtol=1e-3) assert_allclose(result["flux_errp"].data[0, 29, 29], 7.948953e-11, rtol=1e-3) assert_allclose(result["flux_errn"].data[0, 29, 29], 7.508168e-11, rtol=1e-3) assert_allclose(result["flux_ul"].data[0, 29, 29], 1.63222157e-10, rtol=1e-3) assert result["flux"].unit == u.Unit("cm-2s-1") assert result["flux_err"].unit == u.Unit("cm-2s-1") assert result["flux_ul"].unit == u.Unit("cm-2s-1")
def spectral_model(self, which="point"): """Spectral model (`~gammapy.modeling.models.PowerLawSpectralModel`). * ``which="point"`` -- Spectral model under the point source assumption. * ``which="extended"`` -- Spectral model under the extended source assumption. Only available for some sources. Raise ValueError if not available. """ idx = self._get_idx(which) pars, errs = {}, {} pars["amplitude"] = self.data[f"spec{idx}_dnde"] errs["amplitude"] = self.data[f"spec{idx}_dnde_err"] pars["index"] = -self.data[f"spec{idx}_index"] errs["index"] = self.data[f"spec{idx}_index_err"] pars["reference"] = "7 TeV" model = PowerLawSpectralModel(**pars) model.parameters.set_error(**errs) return model
def test_flux_point_dataset_serialization(tmp_path): path = "$GAMMAPY_DATA/tests/spectrum/flux_points/diff_flux_points.fits" data = FluxPoints.read(path) data.table["e_ref"] = data.e_ref.to("TeV") spectral_model = PowerLawSpectralModel(index=2.3, amplitude="2e-13 cm-2 s-1 TeV-1", reference="1 TeV") model = SkyModel(spectral_model=spectral_model, name="test_model") dataset = FluxPointsDataset(model, data, name="test_dataset") Datasets([dataset]).write(tmp_path, prefix="tmp") datasets = Datasets.read(tmp_path / "tmp_datasets.yaml", tmp_path / "tmp_models.yaml") new_dataset = datasets[0] assert_allclose(new_dataset.data.table["dnde"], dataset.data.table["dnde"], 1e-4) if dataset.mask_fit is None: assert np.all(new_dataset.mask_fit == dataset.mask_safe) assert np.all(new_dataset.mask_safe == dataset.mask_safe) assert new_dataset.name == "test_dataset"
def test_verify_npred(self): """Verifying npred is preserved during the stacking""" pwl = SkyModel( spectral_model=PowerLawSpectralModel(index=2, amplitude=2e-11 * u.Unit("cm-2 s-1 TeV-1"), reference=1 * u.TeV)) self.stacked_dataset.models = pwl npred_stacked = self.stacked_dataset.npred_signal().data npred_stacked[~self.stacked_dataset.mask_safe.data] = 0 npred_summed = np.zeros_like(npred_stacked) for dataset in self.datasets: dataset.models = pwl npred_summed[dataset.mask_safe] += dataset.npred_signal().data[ dataset.mask_safe] assert_allclose(npred_stacked, npred_summed, rtol=1e-6)
def test_map_properties(self, map_flux_estimate): model = PowerLawSpectralModel(amplitude="1e-10 cm-2s-1TeV-1", index=2) fe = FluxEstimate(data=map_flux_estimate, reference_spectral_model=model) assert fe.dnde.unit == u.Unit("cm-2s-1TeV-1") assert_allclose(fe.dnde.quantity.value[:, 2, 2], [1e-9, 1e-11]) assert_allclose(fe.dnde_err.quantity.value[:, 2, 2], [1e-10, 1e-12]) assert_allclose(fe.dnde_errn.quantity.value[:, 2, 2], [2e-10, 2e-12]) assert_allclose(fe.dnde_errp.quantity.value[:, 2, 2], [1.5e-10, 1.5e-12]) assert_allclose(fe.dnde_ul.quantity.value[:, 2, 2], [2e-9, 2e-11]) assert fe.e2dnde.unit == u.Unit("TeV cm-2s-1") assert_allclose(fe.e2dnde.quantity.value[:, 2, 2], [1e-10, 1e-10]) assert_allclose(fe.e2dnde_err.quantity.value[:, 2, 2], [1e-11, 1e-11]) assert_allclose(fe.e2dnde_errn.quantity.value[:, 2, 2], [2e-11, 2e-11]) assert_allclose(fe.e2dnde_errp.quantity.value[:, 2, 2], [1.5e-11, 1.5e-11]) assert_allclose(fe.e2dnde_ul.quantity.value[:, 2, 2], [2e-10, 2e-10]) assert fe.flux.unit == u.Unit("cm-2s-1") assert_allclose(fe.flux.quantity.value[:, 2, 2], [9e-10, 9e-11]) assert_allclose(fe.flux_err.quantity.value[:, 2, 2], [9e-11, 9e-12]) assert_allclose(fe.flux_errn.quantity.value[:, 2, 2], [1.8e-10, 1.8e-11]) assert_allclose(fe.flux_errp.quantity.value[:, 2, 2], [1.35e-10, 1.35e-11]) assert_allclose(fe.flux_ul.quantity.value[:, 2, 2], [1.8e-9, 1.8e-10]) assert fe.eflux.unit == u.Unit("TeV cm-2s-1") assert_allclose(fe.eflux.quantity.value[:, 2, 2], [2.302585e-10, 2.302585e-10]) assert_allclose(fe.eflux_err.quantity.value[:, 2, 2], [2.302585e-11, 2.302585e-11]) assert_allclose(fe.eflux_errn.quantity.value[:, 2, 2], [4.60517e-11, 4.60517e-11]) assert_allclose(fe.eflux_errp.quantity.value[:, 2, 2], [3.4538775e-11, 3.4538775e-11]) assert_allclose(fe.eflux_ul.quantity.value[:, 2, 2], [4.60517e-10, 4.60517e-10])
def __init__( self, model=None, kernel_width="0.2 deg", downsampling_factor=None, n_sigma=1, n_sigma_ul=2, threshold=None, rtol=0.01, selection_optional=None, energy_edges=None, sum_over_energy_groups=True, n_jobs=None, ): self.kernel_width = Angle(kernel_width) if model is None: model = SkyModel( spectral_model=PowerLawSpectralModel(), spatial_model=PointSpatialModel(), name="ts-kernel", ) self.model = model self.downsampling_factor = downsampling_factor self.n_sigma = n_sigma self.n_sigma_ul = n_sigma_ul self.threshold = threshold self.rtol = rtol self.n_jobs = n_jobs self.sum_over_energy_groups = sum_over_energy_groups self.selection_optional = selection_optional self.energy_edges = energy_edges self._flux_estimator = BrentqFluxEstimator( rtol=self.rtol, n_sigma=self.n_sigma, n_sigma_ul=self.n_sigma_ul, selection_optional=selection_optional, ts_threshold=threshold, )
def __init__( self, correlation_radius="0.1 deg", n_sigma=1, n_sigma_ul=2, selection_optional=None, energy_edges=None, correlate_off=True, spectral_model=None, ): self.correlation_radius = correlation_radius self.n_sigma = n_sigma self.n_sigma_ul = n_sigma_ul self.selection_optional = selection_optional self.energy_edges = energy_edges self.correlate_off = correlate_off if spectral_model is None: spectral_model = PowerLawSpectralModel(index=2) self.spectral_model = spectral_model
def _dnde_from_flux(flux, model, e_ref, e_min, e_max, pwl_approx): """Helper for `to_sed_type`. Compute dnde under the assumption that flux equals expected flux from model. """ dnde_model = model(e_ref) if pwl_approx: index = model.spectral_index(e_ref) flux_model = PowerLawSpectralModel.evaluate_integral( emin=e_min, emax=e_max, index=index, reference=e_ref, amplitude=dnde_model, ) else: flux_model = model.integral(e_min, e_max, intervals=True) return dnde_model * (flux / flux_model)
def test_contributes(): 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)
def setup(self): path = "$GAMMAPY_DATA/joint-crab/spectra/hess/" obs1 = SpectrumDatasetOnOff.from_ogip_files(path + "pha_obs23523.fits") obs2 = SpectrumDatasetOnOff.from_ogip_files(path + "pha_obs23592.fits") self.obs_list = [obs1, obs2] self.pwl = PowerLawSpectralModel(index=2, amplitude=1e-12 * u.Unit("cm-2 s-1 TeV-1"), reference=1 * u.TeV) self.ecpl = ExpCutoffPowerLawSpectralModel( index=2, amplitude=1e-12 * u.Unit("cm-2 s-1 TeV-1"), reference=1 * u.TeV, lambda_=0.1 / u.TeV, ) # Example fit for one observation self.obs_list[0].model = self.pwl self.fit = Fit(self.obs_list[0])
def spectral_model(self): """Best fit spectral model (`~gammapy.modeling.models.SpectralModel`).""" spec_type = self.data["SpectrumType"].strip() pars, errs = {}, {} pars["amplitude"] = self.data["Flux_Density"] errs["amplitude"] = self.data["Unc_Flux_Density"] pars["reference"] = self.data["Pivot_Energy"] if spec_type == "PowerLaw": pars["index"] = self.data["Spectral_Index"] errs["index"] = self.data["Unc_Spectral_Index"] model = PowerLawSpectralModel(**pars) elif spec_type == "PLExpCutoff": pars["index"] = self.data["Spectral_Index"] pars["ecut"] = self.data["Cutoff"] errs["index"] = self.data["Unc_Spectral_Index"] errs["ecut"] = self.data["Unc_Cutoff"] model = ExpCutoffPowerLaw3FGLSpectralModel(**pars) elif spec_type == "LogParabola": pars["alpha"] = self.data["Spectral_Index"] pars["beta"] = self.data["beta"] errs["alpha"] = self.data["Unc_Spectral_Index"] errs["beta"] = self.data["Unc_beta"] model = LogParabolaSpectralModel(**pars) elif spec_type == "PLSuperExpCutoff": # TODO: why convert to GeV here? Remove? pars["reference"] = pars["reference"].to("GeV") pars["index_1"] = self.data["Spectral_Index"] pars["index_2"] = self.data["Exp_Index"] pars["ecut"] = self.data["Cutoff"].to("GeV") errs["index_1"] = self.data["Unc_Spectral_Index"] errs["index_2"] = self.data["Unc_Exp_Index"] errs["ecut"] = self.data["Unc_Cutoff"].to("GeV") model = SuperExpCutoffPowerLaw3FGLSpectralModel(**pars) else: raise ValueError(f"Invalid spec_type: {spec_type!r}") model.parameters.set_parameter_errors(errs) return model
def models(backgrounds): spatial_model = GaussianSpatialModel(lon_0="3 deg", lat_0="4 deg", sigma="3 deg", frame="galactic") spectral_model = PowerLawSpectralModel(index=2, amplitude="1e-11 cm-2 s-1 TeV-1", reference="1 TeV") model1 = SkyModel( spatial_model=spatial_model, spectral_model=spectral_model, name="source-1", ) model2 = model1.copy(name="source-2") model2.datasets_names = ["dataset-1"] model3 = model1.copy(name="source-3") model3.datasets_names = "dataset-2" model3.spatial_model = PointSpatialModel() model3.parameters.freeze_all() models = Models([model1, model2, model3] + backgrounds) return models
def test_flux_point_dataset_serialization(tmp_path): path = "$GAMMAPY_DATA/tests/spectrum/flux_points/diff_flux_points.fits" data = FluxPoints.read(path) data.table["e_ref"] = data.e_ref.to("TeV") # TODO: remove duplicate definition this once model is redefine as skymodel spatial_model = ConstantSpatialModel() spectral_model = PowerLawSpectralModel(index=2.3, amplitude="2e-13 cm-2 s-1 TeV-1", reference="1 TeV") model = SkyModel(spatial_model, spectral_model, name="test_model") dataset = FluxPointsDataset(SkyModels([model]), data, name="test_dataset") Datasets([dataset]).to_yaml(tmp_path, prefix="tmp") datasets = Datasets.from_yaml(tmp_path / "tmp_datasets.yaml", tmp_path / "tmp_models.yaml") new_dataset = datasets[0] assert_allclose(new_dataset.data.table["dnde"], dataset.data.table["dnde"], 1e-4) if dataset.mask_fit is None: assert np.all(new_dataset.mask_fit == dataset.mask_safe) assert np.all(new_dataset.mask_safe == dataset.mask_safe) assert new_dataset.name == "test_dataset"
def __init__( self, scales=None, kernel=Gaussian2DKernel, spectrum=None, method="lima", threshold=5, energy_edges=None, ): if spectrum is None: spectrum = PowerLawSpectralModel() self.spectrum = spectrum if scales is None: scales = self.get_scales(n_scales=9, kernel=kernel) self.scales = scales self.kernel = kernel self.threshold = threshold self.method = method self.energy_edges = energy_edges
def __init__( self, model=None, kernel_width="0.2 deg", downsampling_factor=None, method="root brentq", error_method="covar", error_sigma=1, ul_method="covar", ul_sigma=2, threshold=None, rtol=0.001, ): if method not in ["root brentq", "root newton", "leastsq iter"]: raise ValueError(f"Not a valid method: '{method}'") if error_method not in ["covar", "conf"]: raise ValueError(f"Not a valid error method '{error_method}'") self.kernel_width = Angle(kernel_width) if model is None: model = SkyModel( spectral_model=PowerLawSpectralModel(), spatial_model=PointSpatialModel(), ) self.model = model self.downsampling_factor = downsampling_factor self.parameters = { "method": method, "error_method": error_method, "error_sigma": error_sigma, "ul_method": ul_method, "ul_sigma": ul_sigma, "threshold": threshold, "rtol": rtol, }
def test_significance_map_estimator_map_dataset_exposure(simple_dataset): simple_dataset.exposure += 1e10 * u.cm**2 * u.s axis = simple_dataset.exposure.geom.axes[0] simple_dataset.psf = PSFMap.from_gauss(axis, sigma="0.05 deg") model = SkyModel( PowerLawSpectralModel(amplitude="1e-9 cm-2 s-1 TeV-1"), GaussianSpatialModel(lat_0=0.0 * u.deg, lon_0=0.0 * u.deg, sigma=0.1 * u.deg, frame="icrs"), name="sky_model", ) simple_dataset.models = [model] simple_dataset.npred() estimator = ExcessMapEstimator(0.1 * u.deg, selection_optional="all") result = estimator.run(simple_dataset) assert_allclose(result["npred_excess"].data.sum(), 19733.602, rtol=1e-3) assert_allclose(result["sqrt_ts"].data[0, 10, 10], 4.217129, rtol=1e-3)
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]) integral = sky_model.integrate_geom(geom).data assert_allclose(integral / 1e-12, [[[5.299]], [[2.460]], [[1.142]]], rtol=1e-3)