foscat 2026.2.2__tar.gz → 2026.2.5__tar.gz

{foscat-2026.2.2/src/foscat.egg-info → foscat-2026.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foscat
-Version: 2026.2.2
+Version: 2026.2.5
 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>

{foscat-2026.2.2 → foscat-2026.2.5}/pyproject.toml

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

{foscat-2026.2.2 → foscat-2026.2.5}/src/foscat/FoCUS.py

@@ -39,7 +39,7 @@ class FoCUS:
             mpi_rank=0
     ):
 
-        self.__version__ = "2026.02.2"
+        self.__version__ = "2026.02.4"
         # P00 coeff for normalization for scat_cov
         self.TMPFILE_VERSION = TMPFILE_VERSION
         self.P1_dic = None
@@ -1579,7 +1579,7 @@ class FoCUS:
                     
                     xx=np.tile(np.arange(self.KERNELSZ)-self.KERNELSZ//2,self.KERNELSZ).reshape(self.KERNELSZ,self.KERNELSZ)
                     
-                    if nside>1:
+                    if nside>0:
                         wwr=(np.exp(-pw2*(xx**2+(xx.T)**2))*np.cos(pw*xx*np.pi)).reshape(1,1,self.KERNELSZ*self.KERNELSZ)
                         wwr-=wwr.mean()
                         wwi=(np.exp(-pw2*(xx**2+(xx.T)**2))*np.sin(pw*xx*np.pi)).reshape(1,1,self.KERNELSZ*self.KERNELSZ)

{foscat-2026.2.2 → foscat-2026.2.5}/src/foscat/SphereDownGeo.py

@@ -106,7 +106,7 @@ class SphereDownGeo(nn.Module):
                                         
             M = self._build_down_matrix()  # shape (K_out, K_in or N_in)
               
-            self.M = M.coalesce()
+            self.M = M
             
             if use_csr:
                 self.M = self.M.to_sparse_csr().to(self.device)
@@ -209,6 +209,113 @@ class SphereDownGeo(nn.Module):
             return np.ones_like(w) / max(np.sqrt(w.size), 1.0)
         return w / np.sqrt(s2)
 
+    def _build_down_matrix(self) -> torch.Tensor:
+        nside_in = self.nside_in
+        nside_out = self.nside_out
+        sigma = float(self.sigma_rad)
+
+        p_out = self.cell_ids_out.astype(np.int64)  # [K]
+        K = p_out.size
+        offs = np.arange(4, dtype=np.int64)         # [4]
+
+        # --- (A) Choix du voisinage côté coarse
+        # Option 1 (minimal, très rapide) : uniquement le parent -> 4 enfants
+        #parents = p_out[:, None]                    # [K,1]
+
+        # Option 2 (plus “lisse”) : parent + 8 voisins -> 9 parents -> 36 enfants
+        neigh8 = hp.get_all_neighbours(nside_out, p_out, nest=True)  # [8,K] (healpy renvoie souvent [8,K])
+        parents = np.concatenate([p_out[None, :], neigh8], axis=0).T # [K,9]
+        idx=np.where(parents==-1)
+        parents[idx[0],idx[1]]=parents[idx[0],idx[1]-1]
+
+        # --- enfants fins (NESTED) : child_id = 4*parent + {0,1,2,3}
+        children = (4 * parents[..., None] + offs[None, None, :]).reshape(K, -1)  # [K, 4] ou [K,36]
+
+        # Si option voisins activée : invalider enfants des parents=-1
+        #mask_child = np.repeat(mask_parent, 4, axis=1)               # [K,36]
+        #children_flat = children[mask_child]
+        #print(mask_child.shape,children.shape,K)
+        rows_flat = np.repeat(np.arange(K, dtype=np.int64), children.shape[1])#[mask_child.ravel()]
+
+        # Option minimal (sans voisins) :
+        children_flat = children.reshape(-1)                           # [K*4]
+        #rows_flat = np.repeat(np.arange(K, dtype=np.int64), children.shape[1])
+
+        # --- Subset: map vers indices compacts
+        if self.has_in_subset:
+            in_ids = self.in_cell_ids  # trié/unique :contentReference[oaicite:4]{index=4}
+            idx = np.searchsorted(in_ids, children_flat)
+
+            in_range = idx < in_ids.size          # idx est toujours >=0 pour searchsorted
+            idx2 = idx[in_range]
+            child2 = children_flat[in_range]
+
+            ok2 = (in_ids[idx2] == child2)        # comparaison safe
+            ok = np.zeros_like(in_range, dtype=bool)
+            ok[in_range] = ok2
+
+            cols_flat = idx[ok]
+            rows_flat2 = rows_flat[ok]
+            child_ids_kept = children_flat[ok]
+        else:
+            cols_flat = children_flat
+            rows_flat2 = rows_flat
+            child_ids_kept = children_flat
+
+        if rows_flat2.size == 0:
+            indices = torch.zeros((2, 0), dtype=torch.long, device=self.device)
+            vals_t = torch.zeros((0,), dtype=self.dtype, device=self.device)
+            return torch.sparse_coo_tensor(indices, vals_t, size=(self.K_out, self.K_in),
+                                           device=self.device, dtype=self.dtype).coalesce()
+
+        # --- poids gaussiens (vectorisé)
+        # centres coarse: vec0 [K,3]
+        vx0, vy0, vz0 = hp.pix2vec(nside_out, p_out, nest=True)
+        vec0 = np.stack([vx0, vy0, vz0], axis=1)                        # [K,3]
+
+        # vec des enfants gardés
+        vx, vy, vz = hp.pix2vec(nside_in, child_ids_kept, nest=True)
+        vec = np.stack([vx, vy, vz], axis=1)                            # [nnz,3]
+
+        # dot(vec, vec0[row])
+        dots = np.einsum("ij,ij->i", vec, vec0[rows_flat2])
+        dots = np.clip(dots, -1.0, 1.0)
+        ang = np.arccos(dots)
+        w = np.exp(-2.0 * (ang / max(sigma, 1e-30)) ** 2)
+
+        # --- normalisation par ligne (row-wise), sans boucle
+        # On recompose un tableau dense “temporaire” [K, m] via indexation
+        m = children.shape[1]
+        # position within row (0..m-1)
+        jpos = np.tile(np.arange(m, dtype=np.int64), K)
+        if self.has_in_subset:
+            jpos = jpos.reshape(-1)[ok]  # aligné sur rows_flat2/child_ids_kept
+        # si option voisins + mask_child : jpos = jpos[mask_child.reshape(-1)][ok] etc.
+
+        W = np.zeros((K, m), dtype=np.float64)
+        W[rows_flat2, jpos] = w
+
+        if self.weight_norm == "l1":
+            s = W.sum(axis=1, keepdims=True)
+            s[s <= 0] = 1.0
+            W /= s
+        else:  # l2
+            s2 = np.sqrt((W * W).sum(axis=1, keepdims=True))
+            s2[s2 <= 0] = 1.0
+            W /= s2
+
+        # extraire w normalisés aux mêmes nnz
+        w_norm = W[rows_flat2, jpos].astype(np.float32)
+
+        # --- sparse
+        rows_t = torch.tensor(rows_flat2, dtype=torch.long, device=self.device)
+        cols_t = torch.tensor(cols_flat, dtype=torch.long, device=self.device)
+        vals_t = torch.tensor(w_norm, dtype=self.dtype, device=self.device)
+
+        indices = torch.stack([rows_t, cols_t], dim=0)
+        return torch.sparse_coo_tensor(indices, vals_t, size=(self.K_out, self.K_in),
+                                    device=self.device, dtype=self.dtype).coalesce()
+    '''
     def _build_down_matrix(self) -> torch.Tensor:
         """Construct sparse matrix M (K_out, K_in or N_in) for the selected coarse pixels."""
         nside_in = self.nside_in
@@ -302,7 +409,7 @@ class SphereDownGeo(nn.Module):
             dtype=self.dtype,
         ).coalesce()
         return M
-
+        '''
     # ---------------- forward ----------------
     def forward(self, x: torch.Tensor):
         """

{foscat-2026.2.2 → foscat-2026.2.5}/src/foscat/scat_cov.py

@@ -2378,7 +2378,7 @@ class funct(FOC.FoCUS):
             if image2 is not None:
                 tmpi2 = self.up_grade(tmpi2, l_nside * 2)
         l_nside = int(np.sqrt(tmp.shape[-1] // 12))
-        nscale = int(np.log(l_nside) / np.log(2))
+        nscale = int(np.log(l_nside) / np.log(2)+1)
         cmat = {}
         cmat2 = {}
 
@@ -2564,7 +2564,7 @@ class funct(FOC.FoCUS):
                     mat2[0 : k + 1, None, ...].astype("complex64")
                 )
 
-            if k < l_nside - 1:
+            if k < nscale - 1:
                 tmp, _ = self.ud_grade_2(tmp)
                 if image2 is not None:
                     tmpi2, _ = self.ud_grade_2(tmpi)
@@ -2702,6 +2702,7 @@ class funct(FOC.FoCUS):
                 nside = int(np.sqrt(npix // 12))
 
             J = int(np.log2(nside)+1)  # Number of j scales
+                
             if cell_ids is not None:
                 J=np.min([J,int(np.log(cell_ids.shape[0]) / (2*np.log(2)))-1])
 
@@ -2764,6 +2765,7 @@ class funct(FOC.FoCUS):
                     I2 = self.up_grade(I2, nside * 2)
 
                 nside = nside * 2
+                Jmax = Jmax +1
 
         # Normalize the masks because they have different pixel numbers
         # vmask /= self.backend.bk_reduce_sum(vmask, axis=1)[:, None]  # [Nmask, Npix]

{foscat-2026.2.2 → foscat-2026.2.5/src/foscat.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foscat
-Version: 2026.2.2
+Version: 2026.2.5
 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>