RegionNDMap#

class gammapy.maps.RegionNDMap(geom, data=None, dtype='float32', meta=None, unit='')[source]#

Bases: gammapy.maps.core.Map

N-dimensional region map. A RegionNDMap owns a RegionGeom instance as well as a data array containing the values associated to that region in the sky along the non-spatial axis, usually an energy axis. The spatial dimensions of a RegionNDMap are reduced to a single spatial bin with an arbitrary shape, and any extra dimensions are described by an arbitrary number of non-spatial axes.

Parameters

geomRegionGeom: Region geometry object.
datandarray: Data array. If none then an empty array will be allocated.
dtypestr, optional: Data type, default is float32
metadict: Dictionary to store meta data.
unitstr or Unit: The map unit

Attributes Summary

`data`	Data array (`ndarray`)
`geom`	Map geometry (`Geom`)
`is_mask`	Whether map is mask with bool dtype
`meta`	Map meta (`dict`)
`quantity`	Map data times unit (`Quantity`)
`tag`
`unit`	Map unit (`Unit`)

Methods Summary

`apply_edisp`(edisp)	Deprecated since version v1.1.
`coadd`(map_in[, weights])	Add the contents of `map_in` to this map.
`copy`(**kwargs)	Copy map instance and overwrite given attributes, except for geometry.
`create`(region[, axes, dtype, meta, unit, ...])	Create an empty region map object.
`crop`()	Crop the spatial dimensions of the map.
`cumsum`(axis_name)	Compute cumulative sum along a given axis
`cutout`(args, *kwargs)	Return self
`dot`(other)	Apply dot product with the input map.
`downsample`(factor[, preserve_counts, ...])	Downsample the non-spatial dimension by a given factor.
`fill_by_coord`(coords[, weights])	Fill pixels at `coords` with given `weights`.
`fill_by_idx`(idx[, weights])	Fill pixels at `idx` with given `weights`.
`fill_by_pix`(pix[, weights])	Fill pixels at `pix` with given `weights`.
`fill_events`(events[, weights])	Fill event coordinates (`EventList`).
`from_geom`(geom[, meta, data, unit, dtype])	Generate an empty map from a `Geom` instance.
`from_hdulist`(hdulist[, format, ogip_column, hdu])	Create from `HDUList`.
`from_stack`(maps[, axis, axis_name])	Create Map from list of images and a non-spatial axis.
`from_table`(table[, format, colname])	Create region map from table
`get_by_coord`(coords[, fill_value])	Return map values at the given map coordinates.
`get_by_idx`(idxs)	Return map values at the given pixel indices.
`get_by_pix`(pix[, fill_value])	Return map values at the given pixel coordinates.
`get_image_by_coord`(coords)	Return spatial map at the given axis coordinates.
`get_image_by_idx`(idx)	Return spatial map at the given axis pixel indices.
`get_image_by_pix`(pix)	Return spatial map at the given axis pixel coordinates
`get_spectrum`(args, *kwargs)	Return self
`integral`(axis_name, coords, **kwargs)	Compute integral along a given axis
`interp_by_coord`(coords, **kwargs)	Interpolate map values at the given map coordinates.
`interp_by_pix`(pix, **kwargs)	Interpolate map values at the given pixel coordinates.
`interp_to_geom`(geom[, preserve_counts, ...])	Interpolate map to input geometry.
`is_allclose`(other[, rtol_axes, atol_axes])	Compare two Maps for close equivalency
`iter_by_axis`(axis_name[, keepdims])	"Iterate over a given axis
`iter_by_axis_data`(axis_name)	Iterate data by axis
`iter_by_image`([keepdims])	Iterate over image planes of a map.
`iter_by_image_data`()	Iterate over image planes of the map.
`mask_nearest_position`(position)	Given a sky coordinate return nearest valid position in the mask
`normalize`([axis_name])	Normalise data in place along a given axis.
`pad`(pad_width[, axis_name, mode, cval, method])	Pad the spatial dimensions of the map.
`plot`([ax, axis_name])	Plot the data contained in region map along the non-spatial axis.
`plot_grid`([figsize, ncols])	Plot map as a grid of subplots for non-spatial axes
`plot_hist`([ax])	Plot as histogram.
`plot_interactive`()	Plot map with interactive widgets to explore the non spatial axes.
`plot_mask`([ax])	Plot the mask as a shaded area in a xmin-xmax range
`plot_region`([ax])	Plot region
`read`(filename[, format, ogip_column, hdu])	Read from file.
`reduce`(axis_name[, func, keepdims, weights])	Reduce map over a single non-spatial axis
`reduce_over_axes`([func, keepdims, ...])	Reduce map over non-spatial axes
`rename_axes`(names, new_names)	Rename the Map axes.
`reorder_axes`(axes_names)	Return a new map re-ordering the non-spatial axes order.
`reproject_to_geom`(geom[, preserve_counts, ...])	Reproject map to input geometry.
`resample`(geom[, weights, preserve_counts])	Resample pixels to `geom` with given `weights`.
`resample_axis`(axis[, weights, ufunc])	Resample map to a new axis by grouping and reducing smaller bins by a given ufunc
`sample_coord`(n_events[, random_state])	Sample position and energy of events.
`set_by_coord`(coords, vals)	Set pixels at `coords` with given `vals`.
`set_by_idx`(idx, value)	Set pixels at `idx` with given `vals`.
`set_by_pix`(pix, vals)	Set pixels at `pix` with given `vals`.
`slice_by_idx`(slices)	Slice sub map from map object.
`split_by_axis`(axis_name)	Split a Map along an axis into multiple maps.
`stack`(other[, weights, nan_to_num])	Stack other region map into map.
`sum_over_axes`([axes_names, keepdims, weights])	To sum map values over all non-spatial axes.
`to_cube`(axes)	Append non-spatial axes to create a higher-dimensional Map.
`to_hdulist`([format, hdu, hdu_bands, hdu_region])	Convert to `HDUList`.
`to_region_nd_map`(args, *kwargs)
`to_table`([format])	Convert to `Table`.
`to_unit`(unit)	Convert map to different unit
`upsample`(factor[, order, preserve_counts, ...])	Upsample the non-spatial dimension by a given factor.
`write`(filename[, overwrite, format, hdu])	Write map to file

