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)