foscat 3.8.0__tar.gz → 3.8.2__tar.gz

{foscat-3.8.0/src/foscat.egg-info → foscat-3.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: foscat
-Version: 3.8.0
+Version: 3.8.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-3.8.0 → foscat-3.8.2}/pyproject.toml

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

{foscat-3.8.0 → foscat-3.8.2}/src/foscat/BkBase.py

@@ -539,7 +539,16 @@ class BackendBase:
     def bk_constant(self,x):
         raise NotImplementedError("This is an abstract class.")
             
-    def bk_empty(self,x):
+    def bk_cos(self,x):
+        raise NotImplementedError("This is an abstract class.")
+        
+    def bk_sin(self,x):
+        raise NotImplementedError("This is an abstract class.")
+        
+    def bk_arctan2(self,c,s):
+        raise NotImplementedError("This is an abstract class.")
+        
+    def bk_empty(self,list):
         raise NotImplementedError("This is an abstract class.")
         
     def to_numpy(self,x):

{foscat-3.8.0 → foscat-3.8.2}/src/foscat/BkNumpy.py

@@ -284,8 +284,17 @@ class BkNumpy(BackendBase.BackendBase):
     def bk_zeros(self, shape, dtype=None):
         return np.zeros(shape, dtype=dtype)
 
-    def bk_gather(self, data, idx):
-        return data[idx]
+    def bk_gather(self, data, idx,axis=0):
+        if axis==0:
+            return data[idx]
+        elif axis==1:
+            return data[:,idx]
+        elif axis==2:
+            return data[:,:,idx]
+        elif axis==3:
+            return data[:,:,:,idx]
+        return data[:,:,:,:,idx]
+        
 
     def bk_reverse(self, data, axis=0):
         return np.reverse(data, axis=axis)
@@ -367,6 +376,15 @@ class BkNumpy(BackendBase.BackendBase):
             
         return self.bk_cast(x)
         
+    def bk_cos(self,x):
+        return self.backend.cos(x)
+        
+    def bk_sin(self,x):
+        return self.backend.sin(x)
+        
+    def bk_arctan2(self,c,s):
+        return self.backend.arctan2(c,s)
+        
     def bk_empty(self,list):
         return self.backend.empty(list)
         

{foscat-3.8.0 → foscat-3.8.2}/src/foscat/BkTensorflow.py

@@ -363,8 +363,8 @@ class BkTensorflow(BackendBase.BackendBase):
     def bk_zeros(self, shape, dtype=None):
         return self.backend.zeros(shape, dtype=dtype)
 
-    def bk_gather(self, data, idx):
-        return self.backend.gather(data, idx)
+    def bk_gather(self, data, idx,axis=0):
+        return self.backend.gather(data, idx,axis=axis)
 
     def bk_reverse(self, data, axis=0):
         return self.backend.reverse(data, axis=[axis])
@@ -469,6 +469,15 @@ class BkTensorflow(BackendBase.BackendBase):
     def bk_constant(self,x):
         return self.backend.constant(x)
         
+    def bk_cos(self,x):
+        return self.backend.cos(x)
+        
+    def bk_sin(self,x):
+        return self.backend.sin(x)
+        
+    def bk_arctan2(self,c,s):
+        return self.backend.arctan2(c,s)
+        
     def bk_empty(self,list):
         return self.backend.constant(list)
         

{foscat-3.8.0 → foscat-3.8.2}/src/foscat/BkTorch.py

@@ -282,7 +282,7 @@ class BkTorch(BackendBase.BackendBase):
         return data.view(shape)
 
     def bk_repeat(self, data, nn, axis=0):
-        return self.backend.repeat(data, nn, axis=axis)
+        return self.backend.repeat_interleave(data, repeats=nn, dim=axis)
 
     def bk_tile(self, data, nn, axis=0):
 
@@ -329,8 +329,16 @@ class BkTorch(BackendBase.BackendBase):
     def bk_zeros(self, shape, dtype=None):
         return self.backend.zeros(shape, dtype=dtype).to(self.torch_device)
 
-    def bk_gather(self, data, idx):
-        return data[idx]
+    def bk_gather(self, data, idx,axis=0):
+        if axis==0:
+            return data[idx]
+        elif axis==1:
+            return data[:,idx]
+        elif axis==2:
+            return data[:,:,idx]
+        elif axis==3:
+            return data[:,:,:,idx]
+        return data[:,:,:,:,idx]
 
     def bk_reverse(self, data, axis=0):
         return self.backend.flip(data, dims=[axis])
@@ -427,6 +435,15 @@ class BkTorch(BackendBase.BackendBase):
             
         return self.bk_cast(x)
         