Attributes Documentation

data#: Data array (ndarray)

geom#: Map geometry (Geom)

is_mask#: Whether map is mask with bool dtype

meta#: Map meta (dict)

quantity#: Map data times unit (Quantity)

tag = 'map'#

unit#: Map unit (Unit)

Methods Documentation

apply_edisp(edisp)#

Deprecated since version v1.1: The apply_edisp function is deprecated and may be removed in a future version. Use gammapy.datasets.apply_edisp instead.

Apply energy dispersion to map. Requires energy axis.

Parameters

edispgammapy.irf.EDispKernel: Energy dispersion matrix

Returns

mapWcsNDMap: Map with energy dispersion applied.

coadd(map_in, weights=None)#

Add the contents of map_in to this map.

This method can be used to combine maps containing integral quantities (e.g. counts) or differential quantities if the maps have the same binning.

Parameters

map_inMap: Input map.
weights: `Map` or `~numpy.ndarray`: The weight factors while adding

copy(**kwargs)#

Copy map instance and overwrite given attributes, except for geometry.

Parameters

**kwargsdict: Keyword arguments to overwrite in the map constructor.

Returns

copyMap: Copied Map.

classmethod create(region, axes=None, dtype='float32', meta=None, unit='', wcs=None, binsz_wcs='0.1deg', data=None)[source]#

Create an empty region map object.

Parameters

