foscat 3.9.0__tar.gz → 2025.5.0__tar.gz

{foscat-3.9.0/src/foscat.egg-info → foscat-2025.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: foscat
-Version: 3.9.0
+Version: 2025.5.0
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Author-email: Jean-Marc DELOUIS <jean.marc.delouis@ifremer.fr>
 Maintainer-email: Theo Foulquier <theo.foulquier@ifremer.fr>
@@ -25,6 +25,7 @@ Requires-Dist: matplotlib
 Requires-Dist: numpy
 Requires-Dist: healpy
 Requires-Dist: spherical
+Dynamic: license-file
 
 # foscat
 

{foscat-3.9.0 → foscat-2025.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "foscat"
-version = "3.9.0"
+version = "2025.05.0"
 description = "Generate synthetic Healpix or 2D data using Cross Scattering Transform"
 readme = "README.md"
 license = { text = "BSD-3-Clause" }

{foscat-3.9.0 → foscat-2025.5.0}/src/foscat/BkBase.py

@@ -23,6 +23,15 @@ class BackendBase:
         self._fft_3_orient = {}
         self._fft_3_orient_C = {}
 
+    def to_dict(self):
+        return {
+            "name": self.BACKEND,
+            "mpi_rank": self.mpi_rank,
+            "all_type": self.all_type,
+            "gpupos": self.gpupos,
+            "silent": self.silent,
+        }
+
     def iso_mean(self, x, use_2D=False):
         shape = list(x.shape)
 

{foscat-3.9.0 → foscat-2025.5.0}/src/foscat/BkTorch.py

@@ -62,6 +62,74 @@ class BkTorch(BackendBase.BackendBase):
             torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
         )
 
+    def binned_mean(self, data, cell_ids):
+        """
+        data: Tensor of shape [B, N, A]
+        I: Tensor of shape [N], integer indices in [0, n_bins)
+        Returns: mean per bin, shape [B, n_bins, A]
+        """
+        groups = cell_ids // 4  # [N]
+
+        unique_groups, I = np.unique(groups, return_inverse=True)
+
+        n_bins = unique_groups.shape[0]
+
+        B = data.shape[0]
+
+        counts = torch.bincount(torch.tensor(I).to(data.device))[None, :]
+
+        I = np.tile(I, B) + np.tile(n_bins * np.arange(B, dtype="int"), data.shape[1])
+
+        if len(data.shape) == 3:
+            A = data.shape[2]
+            I = np.repeat(I, A) * A + np.repeat(
+                np.arange(A, dtype="int"), data.shape[1] * B
+            )
+
+        I = torch.tensor(I).to(data.device)
+
+        # Comptage par bin
+        if len(data.shape) == 2:
+            sum_per_bin = torch.zeros(
+                [B * n_bins], dtype=data.dtype, device=data.device
+            )
+            sum_per_bin = sum_per_bin.scatter_add(
+                0, I, self.bk_reshape(data, B * data.shape[1])
+            ).reshape(B, n_bins)
+
+            mean_per_bin = sum_per_bin / counts  # [B, n_bins, A]
+        else:
+            sum_per_bin = torch.zeros(
+                [B * n_bins * A], dtype=data.dtype, device=data.device
+            )
+            sum_per_bin = sum_per_bin.scatter_add(
+                0, I, self.bk_reshape(data, B * data.shape[1] * A)
+            ).reshape(
+                B, n_bins, A
+            )  # [B, n_bins]
+
+            mean_per_bin = sum_per_bin / counts[:, :, None]  # [B, n_bins, A]
+
+        return mean_per_bin, unique_groups
+
+    def average_by_cell_group(data, cell_ids):
+        """
+        data: tensor of shape [..., N, ...] (ex: [B, N, C])
+        cell_ids: tensor of shape [N]
+        Returns: mean_data of shape [..., G, ...] where G = number of unique cell_ids//4
+        """
+        original_shape = data.shape
+        leading = data.shape[:-2]  # all dims before N
+        N = data.shape[-2]
+        trailing = data.shape[-1:]  # all dims after N
+
+        groups = (cell_ids // 4).long()  # [N]
+        unique_groups, group_indices, counts = torch.unique(
+            groups, return_inverse=True, return_counts=True
+        )
+
+        return torch.bincount(group_indices, weights=data) / counts, unique_groups
+
     # ---------------------------------------------−---------
     # --             BACKEND DEFINITION                    --
     # ---------------------------------------------−---------

{foscat-3.9.0 → foscat-2025.5.0}/src/foscat/FoCUS.py

@@ -35,7 +35,7 @@ class FoCUS:
         mpi_rank=0,
     ):
 
-        self.__version__ = "3.9.0"
+        self.__version__ = "2025.05.0"
         # P00 coeff for normalization for scat_cov
         self.TMPFILE_VERSION = TMPFILE_VERSION
         self.P1_dic = None
@@ -50,6 +50,12 @@ class FoCUS:
         self.return_data = return_data
         self.silent = silent
 
+        self.kernel_smooth = {}
+        self.padding_smooth = {}
+        self.kernelR_conv = {}
+        self.kernelI_conv = {}
+        self.padding_conv = {}
+
         if not self.silent:
             print("================================================")
             print("          START FOSCAT CONFIGURATION")
@@ -68,10 +74,7 @@ class FoCUS:
                 if not self.silent:
                     print("The directory %s is created")
             except:
-                if not self.silent:
-                    print(
-                        "Impossible to create the directory %s" % (self.TEMPLATE_PATH)
-                    )
+                print("Impossible to create the directory %s" % (self.TEMPLATE_PATH))
                 return None
 
         self.number_of_loss = 0
@@ -81,10 +84,9 @@ class FoCUS:
         self.padding = padding
 
         if JmaxDelta != 0:
-            if not self.silent:
-                print(
-                    "OPTION JmaxDelta is not avialable anymore after version 3.6.2. Please use Jmax option in eval function"
-                )
+            print(
+                "OPTION JmaxDelta is not avialable anymore after version 3.6.2. Please use Jmax option in eval function"
+            )
             return None
 
         self.OSTEP = JmaxDelta
@@ -742,14 +744,14 @@ class FoCUS:
         return rim
 
     # --------------------------------------------------------
-    def ud_grade_2(self, im, axis=0):
+    def ud_grade_2(self, im, axis=0, cell_ids=None, nside=None):
 
         if self.use_2D:
             ishape = list(im.shape)
             if len(ishape) < axis + 2:
                 if not self.silent:
                     print("Use of 2D scat with data that has less than 2D")
-                return None
+                return None, None
 
             npix = im.shape[axis]
             npiy = im.shape[axis + 1]
@@ -774,29 +776,40 @@ class FoCUS:
 
             if axis == 0:
                 if len(ishape) == 2:
-                    return self.backend.bk_reshape(res, [npix // 2, npiy // 2])
+                    return self.backend.bk_reshape(res, [npix // 2, npiy // 2]), None
                 else:
-                    return self.backend.bk_reshape(
-                        res, [npix // 2, npiy // 2] + ishape[axis + 2 :]
+                    return (
+                        self.backend.bk_reshape(
+                            res, [npix // 2, npiy // 2] + ishape[axis + 2 :]
+                        ),
+                        None,
                     )
             else:
                 if len(ishape) == axis + 2:
-                    return self.backend.bk_reshape(
-                        res, ishape[0:axis] + [npix // 2, npiy // 2]
+                    return (
+                        self.backend.bk_reshape(
+                            res, ishape[0:axis] + [npix // 2, npiy // 2]
+                        ),
+                        None,
                     )
                 else:
-                    return self.backend.bk_reshape(
-                        res,
-                        ishape[0:axis] + [npix // 2, npiy // 2] + ishape[axis + 2 :],
+                    return (
+                        self.backend.bk_reshape(
+                            res,
+                            ishape[0:axis]
+                            + [npix // 2, npiy // 2]
+                            + ishape[axis + 2 :],
+                        ),
+                        None,
                     )
 
-            return self.backend.bk_reshape(res, [npix // 2, npiy // 2])
+            return self.backend.bk_reshape(res, [npix // 2, npiy // 2]), None
         elif self.use_1D:
             ishape = list(im.shape)
             if len(ishape) < axis + 1:
                 if not self.silent:
                     print("Use of 1D scat with data that has less than 1D")
-                return None
+                return None, None
 
             npix = im.shape[axis]
             odata = 1
@@ -819,23 +832,33 @@ class FoCUS:
 
             if axis == 0:
                 if len(ishape) == 1:
-                    return self.backend.bk_reshape(res, [npix // 2])
+                    return self.backend.bk_reshape(res, [npix // 2]), None
                 else:
-                    return self.backend.bk_reshape(
-                        res, [npix // 2] + ishape[axis + 1 :]
+                    return (
+                        self.backend.bk_reshape(res, [npix // 2] + ishape[axis + 1 :]),
+                        None,
                     )
             else:
                 if len(ishape) == axis + 1:
-                    return self.backend.bk_reshape(res, ishape[0:axis] + [npix // 2])
+                    return (
+                        self.backend.bk_reshape(res, ishape[0:axis] + [npix // 2]),
+                        None,
+                    )
                 else:
-                    return self.backend.bk_reshape(
-                        res, ishape[0:axis] + [npix // 2] + ishape[axis + 1 :]
+                    return (
+                        self.backend.bk_reshape(
+                            res, ishape[0:axis] + [npix // 2] + ishape[axis + 1 :]
+                        ),
+                        None,
                     )
 
-            return self.backend.bk_reshape(res, [npix // 2])
+            return self.backend.bk_reshape(res, [npix // 2]), None
 
         else:
             shape = list(im.shape)
+            if cell_ids is not None:
+                sim, new_cell_ids = self.backend.binned_mean(im, cell_ids)
+                return sim, new_cell_ids
 
             lout = int(np.sqrt(shape[axis] // 12))
             if im.__class__ == np.zeros([0]).__class__:
@@ -854,8 +877,11 @@ class FoCUS:
                 if len(shape) > axis:
                     oshape = oshape + shape[axis + 1 :]
 
-            return self.backend.bk_reduce_mean(
-                self.backend.bk_reshape(im, oshape), axis=axis + 1
+            return (
+                self.backend.bk_reduce_mean(
+                    self.backend.bk_reshape(im, oshape), axis=axis + 1
+                ),
+                None,
             )
 
     # --------------------------------------------------------
@@ -2139,7 +2165,7 @@ class FoCUS:
                 return self.backend.bk_reduce_sum(r)
 
     # ---------------------------------------------−---------
-    def convol(self, in_image, axis=0):
+    def convol(self, in_image, axis=0, cell_ids=None, nside=None):
 
         image = self.backend.bk_cast(in_image)
 
@@ -2304,6 +2330,61 @@ class FoCUS:
             return self.backend.bk_reshape(res, in_image.shape + [self.NORIENT])
 
         else:
+            ishape = list(image.shape)
+
+            if cell_ids is not None:
+                if cell_ids.shape[0] not in self.padding_conv:
+                    import healpix_convolution as hc
+                    from xdggs.healpix import HealpixInfo
+
+                    res = self.backend.bk_zeros(
+                        ishape + [self.NORIENT], dtype=self.backend.all_cbk_type
+                    )
+
+                    grid_info = HealpixInfo(
+                        level=int(np.log(nside) / np.log(2)), indexing_scheme="nested"
+                    )
+
+                    for k in range(self.NORIENT):
+                        kernelR, kernelI = hc.kernels.wavelet_kernel(
+                            cell_ids, grid_info=grid_info, orientation=k, is_torch=True
+                        )
+                        self.kernelR_conv[(cell_ids.shape[0], k)] = kernelR.to(
+                            self.backend.all_bk_type
+                        ).to(image.device)
+                        self.kernelI_conv[(cell_ids.shape[0], k)] = kernelI.to(
+                            self.backend.all_bk_type
+                        ).to(image.device)
+                        self.padding_conv[(cell_ids.shape[0], k)] = hc.pad(
+                            cell_ids,
+                            grid_info=grid_info,
+                            ring=5 // 2,  # wavelet kernel_size=5 is hard coded
+                            mode="mean",
+                            constant_value=0,
+                        )
+
+                for k in range(self.NORIENT):
+
+                    kernelR = self.kernelR_conv[(cell_ids.shape[0], k)]
+                    kernelI = self.kernelI_conv[(cell_ids.shape[0], k)]
+                    padding = self.padding_conv[(cell_ids.shape[0], k)]
+                    if len(ishape) == 2:
+                        for l in range(ishape[0]):
+                            padded_data = padding.apply(image[l], is_torch=True)
+                            res[l, :, k] = kernelR.matmul(
+                                padded_data
+                            ) + 1j * kernelI.matmul(padded_data)
+                    else:
+                        for l in range(ishape[0]):
+                            for k2 in range(ishape[2]):
+                                padded_data = padding.apply(
+                                    image[l, :, k2], is_torch=True
+                                )
+                                res[l, :, k2, k] = kernelR.matmul(
+                                    padded_data
+                                ) + 1j * kernelI.matmul(padded_data)
+                return res
+
             nside = int(np.sqrt(image.shape[axis] // 12))
 
             if self.Idx_Neighbours[nside] is None:
@@ -2320,7 +2401,6 @@ class FoCUS:
             l_ww_real = self.ww_Real[nside]
             l_ww_imag = self.ww_Imag[nside]
 
-            ishape = list(image.shape)
             odata = 1
             for k in range(axis + 1, len(ishape)):
                 odata = odata * ishape[k]
@@ -2474,7 +2554,7 @@ class FoCUS:
         return res
 
     # ---------------------------------------------−---------
-    def smooth(self, in_image, axis=0):
+    def smooth(self, in_image, axis=0, cell_ids=None, nside=None):
 
         image = self.backend.bk_cast(in_image)
 
@@ -2603,6 +2683,50 @@ class FoCUS:
             return self.backend.bk_reshape(res, in_image.shape)
 
         else:
+
+            ishape = list(image.shape)
+
+            if cell_ids is not None:
+                if cell_ids.shape[0] not in self.padding_smooth:
+                    import healpix_convolution as hc
+                    from xdggs.healpix import HealpixInfo
+
+                    grid_info = HealpixInfo(
+                        level=int(np.log(nside) / np.log(2)), indexing_scheme="nested"
+                    )
+
+                    kernel = hc.kernels.wavelet_smooth_kernel(
+                        cell_ids, grid_info=grid_info, is_torch=True
+                    )
+
+                    self.kernel_smooth[cell_ids.shape[0]] = kernel.to(
+                        self.backend.all_bk_type
+                    ).to(image.device)
+
+                    self.padding_smooth[cell_ids.shape[0]] = hc.pad(
+                        cell_ids,
+                        grid_info=grid_info,
+                        ring=5 // 2,  # wavelet kernel_size=5 is hard coded
+                        mode="mean",
+                        constant_value=0,
+                    )
+
+                kernel = self.kernel_smooth[cell_ids.shape[0]]
+                padding = self.padding_smooth[cell_ids.shape[0]]
+
+                res = self.backend.bk_zeros(ishape, dtype=self.backend.all_cbk_type)
+
+                if len(ishape) == 2:
+                    for l in range(ishape[0]):
+                        padded_data = padding.apply(image[l], is_torch=True)
+                        res[l] = kernel.matmul(padded_data)
+                else:
+                    for l in range(ishape[0]):
+                        for k2 in range(ishape[2]):
+                            padded_data = padding.apply(image[l, :, k2], is_torch=True)
+                            res[l, :, k2] = kernel.matmul(padded_data)
+                return res
+
             nside = int(np.sqrt(image.shape[axis] // 12))
 
             if self.Idx_Neighbours[nside] is None:
@@ -2618,7 +2742,6 @@ class FoCUS:
                 self.w_smooth[nside] = ws
 
             l_w_smooth = self.w_smooth[nside]
-            ishape = list(image.shape)
 
             odata = 1
             for k in range(axis + 1, len(ishape)):

{foscat-3.9.0 → foscat-2025.5.0}/src/foscat/Synthesis.py

@@ -240,7 +240,7 @@ class Synthesis:
         grd_mask = self.grd_mask
 
         if grd_mask is not None:
-            g_tot = self.operation.backend.to_numpy(g_tot*grd_mask)
+            g_tot = self.operation.backend.to_numpy(g_tot * grd_mask)
         else:
             g_tot = self.operation.backend.to_numpy(g_tot)