foscat 3.0.47__tar.gz → 3.1.0__tar.gz

{foscat-3.0.47 → foscat-3.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foscat
-Version: 3.0.47
+Version: 3.1.0
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Home-page: https://github.com/jmdelouis/FOSCAT
 Author: Jean-Marc DELOUIS

{foscat-3.0.47 → foscat-3.1.0}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='foscat',
-    version='3.0.47',
+    version='3.1.0',
     description='Generate synthetic Healpix or 2D data using Cross Scattering Transform' ,
     long_description='Utilize the Cross Scattering Transform (described in https://arxiv.org/abs/2207.12527) to synthesize Healpix or 2D data that is suitable for component separation purposes, such as denoising. \n A demo package for this process can be found at https://github.com/jmdelouis/FOSCAT_DEMO. \n Complete doc can be found at https://foscat-documentation.readthedocs.io/en/latest/index.html. \n\n List of developers : J.-M. Delouis, T. Foulquier, L. Mousset, T. Odaka, F. Paul, E. Allys ' ,
     license='MIT',

{foscat-3.0.47 → foscat-3.1.0}/src/foscat/FoCUS.py

@@ -24,6 +24,7 @@ class FoCUS:
                  TEMPLATE_PATH='data',
                  BACKEND='tensorflow',
                  use_2D=False,
+                 use_1D=False,
                  return_data=False,
                  JmaxDelta=0,
                  DODIV=False,
@@ -32,7 +33,7 @@ class FoCUS:
                  mpi_size=1,
                  mpi_rank=0):
 
-        self.__version__ = '3.0.47'
+        self.__version__ = '3.1.0'
         # P00 coeff for normalization for scat_cov
         self.TMPFILE_VERSION=TMPFILE_VERSION
         self.P1_dic = None
@@ -86,6 +87,7 @@ class FoCUS:
             
         self.OSTEP=JmaxDelta
         self.use_2D=use_2D
+        self.use_1D=use_1D
         
         if isMPI:
             from mpi4py import MPI
@@ -214,12 +216,14 @@ class FoCUS:
                         
 
                 w_smooth=w_smooth.flatten()
-
+        if self.use_1D:
+            KERNELSZ=5
+            
         self.KERNELSZ=KERNELSZ
 
         self.Idx_Neighbours={}
         
-        if not self.use_2D:
+        if not self.use_2D and not self.use_1D:
             self.w_smooth = {}
             for i in range(nstep_max):
                 lout=(2**i)
@@ -239,6 +243,21 @@ class FoCUS:
                 self.ww_Real[lout]=wr
                 self.ww_Imag[lout]=wi
                 self.w_smooth[lout]=ws
+        elif self.use_1D==True:
+            self.w_smooth=slope*(w_smooth/w_smooth.sum()).astype(self.all_type)
+            self.ww_RealT={}
+            self.ww_ImagT={}
+            self.ww_SmoothT={}
+            if KERNELSZ==5:
+                xx=np.arange(5)-2
+                w=np.exp(-0.25*(xx)**2)
+                c=np.cos((xx)*np.pi/2)
+                s=np.sin((xx)*np.pi/2)
+                
+                self.ww_RealT[1]=self.backend.constant(np.array(w*c).reshape(xx.shape[0],1,1))
+                self.ww_ImagT[1]=self.backend.constant(np.array(w*s).reshape(xx.shape[0],1,1))
+                self.ww_SmoothT[1] = self.backend.constant(np.array(w).reshape(xx.shape[0],1,1))
+            
         else:
             self.w_smooth=slope*(w_smooth/w_smooth.sum()).astype(self.all_type)
             self.ww_RealT={}