regionstr or SkyRegion: Region specification
axeslist of MapAxis: Non spatial axes.
dtypestr: Data type, default is ‘float32’
unitstr or Unit: Data unit.
metadict: Dictionary to store meta data.
wcsWCS: WCS projection to use for local projections of the region
binsz_wcs: `~astropy.units.Quantity` or str: Bin size used for the default WCS, if wcs=None.
datandarray: Data array

Returns

mapRegionNDMap: Region map

crop()[source]#

Crop the spatial dimensions of the map.

Parameters

crop_width{sequence, array_like, int}: Number of pixels cropped from the edges of each axis. Defined analogously to pad_with from numpy.pad.

Returns

mapMap: Cropped map.

cumsum(axis_name)#

Compute cumulative sum along a given axis

Parameters

axis_namestr: Along which axis to integrate.

Returns

cumsumMap: Map with cumulative sum

cutout(*args, **kwargs)[source]#: Return self

dot(other)#

Apply dot product with the input map.

The input Map has to share a single MapAxis with the current Map. Because it has no spatial dimension, it must be a RegionNDMap.

Parameters

otherRegionNDMap: Map to apply the dot product to. It must share a unique non-spatial MapAxis with the current Map.

Returns

mapMap: Map with dot product applied.

downsample(factor, preserve_counts=True, axis_name=None, weights=None)[source]#

Downsample the non-spatial dimension by a given factor.

By default the first axes is downsampled.

Parameters

factorint: Downsampling factor.
preserve_countsbool: Preserve the integral over each bin. This should be true if the map is an integral quantity (e.g. counts) and false if the map is a differential quantity (e.g. intensity).
axis_namestr: Which axis to downsample. Default is “energy”.
weightsRegionNDMap: Contains the weights to apply to the axis to reduce. Default is just weighs of one.

Returns

mapRegionNDMap: Downsampled region map.

fill_by_coord(coords, weights=None)#

Fill pixels at coords with given weights.

Parameters

coordstuple or MapCoord: Coordinate arrays for each dimension of the map. Tuple should be ordered as (lon, lat, x_0, …, x_n) where x_i are coordinates for non-spatial dimensions of the map.
weightsndarray: Weights vector. Default is weight of one.

fill_by_idx(idx, weights=None)[source]#

Fill pixels at idx with given weights.

Parameters

idxtuple: Tuple of pixel index arrays for each dimension of the map. Tuple should be ordered as (I_lon, I_lat, I_0, …, I_n) for WCS maps and (I_hpx, I_0, …, I_n) for HEALPix maps.
weightsndarray: Weights vector. Default is weight of one.

fill_by_pix(pix, weights=None)#

Fill pixels at pix with given weights.

Parameters

pixtuple: Tuple of pixel index arrays for each dimension of the map. Tuple should be ordered as (I_lon, I_lat, I_0, …, I_n) for WCS maps and (I_hpx, I_0, …, I_n) for HEALPix maps. Pixel indices can be either float or integer type. Float indices will be rounded to the nearest integer.
weightsndarray: Weights vector. Default is weight of one.

fill_events(events, weights=None)#

Fill event coordinates (EventList).

Parameters

eventsEventList: Events to be fill in the map.
weightsndarray: Weights vector. Default is weight of one. The weights vector must be of the same length as the events column length.

static from_geom(geom, meta=None, data=None, unit='', dtype='float32')#

Generate an empty map from a Geom instance.

Parameters

geomGeom: Map geometry.
datanumpy.ndarray: data array
metadict: Dictionary to store meta data.
unitstr or Unit: Data unit.

Returns

map_outMap: Map object

classmethod from_hdulist(hdulist, format='gadf', ogip_column=None, hdu=None, **kwargs)[source]#

Create from HDUList.

Parameters

hdulistHDUList: HDU list.
format{“gadf”, “ogip”, “ogip-arf”}: Format specification
ogip_column{“COUNTS”, “QUALITY”, “BACKSCAL”}: If format ‘ogip’ is chosen which table hdu column to read.
hdustr: Name or index of the HDU with the map data.

