def to_wcs_nd_map(self, energy_axis_mode='center'): """Convert to a `gammapy.maps.WcsNDMap`. There is no copy of the ``data`` or ``wcs`` object, this conversion is cheap. This is meant to help migrate code using `SkyCube` over to the new maps classes. """ from gammapy.maps import WcsNDMap, WcsGeom, MapAxis if energy_axis_mode == 'center': energy = self.energies(mode='center') energy_axis = MapAxis.from_nodes(energy.value, unit=energy.unit) elif energy_axis_mode == 'edges': energy = self.energies(mode='edges') energy_axis = MapAxis.from_edges(energy.value, unit=energy.unit) else: raise ValueError('Invalid energy_axis_mode: {}'.format(energy_axis_mode)) # Axis order in SkyCube: energy, lat, lon npix = (self.data.shape[2], self.data.shape[1]) geom = WcsGeom(wcs=self.wcs, npix=npix, axes=[energy_axis]) # TODO: change maps and SkyCube to have a unit attribute # For now, SkyCube is a mix of numpy array and quantity in `data` # and we just strip the unit here data = np.asarray(self.data) # unit = getattr(self.data, 'unit', None) return WcsNDMap(geom=geom, data=data)
from astropy.coordinates import SkyCoord from astropy.io import fits from astropy.table import Table from regions import CircleSkyRegion, PointSkyRegion, RectangleSkyRegion from gammapy.datasets.map import MapEvaluator from gammapy.irf import EnergyDependentMultiGaussPSF, PSFKernel from gammapy.maps import Map, MapAxis, MapCoord, WcsGeom, WcsNDMap from gammapy.maps.utils import fill_poisson from gammapy.modeling.models import ( GaussianSpatialModel, PowerLawSpectralModel, SkyModel, ) from gammapy.utils.testing import mpl_plot_check, requires_data, requires_dependency axes1 = [MapAxis(np.logspace(0.0, 3.0, 3), interp="log", name="spam")] axes2 = [ MapAxis(np.logspace(0.0, 3.0, 3), interp="log"), MapAxis(np.logspace(1.0, 3.0, 4), interp="lin"), ] skydir = SkyCoord(110.0, 75.0, unit="deg", frame="icrs") wcs_allsky_test_geoms = [ (None, 10.0, "galactic", "AIT", skydir, None), (None, 10.0, "galactic", "AIT", skydir, axes1), (None, [10.0, 20.0], "galactic", "AIT", skydir, axes1), (None, 10.0, "galactic", "AIT", skydir, axes2), (None, [[10.0, 20.0, 30.0], [10.0, 20.0, 30.0]], "galactic", "AIT", skydir, axes2), ]
def make_all_models(): """Make an instance of each model, for testing.""" yield Model.create("ConstantSpatialModel", "spatial") map_constantmodel = Map.create(npix=(10, 20), unit="sr-1") yield Model.create("TemplateSpatialModel", "spatial", map=map_constantmodel) yield Model.create("DiskSpatialModel", "spatial", lon_0="1 deg", lat_0="2 deg", r_0="3 deg") yield Model.create("gauss", "spatial", lon_0="1 deg", lat_0="2 deg", sigma="3 deg") yield Model.create("PointSpatialModel", "spatial", lon_0="1 deg", lat_0="2 deg") yield Model.create( "ShellSpatialModel", "spatial", lon_0="1 deg", lat_0="2 deg", radius="3 deg", width="4 deg", ) yield Model.create("ConstantSpectralModel", "spectral", const="99 cm-2 s-1 TeV-1") yield Model.create( "CompoundSpectralModel", "spectral", model1=Model.create("PowerLawSpectralModel", "spectral"), model2=Model.create("PowerLawSpectralModel", "spectral"), operator=np.add, ) yield Model.create("PowerLawSpectralModel", "spectral") yield Model.create("PowerLawNormSpectralModel", "spectral") yield Model.create("PowerLaw2SpectralModel", "spectral") yield Model.create("ExpCutoffPowerLawSpectralModel", "spectral") yield Model.create("ExpCutoffPowerLawNormSpectralModel", "spectral") yield Model.create("ExpCutoffPowerLaw3FGLSpectralModel", "spectral") yield Model.create("SuperExpCutoffPowerLaw3FGLSpectralModel", "spectral") yield Model.create("SuperExpCutoffPowerLaw4FGLSpectralModel", "spectral") yield Model.create("LogParabolaSpectralModel", "spectral") yield Model.create("LogParabolaNormSpectralModel", "spectral") yield Model.create("TemplateSpectralModel", "spectral", energy=[1, 2] * u.cm, values=[3, 4] * u.cm) # TODO: add unit validation? yield Model.create( "PiecewiseNormSpectralModel", "spectral", energy=[1, 2] * u.cm, norms=[3, 4] * u.cm, ) yield Model.create("GaussianSpectralModel", "spectral") # TODO: yield Model.create("EBLAbsorptionNormSpectralModel") # TODO: yield Model.create("NaimaSpectralModel") # TODO: yield Model.create("ScaleSpectralModel") yield Model.create("ConstantTemporalModel", "temporal") yield Model.create("LinearTemporalModel", "temporal") yield Model.create("PowerLawTemporalModel", "temporal") yield Model.create("SineTemporalModel", "temporal") yield Model.create("LightCurveTemplateTemporalModel", "temporal", Table()) yield Model.create( "SkyModel", spatial_model=Model.create("ConstantSpatialModel", "spatial"), spectral_model=Model.create("PowerLawSpectralModel", "spectral"), ) m1 = Map.create(npix=(10, 20, 30), axes=[MapAxis.from_nodes([1, 2] * u.TeV, name="energy")]) yield Model.create("TemplateSpatialModel", "spatial", map=m1) m2 = Map.create(npix=(10, 20, 30), axes=[MapAxis.from_edges([1, 2] * u.TeV, name="energy")]) yield Model.create("TemplateNPredModel", map=m2)
"""Plot an energy dispersion using a gaussian parametrisation""" import matplotlib.pyplot as plt from gammapy.irf import EDispKernel from gammapy.maps import MapAxis energy_axis = MapAxis.from_energy_bounds("1 TeV", "10 TeV", nbin=10) energy_axis_true = MapAxis.from_energy_bounds( "0.5 TeV", "30 TeV", nbin=10, per_decade=True, name="energy_true" ) edisp = EDispKernel.from_gauss( energy_axis=energy_axis, energy_axis_true=energy_axis_true, sigma=0.1, bias=0 ) edisp.peek() plt.show()
# Or we can also retrieve the solid angle per pixel of the map: # In[ ]: wcs_geom.solid_angle() # ### 1.3 Adding Non-Spatial Axes # # In many analysis scenarios we would like to add extra dimension to the maps to study e.g. energy or time dependency of the data. Those non-spatial dimensions are handled with the `MapAxis` object. Let us first define an energy axis, with 4 bins: # In[ ]: energy_axis = MapAxis.from_bounds(1, 100, nbin=4, unit="TeV", name="energy", interp="log") print(energy_axis) # Where `interp='log'` specifies that a logarithmic spacing is used between the bins, equivalent to `np.logspace(0, 2, 4)`. This `MapAxis` object we can now pass to `Map.create()` using the `axes=` argument: # In[ ]: m_cube = Map.create(binsz=0.02, width=(10, 5), coordsys="GAL", axes=[energy_axis]) print(m_cube.geom) # Now we see that besides `lon` and `lat` the map has an additional axes named `energy` with 4 bins. The total dimension of the map is now `ndim=3`.
def simulate(): irfs = load_cta_irfs( "$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits" ) center = SkyCoord(0.0, 0.0, unit="deg", frame="galactic") energy_reco = MapAxis.from_edges(np.logspace(-1.0, 1.0, 10), unit="TeV", name="energy", interp="log") pointing = SkyCoord(0.5, 0.5, unit="deg", frame="galactic") geom = WcsGeom.create( skydir=center, binsz=0.02, width=(4, 4), frame="galactic", axes=[energy_reco], ) energy_true = MapAxis.from_edges(np.logspace(-1.5, 1.5, 30), unit="TeV", name="energy_true", interp="log") 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) spatial_model = GaussianSpatialModel(lon_0="0.2 deg", lat_0="0.1 deg", sigma="0.3 deg", frame="galactic") model_simu = SkyModel( spectral_model=spectral_model, spatial_model=spatial_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 = MapDataset.create(geom, name=f"dataset_{i}", energy_axis_true=energy_true) maker = MapDatasetMaker( selection=["exposure", "background", "psf", "edisp"]) maker_safe_mask = SafeMaskMaker(methods=["offset-max"], offset_max=4.0 * u.deg) dataset = maker.run(empty, obs) dataset = maker_safe_mask.run(dataset, obs) dataset.models = [ model_simu, FoVBackgroundModel(dataset_name=dataset.name) ] dataset.fake() datasets.append(dataset) tstart = tstart + 2.0 * u.hr return datasets
def test_wcsgeom_squash(): axis = MapAxis.from_nodes([1, 2, 3], name="test-axis") geom = WcsGeom.create(npix=(3, 3), axes=[axis]) geom_squashed = geom.squash(axis="test-axis") assert geom_squashed.data_shape == (1, 3, 3)
def spectrum_dataset_crab_fine(): e_true = MapAxis.from_edges(np.logspace(-2, 2.5, 109) * u.TeV, name="energy_true") e_reco = MapAxis.from_energy_edges(np.logspace(-2, 2, 73) * u.TeV) geom = RegionGeom.create("icrs;circle(83.63, 22.01, 0.11)", axes=[e_reco]) return SpectrumDataset.create(geom=geom, energy_axis_true=e_true)
def test_repr(region): axis = MapAxis.from_edges([1, 3.162278, 10] * u.TeV, name="energy", interp="log") geom = RegionGeom.create(region, axes=[axis]) assert "RegionGeom" in repr(geom) assert "CircleSkyRegion" in repr(geom)
def test_downsample(region): axis = MapAxis.from_edges([1, 3.162278, 10] * u.TeV, name="energy", interp="log") geom = RegionGeom.create(region, axes=[axis]) geom_down = geom.downsample(factor=2, axis_name="energy") assert_allclose(geom_down.axes[0].edges.value, [1.0, 10.0], rtol=1e-5)
def energy_axis(): return MapAxis.from_energy_bounds("1 TeV", "10 TeV", nbin=3)
def test_interp_to_geom(): energy = MapAxis.from_energy_bounds("1 TeV", "300 TeV", nbin=5, name="energy") energy_target = MapAxis.from_energy_bounds("1 TeV", "300 TeV", nbin=7, name="energy") value = 30 coords = { "skycoord": SkyCoord("0 deg", "0 deg"), "energy": energy_target.center[3] } # WcsNDMap geom_wcs = WcsGeom.create(npix=(5, 3), proj="CAR", binsz=60, axes=[energy], skydir=(0, 0)) wcs_map = Map.from_geom(geom_wcs, unit="") wcs_map.data = value * np.ones(wcs_map.data.shape) wcs_geom_target = WcsGeom.create(skydir=(0, 0), width=(10, 10), binsz=0.1 * u.deg, axes=[energy_target]) interp_wcs_map = wcs_map.interp_to_geom(wcs_geom_target, method="linear") assert_allclose(interp_wcs_map.get_by_coord(coords)[0], value, atol=1e-7) assert isinstance(interp_wcs_map, WcsNDMap) assert interp_wcs_map.geom == wcs_geom_target # HpxNDMap geom_hpx = HpxGeom.create(binsz=60, axes=[energy], skydir=(0, 0)) hpx_map = Map.from_geom(geom_hpx, unit="") hpx_map.data = value * np.ones(hpx_map.data.shape) hpx_geom_target = HpxGeom.create(skydir=(0, 0), width=10, binsz=0.1 * u.deg, axes=[energy_target]) interp_hpx_map = hpx_map.interp_to_geom(hpx_geom_target) assert_allclose(interp_hpx_map.get_by_coord(coords)[0], value, atol=1e-7) assert isinstance(interp_hpx_map, HpxNDMap) assert interp_hpx_map.geom == hpx_geom_target # Preserving the counts geom_initial = WcsGeom.create( skydir=(20, 20), width=(5, 5), binsz=0.2 * u.deg, ) test_map = Map.from_geom(geom_initial, unit="") test_map.data = value * np.ones(test_map.data.shape) geom_target = WcsGeom.create( skydir=(20, 20), width=(5, 5), binsz=0.1 * u.deg, ) new_map = test_map.interp_to_geom(geom_target, preserve_counts=True) assert np.floor(np.sum(new_map.data)) == np.sum(test_map.data)
# Licensed under a 3-clause BSD style license - see LICENSE.rst import pytest import numpy as np from numpy.testing import assert_allclose, assert_equal import astropy.units as u from astropy.coordinates import SkyCoord from astropy.units import Quantity, Unit from gammapy.maps import HpxGeom, HpxNDMap, Map, MapAxis, TimeMapAxis, WcsGeom, WcsNDMap from gammapy.utils.testing import mpl_plot_check, requires_dependency pytest.importorskip("healpy") map_axes = [ MapAxis.from_bounds(1.0, 10.0, 3, interp="log", name="energy"), MapAxis.from_bounds(0.1, 1.0, 4, interp="log", name="time"), ] mapbase_args = [ (0.1, 10.0, "wcs", SkyCoord(0.0, 30.0, unit="deg"), None, ""), (0.1, 10.0, "wcs", SkyCoord(0.0, 30.0, unit="deg"), map_axes[:1], ""), (0.1, 10.0, "wcs", SkyCoord(0.0, 30.0, unit="deg"), map_axes, "m^2"), (0.1, 10.0, "hpx", SkyCoord(0.0, 30.0, unit="deg"), None, ""), (0.1, 10.0, "hpx", SkyCoord(0.0, 30.0, unit="deg"), map_axes[:1], ""), (0.1, 10.0, "hpx", SkyCoord(0.0, 30.0, unit="deg"), map_axes, "s^2"), ] mapbase_args_with_axes = [_ for _ in mapbase_args if _[4] is not None] @pytest.mark.parametrize( ("binsz", "width", "map_type", "skydir", "axes", "unit"), mapbase_args)
l = 150.57 b = -13.26 target = SkyCoord(l, b, unit="deg", frame="galactic") offset = 1.0 * u.deg on_region_radius = Angle("1.0 deg") pointing = target.directional_offset_by(position_angle=0 * u.deg, separation=offset) on_region = CircleSkyRegion(center=target, radius=on_region_radius) # Energy axis in TeV emin = 30 / 1000 emax = 100 energy_axis = MapAxis.from_energy_bounds(emin, emax, 10, unit="TeV", name="energy") # Define spectral model JFAC = 3.03e18 * u.Unit("GeV2 cm-5") mDM = 10000 * u.Unit("GeV") channel = "b" redshift = 0.017284 spectral_model = DarkMatterAnnihilationSpectralModel(mass=mDM, channel=channel, jfactor=JFAC, z=redshift) # If want to consider EBL, uncomment following to lines and in the following change spectral_model->model_simu #absorption = EBLAbsorptionNormSpectralModel.read_builtin("dominguez", redshift=redshift)
def geom(ebounds, binsz=0.5): skydir = SkyCoord(0, -1, unit="deg", frame="galactic") energy_axis = MapAxis.from_edges(ebounds, name="energy", unit="TeV", interp="log") return WcsGeom.create( skydir=skydir, binsz=binsz, width=(10, 5), frame="galactic", axes=[energy_axis] )
def test_interpolate_map_dataset(): energy = MapAxis.from_energy_bounds("1 TeV", "300 TeV", nbin=5, name="energy") energy_true = MapAxis.from_nodes( np.logspace(-1, 3, 20), name="energy_true", interp="log", unit="TeV" ) # make dummy map IRFs geom_allsky = WcsGeom.create( npix=(5, 3), proj="CAR", binsz=60, axes=[energy], skydir=(0, 0) ) geom_allsky_true = geom_allsky.drop("energy").to_cube([energy_true]) # background geom_background = WcsGeom.create( skydir=(0, 0), width=(5, 5), binsz=0.2 * u.deg, axes=[energy] ) value = 30 bkg_map = Map.from_geom(geom_background, unit="") bkg_map.data = value * np.ones(bkg_map.data.shape) # effective area - with a gradient that also depends on energy aeff_map = Map.from_geom(geom_allsky_true, unit="cm2 s") ra_arr = np.arange(aeff_map.data.shape[1]) dec_arr = np.arange(aeff_map.data.shape[2]) for i in np.arange(aeff_map.data.shape[0]): aeff_map.data[i, :, :] = ( (i + 1) * 10 * np.meshgrid(dec_arr, ra_arr)[0] + 10 * np.meshgrid(dec_arr, ra_arr)[1] + 10 ) aeff_map.meta["TELESCOP"] = "HAWC" # psf map width = 0.2 * u.deg rad_axis = MapAxis.from_nodes(np.linspace(0, 2, 50), name="rad", unit="deg") psfMap = PSFMap.from_gauss(energy_true, rad_axis, width) # edispmap edispmap = EDispKernelMap.from_gauss( energy, energy_true, sigma=0.1, bias=0.0, geom=geom_allsky ) # events and gti nr_ev = 10 ev_t = Table() gti_t = Table() ev_t["EVENT_ID"] = np.arange(nr_ev) ev_t["TIME"] = nr_ev * [Time("2011-01-01 00:00:00", scale="utc", format="iso")] ev_t["RA"] = np.linspace(-1, 1, nr_ev) * u.deg ev_t["DEC"] = np.linspace(-1, 1, nr_ev) * u.deg ev_t["ENERGY"] = np.logspace(0, 2, nr_ev) * u.TeV gti_t["START"] = [Time("2010-12-31 00:00:00", scale="utc", format="iso")] gti_t["STOP"] = [Time("2011-01-02 00:00:00", scale="utc", format="iso")] events = EventList(ev_t) gti = GTI(gti_t) # define observation obs = Observation( obs_id=0, obs_info={}, gti=gti, aeff=aeff_map, edisp=edispmap, psf=psfMap, bkg=bkg_map, events=events, obs_filter=None, ) # define analysis geometry geom_target = WcsGeom.create( skydir=(0, 0), width=(5, 5), binsz=0.1 * u.deg, axes=[energy] ) maker = MapDatasetMaker( selection=["exposure", "counts", "background", "edisp", "psf"] ) dataset = MapDataset.create( geom=geom_target, energy_axis_true=energy_true, name="test" ) dataset = maker.run(dataset, obs) # test counts assert dataset.counts.data.sum() == nr_ev # test background assert np.floor(np.sum(dataset.npred_background().data)) == np.sum(bkg_map.data) coords_bg = {"skycoord": SkyCoord("0 deg", "0 deg"), "energy": energy.center[0]} assert_allclose( dataset.npred_background().get_by_coord(coords_bg)[0], 7.5, atol=1e-4 ) # test effective area coords_aeff = { "skycoord": SkyCoord("0 deg", "0 deg"), "energy_true": energy_true.center[0], } assert_allclose( aeff_map.get_by_coord(coords_aeff)[0], dataset.exposure.interp_by_coord(coords_aeff)[0], atol=1e-3, ) # test edispmap pdfmatrix_preinterp = edispmap.get_edisp_kernel( SkyCoord("0 deg", "0 deg") ).pdf_matrix pdfmatrix_postinterp = dataset.edisp.get_edisp_kernel( SkyCoord("0 deg", "0 deg") ).pdf_matrix assert_allclose(pdfmatrix_preinterp, pdfmatrix_postinterp, atol=1e-7) # test psfmap geom_psf = geom_target.drop("energy").to_cube([energy_true]) psfkernel_preinterp = psfMap.get_psf_kernel( SkyCoord("0 deg", "0 deg"), geom_psf, max_radius=2 * u.deg ).data psfkernel_postinterp = dataset.psf.get_psf_kernel( SkyCoord("0 deg", "0 deg"), geom_psf, max_radius=2 * u.deg ).data assert_allclose(psfkernel_preinterp, psfkernel_postinterp, atol=1e-4)
def spectrum_dataset_gc(): e_reco = MapAxis.from_edges(np.logspace(0, 2, 5) * u.TeV, name="energy") e_true = MapAxis.from_edges(np.logspace(-1, 2, 13) * u.TeV, name="energy_true") geom = RegionGeom.create("galactic;circle(0, 0, 0.11)", axes=[e_reco]) return SpectrumDataset.create(geom=geom, energy_axis_true=e_true)
def test_axis(): return MapAxis.from_nodes([1,2], unit="", name="test")
# Licensed under a 3-clause BSD style license - see LICENSE.rst import pytest import numpy as np from numpy.testing import assert_allclose import astropy.units as u from astropy.coordinates import Angle, SkyCoord from astropy.io import fits from gammapy.maps import Map, MapAxis, WcsGeom from gammapy.maps.wcs import _check_width axes1 = [MapAxis(np.logspace(0.0, 3.0, 3), interp="log", name="energy")] axes2 = [ MapAxis(np.logspace(0.0, 3.0, 3), interp="log", name="energy"), MapAxis(np.logspace(1.0, 3.0, 4), interp="lin"), ] skydir = SkyCoord(110.0, 75.0, unit="deg", frame="icrs") wcs_allsky_test_geoms = [ (None, 10.0, "galactic", "AIT", skydir, None), (None, 10.0, "galactic", "AIT", skydir, axes1), (None, [10.0, 20.0], "galactic", "AIT", skydir, axes1), (None, 10.0, "galactic", "AIT", skydir, axes2), (None, [[10.0, 20.0, 30.0], [10.0, 20.0, 30.0]], "galactic", "AIT", skydir, axes2), ] wcs_partialsky_test_geoms = [ (10, 0.1, "galactic", "AIT", skydir, None), (10, 0.1, "galactic", "AIT", skydir, axes1), (10, [0.1, 0.2], "galactic", "AIT", skydir, axes1), ]
def test_wcs_geom_pad(): axis = MapAxis.from_bounds(0, 1, nbin=1, name="axis", unit="") geom = WcsGeom.create(skydir=(0, 0), npix=10, binsz=0.1, axes=[axis]) geom_pad = geom.pad(axis_name="axis", pad_width=1) assert_allclose(geom_pad.axes["axis"].edges, [-1, 0, 1, 2])
def test_get_axis_index_by_name(): e_axis = MapAxis.from_edges([1, 5], name="energy") geom = WcsGeom.create(width=5, binsz=1.0, axes=[e_axis]) assert geom.get_axis_index_by_name("Energy") == 0 with pytest.raises(ValueError): geom.get_axis_index_by_name("time")
selected_obs_table = data_store.obs_table.select_observations(selection) # We can now retrieve the relevant observations by passing their `obs_id` to the`~gammapy.data.DataStore.get_observations()` method. # In[ ]: observations = data_store.get_observations(selected_obs_table["OBS_ID"]) # ## Preparing reduced datasets geometry # # Now we define a reference geometry for our analysis, We choose a WCS based geometry with a binsize of 0.02 deg and also define an energy axis: # In[ ]: energy_axis = MapAxis.from_edges(np.logspace(0.0, 1.0, 4), unit="TeV", name="energy", interp="log") geom = WcsGeom.create( skydir=(83.633, 22.014), binsz=0.02, width=(2, 2), coordsys="CEL", proj="CAR", axes=[energy_axis], ) # Reduced IRFs are defined in true energy (i.e. not measured energy). energy_axis_true = MapAxis.from_edges(np.logspace(-0.3, 1.3, 10), unit="TeV", name="energy", interp="log")
"disk-pwlsimple", "point-pwltest" ] DPI = 120 # observation config IRF_FILE = "$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits" #IRF_FILE = "$GAMMAPY_DATA/cta-prod3b/caldb/data/cta/prod3b-v2/bcf/South_z20_50h/irf_file.fits" POINTING = SkyCoord(0.0, 0.5, frame="galactic", unit="deg") LIVETIME = 1 * u.hr GTI_TABLE = GTI.create(start=0 * u.s, stop=LIVETIME.to(u.s)) # dataset config ENERGY_AXIS = MapAxis.from_energy_bounds("0.1 TeV", "100 TeV", nbin=10, per_decade=True) ENERGY_AXIS_TRUE = MapAxis.from_energy_bounds("0.03 TeV", "300 TeV", nbin=20, per_decade=True) MIGRA_AXIS = MapAxis.from_bounds(0.5, 2, nbin=150, node_type="edges", name="migra") WCS_GEOM = WcsGeom.create(skydir=POINTING, width=(4, 4), binsz=0.02, frame="galactic",
E_ref = 1e6 #MeV Ecut = 19e6 # cutoff in MeV ### interpolate the function of index, fluxes and normalizations d = np.linspace(0.0,1.55,100) ### Position of the pulsar ra_0_psr = 276.554417 dec_0_psr = -13.580028 position_psr = SkyCoord(ra_0_psr, dec_0_psr, frame='icrs', unit='deg') ### Position of the map center position = SkyCoord(276.4, -13.966667, frame='icrs', unit='deg') ### Energy axes and size energy_axis = MapAxis.from_bounds(0.2e5, 250e6, 40, interp='log', name='energy', unit='MeV') enlarger = 1.2 r_0 = rad_interpolate(energy_axis.center) * u.deg * enlarger r_0 = np.where(r_0>=0, r_0, 0) * u.deg ### Fill the index and normalization at the positions of the pixels binsize=0.02 eccentricity = 0.69 ang = 45. width = 3. m_wcs = WcsGeom.create(binsz=binsize, coordsys="CEL", skydir=position_psr, width=width*u.deg, axes=[energy_axis])
# In[ ]: obs_cols = ["OBS_ID", "GLON_PNT", "GLAT_PNT", "LIVETIME"] data_store.obs_table.select_obs_id(obs_id)[obs_cols] # ## Make sky images # # ### Define map geometry # # Select the target position and define an ON region for the spectral analysis # In[ ]: axis = MapAxis.from_edges(np.logspace(-1.0, 1.0, 10), unit="TeV", name="energy", interp="log") geom = WcsGeom.create(skydir=(0, 0), npix=(500, 400), binsz=0.02, coordsys="GAL", axes=[axis]) geom # ### Compute images # # Exclusion mask currently unused. Remove here or move to later in the tutorial? # In[ ]: target_position = SkyCoord(0, 0, unit="deg", frame="galactic")
spectral_model_1 = PowerLaw( index=3, amplitude="1e-11 cm-2 s-1 TeV-1", reference="1 TeV" ) spectral_model_2 = PowerLaw( index=3, amplitude="1e-11 cm-2 s-1 TeV-1", reference="1 TeV" ) sky_model_1 = SkyModel(spatial_model=spatial_model_1, spectral_model=spectral_model_1) sky_model_2 = SkyModel(spatial_model=spatial_model_2, spectral_model=spectral_model_2) models = sky_model_1 + sky_model_2 # Define map geometry axis = MapAxis.from_edges(np.logspace(-1.0, 1.0, 10), unit="TeV") geom = WcsGeom.create( skydir=(0, 0), binsz=0.02, width=(2, 2), coordsys="GAL", axes=[axis] ) # Define some observation parameters # we are not simulating many pointings / observations pointing = SkyCoord(0.2, 0.5, unit="deg", frame="galactic") livetime = 20 * u.hour exposure_map = make_map_exposure_true_energy( pointing=pointing, livetime=livetime, aeff=aeff, geom=geom ) evaluator = MapEvaluator(model=models, exposure=exposure_map)
import pytest import numpy as np from numpy.testing import assert_allclose from astropy import units as u from astropy.coordinates import SkyCoord from astropy.io import fits from regions import CircleSkyRegion from gammapy.maps import HpxGeom, HpxMap, HpxNDMap, Map, MapAxis, WcsGeom from gammapy.utils.testing import mpl_plot_check, requires_data, requires_dependency from gammapy.maps.utils import find_bintable_hdu from gammapy.maps.hpx import HpxConv from gammapy.irf import PSFKernel, PSFMap pytest.importorskip("healpy") axes1 = [MapAxis(np.logspace(0.0, 3.0, 3), interp="log")] hpx_test_allsky_geoms = [ (8, False, "galactic", None, None), (8, False, "galactic", None, axes1), ([4, 8], False, "galactic", None, axes1), ] hpx_test_partialsky_geoms = [ ([4, 8], False, "galactic", "DISK(110.,75.,30.)", axes1), (8, False, "galactic", "DISK(110.,75.,10.)", [MapAxis(np.logspace(0.0, 3.0, 4))]), ( 8, False, "galactic",
"pars", [ { "energy": None, "rad": None, "energy_shape": 32, "psf_energy": 0.8659643, "rad_shape": 144, "psf_rad": 0.0015362848, "psf_exposure": 3.14711e12, "psf_value_shape": (32, 144), "psf_value": 4369.96391, }, { "energy": MapAxis.from_energy_bounds(1, 10, 100, "TeV", name="energy_true"), "rad": None, "energy_shape": 100, "psf_energy": 1.428893959, "rad_shape": 144, "psf_rad": 0.0015362848, "psf_exposure": 4.723409e12, "psf_value_shape": (100, 144), "psf_value": 3714.303683,
def plot_ts_profiles( self, ax=None, sed_type="dnde", add_cbar=True, **kwargs, ): """Plot fit statistic SED profiles as a density plot. Parameters ---------- ax : `~matplotlib.axes.Axes` Axis object to plot on. sed_type : {"dnde", "flux", "eflux", "e2dnde"} Sed type add_cbar : bool Whether to add a colorbar to the plot. **kwargs : dict Keyword arguments passed to `~matplotlib.pyplot.pcolormesh` Returns ------- ax : `~matplotlib.axes.Axes` Axis object """ import matplotlib.pyplot as plt if ax is None: ax = plt.gca() if not self.norm.geom.is_region: raise ValueError( "Plotting only supported for region based flux points") if not self.geom.axes.is_unidimensional: raise ValueError( "Profile plotting is only supported for unidimensional maps") axis = self.geom.axes.primary_axis if isinstance(axis, TimeMapAxis) and not axis.is_contiguous: axis = axis.to_contiguous() yunits = kwargs.pop("yunits", DEFAULT_UNIT[sed_type]) flux_ref = getattr(self, sed_type + "_ref").to(yunits) ts = self.ts_scan norm_min, norm_max = ts.geom.axes["norm"].bounds.to_value("") flux = MapAxis.from_bounds(norm_min * flux_ref.value.min(), norm_max * flux_ref.value.max(), nbin=500, interp=axis.interp, unit=flux_ref.unit) norm = flux.center / flux_ref.reshape((-1, 1)) coords = ts.geom.get_coord() coords["norm"] = norm coords[axis.name] = axis.center.reshape((-1, 1)) z = ts.interp_by_coord(coords, values_scale="stat-profile") kwargs.setdefault("vmax", 0) kwargs.setdefault("vmin", -4) kwargs.setdefault("zorder", 0) kwargs.setdefault("cmap", "Blues") kwargs.setdefault("linewidths", 0) kwargs.setdefault("shading", "auto") # clipped values are set to NaN so that they appear white on the plot z[-z < kwargs["vmin"]] = np.nan with quantity_support(): caxes = ax.pcolormesh(axis.as_plot_edges, flux.edges, -z.T, **kwargs) axis.format_plot_xaxis(ax=ax) ax.set_ylabel(f"{sed_type} ({ax.yaxis.units})") ax.set_yscale("log") if add_cbar: label = "Fit statistic difference" ax.figure.colorbar(caxes, ax=ax, label=label) return ax
def geom(): axis = MapAxis.from_edges(np.logspace(-1, 1, 3), unit=u.TeV, name="energy") return WcsGeom.create(skydir=(0, 0), npix=(5, 4), frame="galactic", axes=[axis])
def test_plot_grid(): axis = MapAxis([0, 1, 2], node_type="edges") m = WcsNDMap.create(binsz=0.1 * u.deg, width=1 * u.deg, axes=[axis]) with mpl_plot_check(): m.plot_grid()
reference="1 TeV") spectral_model_2 = PowerLaw(index=3, amplitude="1e-11 cm-2 s-1 TeV-1", reference="1 TeV") sky_model_1 = SkyModel(spatial_model=spatial_model_1, spectral_model=spectral_model_1) sky_model_2 = SkyModel(spatial_model=spatial_model_2, spectral_model=spectral_model_2) models = sky_model_1 + sky_model_2 # Define map geometry axis = MapAxis.from_edges(np.logspace(-1.0, 1.0, 10), unit="TeV") geom = WcsGeom.create(skydir=(0, 0), binsz=0.02, width=(2, 2), coordsys="GAL", axes=[axis]) # Define some observation parameters # we are not simulating many pointings / observations pointing = SkyCoord(0.2, 0.5, unit="deg", frame="galactic") livetime = 20 * u.hour exposure_map = make_map_exposure_true_energy(pointing=pointing, livetime=livetime, aeff=aeff, geom=geom)