foscat 2025.3.0__py3-none-any.whl → 2025.5.2__py3-none-any.whl

foscat/scat_cov.py

@@ -2378,16 +2378,16 @@ class funct(FOC.FoCUS):
             # of cosine and sine contributions using all channels
             angles = self.backend.bk_cast(
                 (2 * np.pi * np.arange(self.NORIENT) / self.NORIENT).reshape(
-                    1, 1, self.NORIENT
+                    1, self.NORIENT, 1
                 )
             )  # shape: (NORIENT,)
 
             # we use cosines and sines as weights for sim
             weighted_cos = self.backend.bk_reduce_mean(
-                sim * self.backend.bk_cos(angles), axis=-1
+                sim * self.backend.bk_cos(angles), axis=-2
             )
             weighted_sin = self.backend.bk_reduce_mean(
-                sim * self.backend.bk_sin(angles), axis=-1
+                sim * self.backend.bk_sin(angles), axis=-2
             )
             # For simplicity, take first element of the batch
             cc = weighted_cos[0]
@@ -2423,43 +2423,46 @@ class funct(FOC.FoCUS):
             w1 = np.sin(delta * np.pi / 2) ** 2
 
             # build rotation matrix
-            mat = np.zeros([sim.shape[1], self.NORIENT * self.NORIENT])
-            lidx = np.arange(sim.shape[1])
+            mat = np.zeros([self.NORIENT * self.NORIENT, sim.shape[2]])
+            lidx = np.arange(sim.shape[2])
             for ell in range(self.NORIENT):
                 # Instead of simple linear weights, we use the cosine weights w0 and w1.
                 col0 = self.NORIENT * ((ell + iph) % self.NORIENT) + ell
                 col1 = self.NORIENT * ((ell + iph + 1) % self.NORIENT) + ell
-                mat[lidx, col0] = w0
-                mat[lidx, col1] = w1
 
-            cmat[k] = self.backend.bk_cast(mat.astype("complex64"))
+                mat[col0, lidx] = w0
+                mat[col1, lidx] = w1
+
+            cmat[k] = self.backend.bk_cast(mat[None, ...].astype("complex64"))
 
             # do same modifications for mat2
             mat2 = np.zeros(
-                [k + 1, sim.shape[1], self.NORIENT, self.NORIENT * self.NORIENT]
+                [k + 1, self.NORIENT * self.NORIENT, self.NORIENT, sim.shape[2]]
             )
 
             for k2 in range(k + 1):
-                tmp2 = self.backend.bk_repeat(sim, self.NORIENT, axis=-1)
+
+                tmp2 = self.backend.bk_repeat(sim, self.NORIENT, axis=1)
 
                 sim2 = self.backend.bk_reduce_sum(
                     self.backend.bk_reshape(
                         self.backend.bk_cast(
-                            mat.reshape(1, mat.shape[0], self.NORIENT * self.NORIENT)
+                            mat.reshape(1, self.NORIENT * self.NORIENT, mat.shape[1])
                         )
                         * tmp2,
-                        [sim.shape[0], cmat[k].shape[0], self.NORIENT, self.NORIENT],
+                        [sim.shape[0], self.NORIENT, self.NORIENT, mat.shape[1]],
                     ),
-                    2,
+                    1,
                 )
 
-                sim2 = self.backend.bk_abs(self.convol(sim2, axis=1))
+                sim2 = self.backend.bk_abs(self.convol(sim2, axis=-1))
 
+                angles = self.backend.bk_reshape(angles, [1, self.NORIENT, 1, 1])
                 weighted_cos2 = self.backend.bk_reduce_mean(
-                    sim2 * self.backend.bk_cos(angles), axis=-1
+                    sim2 * self.backend.bk_cos(angles), axis=1
                 )
                 weighted_sin2 = self.backend.bk_reduce_mean(
-                    sim2 * self.backend.bk_sin(angles), axis=-1
+                    sim2 * self.backend.bk_sin(angles), axis=1
                 )
 
                 cc2 = weighted_cos2[0]