Returns

region_nd_mapRegionNDMap: Region map.

classmethod from_stack(maps, axis=None, axis_name=None)#

Create Map from list of images and a non-spatial axis.

The image geometries must be aligned, except for the axis that is stacked.

Parameters

mapslist of Map objects: List of maps
axisMapAxis: If a MapAxis is provided the maps are stacked along the last data axis and the new axis is introduced.
axis_namestr: If an axis name is as string the given the maps are stacked along the given axis name.

Returns

mapMap: Map with additional non-spatial axis.

classmethod from_table(table, format='', colname=None)[source]#

Create region map from table

Parameters

tableTable: Table with input data
format{“gadf-sed”, “lightcurve”, “profile”}: Format to use
colnamestr: Column name to take the data from.

Returns

region_mapRegionNDMap: Region map

get_by_coord(coords, fill_value=nan)#

Return map values at the given map coordinates.

Parameters

coordstuple or MapCoord: Coordinate arrays for each dimension of the map. Tuple should be ordered as (lon, lat, x_0, …, x_n) where x_i are coordinates for non-spatial dimensions of the map.
fill_valuefloat: Value which is returned if the position is outside of the projection footprint

Returns

valsndarray: Values of pixels in the map. np.nan used to flag coords outside of map.

get_by_idx(idxs)[source]#

Return map values at the given pixel indices.

Parameters

idxtuple: Tuple of pixel index arrays for each dimension of the map. Tuple should be ordered as (I_lon, I_lat, I_0, …, I_n) for WCS maps and (I_hpx, I_0, …, I_n) for HEALPix maps.

Returns

valsndarray: Array of pixel values. np.nan used to flag coordinate outside of map

get_by_pix(pix, fill_value=nan)#

Return map values at the given pixel coordinates.

Parameters

pixtuple: Tuple of pixel index arrays for each dimension of the map. Tuple should be ordered as (I_lon, I_lat, I_0, …, I_n) for WCS maps and (I_hpx, I_0, …, I_n) for HEALPix maps. Pixel indices can be either float or integer type.
fill_valuefloat: Value which is returned if the position is outside of the projection footprint

Returns

valsndarray: Array of pixel values. np.nan used to flag coordinates outside of map

get_image_by_coord(coords)#

Return spatial map at the given axis coordinates.

Parameters

coordstuple or dict: Tuple should be ordered as (x_0, …, x_n) where x_i are coordinates for non-spatial dimensions of the map. Dict should specify the axis names of the non-spatial axes such as {‘axes0’: x_0, …, ‘axesn’: x_n}.

Returns

map_outMap: Map with spatial dimensions only.

See also

get_image_by_idx, get_image_by_pix

Examples

import numpy as np
from gammapy.maps import Map, MapAxis
from astropy.coordinates import SkyCoord
from astropy import units as u

# Define map axes
energy_axis = MapAxis.from_edges(
    np.logspace(-1., 1., 4), unit='TeV', name='energy',
)

time_axis = MapAxis.from_edges(
    np.linspace(0., 10, 20), unit='h', name='time',
)

# Define map center
skydir = SkyCoord(0, 0, frame='galactic', unit='deg')

# Create map
m_wcs = Map.create(
    map_type='wcs',
    binsz=0.02,
    skydir=skydir,
    width=10.0,
    axes=[energy_axis, time_axis],
)

# Get image by coord tuple
image = m_wcs.get_image_by_coord(('500 GeV', '1 h'))

# Get image by coord dict with strings
image = m_wcs.get_image_by_coord({'energy': '500 GeV', 'time': '1 h'})

# Get image by coord dict with quantities
image = m_wcs.get_image_by_coord({'energy': 0.5 * u.TeV, 'time': 1 * u.h})

get_image_by_idx(idx)#

Return spatial map at the given axis pixel indices.

Parameters

