def wl_peak_counts( self, nbins: int, field_conversion: str, of: str = "orig", limits: Optional[tuple] = None, ) -> pd.DataFrame: """ Signal peak counts. This is used commonly used in weak-lensing, but it doesn't need to stop there... """ if field_conversion == "normalize": _map = self.data[of] - np.mean(self.skymap.data[of]) else: _map = self.data[of] if limits is None: lower_bound = np.percentile(self.data[of], 5) # np.min(self.data[of]) upper_bound = np.percentile(self.data[of], 95) # np.max(self.data[of]) else: lower_bound = min(limits) upper_bound = max(limits) map_bins = np.arange(lower_bound, upper_bound, (upper_bound - lower_bound) / nbins) _map = ConvergenceMap(data=_map, angle=self._opening_angle * un.deg) _kappa, _pos = _map.locatePeaks(map_bins) _hist, _kappa = np.histogram(_kappa, bins=nbins, density=False) _kappa = (_kappa[1:] + _kappa[:-1]) / 2 peak_counts_dic = {"kappa": _kappa, "counts": _hist} peak_counts_df = pd.DataFrame(data=peak_counts_dic) return peak_counts_df
def from_sky( cls, skymap: Type[SkyArray], on: str, bin_dsc: dict, kernel_width: float = 5, direction: int = 1, filters: bool = True, ) -> "Dipoles": """ Find peaks on the dipole signal map. It is assumed that the convergence maps were created with astrild.rays.visuals.map and filter with: I) high-pass II) DGD3 III) low-pass gaussian filters. Args: kernel_width: Smoothing kernel with [arcmin] Returns: """ if filters is True: skymap = cls._filter(skymap, kernel_width, direction) thresholds = cls._get_convergence_thresholds( sky_array=skymap.data[bin_dsc["on"]], nbins=bin_dsc["nbins"]) _map = ConvergenceMap(data=skymap.data[on], angle=skymap.opening_angle * un.deg) deltaT, pos_deg = _map.locatePeaks(thresholds) deltaT, pos_deg = cls._remove_peaks_crossing_edge( skymap.npix, skymap.opening_angle, kernel_width, deltaT, pos_deg) assert len(deltaT) != 0, "No peaks" peak_dir = { "deltaT": deltaT, "x_deg": pos_deg[:, 0], "y_deg": pos_deg[:, 1], } # find significance of peaks peak_dir["snr"] = cls._signal_to_noise_ratio(peak_dir["deltaT"], _map.data) peak_dir["x_pix"] = np.rint(peak_dir["x_deg"] * skymap.npix / skymap.opening_angle).astype(int) peak_dir["y_pix"] = np.rint(peak_dir["y_deg"] * skymap.npix / skymap.opening_angle).astype(int) peak_df = pd.DataFrame(data=peak_dir) # attrs is experimental and may change without warning. peak_df.attrs["map_file"] = skymap.map_file peak_df.attrs["filters"] = filters peak_df.attrs["kernel_width"] = kernel_width return cls.from_dataframe(peak_df)
def find_peaks( self, on: str, field_conversion: str, thresholds_dsc: dict, snr_sigma: Optional[float] = None, save: bool = False, ) -> None: """ Find peaks on convergence map. It is assumed that the convergence maps were created with astrild.rays.visuals.map and have appropriate smoothing and galaxy shape noise. Args: Returns: """ self.on = on if field_conversion == "normalize": _map = self.skymap.data[on] - np.mean(self.skymap.data[on]) else: _map = self.skymap.data[on] thresholds = self._get_convergence_thresholds(**thresholds_dsc) _map = ConvergenceMap(data=_map, angle=self.skymap.opening_angle * un.deg) _peaks = {} _peaks["kappa"], _peaks["pos"] = _map.locatePeaks(thresholds) _peaks["kappa"], _peaks["pos"] = self._remove_peaks_crossing_edge( **_peaks) assert len(_peaks["kappa"]) != 0, "No peaks" # find significance of peaks _peaks["snr"] = self._signal_to_noise_ratio(_peaks["kappa"], _map.data, snr_sigma) self.peaks = _peaks if save: # IO.save() pass