foscat 2026.2.3__py3-none-any.whl → 2026.2.5__py3-none-any.whl

foscat/FoCUS.py

@@ -39,7 +39,7 @@ class FoCUS:
             mpi_rank=0
     ):
 
-        self.__version__ = "2026.02.3"
+        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/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/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)

{foscat-2026.2.3.dist-info → foscat-2026.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foscat
-Version: 2026.2.3
+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.3.dist-info → foscat-2026.2.5.dist-info}/RECORD

@@ -4,14 +4,14 @@ foscat/BkTensorflow.py,sha256=iIdLx6VTOfOEocfZBOGyizQn5geDLTfdWWAwDeQr9YA,20056
 foscat/BkTorch.py,sha256=9utOTAfS99E7DPN0QfCnn5ULS1WdS4z3-Z0XJMriJY4,53202
 foscat/CNN.py,sha256=4vky7jqTshL1aYLWsc-hQwf7gDjTVjL7I6HZiAsa6x4,5158
 foscat/CircSpline.py,sha256=CXi49FxF8ZoeZ17Ua8c1AZXe2B5ICEC9aCXb97atB3s,4028
-foscat/FoCUS.py,sha256=8dTRKUNXHHqLDESmsEr-xWXArZWLrmEase2I1y_8BVs,109790
+foscat/FoCUS.py,sha256=pK8cmsUSbaAUJbfoXGpQM9Fo2HCprBFAnMyW4bjRbzM,109790
 foscat/GCNN.py,sha256=q7yWHCMJpP7-m3WvR3OQnp5taeYWaMxIY2hQ6SIb9gs,4487
 foscat/HOrientedConvol.py,sha256=xMaS-zzoUyXisBCPsHBVpn54tuA9Qv3na-tT86Cwn7U,38744
 foscat/HealBili.py,sha256=YRPk9PO5G8NdwKeb33xiJs3_pMPAgIv5phCs8GT6LN0,12943
 foscat/HealSpline.py,sha256=YRotJ1NQuXYFyFiM8fp6qkATIwRJ8lqIVo4vGXpHO-w,7472
 foscat/Plot.py,sha256=bpohWGsblTBxMrqE_X-iRvuvT-YyHDcgfWB4iYk5l10,49218
 foscat/Softmax.py,sha256=UDZGrTroYtmGEyokGUVpwNO_cgbICi9QVuRr8Yx52_k,2917
-foscat/SphereDownGeo.py,sha256=B_ENfL4Mqn6VmpXEGGxEW8DR3R6zCNV-YVtsU00xwjY,15380
+foscat/SphereDownGeo.py,sha256=UprhvwgBNH996L70hksfgZ33S6rcvL9qjz_ZTHFhH6U,20162
 foscat/SphereUpGeo.py,sha256=KvvXqVRW7eX79MJsJJS6g5ll84Qyx0bLZzQaDXy4fp4,7023
 foscat/SphericalStencil.py,sha256=kRyQXwZyoxdRW326e2ht8eGzg1-Lvl89tdHSpVTfJzg,47620
 foscat/Spline1D.py,sha256=rKzzenduaZZ-yBDJd35it6Gyrj1spqb7hoIaUgISPzY,2983
@@ -33,14 +33,14 @@ foscat/planar_vit.py,sha256=lQqwyz_P8G-Dav2vLqgkssDfeSe15YmjFzP5W-otjs0,6888
 foscat/scat.py,sha256=emN7MsSuoJzPWQfgDETScZeKLmu8K-jjEh5Dp7szQzY,72809
 foscat/scat1D.py,sha256=FvvxwhlzxwvIETkenpisvDteJ06DBYP5K7wsnJ2nHjM,53713
 foscat/scat2D.py,sha256=boKj0ASqMMSy7uQLK6hPniG87m3hZGJBYBiq5v8F9IQ,532
-foscat/scat_cov.py,sha256=enGg_OdhB1pXvvoG3ECt_9K-sFlwOjzyn_jaoC_Kmes,271818
+foscat/scat_cov.py,sha256=F9TpikUi4njrLmKHsSCtfSUJ6cepYXVXYjXVBzsTbd8,271819
 foscat/scat_cov1D.py,sha256=XOxsZZ5TYq8f34i2tUgIfzyaqaTDlICB3HzD2l_puro,531
 foscat/scat_cov2D.py,sha256=pAm0fKw8wyXram0TFbtw8tGcc8QPKuPXpQk0kh10r4U,7078
 foscat/scat_cov_map.py,sha256=9MzpwT2g9S3dmnjHEMK7PPLQ27oGQg2VFVsP_TDUU5E,2869
 foscat/scat_cov_map2D.py,sha256=zaIIYshXCqAeZ04I158GhD-Op4aoMlLnLEy7rxckVYY,2842
 foscat/unet_2_d_from_healpix_params.py,sha256=r8hN-s091f3yHYlvAAiBbLOvtsz9vPrdwrWPM0ULR2Q,15949
-foscat-2026.2.3.dist-info/licenses/LICENSE,sha256=i0ukIr8ZUpkSY2sZaE9XZK-6vuSU5iG6IgX_3pjatP8,1505
-foscat-2026.2.3.dist-info/METADATA,sha256=DOWjA-o0BmegWKQQV4olIwL5L6FJePFOdLZujE1-YFM,4489
-foscat-2026.2.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-foscat-2026.2.3.dist-info/top_level.txt,sha256=AGySXBBAlJgb8Tj8af6m_F-aiNg2zNTcybCUPVOKjAg,7
-foscat-2026.2.3.dist-info/RECORD,,
+foscat-2026.2.5.dist-info/licenses/LICENSE,sha256=i0ukIr8ZUpkSY2sZaE9XZK-6vuSU5iG6IgX_3pjatP8,1505
+foscat-2026.2.5.dist-info/METADATA,sha256=U6Edka4THjcirgIpweyeLh0EGdV6JqSHuwND147x6JU,4489
+foscat-2026.2.5.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+foscat-2026.2.5.dist-info/top_level.txt,sha256=AGySXBBAlJgb8Tj8af6m_F-aiNg2zNTcybCUPVOKjAg,7
+foscat-2026.2.5.dist-info/RECORD,,