idxtuple: Tuple of scalar indices for each non spatial dimension of the map. Tuple should be ordered as (I_0, …, I_n).

Returns

map_outMap: Map with spatial dimensions only.

See also

get_image_by_coord, get_image_by_pix

get_image_by_pix(pix)#

Return spatial map at the given axis pixel coordinates

Parameters

pixtuple: Tuple of scalar pixel coordinates for each non-spatial dimension of the map. Tuple should be ordered as (I_0, …, I_n). Pixel coordinates can be either float or integer type.

Returns

map_outMap: Map with spatial dimensions only.

See also

get_image_by_coord, get_image_by_idx

get_spectrum(*args, **kwargs)[source]#: Return self

integral(axis_name, coords, **kwargs)#

Compute integral along a given axis

This method uses interpolation of the cumulative sum.

Parameters

axis_namestr: Along which axis to integrate.
coordsdict or MapCoord: Map coordinates
**kwargsdict: Coordinates at which to evaluate the IRF

Returns

arrayQuantity: Returns 2D array with axes offset

interp_by_coord(coords, **kwargs)[source]#

Interpolate map values at the given map coordinates.

Parameters

coordstuple, dict or MapCoord: Coordinate arrays for each dimension of the map. Tuple should be ordered as (lon, lat, x_0, …, x_n) where x_i are coordinates for non-spatial dimensions of the map. “lon” and “lat” are optional and will be taken at the center of the region by default.
method{“linear”, “nearest”}: Method to interpolate data values. By default linear interpolation is performed.
fill_valueNone or float value: The value to use for points outside of the interpolation domain. If None, values outside the domain are extrapolated.
values_scale{“lin”, “log”, “sqrt”}: Optional value scaling.

Returns

valsndarray: Interpolated pixel values.

interp_by_pix(pix, **kwargs)[source]#

Interpolate map values at the given pixel coordinates.

Parameters

pixtuple: Tuple of pixel coordinate arrays for each dimension of the map. Tuple should be ordered as (p_lon, p_lat, p_0, …, p_n) where p_i are pixel coordinates for non-spatial dimensions of the map.
method{“linear”, “nearest”}: Method to interpolate data values. By default linear interpolation is performed.
fill_valueNone or float value: The value to use for points outside of the interpolation domain. If None, values outside the domain are extrapolated.

Returns

valsndarray: Interpolated pixel values.

interp_to_geom(geom, preserve_counts=False, fill_value=0, **kwargs)#

Interpolate map to input geometry.

Parameters

geomGeom: Target Map geometry
preserve_countsbool: Preserve the integral over each bin. This should be true if the map is an integral quantity (e.g. counts) and false if the map is a differential quantity (e.g. intensity)
**kwargsdict: Keyword arguments passed to Map.interp_by_coord

Returns

interp_mapMap: Interpolated Map

is_allclose(other, rtol_axes=0.001, atol_axes=1e-06, **kwargs)#

Compare two Maps for close equivalency

Parameters

othergammapy.maps.Map: The Map to compare against
rtol_axesfloat: Relative tolerance for the axes comparison.
atol_axesfloat: Relative tolerance for the axes comparison.
**kwargsdict: keywords passed to numpy.allclose

Returns

is_allclosebool: Whether the Map is all close.

iter_by_axis(axis_name, keepdims=False)#

“Iterate over a given axis

Yields

mapMap: Map iteration.

See also

iter_by_image: iterate by image returning a map

iter_by_axis_data(axis_name)[source]#

Iterate data by axis

Parameters

axis_namestr: Axis name

Returns

idx, datatuple, Quantity: Data and index

iter_by_image(keepdims=False)#

Iterate over image planes of a map.

Parameters

keepdimsbool: Keep dimensions.

Yields

mapMap: Map iteration.

See also

iter_by_image_data: iterate by image returning data and index

iter_by_image_data()#

Iterate over image planes of the map.

The image plane index is in data order, so that the data array can be indexed directly.