+    def bk_cos(self,x):
+        return self.backend.cos(x)
+        
+    def bk_sin(self,x):
+        return self.backend.sin(x)
+        
+    def bk_arctan2(self,c,s):
+        return self.backend.arctan2(c,s)
+        
     def bk_empty(self,list):
         return self.backend.empty(list)
         

{foscat-3.8.0 → foscat-3.8.2}/src/foscat/FoCUS.py

@@ -36,7 +36,7 @@ class FoCUS:
             mpi_rank=0,
     ):
 
-        self.__version__ = "3.8.0"
+        self.__version__ = "3.8.2"
         # P00 coeff for normalization for scat_cov
         self.TMPFILE_VERSION = TMPFILE_VERSION
         self.P1_dic = None

{foscat-3.8.0 → foscat-3.8.2}/src/foscat/alm.py

@@ -615,14 +615,13 @@ class alm:
 
             if nest:
                 idx = hp.ring2nest(nside, np.arange(12 * nside**2))
-                if len(i_im.shape) == 1:  # nopol
-                    ft_im = self.comp_tf(
-                        self.backend.bk_gather(l_im, idx), nside, realfft=True
+                ft_im = self.comp_tf(
+                    self.backend.bk_gather(l_im, idx, axis=1), nside, realfft=True
+                )
+                if map2 is not None:
+                    ft_im2 = self.comp_tf(
+                        self.backend.bk_gather(l_map2, idx, axis=1), nside, realfft=True
                     )
-                    if map2 is not None:
-                        ft_im2 = self.comp_tf(
-                            self.backend.bk_gather(l_map2, idx), nside, realfft=True
-                        )
             else:
                 ft_im = self.comp_tf(l_im, nside, realfft=True)
                 if map2 is not None:
@@ -657,13 +656,13 @@ class alm:
 
             if nest:
                 idx = hp.ring2nest(nside, np.arange(12 * nside**2))
-                l_Q = self.backend.bk_gather(l_im[:,int(do_all_pol)], idx)
-                l_U = self.backend.bk_gather(l_im[:,1 + int(do_all_pol)], idx)
+                l_Q = self.backend.bk_gather(l_im[:,int(do_all_pol)], idx,axis=1)
+                l_U = self.backend.bk_gather(l_im[:,1 + int(do_all_pol)], idx,axis=1)
                 ft_im_Pp = self.comp_tf(self.backend.bk_complex(l_Q, l_U), nside)
                 ft_im_Pm = self.comp_tf(self.backend.bk_complex(l_Q, -l_U), nside)
                 if map2 is not None:
-                    l_Q = self.backend.bk_gather(l_map2[:,int(do_all_pol)], idx)
-                    l_U = self.backend.bk_gather(l_map2[:,1 + int(do_all_pol)], idx)
+                    l_Q = self.backend.bk_gather(l_map2[:,int(do_all_pol)], idx,axis=1)
+                    l_U = self.backend.bk_gather(l_map2[:,1 + int(do_all_pol)], idx,axis=1)
                     ft_im2_Pp = self.comp_tf(self.backend.bk_complex(l_Q, l_U), nside)
                     ft_im2_Pm = self.comp_tf(self.backend.bk_complex(l_Q, -l_U), nside)
             else:

{foscat-3.8.0 → foscat-3.8.2}/src/foscat/scat_cov.py

@@ -2277,14 +2277,14 @@ class funct(FOC.FoCUS):
                     if tmp.S1 is not None:
                         nS1 = np.expand_dims(tmp.S1, 0)
                 else:
-                    nS0 = np.expand_dims(tmp.S0.numpy(), 0)
-                    nS2 = np.expand_dims(tmp.S2.numpy(), 0)
-                    nS3 = np.expand_dims(tmp.S3.numpy(), 0)
-                    nS4 = np.expand_dims(tmp.S4.numpy(), 0)
+                    nS0 = np.expand_dims(self.backend.to_numpy(tmp.S0), 0)
+                    nS2 = np.expand_dims(self.backend.to_numpy(tmp.S2), 0)
+                    nS3 = np.expand_dims(self.backend.to_numpy(tmp.S3), 0)
+                    nS4 = np.expand_dims(self.backend.to_numpy(tmp.S4), 0)
                     if tmp.S3P is not None:
-                        nS3P = np.expand_dims(tmp.S3P.numpy(), 0)
+                        nS3P = np.expand_dims(self.backend.to_numpy(tmp.S3P), 0)
                     if tmp.S1 is not None:
-                        nS1 = np.expand_dims(tmp.S1.numpy(), 0)
+                        nS1 = np.expand_dims(self.backend.to_numpy(tmp.S1), 0)
 
                 if S0 is None:
                     S0 = nS0
@@ -2304,24 +2304,24 @@ class funct(FOC.FoCUS):
                         S3P = np.concatenate([S3P, nS3P], 0)
                     if tmp.S1 is not None:
                         S1 = np.concatenate([S1, nS1], 0)
-            sS0 = np.std(S0, 0)
-            sS2 = np.std(S2, 0)
-            sS3 = np.std(S3, 0)
-            sS4 = np.std(S4, 0)
-            mS0 = np.mean(S0, 0)
-            mS2 = np.mean(S2, 0)
-            mS3 = np.mean(S3, 0)
-            mS4 = np.mean(S4, 0)
+            sS0 = self.backend.bk_cast(np.std(S0, 0))
+            sS2 = self.backend.bk_cast(np.std(S2, 0))
+            sS3 = self.backend.bk_cast(np.std(S3, 0))
+            sS4 = self.backend.bk_cast(np.std(S4, 0))
+            mS0 = self.backend.bk_cast(np.mean(S0, 0))
+            mS2 = self.backend.bk_cast(np.mean(S2, 0))
+            mS3 = self.backend.bk_cast(np.mean(S3, 0))
+            mS4 = self.backend.bk_cast(np.mean(S4, 0))
             if tmp.S3P is not None:
-                sS3P = np.std(S3P, 0)
-                mS3P = np.mean(S3P, 0)
+                sS3P = self.backend.bk_cast(np.std(S3P, 0))
+                mS3P = self.backend.bk_cast(np.mean(S3P, 0))
             else:
                 sS3P = None
                 mS3P = None
 
             if tmp.S1 is not None:
-                sS1 = np.std(S1, 0)
-                mS1 = np.mean(S1, 0)
+                sS1 = self.backend.bk_cast(np.std(S1, 0))
+                mS1 = self.backend.bk_cast(np.mean(S1, 0))
             else:
                 sS1 = None
                 mS1 = None
@@ -2375,14 +2375,13 @@ class funct(FOC.FoCUS):
 
             # instead of difference between "opposite" channels use weighted average
             # of cosine and sine contributions using all channels
-            angles = (
+            angles = self.backend.bk_cast((
                 2 * np.pi * np.arange(self.NORIENT) / self.NORIENT
-            )  # shape: (NORIENT,)
-            angles = angles.reshape(1, 1, self.NORIENT)
+            ).reshape(1, 1, self.NORIENT))  # shape: (NORIENT,)
 
             # we use cosines and sines as weights for sim
-            weighted_cos = self.backend.bk_reduce_mean(sim * np.cos(angles), axis=-1)
-            weighted_sin = self.backend.bk_reduce_mean(sim * np.sin(angles), axis=-1)
+            weighted_cos = self.backend.bk_reduce_mean(sim * self.backend.bk_cos(angles), axis=-1)
+            weighted_sin = self.backend.bk_reduce_mean(sim * self.backend.bk_sin(angles), axis=-1)
             # For simplicity, take first element of the batch
             cc = weighted_cos[0]
             ss = weighted_sin[0]
@@ -2402,7 +2401,8 @@ class funct(FOC.FoCUS):
                 phase = np.fmod(np.arctan2(ss, cc) + 2 * np.pi, 2 * np.pi)
             else:
                 phase = np.fmod(
-                    np.arctan2(ss.numpy(), cc.numpy()) + 2 * np.pi, 2 * np.pi
+                    np.arctan2(self.backend.to_numpy(ss), 
+                                self.backend.to_numpy(cc)) + 2 * np.pi, 2 * np.pi
                 )
 
             # instead of linear interpolation cosine‐based interpolation
@@ -2435,7 +2435,8 @@ class funct(FOC.FoCUS):
 
                 sim2 = self.backend.bk_reduce_sum(
                     self.backend.bk_reshape(
-                        mat.reshape(1, mat.shape[0], self.NORIENT * self.NORIENT)
+                        self.backend.bk_cast(
+                        mat.reshape(1, mat.shape[0], self.NORIENT * self.NORIENT))
                         * tmp2,
                         [sim.shape[0], cmat[k].shape[0], self.NORIENT, self.NORIENT],
                     ),
@@ -2445,10 +2446,10 @@ class funct(FOC.FoCUS):
                 sim2 = self.backend.bk_abs(self.convol(sim2, axis=1))
 
                 weighted_cos2 = self.backend.bk_reduce_mean(
-                    sim2 * np.cos(angles), axis=-1
+                    sim2 * self.backend.bk_cos(angles), axis=-1
                 )
                 weighted_sin2 = self.backend.bk_reduce_mean(
-                    sim2 * np.sin(angles), axis=-1
+                    sim2 * self.backend.bk_sin(angles), axis=-1
                 )
 
                 cc2 = weighted_cos2[0]
@@ -2469,7 +2470,8 @@ class funct(FOC.FoCUS):
                     phase2 = np.fmod(np.arctan2(ss2, cc2) + 2 * np.pi, 2 * np.pi)
                 else:
                     phase2 = np.fmod(
-                        np.arctan2(ss2.numpy(), cc2.numpy()) + 2 * np.pi, 2 * np.pi
+                        np.arctan2(self.backend.to_numpy(ss2), 
+                                self.backend.to_numpy(cc2)) + 2 * np.pi, 2 * np.pi
                     )
 
                 phase2_scaled = self.NORIENT * phase2 / (2 * np.pi)
@@ -4936,6 +4938,11 @@ class funct(FOC.FoCUS):
         if S4_criteria is None:
             S4_criteria = 'j2>=j1'
         
+        if self.all_bk_type == "float32":
+            C_ONE=np.complex64(1.0)
+        else:
+            C_ONE=np.complex128(1.0)
+            
         # determine jmax and nside corresponding to the input map
         im_shape = data.shape
         if self.use_2D:
@@ -5623,7 +5630,10 @@ class funct(FOC.FoCUS):
             edge_dx = min(4, int(2**j3*dx3*2/M))
             edge_dy = min(4, int(2**j3*dy3*2/N))
             # a normalization change due to the cutoff of frequency space
-            fft_factor = 1 /(M3*N3) * (M3*N3/M/N)**2
+            if self.all_bk_type == "float32":
+                fft_factor = np.complex64(1 /(M3*N3) * (M3*N3/M/N)**2)
+            else:
+                fft_factor = np.complex128(1 /(M3*N3) * (M3*N3/M/N)**2)
             for j2 in range(0,j3+1):
                 #I1_f2_wf3_small = I1_f_small[:,j2].view(N_image,L,1,M3,N3) * wavelet_f3.view(1,1,L,M3,N3)
                 #I1_f2_wf3_2_small = I1_f_small[:,j2].view(N_image,L,1,M3,N3) * wavelet_f3_squared.view(1,1,L,M3,N3)
@@ -5635,21 +5645,24 @@ class funct(FOC.FoCUS):
                 if use_ref:
                     if normalization=='P11':
                         norm_factor_S3 = (ref_S2[:,None,j3,:] * ref_P11[:,j2,j3,:,:]**pseudo_coef)**0.5
+                        norm_factor_S3 = self.backend.bk_complex(norm_factor_S3,0*norm_factor_S3)
                     elif normalization=='S2':
                         norm_factor_S3 = (ref_S2[:,None,j3,:] * ref_S2[:,j2,:,None]**pseudo_coef)**0.5
+                        norm_factor_S3 = self.backend.bk_complex(norm_factor_S3,0*norm_factor_S3)
                     else:
-                        norm_factor_S3 = 1.0
+                        norm_factor_S3 = C_ONE
                 else:
                     if normalization=='P11':
                         # [N_image,l2,l3,x,y]
                         P11_temp = self.backend.bk_reduce_mean((I1_f2_wf3_small.abs()**2),axis=(-2,-1)) * fft_factor
                         norm_factor_S3 = (S2[:,None,j3,:] * P11_temp**pseudo_coef)**0.5
+                        norm_factor_S3 = self.backend.bk_complex(norm_factor_S3,0*norm_factor_S3)
                     elif normalization=='S2':
                         norm_factor_S3 = (S2[:,None,j3,None,:] * S2[:,None,j2,:,None]**pseudo_coef)**0.5
+                        norm_factor_S3 = self.backend.bk_complex(norm_factor_S3,0*norm_factor_S3)
                     else:
-                        norm_factor_S3 = 1.0
+                        norm_factor_S3 = C_ONE
                         
-                norm_factor_S3 = self.backend.bk_complex(norm_factor_S3,0*norm_factor_S3)
 
                 if not edge:
                     S3.append(self.backend.bk_reduce_mean(
@@ -5695,7 +5708,7 @@ class funct(FOC.FoCUS):
                             P = 1/(((S2[:,j3:j3+1,:,None,None] * S2[:,j2:j2+1,None,:,None] )**(0.5*pseudo_coef)))
                         P=self.backend.bk_complex(P,0.0*P)
                     else:
-                        P=self.backend.bk_complex(1.0,0.0)
+                        P=C_ONE
                         
                     for j1 in range(0, j2+1):
                             if not edge:

{foscat-3.8.0 → foscat-3.8.2/src/foscat.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: foscat
-Version: 3.8.0
+Version: 3.8.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>