@@ -573,7 +592,7 @@ class FoCUS:
             tim=self.backend.bk_reshape(self.backend.bk_cast(im),[ndata,npix,npiy,odata])
             tim=self.backend.bk_reshape(tim[:,0:2*(npix//2),0:2*(npiy//2),:],[ndata,npix//2,2,npiy//2,2,odata])
 
-            res=self.backend.bk_reduce_mean(self.backend.bk_reduce_mean(tim,4),2)
+            res=self.backend.bk_reduce_sum(self.backend.bk_reduce_sum(tim,4),2)/4
         
             if axis==0:
                 if len(ishape)==2:
@@ -587,6 +606,40 @@ class FoCUS:
                     return self.backend.bk_reshape(res,ishape[0:axis]+[npix//2,npiy//2]+ishape[axis+2:])
                 
             return self.backend.bk_reshape(res,[npix//2,npiy//2])
+        elif self.use_1D:
+            ishape=list(im.shape)
+            if len(ishape)<axis+1:
+                if not self.silent:
+                    print('Use of 1D scat with data that has less than 1D')
+                return None
+                
+            npix=im.shape[axis]
+            odata=1
+            if len(ishape)>axis+1:
+                for k in range(axis+1,len(ishape)):
+                    odata=odata*ishape[k]
+                    
+            ndata=1
+            for k in range(axis):
+                ndata=ndata*ishape[k]
+
+            tim=self.backend.bk_reshape(self.backend.bk_cast(im),[ndata,npix,odata])
+            tim=self.backend.bk_reshape(tim[:,0:2*(npix//2),:],[ndata,npix//2,2,odata])
+
+            res=self.backend.bk_reduce_mean(tim,2)
+        
+            if axis==0:
+                if len(ishape)==1:
+                    return self.backend.bk_reshape(res,[npix//2])
+                else:
+                    return self.backend.bk_reshape(res,[npix//2]+ishape[axis+1:])
+            else:
+                if len(ishape)==axis+1:
+                    return self.backend.bk_reshape(res,ishape[0:axis]+[npix//2])
+                else:
+                    return self.backend.bk_reshape(res,ishape[0:axis]+[npix//2]+ishape[axis+1:])
+                
+            return self.backend.bk_reshape(res,[npix//2])
             
         else:
             shape=list(im.shape)
@@ -653,6 +706,46 @@ class FoCUS:
                     return self.backend.bk_reshape(res,ishape[0:axis]+[nout,nouty]+ishape[axis+2:])
                 
             return self.backend.bk_reshape(res,[nout,nouty])
+
+        elif self.use_1D:
+            ishape=list(im.shape)
+            if len(ishape)<axis+1:
+                if not self.silent:
+                    print('Use of 1D scat with data that has less than 1D')
+                return None
+                
+            if ishape[axis]==nout:
+                return im
+                
+            npix=im.shape[axis]
+            odata=1
+            if len(ishape)>axis+1:
+                for k in range(axis+1,len(ishape)):
+                    odata=odata*ishape[k]
+                    
+            ndata=1
+            for k in range(axis):
+                ndata=ndata*ishape[k]
+
+            tim=self.backend.bk_reshape(self.backend.bk_cast(im),[ndata,npix,odata])
+
+            while tim.shape[1]!=nout:
+                res2=self.backend.bk_expand_dims(self.backend.bk_concat([(tim[:,1:,:]+3*tim[:,:-1,:])/4,tim[:,-1:,:]],1),-2)
+                res1=self.backend.bk_expand_dims(self.backend.bk_concat([tim[:,0:1,:],(tim[:,1:,:]*3+tim[:,:-1,:])/4],1),-2)
+                tim = self.backend.bk_reshape(self.backend.bk_concat([res1,res2],-2),[ndata,tim.shape[1]*2,odata])
+        
+            if axis==0:
+                if len(ishape)==1:
+                    return self.backend.bk_reshape(tim,[nout])
+                else:
+                    return self.backend.bk_reshape(tim,[nout]+ishape[axis+1:])
+            else:
+                if len(ishape)==axis+1:
+                    return self.backend.bk_reshape(tim,ishape[0:axis]+[nout])
+                else:
+                    return self.backend.bk_reshape(tim,ishape[0:axis]+[nout]+ishape[axis+1:])
+                
+            return self.backend.bk_reshape(tim,[nout])
             
         else:
 
@@ -842,7 +935,7 @@ class FoCUS:
             ndata=ndata*ishape[k]
             
         tim=self.backend.bk_reshape(self.backend.bk_cast(im),[ndata,npix,odata])
-
+        
         res2=self.backend.bk_expand_dims(self.backend.bk_concat([(tim[:,1:,:]+3*tim[:,:-1,:])/4,tim[:,-1:,:]],1),-2)
         res1=self.backend.bk_expand_dims(self.backend.bk_concat([tim[:,0:1,:],(tim[:,1:,:]*3+tim[:,:-1,:])/4],1),-2)
         res = self.backend.bk_concat([res1,res2],-2)
@@ -1278,66 +1371,117 @@ class FoCUS:
             sum_mask=self.backend.bk_reduce_sum(self.backend.bk_reshape(l_mask,[l_mask.shape[0],np.prod(np.array(l_mask.shape[1:]))]),1)
             if not self.use_2D:
                 l_mask=12*nside*nside*l_mask/self.backend.bk_reshape(sum_mask,[l_mask.shape[0]]+[1 for i in l_mask.shape[1:]])
-            else:
+            elif self.use_2D: 
                 l_mask=mask.shape[1]*mask.shape[2]*l_mask/self.backend.bk_reshape(sum_mask,[l_mask.shape[0]]+[1 for i in l_mask.shape[1:]])
-            
+            else:
+                l_mask=mask.shape[1]*l_mask/self.backend.bk_reshape(sum_mask,[l_mask.shape[0]]+[1 for i in l_mask.shape[1:]])
+
         if self.use_2D:
-            if self.padding=='VALID' and shape[axis]!=l_mask.shape[1]:
+            if self.padding=='VALID':
                 l_mask=l_mask[:,self.KERNELSZ//2:-self.KERNELSZ//2+1,self.KERNELSZ//2:-self.KERNELSZ//2+1]
                 if shape[axis]!=l_mask.shape[1]:
                     l_mask=l_mask[:,self.KERNELSZ//2:-self.KERNELSZ//2+1,self.KERNELSZ//2:-self.KERNELSZ//2+1]
-            else:
-                l_mask=l_mask[:,self.KERNELSZ//2:-self.KERNELSZ//2+1,self.KERNELSZ//2:-self.KERNELSZ//2+1]
                 
-        # data=[Nbatch,...,X[,Y],NORIENT[,NORIENT]] => data=[Nbatch,...,KERNELSZ//2:-self.KERNELSZ//2,KERNELSZ//2:-self.KERNELSZ//2,NORIENT[,NORIENT]]
-        if self.use_2D:
             ichannel=1
             for i in range(axis):
                 ichannel*=shape[i]
             ochannel=1
             for i in range(axis+2,len(shape)):
                 ochannel*=shape[i]
-            l_x=self.backend.bk_reshape(x,[ichannel,shape[axis],shape[axis+1],ochannel])
-            oshape=[k for k in shape]
-            oshape[axis]=oshape[axis]-self.KERNELSZ+1
-            oshape[axis+1]=oshape[axis+1]-self.KERNELSZ+1
-            l_x=self.backend.bk_reshape(l_x[:,self.KERNELSZ//2:-self.KERNELSZ//2+1,self.KERNELSZ//2:-self.KERNELSZ//2+1,:],oshape)
-        else:
-            l_x=x
+            l_x=self.backend.bk_reshape(x,[ichannel,1,shape[axis],shape[axis+1],ochannel])
+        
+            if self.padding=='VALID':
+                oshape=[k for k in shape]
+                oshape[axis]=oshape[axis]-self.KERNELSZ+1
+                oshape[axis+1]=oshape[axis+1]-self.KERNELSZ+1
+                l_x=self.backend.bk_reshape(l_x[:,:,self.KERNELSZ//2:-self.KERNELSZ//2+1,self.KERNELSZ//2:-self.KERNELSZ//2+1,:],oshape)
+  
+        elif self.use_1D:
+            if self.padding=='VALID':
+                l_mask=l_mask[:,self.KERNELSZ//2:-self.KERNELSZ//2+1]
+                if shape[axis]!=l_mask.shape[1]:
+                    l_mask=l_mask[:,self.KERNELSZ//2:-self.KERNELSZ//2+1]
+               
+            ichannel=1
+            for i in range(axis):
+                ichannel*=shape[i]
+            ochannel=1
+            for i in range(axis+1,len(shape)):
+                ochannel*=shape[i]
+            l_x=self.backend.bk_reshape(x,[ichannel,1,shape[axis],ochannel])
             
+            if self.padding=='VALID':
+                oshape=[k for k in shape]
+                oshape[axis]=oshape[axis]-self.KERNELSZ+1
+                l_x=self.backend.bk_reshape(l_x[:,:,self.KERNELSZ//2:-self.KERNELSZ//2+1,:],oshape)
+        else:
+            ichannel=1
+            for i in range(axis):
+                ichannel*=shape[i]
+            ochannel=1
+            for i in range(axis+1,len(shape)):
+                ochannel*=shape[i]
+            l_x=self.backend.bk_reshape(x,[ichannel,1,shape[axis],ochannel])
+
         # data=[Nbatch,...,X[,Y],NORIENT[,NORIENT]] => data=[Nbatch,1,...,X[,Y],NORIENT[,NORIENT]]
-        l_x=self.backend.bk_expand_dims(l_x,1)
-        
         # mask=[Nmask,X[,Y]] => mask=[1,Nmask,X[,Y]]
         l_mask=self.backend.bk_expand_dims(l_mask,0)
-        
-        # mask=[1,Nmask,X[,Y]] => mask=[1,Nmask,....,X[,Y]]
-        for i in range(1,axis):
-            l_mask=self.backend.bk_expand_dims(l_mask,axis)
+        # mask=[1,Nmask,X[,Y]] => mask=[1,Nmask,X[,Y],1]
+        l_mask=self.backend.bk_expand_dims(l_mask,-1)
             
         if l_x.dtype==self.all_cbk_type:
             l_mask=self.backend.bk_complex(l_mask,self.backend.bk_cast(0.0*l_mask))
             
         if self.use_2D:
+            mtmp=l_mask
+            vtmp=l_x
+            
+            v1=self.backend.bk_reduce_sum(self.backend.bk_reduce_sum(mtmp*vtmp,axis=2),2)
+            v2=self.backend.bk_reduce_sum(self.backend.bk_reduce_sum(mtmp*vtmp*vtmp,axis=2),2)
+            vh=self.backend.bk_reduce_sum(self.backend.bk_reduce_sum(mtmp,axis=2),2)
 
-            # mask=[1,Nmask,....,X,Y] => mask=[1,Nmask,....,X,Y,....]
-            for i in range(axis+2,len(x.shape)):
-                l_mask=self.backend.bk_expand_dims(l_mask,-1)
-
-            shape1=list(l_mask.shape)
-            shape2=list(l_x.shape)
+            res=v1/vh
+            
+            oshape=[]
+            if axis>0:
+                oshape=oshape+list(x.shape[0:axis])
+            oshape=oshape+[mask.shape[0]]
+            if axis+1<len(x.shape):
+                oshape=oshape+list(x.shape[axis+2:])
+                
+            if calc_var:
+                if self.backend.bk_is_complex(vtmp):
+                    res2=self.backend.bk_sqrt(((self.backend.bk_real(v2)/self.backend.bk_real(vh)
+                                            -self.backend.bk_real(res)*self.backend.bk_real(res)) + \
+                                            (self.backend.bk_imag(v2)/self.backend.bk_real(vh) \
+                                             -self.backend.bk_imag(res)*self.backend.bk_imag(res)))/self.backend.bk_real(vh))
+                else:
+                    res2=self.backend.bk_sqrt((v2/vh-res*res)/(vh))
 
-            oshape1=shape1[0:axis+1]+[shape1[axis+1]*shape1[axis+2]]+shape1[axis+3:]
-            oshape2=shape2[0:axis+1]+[shape2[axis+1]*shape2[axis+2]]+shape2[axis+3:]
+                res=self.backend.bk_reshape(res,oshape)
+                res2=self.backend.bk_reshape(res2,oshape)
+                return res,res2
+            else:
+                res=self.backend.bk_reshape(res,oshape)
+                return res
             
-            mtmp=self.backend.bk_reshape(l_mask,oshape1)
-            vtmp=self.backend.bk_reshape(l_x,oshape2)
+        elif self.use_1D:
+            mtmp=l_mask
+            vtmp=l_x
 
-            v1=self.backend.bk_reduce_sum(mtmp*vtmp,axis=axis+1)
-            v2=self.backend.bk_reduce_sum(mtmp*vtmp*vtmp,axis=axis+1)
-            vh=self.backend.bk_reduce_sum(mtmp,axis=axis+1)
+            v1=self.backend.bk_reduce_sum(mtmp*vtmp,axis=2)
+            v2=self.backend.bk_reduce_sum(mtmp*vtmp*vtmp,axis=2)
+            vh=self.backend.bk_reduce_sum(mtmp,axis=2)
 
             res=v1/vh
+            
+            oshape=[]
+            if axis>0:
+                oshape=oshape+list(x.shape[0:axis])
+            oshape=oshape+[mask.shape[0]]
+            if axis+1<len(x.shape):
+                oshape=oshape+list(x.shape[axis+1:])
+                
             if calc_var:
                 if self.backend.bk_is_complex(vtmp):
                     res2=self.backend.bk_sqrt(((self.backend.bk_real(v2)/self.backend.bk_real(vh)
@@ -1346,19 +1490,29 @@ class FoCUS:
                                              -self.backend.bk_imag(res)*self.backend.bk_imag(res)))/self.backend.bk_real(vh))
                 else:
                     res2=self.backend.bk_sqrt((v2/vh-res*res)/(vh))
+
+                    
+                res=self.backend.bk_reshape(res,oshape)
+                res2=self.backend.bk_reshape(res2,oshape)
                 return res,res2
             else:
+                res=self.backend.bk_reshape(res,oshape)
                 return res
-        else:
-            # mask=[1,Nmask,....,X] => mask=[1,Nmask,....,X,....]
-            for i in range(axis+1,len(x.shape)):
-                l_mask=self.backend.bk_expand_dims(l_mask,-1)
-                
-            v1=self.backend.bk_reduce_sum(l_mask*l_x,axis=axis+1)
-            v2=self.backend.bk_reduce_sum(l_mask*l_x*l_x,axis=axis+1)
-            vh=self.backend.bk_reduce_sum(l_mask,axis=axis+1)
+            
+        else:   
+            v1=self.backend.bk_reduce_sum(l_mask*l_x,axis=2)
+            v2=self.backend.bk_reduce_sum(l_mask*l_x*l_x,axis=2)
+            vh=self.backend.bk_reduce_sum(l_mask,axis=2)
             
             res=v1/vh
+            
+            oshape=[]
+            if axis>0:
+                oshape=oshape+list(x.shape[0:axis])
+            oshape=oshape+[mask.shape[0]]
+            if axis+1<len(x.shape):
+                oshape=oshape+list(x.shape[axis+1:])
+                
             if calc_var:
                 if self.backend.bk_is_complex(l_x):
                     res2=self.backend.bk_sqrt((self.backend.bk_real(v2)/self.backend.bk_real(vh)
@@ -1367,8 +1521,12 @@ class FoCUS:
                                                 -self.backend.bk_imag(res)*self.backend.bk_imag(res))/self.backend.bk_real(vh))
                 else:
                     res2=self.backend.bk_sqrt((v2/vh-res*res)/(vh))
+                    
+                res=self.backend.bk_reshape(res,oshape)
+                res2=self.backend.bk_reshape(res2,oshape)
                 return res,res2
             else:
+                res=self.backend.bk_reshape(res,oshape)
                 return res
         
     # ---------------------------------------------−---------
@@ -1485,7 +1643,6 @@ class FoCUS:
         image=self.backend.bk_cast(in_image)
         
         if self.use_2D:
-            
             ishape=list(in_image.shape)
             if len(ishape)<axis+2:
                 if not self.silent:
@@ -1528,6 +1685,49 @@ class FoCUS:
                     return self.backend.bk_reshape(res,ishape[0:axis]+[res.shape[1],res.shape[2],self.NORIENT]+ishape[axis+2:])
                 
             return self.backend.bk_reshape(res,[nout,nouty])
+        elif self.use_1D==True:
+            ishape=list(in_image.shape)
+            if len(ishape)<axis+1:
+                if not self.silent:
+                    print('Use of 1D scat with data that has less than 1D')
+                return None
+                
+            npix=ishape[axis]
+            odata=1
+            if len(ishape)>axis+1:
+                for k in range(axis+1,len(ishape)):
+                    odata=odata*ishape[k]
+                    
+            ndata=1
+            for k in range(axis):
+                ndata=ndata*ishape[k]
+
+            tim=self.backend.bk_reshape(self.backend.bk_cast(in_image),[ndata,npix,odata])
+
+            if self.backend.bk_is_complex(tim):
+                rr1=self.backend.conv1d(self.backend.bk_real(tim),self.ww_RealT[odata],strides=[1, 1, 1],padding=self.padding)
+                ii1=self.backend.conv1d(self.backend.bk_real(tim),self.ww_ImagT[odata],strides=[1, 1, 1],padding=self.padding)
+                rr2=self.backend.conv1d(self.backend.bk_imag(tim),self.ww_RealT[odata],strides=[1, 1, 1],padding=self.padding)
+                ii2=self.backend.conv1d(self.backend.bk_imag(tim),self.ww_ImagT[odata],strides=[1, 1, 1],padding=self.padding)
+                res=self.backend.bk_complex(rr1-ii2,ii1+rr2)
+            else:
+                rr=self.backend.conv1d(tim,self.ww_RealT[odata],strides=[1, 1, 1],padding=self.padding)
+                ii=self.backend.conv1d(tim,self.ww_ImagT[odata],strides=[1, 1, 1],padding=self.padding)
+                res=self.backend.bk_complex(rr,ii)
+                
+            if axis==0:
+                if len(ishape)==1:
+                    return self.backend.bk_reshape(res,[res.shape[1]])
+                else:
+                    return self.backend.bk_reshape(res,[res.shape[1]]+ishape[axis+2:])
+            else:
+                if len(ishape)==axis+1:
+                    return self.backend.bk_reshape(res,ishape[0:axis]+[res.shape[1]])
+                else:
+                    return self.backend.bk_reshape(res,ishape[0:axis]+[res.shape[1]]+ishape[axis+1:])
+                
+            return self.backend.bk_reshape(res,[nout,nouty])
+            
                 
         else:
             nside=int(np.sqrt(image.shape[axis]//12))
@@ -1649,7 +1849,46 @@ class FoCUS:
                     return self.backend.bk_reshape(res,ishape[0:axis]+[res.shape[1],res.shape[2]]+ishape[axis+2:])
                 
             return self.backend.bk_reshape(res,[nout,nouty])
+        elif self.use_1D:
+            
+            ishape=list(in_image.shape)
+            if len(ishape)<axis+1:
+                if not self.silent:
+                    print('Use of 1D scat with data that has less than 1D')
+                return None
                 
+            npix=ishape[axis]
+            odata=1
+            if len(ishape)>axis+1:
+                for k in range(axis+1,len(ishape)):
+                    odata=odata*ishape[k]
+                    
+            ndata=1
+            for k in range(axis):
+                ndata=ndata*ishape[k]
+
+            tim=self.backend.bk_reshape(self.backend.bk_cast(in_image),[ndata,npix,odata])
+
+            if self.backend.bk_is_complex(tim):
+                rr=self.backend.conv1d(self.backend.bk_real(tim),self.ww_SmoothT[odata],strides=[1, 1, 1],padding=self.padding)
+                ii=self.backend.conv1d(self.backend.bk_imag(tim),self.ww_SmoothT[odata],strides=[1, 1, 1],padding=self.padding)
+                res=self.backend.bk_complex(rr,ii)
+            else:
+                res=self.backend.conv1d(tim,self.ww_SmoothT[odata],strides=[1, 1, 1],padding=self.padding)
+                    
+            if axis==0:
+                if len(ishape)==1:
+                    return self.backend.bk_reshape(res,[res.shape[1]])
+                else:
+                    return self.backend.bk_reshape(res,[res.shape[1]]+ishape[axis+1:])
+            else:
+                if len(ishape)==axis+1:
+                    return self.backend.bk_reshape(res,ishape[0:axis]+[res.shape[1]])
+                else:
+                    return self.backend.bk_reshape(res,ishape[0:axis]+[res.shape[1]]+ishape[axis+1:])
+                
+            return self.backend.bk_reshape(res,[nout,nouty])
+        
         else:
             nside=int(np.sqrt(image.shape[axis]//12))
 

{foscat-3.0.47 → foscat-3.1.0}/src/foscat/backend.py

@@ -289,10 +289,33 @@ class foscat_backend:
             for k in range(w.shape[2]):
                 for l in range(w.shape[3]):
                     for j in range(res.shape[0]):
-                        tmp=self.scipy.signal.convolve2d(x[j,:,:,k],w[:,:,k,l], mode='same', boundary='fill', fillvalue=0.0)
+                        tmp=self.scipy.signal.convolve2d(x[j,:,:,k],w[:,:,k,l], mode='same', boundary='symm')
                         res[j,:,:,l]+=tmp
                         del tmp
             return res
+    
+    def conv1d(self,x,w,strides=[1, 1, 1],padding='SAME'):
+        if self.BACKEND==self.TENSORFLOW:
+            kx=w.shape[0]
+            paddings = self.backend.constant([[0,0],
+                                              [kx//2,kx//2],
+                                              [0,0]])
+            tmp=self.backend.pad(x, paddings, "SYMMETRIC")
+            
+            return self.backend.nn.conv1d(tmp,w,
+                                          stride=strides,
+                                          padding="VALID")
+        # to be written!!!
+        if self.BACKEND==self.TORCH:
+            return x
+        if self.BACKEND==self.NUMPY:
+            res=np.zeros([x.shape[0],x.shape[1],w.shape[2]],dtype=x.dtype)
+            for k in range(w.shape[2]):
+                for j in range(res.shape[0]):
+                    tmp=self.scipy.signal.convolve1d(x[j,:,k],w[:,k,l], mode='same', boundary='symm')
+                    res[j,:,:,l]+=tmp
+                    del tmp
+            return res
 
     def bk_threshold(self,x,threshold,greater=True):
 

{foscat-3.0.47 → foscat-3.1.0}/src/foscat/scat_cov.py

@@ -859,6 +859,30 @@ class scat_cov:
                         tab2nx=tab2nx+['%d'%(i2)]
                         ax1.axvline((j2[j1==i2]+n).max()+0.5,ls=':',color='gray') 
                         n=n+j2[j1==i2].shape[0]-1
+        elif len(tmp.shape)==3:
+            for i0 in range(tmp.shape[0]):
+                for i1 in range(tmp.shape[1]):
+                    for i2 in range(j1.max()+1):
+                        dtmp=tmp[i0,i1,j1==i2]
+                        if norm:
+                            dtmp=dtmp/(ntmp[i0,i1,i2]*ntmp[i0,i1,j2[j1==i2]])
+                        if j2[j1==i2].shape[0]==1:
+                            ax1.plot(j2[j1==i2]+n,dtmp,'.', \
+                                     color=color, lw=lw)
+                        else:
+                            if legend and test is None:
+                                ax1.plot(j2[j1==i2]+n,dtmp, \
+                                         color=color, label=lname, lw=lw)
+                                test=1
+                            ax1.plot(j2[j1==i2]+n,dtmp, \
+                                     color=color, lw=lw)
+                        tabnx=tabnx+[r'%d'%(k) for k in j2[j1==i2]]
+                        tabx=tabx+[k+n for k in j2[j1==i2]]
+                        tab2x=tab2x+[(j2[j1==i2]+n).mean()]
+                        tab2nx=tab2nx+['%d'%(i2)]
+                        ax1.axvline((j2[j1==i2]+n).max()+0.5,ls=':',color='gray') 
+                        n=n+j2[j1==i2].shape[0]-1
+            
         else:
             for i0 in range(tmp.shape[0]):
                 for i1 in range(tmp.shape[1]):
@@ -951,6 +975,32 @@ class scat_cov:
                         tab2x=tab2x+[(n+nprev-1)/2]
                         tab2nx=tab2nx+['%d'%(i2)]
                         ax1.axvline(n-0.5,ls=':',color='gray')
+        elif len(tmp.shape)==3:
+            for i0 in range(tmp.shape[0]):
+                for i1 in range(tmp.shape[1]):
+                    for i2 in range(j1.max()+1):
+                        nprev=n
+                        for i2b in range(j2[j1==i2].max()+1):
+                            idx=np.where((j1==i2)*(j2==i2b))[0]
+                            dtmp=tmp[i0,i1,idx]
+                            if norm:
+                                dtmp=dtmp/(ntmp[i0,i1,i2]*ntmp[i0,i1,i2b])
+                            if len(idx)==1:
+                                ax1.plot(np.arange(len(idx))+n,dtmp,'.', \
+                                         color=color, lw=lw)
+                            else:
+                                if legend and test is None:
+                                    ax1.plot(np.arange(len(idx))+n,dtmp, \
+                                             color=color, label=lname, lw=lw)
+                                    test=1
+                                ax1.plot(np.arange(len(idx))+n,dtmp, \
+                                         color=color, lw=lw)
+                            tabnx=tabnx+[r'%d,%d'%(j2[k],j3[k]) for k in idx]
+                            tabx=tabx+[k+n for k in range(len(idx))]
+                            n=n+idx.shape[0]
+                        tab2x=tab2x+[(n+nprev-1)/2]
+                        tab2nx=tab2nx+['%d'%(i2)]
+                        ax1.axvline(n-0.5,ls=':',color='gray')
         else:
             for i0 in range(tmp.shape[0]):
                 for i1 in range(tmp.shape[1]):
@@ -1495,6 +1545,8 @@ class funct(FOC.FoCUS):
     def fill(self,im,nullval=hp.UNSEEN):
         if self.use_2D:
             return self.fill_2d(im,nullval=nullval)
+        if self.use_1D:
+            return self.fill_1d(im,nullval=nullval)
         return self.fill_healpy(im,nullval=nullval)
 
     def moments(self,list_scat):
@@ -1748,6 +1800,15 @@ 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
+        elif self.use_1D:
+            if len(image1.shape)==2:
+                npix = int(im_shape[1])  # Number of pixels
+            else:
+                npix = int(im_shape[0])  # Number of pixels
+                
+            nside=int(npix)
+            
+            J = int(np.log(nside) / np.log(2))  # Number of j scales
         else:
             if len(image1.shape)==2:
                 npix = int(im_shape[1])  # Number of pixels
@@ -1785,6 +1846,11 @@ class funct(FOC.FoCUS):
                 I1=self.up_grade(I1,I1.shape[axis]*2,axis=axis,nouty=I1.shape[axis+1]*2)
                 if cross:
                     I2=self.up_grade(I2,I2.shape[axis]*2,axis=axis,nouty=I2.shape[axis+1]*2)
+            elif self.use_1D:
+                vmask=self.up_grade(vmask,I1.shape[axis]*2,axis=1)
+                I1=self.up_grade(I1,I1.shape[axis]*2,axis=axis)
+                if cross:
+                    I2=self.up_grade(I2,I2.shape[axis]*2,axis=axis)
             else:
                 I1 = self.up_grade(I1, nside * 2, axis=axis)
                 vmask = self.up_grade(vmask, nside * 2, axis=1)
@@ -1798,6 +1864,11 @@ class funct(FOC.FoCUS):
                     I1=self.up_grade(I1,I1.shape[axis]*2,axis=axis,nouty=I1.shape[axis+1]*2)
                     if cross:
                         I2=self.up_grade(I2,I2.shape[axis]*2,axis=axis,nouty=I2.shape[axis+1]*2)
+                elif self.use_1D:
+                    vmask=self.up_grade(vmask,I1.shape[axis]*4,axis=1)
+                    I1=self.up_grade(I1,I1.shape[axis]*4,axis=axis)
+                    if cross:
+                        I2=self.up_grade(I2,I2.shape[axis]*4,axis=axis)
                 else:
                     I1 = self.up_grade(I1, nside * 4, axis=axis)
                     vmask = self.up_grade(vmask, nside * 4, axis=1)
@@ -1811,6 +1882,14 @@ class funct(FOC.FoCUS):
         # Coefficients
         S1, P00, C01, C11, C10 = None, None, None, None, None
 
+        off_P0=-2
+        off_C01=-3
+        off_C11=-4
+        if self.use_1D:
+            off_P0=-1
+            off_C01=-1
+            off_C11=-1
+            
         # Dictionaries for C01 computation
         M1_dic = {}  # M stands for Module M1 = |I1 * Psi|
         if cross:
@@ -1842,7 +1921,6 @@ class funct(FOC.FoCUS):
                     s0 = self.masked_mean(I1,vmask,axis=1)
                 else:
                     s0 = self.masked_mean(I1-I2,vmask,axis=1)
-            
 
         #### COMPUTE S1, P00, C01 and C11
         nside_j3 = nside  # NSIDE start (nside_j3 = nside / 2^j3)
@@ -1887,6 +1965,7 @@ class funct(FOC.FoCUS):
                     else:
                         p00 = self.masked_mean(M1_square, vmask, axis=1,rank=j3)
                 
+        
                 if cond_init_P1_dic:
                     # We fill P1_dic with P00 for normalisation of C01 and C11
                     P1_dic[j3] = p00  # [Nbatch, Nmask, Norient3]
@@ -1900,13 +1979,13 @@ class funct(FOC.FoCUS):
                     if norm == 'auto':  # Normalize P00
                         p00 /= P1_dic[j3]
                     if P00 is None:
-                        P00 = p00[:, :, None, :]  # Add a dimension for NP00
+                        P00 = self.backend.bk_expand_dims(p00,off_P0)  # Add a dimension for NP00
                         if calc_var:
-                            VP00 = vp00[:, :, None, :]  # Add a dimension for NP00
+                            VP00 = self.backend.bk_expand_dims(vp00,off_P0)  # Add a dimension for NP00
                     else:
-                        P00 = self.backend.bk_concat([P00, p00[:, :, None, :]], axis=2)
+                        P00 = self.backend.bk_concat([P00, self.backend.bk_expand_dims(p00,off_P0)], axis=2)
                         if calc_var:
-                            VP00 = self.backend.bk_concat([VP00, vp00[:, :, None, :]], axis=2)
+                            VP00 = self.backend.bk_concat([VP00, self.backend.bk_expand_dims(vp00,off_P0)], axis=2)
 
                 #### S1_auto computation
                 ### Image 1 : S1 = < M1 >_pix
@@ -1929,13 +2008,13 @@ class funct(FOC.FoCUS):
                         self.div_norm(s1,(P1_dic[j3]) ** 0.5)
                     ### We store S1 for image1  [Nbatch, Nmask, NS1, Norient3]
                     if S1 is None:
-                        S1 = s1[:, :, None, :]  # Add a dimension for NS1
+                        S1 = self.backend.bk_expand_dims(s1,off_P0)  # Add a dimension for NS1
                         if calc_var:
-                            VS1 = vs1[:, :, None, :]  # Add a dimension for NS1
+                            VS1 = self.backend.bk_expand_dims(vs1,off_P0)  # Add a dimension for NS1
                     else:
-                        S1 = self.backend.bk_concat([S1, s1[:, :, None, :]], axis=2)
+                        S1 = self.backend.bk_concat([S1,self.backend.bk_expand_dims(s1,off_P0)], axis=2)
                         if calc_var:
-                            VS1 = self.backend.bk_concat([VS1, vs1[:, :, None, :]], axis=2)
+                            VS1 = self.backend.bk_concat([VS1, self.backend.bk_expand_dims(vs1,off_P0)], axis=2)
 
             else:  # Cross
                 ### Make the convolution I2 * Psi_j3
@@ -1994,13 +2073,13 @@ class funct(FOC.FoCUS):
                         p00=self.backend.bk_real(p00)
 
                     if P00 is None:
-                        P00 = p00[:,:,None,:]  # Add a dimension for NP00
+                        P00 = self.backend.bk_expand_dims(p00,off_P0)  # Add a dimension for NP00
                         if calc_var:
-                            VP00 = vp00[:,:,None,:]  # Add a dimension for NP00
+                            VP00 = self.backend.bk_expand_dims(vp00,off_P0)  # Add a dimension for NP00
                     else:
-                        P00 = self.backend.bk_concat([P00, p00[:,:,None,:]], axis=2)
+                        P00 = self.backend.bk_concat([P00, self.backend.bk_expand_dims(p00,off_P0)], axis=2)
                         if calc_var:
-                            VP00 = self.backend.bk_concat([VP00, vp00[:,:,None,:]], axis=2)
+                            VP00 = self.backend.bk_concat([VP00, self.backend.bk_expand_dims(vp00,off_P0)], axis=2)
                     
                 #### S1_auto computation
                 ### Image 1 : S1 = < M1 >_pix
@@ -2022,14 +2101,15 @@ class funct(FOC.FoCUS):
                         self.div_norm(s1,(P1_dic[j3]) ** 0.5)
                     ### We store S1 for image1  [Nbatch, Nmask, NS1, Norient3]
                     if S1 is None:
-                        S1 = s1[:, :, None, :]  # Add a dimension for NS1
+                        S1 = self.backend.bk_expand_dims(s1,off_P0)  # Add a dimension for NS1
                         if calc_var:
-                            VS1 = vs1[:, :, None, :]  # Add a dimension for NS1
+                            VS1 = self.backend.bk_expand_dims(vs1,off_P0)  # Add a dimension for NS1
                     else:
-                        S1 = self.backend.bk_concat([S1, s1[:, :, None, :]], axis=2)
+                        S1 = self.backend.bk_concat([S1, self.backend.bk_expand_dims(s1,off_P0)], axis=2)
                         if calc_var:
-                            VS1 = self.backend.bk_concat([VS1, vs1[:, :, None, :]], axis=2)
-                        
+                            VS1 = self.backend.bk_concat([VS1,
+                                                          self.backend.bk_expand_dims(vs1,off_P0)], axis=2)
+
             # Initialize dictionaries for |I1*Psi_j| * Psi_j3
             M1convPsi_dic = {}
             if cross:
@@ -2067,19 +2147,19 @@ class funct(FOC.FoCUS):
                     else:
                         ### Normalize C01 with P00_j [Nbatch, Nmask, Norient_j]
                         if norm is not None:
-                            self.div_norm(c01,(P1_dic[j2][:, :, None, :] *
-                                    P1_dic[j3][:, :, :, None]) ** 0.5)# [Nbatch, Nmask, Norient3, Norient2]
+                            self.div_norm(c01,(self.backend.bk_expand_dims(P1_dic[j2],off_P0) *
+                                               self.backend.bk_expand_dims(P1_dic[j3],-1)) ** 0.5)# [Nbatch, Nmask, Norient3, Norient2]
 
                         ### Store C01 as a complex [Nbatch, Nmask, NC01, Norient3, Norient2]
                         if C01 is None:
-                            C01 = c01[:,:,None,:,:]  # Add a dimension for NC01
+                            C01 = self.backend.bk_expand_dims(c01,off_C01) # Add a dimension for NC01
                             if calc_var:
-                                VC01 = vc01[:,:,None,:,:]  # Add a dimension for NC01
+                                VC01 =self.backend.bk_expand_dims(vc01,off_C01)  # Add a dimension for NC01
                         else:
-                            C01 = self.backend.bk_concat([C01, c01[:, :, None, :, :]],
+                            C01 = self.backend.bk_concat([C01, self.backend.bk_expand_dims(c01,off_C01)],
                                                      axis=2)  # Add a dimension for NC01
                             if calc_var:
-                                VC01 = self.backend.bk_concat([VC01, vc01[:, :, None, :, :]],
+                                VC01 = self.backend.bk_concat([VC01, self.backend.bk_expand_dims(vc01,off_C01)],
                                                               axis=2)  # Add a dimension for NC01
 
                 ### C01_cross = < (I1 * Psi)_j3 x (|I2 * Psi_j2| * Psi_j3)^* >_pix
@@ -2121,28 +2201,28 @@ class funct(FOC.FoCUS):
                     else:
                         ### Normalize C01 and C10 with P00_j [Nbatch, Nmask, Norient_j]
                         if norm is not None:
-                            self.div_norm(c01,(P2_dic[j2][:, :, None, :] *
-                                    P1_dic[j3][:, :, :, None]) ** 0.5)# [Nbatch, Nmask, Norient3, Norient2]
-                            self.div_norm(c10,(P1_dic[j2][:, :, None, :] *
-                                    P2_dic[j3][:, :, :, None]) ** 0.5)  # [Nbatch, Nmask, Norient3, Norient2]
+                            self.div_norm(c01,(self.backend.bk_expand_dims(P2_dic[j2],off_P0) *
+                                               self.backend.bk_expand_dims(P1_dic[j3],-1)) ** 0.5)# [Nbatch, Nmask, Norient3, Norient2]
+                            self.div_norm(c10,(self.backend.bk_expand_dims(P1_dic[j2],off_P0) *
+                                               self.backend.bk_expand_dims(P2_dic[j3],-1)) ** 0.5)  # [Nbatch, Nmask, Norient3, Norient2]
 
                         ### Store C01 and C10 as a complex [Nbatch, Nmask, NC01, Norient3, Norient2]
                         if C01 is None:
-                            C01 = c01[:, :, None, :, :] # Add a dimension for NC01
+                            C01 = self.backend.bk_expand_dims(c01,off_C01) # Add a dimension for NC01
                             if calc_var:
-                                VC01 = vc01[:, :, None, :, :] # Add a dimension for NC01
+                                VC01 = vself.backend.bk_expand_dims(vc01,off_C01) # Add a dimension for NC01
                         else:
-                            C01 = self.backend.bk_concat([C01,c01[:, :, None, :, :]],axis=2)  # Add a dimension for NC01
+                            C01 = self.backend.bk_concat([C01, self.backend.bk_expand_dims(c01,off_C01)],axis=2)  # Add a dimension for NC01
                             if calc_var:
-                                VC01 = self.backend.bk_concat([VC01,vc01[:, :, None, :, :]],axis=2)  # Add a dimension for NC01
+                                VC01 =self.backend.bk_concat([VC01, self.backend.bk_expand_dims(vc01,off_C01)],axis=2)  # Add a dimension for NC01
                         if C10 is None:
-                            C10 = c10[:, :, None, :, :]  # Add a dimension for NC01
+                            C10 = self.backend.bk_expand_dims(c10,off_C01) # Add a dimension for NC01
                             if calc_var:
-                                VC10 = vc10[:, :, None, :, :]  # Add a dimension for NC01
+                                VC10 = self.backend.bk_expand_dims(vc10,off_C01) # Add a dimension for NC01
                         else:
-                            C10 = self.backend.bk_concat([C10,c10[:, :, None, :, :]], axis=2)  # Add a dimension for NC01
+                            C10 = self.backend.bk_concat([C10, self.backend.bk_expand_dims(c10,off_C01)], axis=2)  # Add a dimension for NC01
                             if calc_var:
-                                VC10 = self.backend.bk_concat([VC10,vc10[:, :, None, :, :]], axis=2)  # Add a dimension for NC01
+                                VC10 = self.backend.bk_concat([VC10, self.backend.bk_expand_dims(vc10,off_C01)], axis=2)  # Add a dimension for NC01
                         
 
                 ##### C11
@@ -2167,18 +2247,18 @@ class funct(FOC.FoCUS):
                         else:
                             ### Normalize C11 with P00_j [Nbatch, Nmask, Norient_j]
                             if norm is not None:
-                                self.div_norm(c11,(P1_dic[j1][:, :, None, None, :] *
-                                        P1_dic[j2][:, :, None, :,None]) ** 0.5)  # [Nbatch, Nmask, Norient3, Norient2, Norient1]
+                                self.div_norm(c11,(self.backend.bk_expand_dims(self.backend.bk_expand_dims(P1_dic[j1],off_P0),off_P0) *
+                                                   self.backend.bk_expand_dims(self.backend.bk_expand_dims(P1_dic[j2],off_P0),-1)) ** 0.5)  # [Nbatch, Nmask, Norient3, Norient2, Norient1]
                             ### Store C11 as a complex [Nbatch, Nmask, NC11, Norient3, Norient2, Norient1]
                             if C11 is None:
-                                C11 = c11[:, :, None, :, :, :]  # Add a dimension for NC11
+                                C11 = self.backend.bk_expand_dims(c11,off_C11)  # Add a dimension for NC11
                                 if calc_var:
-                                    VC11 = vc11[:, :, None, :, :, :]  # Add a dimension for NC11
+                                    VC11 = self.backend.bk_expand_dims(vc11,off_C11)  # Add a dimension for NC11
                             else:
-                                C11 = self.backend.bk_concat([C11,c11[:, :, None, :, :, :]],
+                                C11 = self.backend.bk_concat([C11,self.backend.bk_expand_dims(c11,off_C11)],
                                                      axis=2)  # Add a dimension for NC11
                                 if calc_var:
-                                    VC11 = self.backend.bk_concat([VC11,vc11[:, :, None, :, :, :]],
+                                    VC11 = self.backend.bk_concat([VC11,self.backend.bk_expand_dims(vc11,off_C11)],
                                                              axis=2)  # Add a dimension for NC11
 
                         ### C11_cross = <(|I1 * psi1| * psi3)(|I2 * psi2| * psi3)^*>
@@ -2201,18 +2281,18 @@ class funct(FOC.FoCUS):
                         else:
                             ### Normalize C11 with P00_j [Nbatch, Nmask, Norient_j]
                             if norm is not None:
-                                self.div_norm(c11,(P1_dic[j1][:, :, None, None, :] *
-                                        P2_dic[j2][:, :, None, :, None]) ** 0.5)  # [Nbatch, Nmask, Norient3, Norient2, Norient1]
+                                self.div_norm(c11,(self.backend.bk_expand_dims(self.backend.bk_expand_dims(P1_dic[j1],off_P0),off_P0) *
+                                                   self.backend.bk_expand_dims(self.backend.bk_expand_dims(P2_dic[j2],off_P0),-1)) ** 0.5)  # [Nbatch, Nmask, Norient3, Norient2, Norient1]
                             ### Store C11 as a complex [Nbatch, Nmask, NC11, Norient3, Norient2, Norient1]
                             if C11 is None:
-                                C11 = c11[:, :, None, :, :, :]  # Add a dimension for NC11
+                                C11 = self.backend.bk_expand_dims(c11,off_C11)  # Add a dimension for NC11
                                 if calc_var:
-                                    VC11 = vc11[:, :, None, :, :, :]  # Add a dimension for NC11
+                                    VC11 = self.backend.bk_expand_dims(vc11,off_C11) # Add a dimension for NC11
                             else:
-                                C11 = self.backend.bk_concat([C11,c11[:, :, None, :, :, :]],
+                                C11 = self.backend.bk_concat([C11,self.backend.bk_expand_dims(c11,off_C11)],
                                                      axis=2)  # Add a dimension for NC11
                                 if calc_var:
-                                    VC11 = self.backend.bk_concat([VC11,vc11[:, :, None, :, :, :]],
+                                    VC11 = self.backend.bk_concat([VC11,self.backend.bk_expand_dims(vc11,off_C11)],
                                                                  axis=2)  # Add a dimension for NC11
             
             ###### Reshape for next iteration on j3
@@ -2298,7 +2378,10 @@ class funct(FOC.FoCUS):
         ### 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]
-        c01 = self.backend.bk_expand_dims(conv, -1) * self.backend.bk_conjugate(MconvPsi)   # [Nbatch, Npix_j3, Norient3, Norient2]
+        if self.use_1D:
+            c01 = conv * self.backend.bk_conjugate(MconvPsi) 
+        else:
+            c01 = self.backend.bk_expand_dims(conv, -1) * self.backend.bk_conjugate(MconvPsi)   # [Nbatch, Npix_j3, Norient3, Norient2]
 
         ### Apply the mask [Nmask, Npix_j3] and sum over pixels
         if return_data:
@@ -2327,7 +2410,10 @@ class funct(FOC.FoCUS):
 
         ### Compute the product (|I1 * Psi_j1| * Psi_j3)(|I2 * Psi_j2| * Psi_j3)
         # z_1 x z_2^* = (a1a2 + b1b2) + i(b1a2 - a1b2)
-        c11 = self.backend.bk_expand_dims(M1, -2) * self.backend.bk_conjugate(self.backend.bk_expand_dims(M2, -1))  # [Nbatch, Npix_j3, Norient3, Norient2, Norient1]
+        if self.use_1D:
+            c11 = M1 * self.backend.bk_conjugate(M2) 
+        else:
+            c11 = self.backend.bk_expand_dims(M1, -2) * self.backend.bk_conjugate(self.backend.bk_expand_dims(M2, -1))  # [Nbatch, Npix_j3, Norient3, Norient2, Norient1]
 
         ### Apply the mask and sum over pixels
         if return_data:

foscat-3.0.47/src/foscat/scat_cov1D.py → foscat-3.1.0/src/foscat/scat_cov1D.old.py

@@ -1203,7 +1203,9 @@ class funct(FOC.FoCUS):
                 # z_1 x z_2^* = (a1a2 + b1b2) + i(b1a2 - a1b2)
                 p00 = conv1 * self.backend.bk_conjugate(conv2)
                 # Apply the mask [Nmask, Npix_j3] and average over pixels
+                p00 = self.backend.bk_real(p00)
                 p00 = self.backend.bk_reduce_sum(p00*vmask, axis=1)
+                print(p00.shape)
                 tmp = self.backend.bk_L1(p00)  # [Nbatch, Npix_j3, Norient3]
 
                 ### Normalize P00_cross
@@ -1215,9 +1217,9 @@ class funct(FOC.FoCUS):
                     p00=self.backend.bk_real(p00)
                     
                 if P00 is None:
-                    P00 = p00[:,:,None,:]  # Add a dimension for NP00
+                    P00 = p00[:,:,None]  # Add a dimension for NP00
                 else:
-                    P00 = self.backend.bk_concat([P00, p00[:,:,None,:]], axis=2)
+                    P00 = self.backend.bk_concat([P00, p00[:,:,None]], axis=axis+2)
                     
                 #### S1_auto computation
                 ### Image 1 : S1 = < M1 >_pix

foscat-3.1.0/src/foscat/scat_cov1D.py

@@ -0,0 +1,16 @@
+import foscat.scat_cov as scat
+
+class scat_cov1D:
+    def __init__(self,p00,s0,s1,s2,s2l,j1,j2,cross=False,backend=None):
+
+        the_scat=scat(P00, C01, C11, s1=S1, c10=C10,backend=self.backend)
+        the_scat.set_bk_type('SCAT_COV1D')
+        return the_scat
+    
+    def fill(self,im,nullval=0):
+        return self.fill_1d(im,nullval=nullval)
+
+class funct(scat.funct):
+    def __init__(self, *args, **kwargs):
+        # Impose que use_2D=True pour la classe scat
+        super(funct, self).__init__(use_1D=True, *args, **kwargs)

{foscat-3.0.47 → foscat-3.1.0}/src/foscat.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foscat
-Version: 3.0.47
+Version: 3.1.0
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Home-page: https://github.com/jmdelouis/FOSCAT
 Author: Jean-Marc DELOUIS

{foscat-3.0.47 → foscat-3.1.0}/src/foscat.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ src/foscat/scat.py
 src/foscat/scat1D.py
 src/foscat/scat2D.py
 src/foscat/scat_cov.py
+src/foscat/scat_cov1D.old.py
 src/foscat/scat_cov1D.py
 src/foscat/scat_cov2D.py
 src/foscat/scat_cov_map.py