Yields

(data, idx)tuple: Where data is a numpy.ndarray view of the image plane data, and idx is a tuple of int, the index of the image plane.

See also

iter_by_image: iterate by image returning a map

mask_nearest_position(position)#

Given a sky coordinate return nearest valid position in the mask

If the mask contains additional axes, the mask is reduced over those.

Parameters

positionSkyCoord: Test position

Returns

positionSkyCoord: Nearest position in the mask

normalize(axis_name=None)#

Normalise data in place along a given axis.

Parameters

axis_namestr: Along which axis to normalize.

pad(pad_width, axis_name=None, mode='constant', cval=0, method='linear')#

Pad the spatial dimensions of the map.

Parameters

pad_width{sequence, array_like, int}: Number of pixels padded to the edges of each axis.
axis_namestr: Which axis to downsample. By default spatial axes are padded.
mode{‘edge’, ‘constant’, ‘interp’}: Padding mode. ‘edge’ pads with the closest edge value. ‘constant’ pads with a constant value. ‘interp’ pads with an extrapolated value.
cvalfloat: Padding value when mode=’consant’.

Returns

mapMap: Padded map.

plot(ax=None, axis_name=None, **kwargs)[source]#

Plot the data contained in region map along the non-spatial axis.

Parameters

axAxis: Axis used for plotting
axis_namestr: Which axis to plot on the x axis. Extra axes will be plotted as additional lines.
**kwargsdict: Keyword arguments passed to errorbar

Returns

axAxis: Axis used for plotting

plot_grid(figsize=None, ncols=3, **kwargs)#

Plot map as a grid of subplots for non-spatial axes

Parameters

figsizetuple of int: Figsize to plot on
ncolsint: Number of columns to plot
**kwargsdict: Keyword arguments passed to WcsNDMap.plot.

Returns

axesndarray of Axes: Axes grid

plot_hist(ax=None, **kwargs)[source]#

Plot as histogram.

kwargs are forwarded to hist

Parameters

axaxis (optional): Axis instance to be used for the plot
**kwargsdict: Keyword arguments passed to hist

Returns

axAxis: Axis used for plotting

plot_interactive()[source]#

Plot map with interactive widgets to explore the non spatial axes.

Parameters

rc_paramsdict: Passed to matplotlib.rc_context(rc=rc_params) to style the plot.
**kwargsdict: Keyword arguments passed to WcsNDMap.plot.

Examples

You can try this out e.g. using a Fermi-LAT diffuse model cube with an energy axis:

from gammapy.maps import Map

m = Map.read("$GAMMAPY_DATA/fermi_3fhl/gll_iem_v06_cutout.fits")
m.plot_interactive(add_cbar=True, stretch="sqrt")

If you would like to adjust the figure size you can use the rc_params argument:

rc_params = {'figure.figsize': (12, 6), 'font.size': 12}
m.plot_interactive(rc_params=rc_params)

plot_mask(ax=None, **kwargs)[source]#

Plot the mask as a shaded area in a xmin-xmax range

Parameters

axaxis: Axis instance to be used for the plot.
**kwargsdict: Keyword arguments passed to axvspan

Returns

axAxis: Axis used for plotting

plot_region(ax=None, **kwargs)[source]#

Plot region

Parameters

axWCSAxes: Axes to plot on. If no axes are given, the region is shown using the minimal equivalent WCS geometry.
**kwargsdict: Keyword arguments forwarded to as_artist

classmethod read(filename, format='gadf', ogip_column=None, hdu=None)[source]#

Read from file.

Parameters

filenamepathlib.Path or str: Filename.
format{“gadf”, “ogip”, “ogip-arf”}: Which format to use.
ogip_column{None, “COUNTS”, “QUALITY”, “BACKSCAL”}: If format ‘ogip’ is chosen which table hdu column to read.
hdustr: Name or index of the HDU with the map data.

Returns

