def _interpolate(self):
points = [a.center for a in self.axes]
points_scale = tuple([a.interp for a in self.axes])
return ScaledRegularGridInterpolator(points,
self.quantity,
points_scale=points_scale,
**self.default_interp_kwargs)
def interp_by_pix(self, pix, method="linear", fill_value=None):
if not self.geom.is_regular:
raise ValueError("interp_by_pix only supported for regular geom.")
grid_pix = [np.arange(n, dtype=float) for n in self.data.shape[::-1]]
if np.any(np.isfinite(self.data)):
data = self.data.copy().T
data[~np.isfinite(data)] = 0.0
else:
data = self.data.T
fn = ScaledRegularGridInterpolator(grid_pix,
data,
fill_value=None,
bounds_error=False,
method=method)
interp_data = fn(tuple(pix), clip=False)
if fill_value is not None:
idxs = self.geom.pix_to_idx(pix, clip=False)
invalid = np.broadcast_arrays(*[idx == -1 for idx in idxs])
mask = np.any(invalid, axis=0)
if not interp_data.shape:
mask = mask.squeeze()
interp_data[mask] = fill_value
interp_data[~np.isfinite(interp_data)] = fill_value
return interp_data
def _interpolate(self):
energy = self.energy_axis_true.center
offset = self.offset_axis.center
rad = self.rad_axis.center
return ScaledRegularGridInterpolator(points=(energy, offset, rad),
values=self.psf_value,
**self._interp_kwargs)
def _setup_interpolators(self, values_list):
interps = []
for values in values_list:
interp = ScaledRegularGridInterpolator(points=(self.theta,
self.energy),
values=values)
interps.append(interp)
return interps
def _setup_interpolators(self, values_list):
interps = []
for values in values_list:
interp = ScaledRegularGridInterpolator(
points=(self.offset_axis.center, self.energy_axis_true.center), values=values
)
interps.append(interp)
return interps
def _interpolate(self):
energy = self._energy_logcenter()
offset = self.offset.to("deg")
rad = self._rad_center()
return ScaledRegularGridInterpolator(points=(rad, offset, energy),
values=self.psf_value,
**self._interp_kwargs)
def _interpolators(self):
interps = {}
for name in self.required_parameters:
points = [a.center for a in self.axes]
points_scale = tuple([a.interp for a in self.axes])
interps[name] = ScaledRegularGridInterpolator(
points, values=self.quantity[name], points_scale=points_scale)
return interps
def _interpolate(self):
kwargs = self.interp_kwargs.copy()
# Allow extrap[olation with in bins
kwargs["fill_value"] = None
points = [a.center for a in self.axes]
points_scale = tuple([a.interp for a in self.axes])
return ScaledRegularGridInterpolator(
points,
self.quantity,
points_scale=points_scale,
**kwargs,
)
def _interpolate_containment(self):
rad_drad = (
2 * np.pi * self.rad_axis.center * self.psf_value * self.rad_axis.bin_width
)
values = rad_drad.cumsum().to_value("")
rad = self.rad_axis.edges
values = np.insert(values, 0, 0)
return ScaledRegularGridInterpolator(
points=(rad,), values=values, fill_value=1,
)
def _interpolate_containment(self):
if self.rad[0] > 0:
rad = self.rad.insert(0, 0)
else:
rad = self.rad
rad_drad = 2 * np.pi * rad * self.evaluate(rad)
values = scipy.integrate.cumtrapz(
rad_drad.to_value("rad-1"), rad.to_value("rad"), initial=0
)
return ScaledRegularGridInterpolator(points=(rad,), values=values, fill_value=1)
def interp_by_pix(self, pix, method="linear", fill_value=None):
grid_pix = [np.arange(n, dtype=float) for n in self.data.shape[::-1]]
if np.any(np.isfinite(self.data)):
data = self.data.copy().T
data[~np.isfinite(data)] = 0.0
else:
data = self.data.T
fn = ScaledRegularGridInterpolator(
grid_pix, data, fill_value=fill_value, method=method
)
return fn(tuple(pix), clip=False)
def __init__(self, table, interp_kwargs=None):
interp_kwargs = interp_kwargs or {}
interp_kwargs.setdefault("values_scale", "lin")
self.table = table
glon = Angle(self.table["GLON"]).wrap_at("180d")
interps = {}
for column in table.colnames:
values = self.table[column].quantity
interp = ScaledRegularGridInterpolator((glon,), values, **interp_kwargs)
interps[column] = interp
self._interp = interps
def __init__(self, energy, param, data, filename=None, interp_kwargs=None):
self.data = data
self.filename = filename
# set values log centers
self.param = param
self.energy = energy
interp_kwargs = interp_kwargs or {}
interp_kwargs.setdefault("points_scale", ("log", "lin"))
interp_kwargs.setdefault("extrapolate", True)
self._evaluate = ScaledRegularGridInterpolator(points=(self.param,
self.energy),
values=data,
**interp_kwargs)
def interp_by_pix(self, pix, method="nearest", fill_value=None):
if not self.geom.is_regular:
raise ValueError("interp_by_pix only supported for regular geom.")
grid_pix = [np.arange(n, dtype=float) for n in self.data.shape[::-1]]
if np.any(np.isfinite(self.data)):
data = self.data.copy().T
data[~np.isfinite(data)] = 0.0
else:
data = self.data.T
fn = ScaledRegularGridInterpolator(
grid_pix, data, fill_value=fill_value, bounds_error=False, method=method
)
return fn(tuple(pix), clip=False)
def _interpolate_containment(self):
rad = self.rad_axis.center
if rad[0] > 0:
rad = rad.insert(0, 0)
rad_drad = 2 * np.pi * rad * self.evaluate(
energy=self.energy_axis_true.center, rad=rad)
values = scipy.integrate.cumtrapz(rad_drad.to_value("rad-1"),
rad.to_value("rad"),
initial=0,
axis=1)
points = (self.energy_axis_true.center, rad)
return ScaledRegularGridInterpolator(points=points,
values=values,
fill_value=1)
def integral(self, axis_name, **kwargs):
"""Compute integral along a given axis
This method uses interpolation of the cumulative sum.
Parameters
----------
axis_name : str
Along which axis to integrate.
**kwargs : dict
Coordinates at which to evaluate the IRF
Returns
-------
array : `~astropy.units.Quantity`
Returns 2D array with axes offset
"""
axis = self.axes[axis_name]
axis_idx = self.axes.index(axis_name)
# TODO: the broadcasting should be done by axis.center, axis.bin_width etc.
shape = [1] * len(self.axes)
shape[axis_idx] = -1
values = self.quantity * axis.bin_width.reshape(shape)
if axis_name == "rad":
# take Jacobian into account
values = 2 * np.pi * axis.center.reshape(shape) * values
values = values.cumsum(axis=axis_idx)
points = [ax.center for ax in self.axes]
points[axis_idx] = axis.edges[1:]
f_integrate = ScaledRegularGridInterpolator(
points=points,
values=values,
)
try:
coords = tuple(kwargs[name] for name in self.axes.names)
except KeyError as exc:
raise ValueError(f"Missing coordinate for axis: {str(exc)}")
return f_integrate(coords)
def interp_by_pix(self, pix, **kwargs):
grid_pix = [np.arange(n, dtype=float) for n in self.data.shape[::-1]]
if np.any(np.isfinite(self.data)):
data = self.data.copy().T
data[~np.isfinite(data)] = 0.0
else:
data = self.data.T
scale = kwargs.get("values_scale", "lin")
if scale == "stat-profile":
axis = 2 + self.geom.axes.index("norm")
kwargs["values_scale"] = StatProfileScale(axis=axis)
fn = ScaledRegularGridInterpolator(grid_pix, data, **kwargs)
return fn(tuple(pix), clip=False)
def _interp_by_pix_linear_grid(self, pix, order=1, fill_value=None):
# TODO: Cache interpolator
method_lookup = {0: "nearest", 1: "linear"}
try:
method = method_lookup[order]
except KeyError:
raise ValueError(f"Invalid interpolation order: {order!r}")
grid_pix = [np.arange(n, dtype=float) for n in self.data.shape[::-1]]
if np.any(np.isfinite(self.data)):
data = self.data.copy().T
data[~np.isfinite(data)] = 0.0
else:
data = self.data.T
fn = ScaledRegularGridInterpolator(
grid_pix, data, fill_value=fill_value, bounds_error=False, method=method
)
return fn(tuple(pix), clip=False)
def __init__(
self,
energy,
values,
norm=norm.quantity,
tilt=tilt.quantity,
reference=reference.quantity,
interp_kwargs=None,
meta=None,
):
self.energy = energy
self.values = u.Quantity(values, copy=False)
self.meta = dict() if meta is None else meta
interp_kwargs = interp_kwargs or {}
interp_kwargs.setdefault("values_scale", "log")
interp_kwargs.setdefault("points_scale", ("log", ))
self._evaluate = ScaledRegularGridInterpolator(points=(energy, ),
values=values,
**interp_kwargs)
super().__init__(norm=norm, tilt=tilt, reference=reference)
def _interpolate(self):
points = (self.energy_axis_true.center, self.rad_axis.center)
return ScaledRegularGridInterpolator(points=points,
values=self.psf_value,
**self._interp_kwargs)
def _interpolate(self):
points = (self.rad, )
return ScaledRegularGridInterpolator(points=points,
values=self.psf_value,
**self._interp_kwargs)