def test_sky_point_source(): geom = WcsGeom.create(skydir=(2.4, 2.3), npix=(10, 10), binsz=0.3) model = PointSpatialModel(lon_0="2.5 deg", lat_0="2.5 deg", frame="icrs") assert model.evaluation_radius.unit == "deg" assert_allclose(model.evaluation_radius.value, 0) assert model.frame == "icrs" assert_allclose(model.position.ra.deg, 2.5) assert_allclose(model.position.dec.deg, 2.5) val = model.evaluate_geom(geom) assert val.unit == "sr-1" assert_allclose(np.sum(val * geom.solid_angle()), 1)
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], 835.140605, rtol=1e-2) assert_allclose(result["niter"].data[0, 29, 29], 7) assert_allclose(result["flux"].data[0, 29, 29], 1.351949e-09, rtol=1e-2) assert_allclose(result["flux_err"].data[0, 29, 29], 7.93751176e-11, rtol=1e-2) assert_allclose(result["flux_errp"].data[0, 29, 29], 7.9376134e-11, rtol=1e-2) assert_allclose(result["flux_errn"].data[0, 29, 29], 7.5180404579e-11, rtol=1e-2) assert_allclose(result["flux_ul"].data[0, 29, 29], 1.63222157e-10, rtol=1e-2) 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 test_compute_ts_map_energy(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="0.6 deg", energy_edges=[10, 100, 1000] * u.GeV, sum_over_energy_groups=False, ) result = estimator.run(fermi_dataset) assert_allclose(result["ts"].data[:, 29, 29], [804.86171, 16.988756], rtol=1e-2) assert_allclose(result["flux"].data[:, 29, 29], [1.233119e-09, 3.590694e-11], rtol=1e-2) assert_allclose(result["flux_err"].data[:, 29, 29], [7.382305e-11, 1.338985e-11], rtol=1e-2) assert_allclose(result["niter"].data[:, 29, 29], [6, 6]) energy_axis = result["ts"].geom.axes["energy"] assert_allclose(energy_axis.edges.to_value("GeV"), [10, 84.471641, 500], rtol=1e-4)
def test_sky_point_source(): # Test special case of point source. Regression test for GH 2367. energy_axis = MapAxis.from_edges( [1, 10], unit="TeV", name="energy_true", interp="log" ) exposure = Map.create( skydir=(100, 70), npix=(4, 4), binsz=0.1, proj="AIT", unit="cm2 s", axes=[energy_axis], ) exposure.data = np.ones_like(exposure.data) spatial_model = PointSpatialModel( lon_0=100.06 * u.deg, lat_0=70.03 * u.deg, frame="icrs" ) # Create a spectral model with integral flux of 1 cm-2 s-1 in this energy band spectral_model = ConstantSpectralModel(const="1 cm-2 s-1 TeV-1") spectral_model.const.value /= spectral_model.integral(1 * u.TeV, 10 * u.TeV).value model = SkyModel(spatial_model=spatial_model, spectral_model=spectral_model) evaluator = MapEvaluator(model=model, exposure=exposure) flux = evaluator.compute_flux().quantity.to_value("cm-2 s-1")[0] expected = [ [0, 0, 0, 0], [0, 0.140, 0.058, 0.0], [0, 0.564, 0.236, 0], [0, 0, 0, 0], ] assert_allclose(flux, expected, atol=0.01) assert_allclose(flux.sum(), 1)
def spatial_model(self, which="point"): """Spatial model (`~gammapy.modeling.models.SpatialModel`). * ``which="point"`` - `~gammapy.modeling.models.PointSpatialModel` * ``which="extended"`` - `~gammapy.modeling.models.DiskSpatialModel`. Only available for some sources. Raise ValueError if not available. """ idx = self._get_idx(which) if idx == 0: model = PointSpatialModel( lon_0=self.data["glon"], lat_0=self.data["glat"], frame="galactic" ) else: model = DiskSpatialModel( lon_0=self.data["glon"], lat_0=self.data["glat"], r_0=self.data[f"spec{idx}_radius"], frame="galactic", ) lat_err = self.data["pos_err"].to("deg") lon_err = self.data["pos_err"].to("deg") / np.cos(self.data["glat"].to("rad")) model.parameters.set_error(lon_0=lon_err, lat_0=lat_err) return model
def spatial_model(self): """Spatial model (`~gammapy.modeling.models.SpatialModel`).""" d = self.data ra = d["RAJ2000"] dec = d["DEJ2000"] if self.is_pointlike: model = PointSpatialModel(lon_0=ra, lat_0=dec, frame="icrs") else: de = self.data_extended morph_type = de["Model_Form"].strip() e = (1 - (de["Model_SemiMinor"] / de["Model_SemiMajor"]) ** 2.0) ** 0.5 sigma = de["Model_SemiMajor"] phi = de["Model_PosAng"] if morph_type == "Disk": r_0 = de["Model_SemiMajor"] model = DiskSpatialModel( lon_0=ra, lat_0=dec, r_0=r_0, e=e, phi=phi, frame="icrs" ) elif morph_type in ["Map", "Ring", "2D Gaussian x2"]: filename = de["Spatial_Filename"].strip() path = make_path( "$GAMMAPY_DATA/catalogs/fermi/LAT_extended_sources_8years/Templates/" ) with warnings.catch_warnings(): # ignore FITS units warnings warnings.simplefilter("ignore", FITSFixedWarning) model = TemplateSpatialModel.read(path / filename) elif morph_type == "2D Gaussian": model = GaussianSpatialModel( lon_0=ra, lat_0=dec, sigma=sigma, e=e, phi=phi, frame="icrs" ) else: raise ValueError(f"Invalid spatial model: {morph_type!r}") self._set_spatial_errors(model) return model
def test_compute_flux_spatial(): center = SkyCoord("0 deg", "0 deg", frame="galactic") region = CircleSkyRegion(center=center, radius=0.1 * u.deg) nbin = 2 energy_axis_true = MapAxis.from_energy_bounds(".1 TeV", "10 TeV", nbin=nbin, name="energy_true") spectral_model = ConstantSpectralModel() spatial_model = PointSpatialModel(lon_0=0 * u.deg, lat_0=0 * u.deg, frame="galactic") models = SkyModel(spectral_model=spectral_model, spatial_model=spatial_model) model = Models(models) exposure_region = RegionNDMap.create(region, axes=[energy_axis_true], binsz_wcs="0.01deg") exposure_region.data += 1.0 exposure_region.unit = "m2 s" geom = RegionGeom(region, axes=[energy_axis_true], binsz_wcs="0.01deg") psf = PSFKernel.from_gauss(geom.to_wcs_geom(), sigma="0.1 deg") evaluator = MapEvaluator(model=model[0], exposure=exposure_region, psf=psf) flux = evaluator.compute_flux_spatial() g = Gauss2DPDF(0.1) reference = g.containment_fraction(0.1) assert_allclose(flux.value, reference, rtol=0.003)
def spatial_model(self): """Spatial model (`~gammapy.modeling.models.SpatialModel`).""" d = self.data ra = d["RAJ2000"] dec = d["DEJ2000"] if self.is_pointlike: model = PointSpatialModel(lon_0=ra, lat_0=dec, frame="icrs") else: de = self.data_extended morph_type = de["Model_Form"].strip() e = (1 - (de["Model_SemiMinor"] / de["Model_SemiMajor"]) ** 2.0) ** 0.5 sigma = de["Model_SemiMajor"] phi = de["Model_PosAng"] if morph_type in ["Disk", "Elliptical Disk"]: r_0 = de["Model_SemiMajor"] model = DiskSpatialModel( lon_0=ra, lat_0=dec, r_0=r_0, e=e, phi=phi, frame="icrs" ) elif morph_type in ["Map", "Ring", "2D Gaussian x2"]: filename = de["Spatial_Filename"].strip() path = make_path( "$GAMMAPY_DATA/catalogs/fermi/Extended_archive_v15/Templates/" ) return TemplateSpatialModel.read(path / filename) elif morph_type in ["2D Gaussian", "Elliptical 2D Gaussian"]: model = GaussianSpatialModel( lon_0=ra, lat_0=dec, sigma=sigma, e=e, phi=phi, frame="icrs" ) else: raise ValueError(f"Invalid spatial model: {morph_type!r}") self._set_spatial_errors(model) return model
def fit_start_model(self) -> Models: ra = self.source_pos_radec["ra"] dec = self.source_pos_radec["dec"] spatial_model_fit = PointSpatialModel(lon_0=ra, lat_0=dec) spatial_model_fit.lon_0.frozen = False spatial_model_fit.lat_0.frozen = False spatial_model_fit.lon_0.min = spatial_model_fit.lon_0.value - 0.1 spatial_model_fit.lon_0.max = spatial_model_fit.lon_0.value + 0.1 spatial_model_fit.lat_0.min = spatial_model_fit.lat_0.value - 0.1 spatial_model_fit.lat_0.max = spatial_model_fit.lat_0.value + 0.1 spectral_model_ecpl_fit = ExpCutoffPowerLawSpectralModel( index=2.0, amplitude="1.3e-12 cm-2 s-1 TeV-1", reference="1 TeV", lambda_="0.1 TeV-1", alpha=1.0) spectral_model_ecpl_fit.amplitude.min = 1e-17 spectral_model_ecpl_fit.amplitude.max = 1e-5 spectral_model_ecpl_fit.index.min = 0.0 spectral_model_ecpl_fit.index.max = 4.0 spectral_model_ecpl_fit.lambda_.min = -1.0 spectral_model_ecpl_fit.lambda_.max = 1.0 spectral_model_ecpl_fit.reference.frozen = True spectral_model_ecpl_fit.alpha.frozen = True spectral_model_ecpl_fit.lambda_.frozen = False return Models( SkyModel(spatial_model=spatial_model_fit, spectral_model=spectral_model_ecpl_fit, name="fitstartmodel"))
def true_model(self) -> SkyModel: def ecpl_model(amplitude): return ExpCutoffPowerLawSpectralModel(index=self.index_true, amplitude=amplitude / (u.cm**2 * u.s * u.TeV), reference=1 * u.TeV, lambda_=self.lambda_true, alpha=1.0) def flux_difference_at_reference(x): diff_norm = self.normalization_true.value flux = ecpl_model(x)(energy=1 * u.TeV) return flux.value - diff_norm amplitude = fsolve(flux_difference_at_reference, self.normalization_true.value)[0] spectral_model_sim = ExpCutoffPowerLawSpectralModel( index=self.index_true, amplitude=amplitude / (u.cm**2 * u.s * u.TeV), lambda_=self.lambda_true, reference=1 * u.TeV) ra = self.source_pos_radec["ra"] dec = self.source_pos_radec["dec"] spatial_model_sim = PointSpatialModel(lon_0=ra, lat_0=dec) return SkyModel(spatial_model=spatial_model_sim, spectral_model=spectral_model_sim, name="source")
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="all", 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.selection_optional = selection_optional 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 test_contributes_region_mask(): axis = MapAxis.from_edges(np.logspace(-1, 1, 3), unit=u.TeV, name="energy") geom = RegionGeom.create("galactic;circle(0, 0, 0.2)", axes=[axis], binsz_wcs="0.05 deg") mask = Map.from_geom(geom, unit="", dtype="bool") mask.data[...] = True spatial_model1 = GaussianSpatialModel(lon_0="0.2 deg", lat_0="0 deg", sigma="0.1 deg", frame="galactic") spatial_model2 = PointSpatialModel(lon_0="0.3 deg", lat_0="0.3 deg", frame="galactic") model1 = SkyModel( spatial_model=spatial_model1, spectral_model=PowerLawSpectralModel(), name="source-1", ) model2 = SkyModel( spatial_model=spatial_model2, spectral_model=PowerLawSpectralModel(), name="source-2", ) assert model1.contributes(mask, margin=0 * u.deg) assert not model2.contributes(mask, margin=0 * u.deg) assert model2.contributes(mask, margin=0.3 * u.deg)
def test_npred_psf_after_edisp(): energy_axis = MapAxis.from_energy_bounds("1 TeV", "10 TeV", nbin=3) energy_axis_true = MapAxis.from_energy_bounds( "0.8 TeV", "15 TeV", nbin=6, name="energy_true" ) geom = WcsGeom.create(width=4 * u.deg, binsz=0.02, axes=[energy_axis]) dataset = MapDataset.create(geom=geom, energy_axis_true=energy_axis_true) dataset.background.data += 1 dataset.exposure.data += 1e12 dataset.mask_safe.data += True dataset.psf = PSFMap.from_gauss( energy_axis_true=energy_axis_true, sigma=0.2 * u.deg ) model = SkyModel( spectral_model=PowerLawSpectralModel(), spatial_model=PointSpatialModel(), name="test-model", ) model.apply_irf["psf_after_edisp"] = True bkg_model = FoVBackgroundModel(dataset_name=dataset.name) dataset.models = [bkg_model, model] npred = dataset.npred() assert_allclose(npred.data.sum(), 129553.858658)
def data_prep(): data_store = DataStore.from_dir("$GAMMAPY_DATA/cta-1dc/index/gps/") OBS_ID = 110380 obs_ids = OBS_ID * np.ones(N_OBS) observations = data_store.get_observations(obs_ids) energy_axis = MapAxis.from_bounds(0.1, 10, nbin=10, unit="TeV", name="energy", interp="log") geom = WcsGeom.create( skydir=(0, 0), binsz=0.02, width=(10, 8), frame="galactic", proj="CAR", axes=[energy_axis], ) energy_axis_true = MapAxis.from_bounds(0.05, 20, nbin=30, unit="TeV", name="energy_true", interp="log") offset_max = 4 * u.deg maker = MapDatasetMaker() safe_mask_maker = SafeMaskMaker(methods=["offset-max"], offset_max=offset_max) stacked = MapDataset.create(geom=geom, energy_axis_true=energy_axis_true) spatial_model = PointSpatialModel(lon_0="-0.05 deg", lat_0="-0.05 deg", frame="galactic") spectral_model = ExpCutoffPowerLawSpectralModel( index=2, amplitude=3e-12 * u.Unit("cm-2 s-1 TeV-1"), reference=1.0 * u.TeV, lambda_=0.1 / u.TeV, ) model = SkyModel(spatial_model=spatial_model, spectral_model=spectral_model, name="gc-source") datasets = Datasets([]) for idx, obs in enumerate(observations): cutout = stacked.cutout(obs.pointing_radec, width=2 * offset_max, name=f"dataset{idx}") dataset = maker.run(cutout, obs) dataset = safe_mask_maker.run(dataset, obs) dataset.models = [model, FoVBackgroundModel(dataset_name=dataset.name)] datasets.append(dataset) return datasets
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.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) exclusion_region = CircleSkyRegion( center=SkyCoord(183.604, -8.708, unit="deg", frame="galactic"), radius=0.5 * u.deg, ) skydir = target_position.galactic exclusion_mask = Map.create( npix=(150, 150), binsz=0.05, skydir=skydir, proj="TAN", coordsys="GAL" ) mask = exclusion_mask.geom.region_mask([exclusion_region], inside=False) exclusion_mask.data = mask 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 dataset_maker = SpectrumDatasetMaker( region=on_region, e_reco=e_reco, e_true=e_true, containment_correction=True ) bkg_maker = ReflectedRegionsBackgroundMaker(exclusion_mask=exclusion_mask) safe_mask_masker = SafeMaskMaker(methods=["aeff-max"], aeff_percent=10) spectral_model = PowerLawSpectralModel( index=2, amplitude=2e-11 * u.Unit("cm-2 s-1 TeV-1"), reference=1 * u.TeV ) spatial_model = PointSpatialModel( lon_0=target_position.ra, lat_0=target_position.dec, frame="icrs" ) spatial_model.lon_0.frozen = True spatial_model.lat_0.frozen = True sky_model = SkyModel( spatial_model=spatial_model, spectral_model=spectral_model, name="" ) # Data preparation datasets = [] for ind, observation in enumerate(observations): dataset = dataset_maker.run(observation, selection=["counts", "aeff", "edisp"]) dataset_on_off = bkg_maker.run(dataset, observation) dataset_on_off = safe_mask_masker.run(dataset_on_off, observation) dataset_on_off.name = f"dataset{ind}" dataset_on_off.models = sky_model datasets.append(dataset_on_off) return Datasets(datasets)
def define_model_pointlike(model): spatial_model = PointSpatialModel(lon_0=model.spatial_model.lon_0, lat_0=model.spatial_model.lat_0, frame=model.spatial_model.frame) spectral_model = model.spectral_model.copy() sky_model = SkyModel(spatial_model=spatial_model, spectral_model=spectral_model, name=f"{model.name}_point") return sky_model
def fit_estimator(dataset): spatial_model = PointSpatialModel() spectral_model = PowerLawSpectralModel(index=2) model = SkyModel(spatial_model=spatial_model, spectral_model=spectral_model) estimator = TSMapEstimator(model, kernel_width="1 deg", energy_edges=[10, 30, 300] * u.GeV) images = estimator.run(dataset) return images
def __init__(self): """ This initializes a default GRB. Returns ------- None. """ self.name = 'dummy' self.z = 0 # GRB properties - Dummy default values self.radec = SkyCoord(100 * u.degree, -15 * u.degree, frame='icrs') self.Eiso = 0. * u.erg self.Epeak = 0. * u.keV self.t90 = 0. * u.s self.G0H = 0. * u.dimensionless_unscaled self.G0W = 0. * u.dimensionless_unscaled self.FluxPeak = 0. * u.erg self.gamma_le = 0. * u.dimensionless_unscaled self.gamma_he = 0. * u.dimensionless_unscaled # GRB detection positions self.site_keys = ["North", "South"] # Put it somewhere else ! self.site = {"North": 'Roque de los Muchachos', "South": 'Paranal'} # GRB alert received self.t_trig = Time('2000-01-01 02:00:00', scale='utc') # Afterglow Flux table - Flux at a series of points self.Eval = [0] * u.GeV self.tval = [0] * u.s self.fluxval = [0] * u.Unit("1 / (cm2 GeV s)") self.spec_afterglow = [] # Interpolated, non attenuated # Prompt energy spectrum self.prompt = False # Default : no prompt self.id90 = -1 self.E_prompt = [0] * u.GeV self.flux_prompt = [0] * u.Unit("1 / (cm2 GeV s)") self.spec_prompt = None # One Interpolated, non attenuated E-spectrum # Visibility (requires GRB points interval) self.vis = { "North": Visibility(self, "North"), "South": Visibility(self, "South") } # GRB cumulated attenuated spectra and spatial model self.spectra = [] # Gammapy models (one per t slice) self.spatial = PointSpatialModel(lon_0=0 * u.deg, lat_0=0 * u.deg) return
def define_model_3d(target_position): spatial_model = PointSpatialModel(lon_0=target_position.ra, lat_0=target_position.dec, frame="icrs") spectral_model = PowerLawSpectralModel( index=3.4, amplitude=2e-11 * u.Unit("1 / (cm2 s TeV)"), reference=1 * u.TeV, ) spectral_model.parameters["index"].frozen = False sky_model = SkyModel(spatial_model=spatial_model, spectral_model=spectral_model, name="pks2155") return sky_model
def test_spatial_model_plot(): model = PointSpatialModel() model.covariance = np.diag([0.01, 0.01]) with mpl_plot_check(): ax = model.plot() with mpl_plot_check(): model.plot_error(ax=ax)
def data_prep(): data_store = DataStore.from_dir("$GAMMAPY_DATA/cta-1dc/index/gps/") OBS_ID = 110380 obs_ids = OBS_ID * np.ones(N_OBS) observations = data_store.get_observations(obs_ids) energy_axis = MapAxis.from_bounds(0.1, 10, nbin=10, unit="TeV", name="energy", interp="log") geom = WcsGeom.create( skydir=(0, 0), binsz=0.02, width=(10, 8), coordsys="GAL", proj="CAR", axes=[energy_axis], ) src_pos = SkyCoord(0, 0, unit="deg", frame="galactic") offset_max = 4 * u.deg maker = MapDatasetMaker() safe_mask_maker = SafeMaskMaker(methods=["offset-max"], offset_max=offset_max) stacked = MapDataset.create(geom=geom) spatial_model = PointSpatialModel(lon_0="-0.05 deg", lat_0="-0.05 deg", frame="galactic") spectral_model = ExpCutoffPowerLawSpectralModel( index=2, amplitude=3e-12 * u.Unit("cm-2 s-1 TeV-1"), reference=1.0 * u.TeV, lambda_=0.1 / u.TeV, ) model = SkyModel(spatial_model=spatial_model, spectral_model=spectral_model, name="gc-source") datasets = [] for i, obs in enumerate(observations): dataset = maker.run(stacked, obs) dataset = safe_mask_maker.run(dataset, obs) dataset.models = model dataset.name = f"dataset{i}" datasets.append(dataset) return Datasets(datasets)
def spatial_model(self): """Spatial model (`~gammapy.modeling.models.SpatialModel`). One of the following models (given by ``Spatial_Model`` in the catalog): - ``Point-Like`` or has a size upper limit : `~gammapy.modeling.models.PointSpatialModel` - ``Gaussian``: `~gammapy.modeling.models.GaussianSpatialModel` - ``2-Gaussian`` or ``3-Gaussian``: composite model (using ``+`` with Gaussians) - ``Shell``: `~gammapy.modeling.models.ShellSpatialModel` """ d = self.data glon = d["GLON"] glat = d["GLAT"] spatial_type = self.spatial_model_type if self.is_pointlike: model = PointSpatialModel(lon_0=glon, lat_0=glat, frame="galactic") elif spatial_type == "gaussian": model = GaussianSpatialModel(lon_0=glon, lat_0=glat, sigma=d["Size"], frame="galactic") model.parameters.set_error(lon_0=d["GLON_Err"], lat_0=d["GLAT_Err"], sigma=d["Size_Err"]) elif spatial_type in {"2-gaussian", "3-gaussian"}: raise ValueError( "For Gaussian or Multi-Gaussian models, use sky_model()!") elif spatial_type == "shell": # HGPS contains no information on shell width # Here we assume a 5% shell width for all shells. r_out = d["Size"] radius = 0.95 * r_out width = r_out - radius model = ShellSpatialModel(lon_0=glon, lat_0=glat, width=width, radius=radius, frame="galactic") model.parameters.set_error(lon_0=d["GLON_Err"], lat_0=d["GLAT_Err"], radius=d["Size_Err"]) else: raise ValueError(f"Invalid spatial_type: {spatial_type}") return model
def data_prep(): data_store = DataStore.from_dir("$GAMMAPY_DATA/cta-1dc/index/gps/") OBS_ID = 110380 obs_ids = OBS_ID * np.ones(N_OBS) observations = data_store.get_observations(obs_ids) energy_axis = MapAxis.from_bounds(0.1, 10, nbin=10, unit="TeV", name="energy", interp="log") geom = WcsGeom.create( skydir=(0, 0), binsz=0.05, width=(10, 8), frame="galactic", proj="CAR", axes=[energy_axis], ) stacked = MapDataset.create(geom, name="stacked_ds") maker = MapDatasetMaker() safe_mask_maker = SafeMaskMaker(methods=["offset-max"], offset_max="4 deg") for obs in observations: dataset = maker.run(stacked, obs) dataset = safe_mask_maker.run(dataset, obs) stacked.stack(dataset) spatial_model = PointSpatialModel(lon_0="0.01 deg", lat_0="0.01 deg", frame="galactic") spectral_model = ExpCutoffPowerLawSpectralModel( index=2, amplitude=3e-12 * u.Unit("cm-2 s-1 TeV-1"), reference=1.0 * u.TeV, lambda_=0.1 / u.TeV, ) model = SkyModel(spatial_model=spatial_model, spectral_model=spectral_model, name="gc-source") stacked.models.append(model) return Datasets([stacked])
def spatial_model(self): """Source spatial model (`~gammapy.modeling.models.SpatialModel`). TODO: add parameter errors! """ d = self.data morph_type = d["morph_type"] glon = d["glon"] glat = d["glat"] if morph_type == "point": model = PointSpatialModel(lon_0=glon, lat_0=glat, frame="galactic") elif morph_type == "gauss": # TODO: add infos back once model support elongation # pars['x_stddev'] = d['morph_sigma'] # pars['y_stddev'] = d['morph_sigma'] # if not np.isnan(d['morph_sigma2']): # pars['y_stddev'] = d['morph_sigma2'] # if not np.isnan(d['morph_pa']): # # TODO: handle reference frame for rotation angle # pars['theta'] = Angle(d['morph_pa'], 'deg').rad model = GaussianSpatialModel( lon_0=glon, lat_0=glat, sigma=d["morph_sigma"], frame="galactic" ) elif morph_type == "shell": model = ShellSpatialModel( lon_0=glon, lat_0=glat, # TODO: probably we shouldn't guess a shell width here! radius=0.8 * d["morph_sigma"], width=0.2 * d["morph_sigma"], frame="galactic", ) elif morph_type == "none": return None else: raise ValueError(f"Invalid morph_type: {morph_type!r}") lat_err = self.data["pos_err"].to("deg") lon_err = self.data["pos_err"].to("deg") / np.cos(self.data["glat"].to("rad")) model.parameters.set_error(lon_0=lon_err, lat_0=lat_err) # TODO: check if pos_err is really 1sigma return model
def __init__( self, model=None, kernel_width=None, 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, ): if kernel_width is not None: kernel_width = Angle(kernel_width) self.kernel_width = 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 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 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(frame="galactic") model3.parameters.freeze_all() models = Models([model1, model2, model3] + backgrounds) return models
def data_fit(stacked): # Data fitting spatial_model = PointSpatialModel( lon_0="0.01 deg", lat_0="0.01 deg", frame="galactic" ) spectral_model = ExpCutoffPowerLawSpectralModel( index=2, amplitude=3e-12 * u.Unit("cm-2 s-1 TeV-1"), reference=1.0 * u.TeV, lambda_=0.1 / u.TeV, ) model = SkyModel( spatial_model=spatial_model, spectral_model=spectral_model, name="gc-source" ) stacked.model = model fit = Fit([stacked]) result = fit.run(optimize_opts={"print_level": 1})
def read(): datasets = [] spatial_model = PointSpatialModel(lon_0="-0.05 deg", lat_0="-0.05 deg", frame="galactic") spectral_model = ExpCutoffPowerLawSpectralModel( index=2, amplitude=3e-12 * u.Unit("cm-2 s-1 TeV-1"), reference=1.0 * u.TeV, lambda_=0.1 / u.TeV, ) model = SkyModel(spatial_model=spatial_model, spectral_model=spectral_model, name="gc-source") for ind in range(N_OBS): dataset = MapDataset.read(f"dataset-{ind}.fits") dataset.model = model datasets.append(dataset) return datasets
def spatial_model(self): """Source spatial model (`~gammapy.modeling.models.SpatialModel`). TODO: add parameter errors! """ d = self.data morph_type = d["morph_type"] glon = d["glon"] glat = d["glat"] if morph_type == "point": return PointSpatialModel(lon_0=glon, lat_0=glat, frame="galactic") elif morph_type == "gauss": # TODO: add infos back once model support elongation # pars['x_stddev'] = d['morph_sigma'] # pars['y_stddev'] = d['morph_sigma'] # if not np.isnan(d['morph_sigma2']): # pars['y_stddev'] = d['morph_sigma2'] # if not np.isnan(d['morph_pa']): # # TODO: handle reference frame for rotation angle # pars['theta'] = Angle(d['morph_pa'], 'deg').rad return GaussianSpatialModel(lon_0=glon, lat_0=glat, sigma=d["morph_sigma"], frame="galactic") elif morph_type == "shell": return ShellSpatialModel( lon_0=glon, lat_0=glat, # TODO: probably we shouldn't guess a shell width here! radius=0.8 * d["morph_sigma"], width=0.2 * d["morph_sigma"], frame="galactic", ) elif morph_type == "none": raise NoDataAvailableError( f"No spatial model available: {self.name}") else: raise NotImplementedError(f"Unknown spatial model: {morph_type!r}")