@@ -2467,14 +2470,14 @@ class funct(FOC.FoCUS):
 
                 if smooth_scale > 0:
                     for m in range(smooth_scale):
-                        if cc2.shape[0] > 12:
-                            cc2, _ = self.ud_grade_2(self.smooth(cc2))
-                            ss2, _ = self.ud_grade_2(self.smooth(ss2))
+                        if cc2.shape[1] > 12:
+                            cc2, _ = self.ud_grade_2(self.smooth(cc2, axis=1), axis=1)
+                            ss2, _ = self.ud_grade_2(self.smooth(ss2, axis=1), axis=1)
 
-                if cc2.shape[0] != sim.shape[1]:
-                    ll_nside = int(np.sqrt(sim.shape[1] // 12))
-                    cc2 = self.up_grade(cc2, ll_nside)
-                    ss2 = self.up_grade(ss2, ll_nside)
+                if cc2.shape[1] != sim.shape[2]:
+                    ll_nside = int(np.sqrt(sim.shape[2] // 12))
+                    cc2 = self.up_grade(cc2, ll_nside, axis=1)
+                    ss2 = self.up_grade(ss2, ll_nside, axis=1)
 
                 if self.BACKEND == "numpy":
                     phase2 = np.fmod(np.arctan2(ss2, cc2) + 2 * np.pi, 2 * np.pi)
@@ -2492,17 +2495,18 @@ class funct(FOC.FoCUS):
                 delta2 = phase2_scaled - iph2
                 w0_2 = np.cos(delta2 * np.pi / 2) ** 2
                 w1_2 = np.sin(delta2 * np.pi / 2) ** 2
-                lidx = np.arange(sim.shape[1])
+                lidx = np.arange(sim.shape[2])
 
                 for m in range(self.NORIENT):
                     for ell in range(self.NORIENT):
-                        col0 = self.NORIENT * ((ell + iph2[:, m]) % self.NORIENT) + ell
-                        col1 = (
-                            self.NORIENT * ((ell + iph2[:, m] + 1) % self.NORIENT) + ell
-                        )
-                        mat2[k2, lidx, m, col0] = w0_2[:, m]
-                        mat2[k2, lidx, m, col1] = w1_2[:, m]
-                cmat2[k] = self.backend.bk_cast(mat2.astype("complex64"))
+                        col0 = self.NORIENT * ((ell + iph2[m]) % self.NORIENT) + ell
+                        col1 = self.NORIENT * ((ell + iph2[m] + 1) % self.NORIENT) + ell
+                        mat2[k2, col0, m, lidx] = w0_2[m, lidx]
+                        mat2[k2, col1, m, lidx] = w1_2[m, lidx]
+
+                cmat2[k] = self.backend.bk_cast(
+                    mat2[0 : k + 1, None, ...].astype("complex64")
+                )
 
             if k < l_nside - 1:
                 tmp, _ = self.ud_grade_2(tmp, axis=1)
@@ -2620,6 +2624,9 @@ class funct(FOC.FoCUS):
                 x1 = im_shape[1]
                 x2 = im_shape[2]
             J = int(np.log(nside - self.KERNELSZ) / np.log(2))  # Number of j scales
+            if J == 0:
+                print("Use of too small 2D domain does not work J_max=", J)
+                return None
         elif self.use_1D:
             if len(image1.shape) == 2:
                 npix = int(im_shape[1])  # Number of pixels
@@ -2842,21 +2849,25 @@ class funct(FOC.FoCUS):
             ### Make the convolution I1 * Psi_j3
             conv1 = self.convol(
                 I1, axis=1, cell_ids=cell_ids_j3, nside=nside_j3
-            )  # [Nbatch, Npix_j3, Norient3]
+            )  # [Nbatch, Norient3 , Npix_j3]
+
             if cmat is not None:
-                tmp2 = self.backend.bk_repeat(conv1, self.NORIENT, axis=-1)
+
+                tmp2 = self.backend.bk_repeat(conv1, self.NORIENT, axis=-2)
+
                 conv1 = self.backend.bk_reduce_sum(
                     self.backend.bk_reshape(
                         cmat[j3] * tmp2,
-                        [tmp2.shape[0], cmat[j3].shape[0], self.NORIENT, self.NORIENT],
+                        [tmp2.shape[0], self.NORIENT, self.NORIENT, cmat[j3].shape[2]],
                     ),
-                    2,
+                    1,
                 )
 
             ### Take the module M1 = |I1 * Psi_j3|
             M1_square = conv1 * self.backend.bk_conjugate(
                 conv1
-            )  # [Nbatch, Npix_j3, Norient3]
+            )  # [Nbatch, Norient3, Npix_j3]
+
             M1 = self.backend.bk_L1(M1_square)  # [Nbatch, Npix_j3, Norient3]
             # Store M1_j3 in a dictionary
             M1_dic[j3] = M1
@@ -2871,10 +2882,10 @@ class funct(FOC.FoCUS):
                 else:
                     if calc_var:
                         s2, vs2 = self.masked_mean(
-                            M1_square, vmask, axis=1, rank=j3, calc_var=True
+                            M1_square, vmask, axis=2, rank=j3, calc_var=True
                         )
                     else:
-                        s2 = self.masked_mean(M1_square, vmask, axis=1, rank=j3)
+                        s2 = self.masked_mean(M1_square, vmask, axis=2, rank=j3)
 
                 if cond_init_P1_dic:
                     # We fill P1_dic with S2 for normalisation of S3 and S4
@@ -2890,9 +2901,9 @@ class funct(FOC.FoCUS):
                                 s2,
                                 [
                                     s2.shape[0],
+                                    s2.shape[2],
                                     12 * out_nside**2,
                                     (nside_j3 // out_nside) ** 2,
-                                    s2.shape[2],
                                 ],
                             ),
                             2,
@@ -2918,11 +2929,11 @@ class funct(FOC.FoCUS):
                 else:
                     if calc_var:
                         s1, vs1 = self.masked_mean(
-                            M1, vmask, axis=1, rank=j3, calc_var=True
+                            M1, vmask, axis=2, rank=j3, calc_var=True
                         )  # [Nbatch, Nmask, Norient3]
                     else:
                         s1 = self.masked_mean(
-                            M1, vmask, axis=1, rank=j3
+                            M1, vmask, axis=2, rank=j3
                         )  # [Nbatch, Nmask, Norient3]
 
                 if return_data:
@@ -2932,9 +2943,9 @@ class funct(FOC.FoCUS):
                                 s1,
                                 [
                                     s1.shape[0],
+                                    s1.shape[2],
                                     12 * out_nside**2,
                                     (nside_j3 // out_nside) ** 2,
-                                    s1.shape[2],
                                 ],
                             ),
                             2,
@@ -2956,21 +2967,21 @@ class funct(FOC.FoCUS):
             else:  # Cross
                 ### Make the convolution I2 * Psi_j3
                 conv2 = self.convol(
-                    I2, axis=1, cell_ids=cell_ids_j3, nside=nside_j3
+                    I2, axis=2, cell_ids=cell_ids_j3, nside=nside_j3
                 )  # [Nbatch, Npix_j3, Norient3]
                 if cmat is not None:
-                    tmp2 = self.backend.bk_repeat(conv2, self.NORIENT, axis=-1)
+                    tmp2 = self.backend.bk_repeat(conv2, self.NORIENT, axis=-2)
                     conv2 = self.backend.bk_reduce_sum(
                         self.backend.bk_reshape(
                             cmat[j3] * tmp2,
                             [
                                 tmp2.shape[0],
-                                cmat[j3].shape[0],
                                 self.NORIENT,
                                 self.NORIENT,
+                                cmat[j3].shape[2],
                             ],
                         ),
-                        2,
+                        1,
                     )
                 ### Take the module M2 = |I2 * Psi_j3|
                 M2_square = conv2 * self.backend.bk_conjugate(
@@ -2990,17 +3001,17 @@ class funct(FOC.FoCUS):
                     else:
                         if calc_var:
                             p1, vp1 = self.masked_mean(
-                                M1_square, vmask, axis=1, rank=j3, calc_var=True
+                                M1_square, vmask, axis=2, rank=j3, calc_var=True
                             )  # [Nbatch, Nmask, Norient3]
                             p2, vp2 = self.masked_mean(
-                                M2_square, vmask, axis=1, rank=j3, calc_var=True
+                                M2_square, vmask, axis=2, rank=j3, calc_var=True
                             )  # [Nbatch, Nmask, Norient3]
                         else:
                             p1 = self.masked_mean(
-                                M1_square, vmask, axis=1, rank=j3
+                                M1_square, vmask, axis=2, rank=j3
                             )  # [Nbatch, Nmask, Norient3]
                             p2 = self.masked_mean(
-                                M2_square, vmask, axis=1, rank=j3
+                                M2_square, vmask, axis=2, rank=j3
                             )  # [Nbatch, Nmask, Norient3]
                     # We fill P1_dic with S2 for normalisation of S3 and S4
                     P1_dic[j3] = self.backend.bk_real(p1)  # [Nbatch, Nmask, Norient3]
@@ -3016,10 +3027,10 @@ class funct(FOC.FoCUS):
                 else:
                     if calc_var:
                         s2, vs2 = self.masked_mean(
-                            s2, vmask, axis=1, rank=j3, calc_var=True
+                            s2, vmask, axis=2, rank=j3, calc_var=True
                         )
                     else:
-                        s2 = self.masked_mean(s2, vmask, axis=1, rank=j3)
+                        s2 = self.masked_mean(s2, vmask, axis=2, rank=j3)
 
                 if return_data:
                     if out_nside is not None and out_nside < nside_j3:
@@ -3028,22 +3039,23 @@ class funct(FOC.FoCUS):
                                 s2,
                                 [
                                     s2.shape[0],
+                                    s2.shape[2],
                                     12 * out_nside**2,
                                     (nside_j3 // out_nside) ** 2,
-                                    s2.shape[2],
                                 ],
                             ),
                             2,
                         )
                     S2[j3] = s2
                 else:
-                    ### Normalize S2_cross
-                    if norm == "auto":
-                        s2 /= (P1_dic[j3] * P2_dic[j3]) ** 0.5
 
                     ### Store S2_cross as complex [Nbatch, Nmask, NS2, Norient3]
                     s2 = self.backend.bk_real(s2)
 
+                    ### Normalize S2_cross
+                    if norm == "auto":
+                        s2 /= (P1_dic[j3] * P2_dic[j3]) ** 0.5
+
                     S2.append(
                         self.backend.bk_expand_dims(s2, off_S2)
                     )  # Add a dimension for NS2
@@ -3060,11 +3072,11 @@ class funct(FOC.FoCUS):
                 else:
                     if calc_var:
                         s1, vs1 = self.masked_mean(
-                            MX, vmask, axis=1, rank=j3, calc_var=True
+                            MX, vmask, axis=2, rank=j3, calc_var=True
                         )  # [Nbatch, Nmask, Norient3]
                     else:
                         s1 = self.masked_mean(
-                            MX, vmask, axis=1, rank=j3
+                            MX, vmask, axis=2, rank=j3
                         )  # [Nbatch, Nmask, Norient3]
                 if return_data:
                     if out_nside is not None and out_nside < nside_j3:
@@ -3073,9 +3085,9 @@ class funct(FOC.FoCUS):
                                 s1,
                                 [
                                     s1.shape[0],
+                                    s1.shape[2],
                                     12 * out_nside**2,
                                     (nside_j3 // out_nside) ** 2,
-                                    s1.shape[2],
                                 ],
                             ),
                             2,
@@ -3486,19 +3498,19 @@ class funct(FOC.FoCUS):
                 for j2 in range(0, j3 + 1):  # j2 =< j3
                     ### Dictionary M1_dic[j2]
                     M1_smooth = self.smooth(
-                        M1_dic[j2], axis=1, cell_ids=cell_ids_j3, nside=nside_j3
+                        M1_dic[j2], axis=2, cell_ids=cell_ids_j3, nside=nside_j3
                     )  # [Nbatch, Npix_j3, Norient3]
                     M1_dic[j2], new_cell_ids_j2 = self.ud_grade_2(
-                        M1_smooth, axis=1, cell_ids=cell_ids_j3, nside=nside_j3
+                        M1_smooth, axis=2, cell_ids=cell_ids_j3, nside=nside_j3
                     )  # [Nbatch, Npix_j3, Norient3]
 
                     ### Dictionary M2_dic[j2]
                     if cross:
                         M2_smooth = self.smooth(
-                            M2_dic[j2], axis=1, cell_ids=cell_ids_j3, nside=nside_j3
+                            M2_dic[j2], axis=2, cell_ids=cell_ids_j3, nside=nside_j3
                         )  # [Nbatch, Npix_j3, Norient3]
                         M2_dic[j2], new_cell_ids_j2 = self.ud_grade_2(
-                            M2_smooth, axis=1, cell_ids=cell_ids_j3, nside=nside_j3
+                            M2_smooth, axis=2, cell_ids=cell_ids_j3, nside=nside_j3
                         )  # [Nbatch, Npix_j3, Norient3]
                 ### Mask
                 vmask, new_cell_ids_j3 = self.ud_grade_2(
@@ -3623,51 +3635,51 @@ class funct(FOC.FoCUS):
         cs3, ss3: real and imag parts of S3 coeff
         """
         ### Compute |I1 * Psi_j2| * Psi_j3 = M1_j2 * Psi_j3
-        # Warning: M1_dic[j2] is already at j3 resolution [Nbatch, Npix_j3, Norient3]
+        # Warning: M1_dic[j2] is already at j3 resolution [Nbatch, Norient3, Npix_j3]
         MconvPsi = self.convol(
-            M_dic[j2], axis=1, cell_ids=cell_ids, nside=nside_j2
-        )  # [Nbatch, Npix_j3, Norient3, Norient2]
+            M_dic[j2], axis=2, cell_ids=cell_ids, nside=nside_j2
+        )  # [Nbatch,   Norient3, Norient2, Npix_j3]
+
         if cmat2 is not None:
-            tmp2 = self.backend.bk_repeat(MconvPsi, self.NORIENT, axis=-1)
+            tmp2 = self.backend.bk_repeat(MconvPsi, self.NORIENT, axis=-3)
             MconvPsi = self.backend.bk_reduce_sum(
                 self.backend.bk_reshape(
                     cmat2[j3][j2] * tmp2,
                     [
                         tmp2.shape[0],
-                        cmat2[j3].shape[1],
                         self.NORIENT,
                         self.NORIENT,
                         self.NORIENT,
+                        cmat2[j3][j2].shape[3],
                     ],
                 ),
-                3,
+                1,
             )
 
         # Store it so we can use it in S4 computation
-        MconvPsi_dic[j2] = MconvPsi  # [Nbatch, Npix_j3, Norient3, Norient2]
+        MconvPsi_dic[j2] = MconvPsi  # [Nbatch, Norient3, Norient2, Npix_j3]
 
         ### Compute the product (I2 * Psi)_j3 x (M1_j2 * Psi_j3)^*
         # z_1 x z_2^* = (a1a2 + b1b2) + i(b1a2 - a1b2)
-        # cconv, sconv are [Nbatch, Npix_j3, Norient3]
+        # cconv, sconv are [Nbatch, Norient3, Npix_j3]
         if self.use_1D:
             s3 = conv * self.backend.bk_conjugate(MconvPsi)
         else:
-            s3 = self.backend.bk_expand_dims(conv, -1) * self.backend.bk_conjugate(
+            s3 = self.backend.bk_expand_dims(conv, -3) * self.backend.bk_conjugate(
                 MconvPsi
-            )  # [Nbatch, Npix_j3, Norient3, Norient2]
-
+            )  # [Nbatch, Norient3, Norient2, Npix_j3]
         ### Apply the mask [Nmask, Npix_j3] and sum over pixels
         if return_data:
             return s3
         else:
             if calc_var:
                 s3, vs3 = self.masked_mean(
-                    s3, vmask, axis=1, rank=j2, calc_var=True
+                    s3, vmask, axis=3, rank=j2, calc_var=True
                 )  # [Nbatch, Nmask, Norient3, Norient2]
                 return s3, vs3
             else:
                 s3 = self.masked_mean(
-                    s3, vmask, axis=1, rank=j2
+                    s3, vmask, axis=3, rank=j2
                 )  # [Nbatch, Nmask, Norient3, Norient2]
             return s3
 
@@ -3682,11 +3694,11 @@ class funct(FOC.FoCUS):
         return_data=False,
     ):
         #### Simplify notations
-        M1 = M1convPsi_dic[j1]  # [Nbatch, Npix_j3, Norient3, Norient1]
+        M1 = M1convPsi_dic[j1]  # [Nbatch, Norient3, Norient1, Npix_j3]
 
         # Auto or Cross coefficients
         if M2convPsi_dic is None:  # Auto
-            M2 = M1convPsi_dic[j2]  # [Nbatch, Npix_j3, Norient3, Norient2]
+            M2 = M1convPsi_dic[j2]  # [Nbatch, Norient3, Norient2, Npix_j3]
         else:  # Cross
             M2 = M2convPsi_dic[j2]
 
@@ -3695,9 +3707,9 @@ class funct(FOC.FoCUS):
         if self.use_1D:
             s4 = M1 * self.backend.bk_conjugate(M2)
         else:
-            s4 = self.backend.bk_expand_dims(M1, -2) * self.backend.bk_conjugate(
-                self.backend.bk_expand_dims(M2, -1)
-            )  # [Nbatch, Npix_j3, Norient3, Norient2, Norient1]
+            s4 = self.backend.bk_expand_dims(M1, -4) * self.backend.bk_conjugate(
+                self.backend.bk_expand_dims(M2, -3)
+            )  # [Nbatch,  Norient3, Norient2, Norient1,Npix_j3]
 
         ### Apply the mask and sum over pixels
         if return_data:
@@ -3705,12 +3717,12 @@ class funct(FOC.FoCUS):
         else:
             if calc_var:
                 s4, vs4 = self.masked_mean(
-                    s4, vmask, axis=1, rank=j2, calc_var=True
+                    s4, vmask, axis=4, rank=j2, calc_var=True
                 )  # [Nbatch, Nmask, Norient3, Norient2, Norient1]
                 return s4, vs4
             else:
                 s4 = self.masked_mean(
-                    s4, vmask, axis=1, rank=j2
+                    s4, vmask, axis=4, rank=j2
                 )  # [Nbatch, Nmask, Norient3, Norient2, Norient1]
                 return s4
 
@@ -6045,14 +6057,11 @@ class funct(FOC.FoCUS):
         image2=None,
         mask=None,
         norm=None,
-        Auto=True,
         cmat=None,
         cmat2=None,
     ):
 
-        res = self.eval(
-            image1, image2=image2, mask=mask, Auto=Auto, cmat=cmat, cmat2=cmat2
-        )
+        res = self.eval(image1, image2=image2, mask=mask, cmat=cmat, cmat2=cmat2)
         return res.S0, res.S2, res.S1, res.S3, res.S4, res.S3P
 
     def eval_fast(
@@ -6061,12 +6070,11 @@ class funct(FOC.FoCUS):
         image2=None,
         mask=None,
         norm=None,
-        Auto=True,
         cmat=None,
         cmat2=None,
     ):
         s0, s2, s1, s3, s4, s3p = self.eval_comp_fast(
-            image1, image2=image2, mask=mask, Auto=Auto, cmat=cmat, cmat2=cmat2
+            image1, image2=image2, mask=mask, cmat=cmat, cmat2=cmat2
         )
         return scat_cov(
             s0, s2, s3, s4, s1=s1, s3p=s3p, backend=self.backend, use_1D=self.use_1D
@@ -6102,6 +6110,15 @@ class funct(FOC.FoCUS):
         if edge:
             self.purge_edge_mask()
 
+        def The_loss_ref_image(u, scat_operator, args):
+            input_image = args[0]
+            mask = args[1]
+
+            loss = 1e-3 * scat_operator.backend.bk_reduce_mean(
+                scat_operator.backend.bk_square(mask * (input_image - u))
+            )
+            return loss
+
         def The_loss(u, scat_operator, args):
             ref = args[0]
             sref = args[1]
@@ -6339,7 +6356,18 @@ class funct(FOC.FoCUS):
                     The_lossX, self, ref, sref, use_variance, l_ref[k], l_jmax[k]
                 )
 
-            sy = synthe.Synthesis([loss])
+            if input_image is not None:
+                # define a loss to minimize
+                loss_input = synthe.Loss(
+                    The_loss_ref_image,
+                    self,
+                    self.backend.bk_cast(l_input_image[k]),
+                    self.backend.bk_cast(l_in_mask[k]),
+                )
+
+                sy = synthe.Synthesis([loss])  # ,loss_input])
+            else:
+                sy = synthe.Synthesis([loss])
 
             # initialize the synthesised map
             if self.use_2D:

foscat/scat_cov_map.py

@@ -29,7 +29,6 @@ class funct(scat.funct):
         image2=None,
         mask=None,
         norm=None,
-        Auto=True,
         calc_var=False,
         out_nside=None,
     ):
@@ -38,7 +37,6 @@ class funct(scat.funct):
             image2=image2,
             mask=mask,
             norm=norm,
-            Auto=Auto,
             calc_var=calc_var,
             out_nside=out_nside,
         )

foscat/scat_cov_map2D.py

@@ -23,10 +23,10 @@ class funct(scat.funct):
         super().__init__(use_2D=True, return_data=True, *args, **kwargs)
 
     def eval(
-        self, image1, image2=None, mask=None, norm=None, Auto=True, calc_var=False
+        self, image1, image2=None, mask=None, norm=None, calc_var=False, Jmax=None
     ):
         r = super().eval(
-            image1, image2=image2, mask=mask, norm=norm, Auto=Auto, calc_var=calc_var
+            image1, image2=image2, mask=mask, norm=norm, calc_var=calc_var, Jmax=Jmax
         )
         return scat_cov_map(
             r.S2, r.S0, r.S3, r.S4, S1=r.S1, S3P=r.S3P, backend=r.backend

{foscat-2025.3.0.dist-info → foscat-2025.5.2.dist-info}/METADATA

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

@@ -1,10 +1,10 @@
-foscat/BkBase.py,sha256=_iszgMdVIVEB47EBxNt5xemsdaKzsNFPStDF00M_-Ng,21281
+foscat/BkBase.py,sha256=TEhfqUpIOh_bGBCyQfRCs0yjKdhgELjFpvq_QiouX5A,21514
 foscat/BkNumpy.py,sha256=zRldS_-L6A7y1zDzEPZXQntuw3Paw2zHZowhD43FHRs,10589
-foscat/BkTensorflow.py,sha256=N5TBacuyFB1-qGTi2kOc8zbgWzj5lVRRN47uZJpJJ10,15713
-foscat/BkTorch.py,sha256=011L9WCBtrRzV1jfGWCYOMSkt1IJ0PfEO82NnrIYbAc,16648
+foscat/BkTensorflow.py,sha256=K2s3xYVMHqLlTyApQpeKf9dc3hbRv8EqtCA_gE1bRQA,19958
+foscat/BkTorch.py,sha256=7TwJxSw_XGyJyvombHrfsT7LFm4RNHt1sDQD53Fbll0,18105
 foscat/CNN.py,sha256=j0F2a4Xf3LijhyD_WVZ6Eg_IjGuXw3ddH6Iudj1xVaw,4874
 foscat/CircSpline.py,sha256=CXi49FxF8ZoeZ17Ua8c1AZXe2B5ICEC9aCXb97atB3s,4028
-foscat/FoCUS.py,sha256=iCWuhQqYQ1ub3F0flO2iVuMoN7gCDd1oZ79SIH9-oww,108768
+foscat/FoCUS.py,sha256=kKjuLvdCrR8VHjnxzdgYSCpe8LnNlHaDOV6Riu8UEO4,95289
 foscat/GCNN.py,sha256=5RV-FKuvqbD-k99TwiM4CttM2LMZE21WD0IK0j5Mkko,7599
 foscat/Softmax.py,sha256=aBLQauoG0q2SJYPotV6U-cxAhsJcspWHNRWdnA_nAiQ,2854
 foscat/Spline1D.py,sha256=rKzzenduaZZ-yBDJd35it6Gyrj1spqb7hoIaUgISPzY,2983
@@ -18,13 +18,13 @@ foscat/loss_backend_torch.py,sha256=k3z18Dj3SaLKK6ZIKcm7GO4U_YKYVP6LtHG1aIbxkYk,
 foscat/scat.py,sha256=qGYiBIysPt65MdmF07WWA4piVlTfA9-lFDTaicnqC2w,72822
 foscat/scat1D.py,sha256=W5Uu6wdQ4ZsFKXpof0f1OBl-1wjJmW7ruvddRWxe7uM,53726
 foscat/scat2D.py,sha256=boKj0ASqMMSy7uQLK6hPniG87m3hZGJBYBiq5v8F9IQ,532
-foscat/scat_cov.py,sha256=ZOFDWNC8q04N6Tvpe7RxSWlRgJ8jgsIyPJ_EJ39CXOg,258297
+foscat/scat_cov.py,sha256=tpuYqyPwYdG8vjm4uwYUjajeHzxYwCto-Bky475oPXA,259203
 foscat/scat_cov1D.py,sha256=XOxsZZ5TYq8f34i2tUgIfzyaqaTDlICB3HzD2l_puro,531
 foscat/scat_cov2D.py,sha256=pAm0fKw8wyXram0TFbtw8tGcc8QPKuPXpQk0kh10r4U,7078
-foscat/scat_cov_map.py,sha256=Swt39-nYEaQkBzyX4EOAQBvUuYQpERzJ-uVxSWS2b-Y,2911
-foscat/scat_cov_map2D.py,sha256=FqF45FBcoiQbvuVsrLWUIPRUc95GsKsrnH6fKzB3GlE,2841
-foscat-2025.3.0.dist-info/licenses/LICENSE,sha256=i0ukIr8ZUpkSY2sZaE9XZK-6vuSU5iG6IgX_3pjatP8,1505
-foscat-2025.3.0.dist-info/METADATA,sha256=hfPyoLACrvhbOjv70ve--tjL5CseBXEHMFvC3CNzSr0,7215
-foscat-2025.3.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-foscat-2025.3.0.dist-info/top_level.txt,sha256=AGySXBBAlJgb8Tj8af6m_F-aiNg2zNTcybCUPVOKjAg,7
-foscat-2025.3.0.dist-info/RECORD,,
+foscat/scat_cov_map.py,sha256=9MzpwT2g9S3dmnjHEMK7PPLQ27oGQg2VFVsP_TDUU5E,2869
+foscat/scat_cov_map2D.py,sha256=1dS4P1KHqZYkYCLA1sYpPSZulJrCTd_2eL8HFOjlcz4,2841
+foscat-2025.5.2.dist-info/licenses/LICENSE,sha256=i0ukIr8ZUpkSY2sZaE9XZK-6vuSU5iG6IgX_3pjatP8,1505
+foscat-2025.5.2.dist-info/METADATA,sha256=sbR5VT1kq7d1qrLd74c-CdprtKhpkC6eHQ1nE24nqtI,7215
+foscat-2025.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+foscat-2025.5.2.dist-info/top_level.txt,sha256=AGySXBBAlJgb8Tj8af6m_F-aiNg2zNTcybCUPVOKjAg,7
+foscat-2025.5.2.dist-info/RECORD,,

{foscat-2025.3.0.dist-info → foscat-2025.5.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any