foscat 3.3.5__tar.gz → 3.4.0__tar.gz

{foscat-3.3.5/src/foscat.egg-info → foscat-3.4.0}/PKG-INFO

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

{foscat-3.3.5 → foscat-3.4.0}/pyproject.toml

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

{foscat-3.3.5 → foscat-3.4.0}/src/foscat/FoCUS.py

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

{foscat-3.3.5 → foscat-3.4.0}/src/foscat/alm.py

@@ -3,7 +3,8 @@ import numpy as np
 
 class alm():
 
-    def __init__(self,backend=None,lmax=24,nside=None,limit_range=1E10):
+    def __init__(self,backend=None,lmax=24,
+                 nside=None,limit_range=1E10):
         self._logtab={}
         self.lth={}
         if nside is not None:
@@ -232,47 +233,57 @@ class alm():
             ii+=1
         return self.backend.bk_reshape(self.backend.bk_concat(ft_im,axis=0),[4*nside-1,3*nside])
 
-    def anafast(self,im,map2=None,nest=False):
+    def anafast(self,im,map2=None,nest=False,spin=2):
+        
         """The `anafast` function computes the L1 and L2 norm power spectra. 
 
         Currently, it is not optimized for single-pass computation due to the relatively inefficient computation of \(Y_{lm}\). 
         Nonetheless, it utilizes TensorFlow and can be integrated into gradient computations.
 
         Input:
-        - `im`: a vector of size \([12 \times \text{Nside}^2]\) for scalar data, or of size \([3, 12 \times \text{Nside}^2]\) for polar data.
+        - `im`: a vector of size \([12 \times \text{Nside}^2]\) for scalar data, or of size \([2, 12 \times \text{Nside}^2]\) for Q,U polar data, 
+        or of size \([3, 12 \times \text{Nside}^2]\) for I,Q,U polar data.
         - `map2` (optional): a vector of size \([12 \times \text{Nside}^2]\) for scalar data, or of size 
         \([3, 12 \times \text{Nside}^2]\) for polar data. If provided, cross power spectra will be computed.
         - `nest=True`: alters the ordering of the input maps.
+        - `spin=2` for 1/2 spin data as Q and U. Spin=1 for seep fields
 
         Output:
         -A tensor of size \([l_{\text{max}} \times (l_{\text{max}}-1)]\) formatted as \([6, \ldots]\), 
         ordered as TT, EE, BB, TE, EB.TBanafast function computes L1 and L2 norm powerspctra.
 
         """