region_mapRegionNDMap: Region nd map

reduce(axis_name, func=<ufunc 'add'>, keepdims=False, weights=None)#

Reduce map over a single non-spatial axis

Parameters

axis_name: str: The name of the axis to reduce over
funcufunc: Function to use for reducing the data.
keepdimsbool, optional: If this is set to true, the axes which are summed over are left in the map with a single bin
weightsMap: Weights to be applied.

Returns

map_outMap: Map with the given non-spatial axes reduced

reduce_over_axes(func=<ufunc 'add'>, keepdims=False, axes_names=None, weights=None)#

Reduce map over non-spatial axes

Parameters

funcufunc: Function to use for reducing the data.
keepdimsbool, optional: If this is set to true, the axes which are summed over are left in the map with a single bin
axes_names: list: Names of MapAxis to reduce over If None, all will reduced
weightsMap: Weights to be applied.

Returns

map_outMap: Map with non-spatial axes reduced

rename_axes(names, new_names)#

Rename the Map axes.

Parameters

nameslist or str: Names of the axes.
new_nameslist or str: New names of the axes (list must be of same length than names).

Returns

geomMap: Renamed Map.

reorder_axes(axes_names)#

Return a new map re-ordering the non-spatial axes order.

Parameters

axes_nameslist of str: the list of axes names in the required order

Returns

mapMap: the map with axes re-ordered

reproject_to_geom(geom, preserve_counts=False, precision_factor=10)#

Reproject map to input geometry.

Parameters

geomGeom: Target Map geometry
preserve_countsbool: Preserve the integral over each bin. This should be true if the map is an integral quantity (e.g. counts) and false if the map is a differential quantity (e.g. intensity)
precision_factorint: Minimal factor between the bin size of the output map and the oversampled base map. Used only for the oversampling method.

Returns

output_mapMap: Reprojected Map

resample(geom, weights=None, preserve_counts=True)#

Resample pixels to geom with given weights.

Parameters

geomGeom: Target Map geometry
weightsndarray: Weights vector. Default is weight of one. Must have same shape as the data of the map.
preserve_countsbool: Preserve the integral over each bin. This should be true if the map is an integral quantity (e.g. counts) and false if the map is a differential quantity (e.g. intensity)

Returns

resampled_mapMap: Resampled map

resample_axis(axis, weights=None, ufunc=<ufunc 'add'>)#

Resample map to a new axis by grouping and reducing smaller bins by a given ufunc

By default, the map content are summed over the smaller bins. Other numpy ufunc can be used, e.g. numpy.logical_and or numpy.logical_or.

Parameters

axisMapAxis: New map axis.
weightsMap: Array to be used as weights. The spatial geometry must be equivalent to other and additional axes must be broadcastable.
ufuncufunc: ufunc to use to resample the axis. Default is numpy.add.

Returns

mapMap: Map with resampled axis.

sample_coord(n_events, random_state=0)#

Sample position and energy of events.

Parameters

n_eventsint: Number of events to sample.
random_state{int, ‘random-seed’, ‘global-rng’, RandomState}: Defines random number generator initialisation. Passed to get_random_state.

Returns

coordsMapCoord object.: Sequence of coordinates and energies of the sampled events.

set_by_coord(coords, vals)#

Set pixels at coords with given vals.

Parameters

coordstuple or MapCoord: Coordinate arrays for each dimension of the map. Tuple should be ordered as (lon, lat, x_0, …, x_n) where x_i are coordinates for non-spatial dimensions of the map.
valsndarray: Values vector.

set_by_idx(idx, value)[source]#

Set pixels at idx with given vals.

Parameters

idxtuple: Tuple of pixel index arrays for each dimension of the map. Tuple should be ordered as (I_lon, I_lat, I_0, …, I_n) for WCS maps and (I_hpx, I_0, …, I_n) for HEALPix maps.
valsndarray: Values vector.

set_by_pix(pix, vals)#