+        doT=True
         if len(im.shape)==1: # nopol
             nside=int(np.sqrt(im.shape[0]//12))
         else:
+            if im.shape[0]==2:
+                doT=False
+                
             nside=int(np.sqrt(im.shape[1]//12))
+            
         th,ph=hp.pix2ang(nside,np.arange(12*nside*nside))
-        if nest:
-            idx=hp.ring2nest(nside,np.arange(12*nside**2))
-            if len(im.shape)==1: # nopol
-                ft_im=self.comp_tf(self.backend.bk_complex(self.backend.bk_gather(im,idx),0*im),ph)
-                if map2 is not None:
-                    ft_im2=self.comp_tf(self.backend.bk_complex(self.backend.bk_gather(map2,idx),0*im),ph)
-            else:
-                ft_im=self.comp_tf(self.backend.bk_complex(self.backend.bk_gather(im[0],idx),0*im[0]),ph)
-                if map2 is not None:
-                    ft_im2=self.comp_tf(self.backend.bk_complex(self.backend.bk_gather(map2[0],idx),0*im[0]),ph)
-        else:
-            if len(im.shape)==1: # nopol
-                ft_im=self.comp_tf(self.backend.bk_complex(im,0*im),ph)
-                if map2 is not None:
-                    ft_im2=self.comp_tf(self.backend.bk_complex(map2,0*im),ph)
+        
+        if doT: # nopol
+            if nest:
+                idx=hp.ring2nest(nside,np.arange(12*nside**2))
+                if len(im.shape)==1: # nopol
+                    ft_im=self.comp_tf(self.backend.bk_complex(self.backend.bk_gather(im,idx),0*im),ph)
+                    if map2 is not None:
+                        ft_im2=self.comp_tf(self.backend.bk_complex(self.backend.bk_gather(map2,idx),0*im),ph)
+                else:
+                    ft_im=self.comp_tf(self.backend.bk_complex(self.backend.bk_gather(im[0],idx),0*im[0]),ph)
+                    if map2 is not None:
+                        ft_im2=self.comp_tf(self.backend.bk_complex(self.backend.bk_gather(map2[0],idx),0*im[0]),ph)
             else:
-                ft_im=self.comp_tf(self.backend.bk_complex(im[0],0*im[0]),ph)
-                if map2 is not None:
-                    ft_im2=self.comp_tf(self.backend.bk_complex(map2[0],0*im[0]),ph)
+                if len(im.shape)==1: # nopol
+                    ft_im=self.comp_tf(self.backend.bk_complex(im,0*im),ph)
+                    if map2 is not None:
+                        ft_im2=self.comp_tf(self.backend.bk_complex(map2,0*im),ph)
+                else:
+                    ft_im=self.comp_tf(self.backend.bk_complex(im[0],0*im[0]),ph)
+                    if map2 is not None:
+                        ft_im2=self.comp_tf(self.backend.bk_complex(map2[0],0*im[0]),ph)
                     
         lth=self.ring_th(nside)
 
@@ -282,34 +293,40 @@ class alm():
         
         cl2=None
         cl2_L1=None
-
         
         if len(im.shape)==2: # nopol
-            
-            spin=2
         
             self.init_Ys(spin,nside)
             
             if nest:
                 idx=hp.ring2nest(nside,np.arange(12*nside**2))
-                l_Q=self.backend.bk_gather(im[1],idx)
-                l_U=self.backend.bk_gather(im[2],idx)
+                l_Q=self.backend.bk_gather(im[int(doT)],idx)
+                l_U=self.backend.bk_gather(im[1+int(doT)],idx)
                 ft_im_Pp=self.comp_tf(self.backend.bk_complex(l_Q,l_U),ph)
                 ft_im_Pm=self.comp_tf(self.backend.bk_complex(l_Q,-l_U),ph)
+                if map2 is not None:
+                    l_Q=self.backend.bk_gather(map2[int(doT)],idx)
+                    l_U=self.backend.bk_gather(map2[1+int(doT)],idx)
+                    ft_im2_Pp=self.comp_tf(self.backend.bk_complex(l_Q,l_U),ph)
+                    ft_im2_Pm=self.comp_tf(self.backend.bk_complex(l_Q,-l_U),ph)
             else:
-                ft_im_Pp=self.comp_tf(self.backend.bk_complex(im[1],im[2]),ph)
-                ft_im_Pm=self.comp_tf(self.backend.bk_complex(im[1],-im[2]),ph)
+                ft_im_Pp=self.comp_tf(self.backend.bk_complex(im[int(doT)],im[1+int(doT)]),ph)
+                ft_im_Pm=self.comp_tf(self.backend.bk_complex(im[int(doT)],-im[1+int(doT)]),ph)
+                if map2 is not None:
+                    ft_im2_Pp=self.comp_tf(self.backend.bk_complex(map2[int(doT)],map2[1+int(doT)]),ph)
+                    ft_im2_Pm=self.comp_tf(self.backend.bk_complex(map2[int(doT)],-map2[1+int(doT)]),ph)
 
         for m in range(lmax+1):
 
             plm=self.compute_legendre_m(co_th,m,3*nside-1)/(12*nside**2)
-            
-            tmp=self.backend.bk_reduce_sum(plm*ft_im[:,m],1)
-            
-            if map2 is not None:
-                tmp2=self.backend.bk_reduce_sum(plm*ft_im2[:,m],1)
-            else:
-                tmp2=tmp
+
+            if doT:
+                tmp=self.backend.bk_reduce_sum(plm*ft_im[:,m],1)
+
+                if map2 is not None:
+                    tmp2=self.backend.bk_reduce_sum(plm*ft_im2[:,m],1)
+                else:
+                    tmp2=tmp
                 
             if len(im.shape)==2: # pol
                 plmp=self.Yp[spin,nside][m]
@@ -325,35 +342,52 @@ class alm():
                     tmpp2=self.backend.bk_reduce_sum(plmp*ft_im2_Pp[:,m],1)
                     tmpm2=self.backend.bk_reduce_sum(plmm*ft_im2_Pm[:,m],1)
                 
-                    almE2=-(tmpp+tmpm)/2.0
-                    almB2=(tmpp-tmpm)/(2J)
+                    almE2=-(tmpp2+tmpm2)/2.0
+                    almB2=(tmpp2-tmpm2)/(2J)
                 else:
                     almE2=almE
                     almB2=almB
-
-                tmpTT=self.backend.bk_real((tmp*self.backend.bk_conjugate(tmp2)))
+                    
+                if doT:
+                    tmpTT=self.backend.bk_real((tmp*self.backend.bk_conjugate(tmp2)))
+                    tmpTE=self.backend.bk_real((tmp*self.backend.bk_conjugate(almE2)))
+                    tmpTB=-self.backend.bk_real((tmp*self.backend.bk_conjugate(almB2)))
+                
                 tmpEE=self.backend.bk_real((almE*self.backend.bk_conjugate(almE2)))
                 tmpBB=self.backend.bk_real((almB*self.backend.bk_conjugate(almB2)))
-                tmpTE=self.backend.bk_real((tmp*self.backend.bk_conjugate(almE2)))
-                tmpTB=-self.backend.bk_real((tmp*self.backend.bk_conjugate(almB2)))
                 tmpEB=-self.backend.bk_real((almE*self.backend.bk_conjugate(almB2)))
+                
                 if map2 is not None:
-                    tmpTE=(tmpTE+self.backend.bk_real((tmp2*self.backend.bk_conjugate(almE))))/2
-                    tmpTB=(tmpTB-self.backend.bk_real((tmp2*self.backend.bk_conjugate(almB))))/2
                     tmpEB=(tmpEB-self.backend.bk_real((almE2*self.backend.bk_conjugate(almB))))/2
+                    
+                    if doT:
+                        tmpTE=(tmpTE+self.backend.bk_real((tmp2*self.backend.bk_conjugate(almE))))/2
+                        tmpTB=(tmpTB-self.backend.bk_real((tmp2*self.backend.bk_conjugate(almB))))/2
+                
 
                 if m==0:
-                    l_cl=self.backend.bk_concat([tmpTT,tmpEE,tmpBB,tmpTE,tmpEB,tmpTB],0)
+                    if doT:
+                        l_cl=self.backend.bk_concat([tmpTT,tmpEE,tmpBB,tmpTE,tmpEB,tmpTB],0)
+                    else:
+                        l_cl=self.backend.bk_concat([tmpEE,tmpBB,tmpEB],0)
                 else:
                     offset_tensor=self.backend.bk_zeros((m),dtype=self.backend.all_bk_type)
-                    l_cl=self.backend.bk_concat([self.backend.bk_concat([offset_tensor,tmpTT],axis=0),
-                                                 self.backend.bk_concat([offset_tensor,tmpEE],axis=0),
-                                                 self.backend.bk_concat([offset_tensor,tmpBB],axis=0),
-                                                 self.backend.bk_concat([offset_tensor,tmpTE],axis=0),
-                                                 self.backend.bk_concat([offset_tensor,tmpEB],axis=0),
-                                                 self.backend.bk_concat([offset_tensor,tmpTB],axis=0)],axis=0)
+                    if doT:
+                        l_cl=self.backend.bk_concat([self.backend.bk_concat([offset_tensor,tmpTT],axis=0),
+                                                     self.backend.bk_concat([offset_tensor,tmpEE],axis=0),
+                                                     self.backend.bk_concat([offset_tensor,tmpBB],axis=0),
+                                                     self.backend.bk_concat([offset_tensor,tmpTE],axis=0),
+                                                     self.backend.bk_concat([offset_tensor,tmpEB],axis=0),
+                                                     self.backend.bk_concat([offset_tensor,tmpTB],axis=0)],axis=0)
+                    else:
+                        l_cl=self.backend.bk_concat([self.backend.bk_concat([offset_tensor,tmpEE],axis=0),
+                                                     self.backend.bk_concat([offset_tensor,tmpBB],axis=0),
+                                                     self.backend.bk_concat([offset_tensor,tmpEB],axis=0)],axis=0)
                     
-                l_cl=self.backend.bk_reshape(l_cl,[6,lmax+1])
+                if doT:
+                    l_cl=self.backend.bk_reshape(l_cl,[6,lmax+1])
+                else:
+                    l_cl=self.backend.bk_reshape(l_cl,[3,lmax+1])
             else:
                 tmp=self.backend.bk_real((tmp*self.backend.bk_conjugate(tmp2)))
                 if m==0:

{foscat-3.3.5 → foscat-3.4.0}/src/foscat/backend.py

@@ -590,6 +590,17 @@ class foscat_backend:
             if self.BACKEND == self.NUMPY:
                 return np.sum(data, axis)
 
+    # ---------------------------------------------−---------
+    # return a tensor size
+    
+    def bk_size(self, data):
+        if self.BACKEND == self.TENSORFLOW:
+            return self.backend.size(data)
+        if self.BACKEND == self.TORCH:
+            return data.numel()
+        if self.BACKEND == self.NUMPY:
+            return data.size
+        
     # ---------------------------------------------−---------
 
     def iso_mean(self, x, use_2D=False):

{foscat-3.3.5 → foscat-3.4.0}/src/foscat/scat_cov.py

@@ -3548,36 +3548,81 @@ class funct(FOC.FoCUS):
             return self.backend.bk_abs(self.backend.bk_sqrt(x))
 
     def reduce_mean(self, x):
+        
         if isinstance(x, scat_cov):
-            if x.S1 is None:
-                result = (
-                    self.backend.bk_reduce_mean(self.backend.bk_abs(x.S0))
-                    + self.backend.bk_reduce_mean(self.backend.bk_abs(x.S2))
-                    + self.backend.bk_reduce_mean(self.backend.bk_abs(x.S3))
-                    + self.backend.bk_reduce_mean(self.backend.bk_abs(x.S4))
-                ) / 3
-            else:
-                result = (
-                    self.backend.bk_reduce_mean(self.backend.bk_abs(x.S0))
-                    + self.backend.bk_reduce_mean(self.backend.bk_abs(x.S2))
-                    + self.backend.bk_reduce_mean(self.backend.bk_abs(x.S1))
-                    + self.backend.bk_reduce_mean(self.backend.bk_abs(x.S3))
-                    + self.backend.bk_reduce_mean(self.backend.bk_abs(x.S4))
-                ) / 4
-        else:
-            return self.backend.bk_reduce_mean(x)
-        return result
+            result = self.backend.bk_reduce_sum(self.backend.bk_abs(x.S0)) + \
+                     self.backend.bk_reduce_sum(self.backend.bk_abs(x.S2)) + \
+                     self.backend.bk_reduce_sum(self.backend.bk_abs(x.S3)) + \
+                     self.backend.bk_reduce_sum(self.backend.bk_abs(x.S4))
+                
+            N = self.backend.bk_size(x.S0)+self.backend.bk_size(x.S2)+ \
+                self.backend.bk_size(x.S3)+self.backend.bk_size(x.S4)
+                
+            if x.S1 is not None:
+                result = result+self.backend.bk_reduce_sum(self.backend.bk_abs(x.S1))
+                N = N + self.backend.bk_size(x.S1)
+            if x.S3P is not None:
+                result = result+self.backend.bk_reduce_sum(self.backend.bk_abs(x.S3P))
+                N = N + self.backend.bk_size(x.S3P)
+            return result/self.backend.bk_cast(N)
+        else:
+            return self.backend.bk_reduce_mean(x, axis=0)
+                
 
     def reduce_mean_batch(self, x):
+        
         if isinstance(x, scat_cov):
-            result = scat_cov()
-            # Assuming the batch dimension is the first dimension
-            result.S0 = self.backend.bk_reduce_mean(x.S0, axis=0)
-            result.S2 = self.backend.bk_reduce_mean(x.S2, axis=0)
+            
+            sS0=self.backend.bk_reduce_mean(x.S0, axis=0)
+            sS2=self.backend.bk_reduce_mean(x.S2, axis=0)
+            sS3=self.backend.bk_reduce_mean(x.S3, axis=0)
+            sS4=self.backend.bk_reduce_mean(x.S4, axis=0)
+            sS1=None
+            sS3P=None
             if x.S1 is not None:
-                result.S1 = self.backend.bk_reduce_mean(x.S1, axis=0)
-            result.S3 = self.backend.bk_reduce_mean(x.S3, axis=0)
-            result.S4 = self.backend.bk_reduce_mean(x.S4, axis=0)
+                sS1 = self.backend.bk_reduce_mean(x.S1, axis=0)
+            if x.S3P is not None:
+                sS3P = self.backend.bk_reduce_mean(x.S3P, axis=0)
+                
+            result = scat_cov(
+                sS0,
+                sS2,
+                sS3,
+                sS4,
+                s1=sS1,
+                s3p=sS3P,
+                backend=self.backend,
+                use_1D=self.use_1D,
+            )
+            return result
+        else:
+            return self.backend.bk_reduce_mean(x, axis=0)
+    
+    def reduce_sum_batch(self, x):
+        
+        if isinstance(x, scat_cov):
+            
+            sS0=self.backend.bk_reduce_sum(x.S0, axis=0)
+            sS2=self.backend.bk_reduce_sum(x.S2, axis=0)
+            sS3=self.backend.bk_reduce_sum(x.S3, axis=0)
+            sS4=self.backend.bk_reduce_sum(x.S4, axis=0)
+            sS1=None
+            sS3P=None
+            if x.S1 is not None:
+                sS1 = self.backend.bk_reduce_sum(x.S1, axis=0)
+            if x.S3P is not None:
+                sS3P = self.backend.bk_reduce_sum(x.S3P, axis=0)
+                
+            result = scat_cov(
+                sS0,
+                sS2,
+                sS3,
+                sS4,
+                s1=sS1,
+                s3p=sS3P,
+                backend=self.backend,
+                use_1D=self.use_1D,
+            )
             return result
         else:
             return self.backend.bk_reduce_mean(x, axis=0)

{foscat-3.3.5 → foscat-3.4.0/src/foscat.egg-info}/PKG-INFO

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