Set pixels at pix with given vals.

Parameters

pixtuple: Tuple of pixel index arrays for each dimension of the map. Tuple should be ordered as (I_lon, I_lat, I_0, …, I_n) for WCS maps and (I_hpx, I_0, …, I_n) for HEALPix maps. Pixel indices can be either float or integer type. Float indices will be rounded to the nearest integer.
valsndarray: Values vector.

slice_by_idx(slices)#

Slice sub map from map object.

Parameters

slicesdict: Dict of axes names and integers or slice object pairs. Contains one element for each non-spatial dimension. For integer indexing the corresponding axes is dropped from the map. Axes not specified in the dict are kept unchanged.

Returns

map_outMap: Sliced map object.

split_by_axis(axis_name)#

Split a Map along an axis into multiple maps.

Parameters

axis_namestr: Name of the axis to split

Returns

mapslist: A list of Map

stack(other, weights=None, nan_to_num=True)[source]#

Stack other region map into map.

Parameters

otherRegionNDMap: Other map to stack
weightsRegionNDMap: Array to be used as weights. The spatial geometry must be equivalent to other and additional axes must be broadcastable.
nan_to_num: bool: Non-finite values are replaced by zero if True (default).

sum_over_axes(axes_names=None, keepdims=True, weights=None)#

To sum map values over all non-spatial axes.

Parameters

keepdimsbool, optional: If this is set to true, the axes which are summed over are left in the map with a single bin
axes_names: list of str: Names of MapAxis to reduce over. If None, all will summed over
weightsMap: Weights to be applied. The Map should have the same geometry.

Returns

map_outMap: Map with non-spatial axes summed over

to_cube(axes)#

Append non-spatial axes to create a higher-dimensional Map.

This will result in a Map with a new geometry with N+M dimensions where N is the number of current dimensions and M is the number of axes in the list. The data is reshaped onto the new geometry

Parameters

axeslist: Axes that will be appended to this Map. The axes should have only one bin

Returns

mapWcsNDMap: new map

to_hdulist(format='gadf', hdu='SKYMAP', hdu_bands=None, hdu_region=None)[source]#

Convert to HDUList.

Parameters

format{“gadf”, “ogip”, “ogip-sherpa”, “ogip-arf”, “ogip-arf-sherpa”}: Format specification
hdustr: Name of the HDU with the map data, used for “gadf” format.
hdu_bandsstr: Name or index of the HDU with the BANDS table, used for “gadf” format.
hdu_regionstr: Name or index of the HDU with the region table.

Returns

hdulistHDUList: HDU list

to_region_nd_map(*args, **kwargs)[source]#

to_table(format='gadf')[source]#

Convert to Table.

Data format specification: PHA

Parameters

format{“gadf”, “ogip”, “ogip-arf”, “ogip-arf-sherpa”}: Format specification

Returns

tableTable: Table

to_unit(unit)#

Convert map to different unit

Parameters

unitUnit or str: New unit

Returns

mapMap: Map with new unit and converted data

upsample(factor, order=0, preserve_counts=True, axis_name=None)[source]#

Upsample the non-spatial dimension by a given factor.

By default the first axes is upsampled.

Parameters

factorint: Upsampling factor.
orderint: Order of the interpolation used for upsampling.
preserve_countsbool: Preserve the integral over each bin. This should be true if the RegionNDMap is an integral quantity (e.g. counts) and false if the RegionNDMap is a differential quantity (e.g. intensity).
axis_namestr: Which axis to upsample. Default is “energy”.

Returns

mapRegionNDMap: Upsampled region map.

write(filename, overwrite=False, format='gadf', hdu='SKYMAP')[source]#

Write map to file

Parameters

filenamepathlib.Path or str: Filename.
format{“gadf”, “ogip”, “ogip-sherpa”, “ogip-arf”, “ogip-arf-sherpa”}: Which format to use.
overwritebool: Overwrite existing files?