foscat 3.0.35__tar.gz → 3.0.40__tar.gz

{foscat-3.0.35 → foscat-3.0.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foscat
-Version: 3.0.35
+Version: 3.0.40
 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.35 → foscat-3.0.40}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='foscat',
-    version='3.0.35',
+    version='3.0.40',
     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.35 → foscat-3.0.40}/src/foscat/FoCUS.py

@@ -5,7 +5,7 @@ import foscat.backend as bk
 from scipy.interpolate import griddata
 
 
-TMPFILE_VERSION='V3_0'
+TMPFILE_VERSION='V4_0'
 
 class FoCUS:
     def __init__(self,
@@ -32,7 +32,7 @@ class FoCUS:
                  mpi_size=1,
                  mpi_rank=0):
 
-        self.__version__ = '3.0.35'
+        self.__version__ = '3.0.40'
         # P00 coeff for normalization for scat_cov
         self.TMPFILE_VERSION=TMPFILE_VERSION
         self.P1_dic = None
@@ -987,6 +987,98 @@ class FoCUS:
                 tmp=np.load('%s/FOSCAT_%s_W%d_%d_%d_PIDX.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,l_kernel**2,self.NORIENT,nside))
         except:
             if self.use_2D==False:
+                
+                if l_kernel==5:
+                    pw=0.5
+                    pw2=0.5
+                    threshold=2E-4
+                    
+                elif l_kernel==3:
+                    pw=1.0/np.sqrt(2)
+                    pw2=1.0
+                    threshold=1E-3
+                    
+                elif l_kernel==7:
+                    pw=0.5
+                    pw2=0.25
+                    threshold=4E-5
+                    
+                th,ph=hp.pix2ang(nside,np.arange(12*nside**2),nest=True)
+                x,y,z=hp.pix2vec(nside,np.arange(12*nside**2),nest=True)
+
+                t,p=hp.pix2ang(nside,np.arange(12*nside*nside),nest=True)
+                phi=[p[k]/np.pi*180 for k in range(12*nside*nside)]
+                thi=[t[k]/np.pi*180 for k in range(12*nside*nside)]
+
+
+                indice2=np.zeros([12*nside*nside*64,2],dtype='int')
+                indice=np.zeros([12*nside*nside*64*self.NORIENT,2],dtype='int')
+                wav=np.zeros([12*nside*nside*64*self.NORIENT],dtype='complex')
+                wwav=np.zeros([12*nside*nside*64*self.NORIENT],dtype='float')
+
+                iv=0
+                iv2=0
+                for iii in range(12*nside*nside):
+    
+                    if iii%(nside*nside)==nside*nside-1:
+                        if not self.silent:
+                            print('Pre-compute nside=%6d %.2f%%'%(nside,100*iii/(12*nside*nside)))
+        
+                    hidx=hp.query_disc(nside, [x[iii],y[iii],z[iii]], 2*np.pi/nside,nest=True)
+    
+                    R=hp.Rotator(rot=[phi[iii],-thi[iii]],eulertype='ZYZ')
+    
+                    t2,p2=R(th[hidx],ph[hidx])
+    
+                    vec2=hp.ang2vec(t2,p2)
+    
+                    x2=vec2[:,0]
+                    y2=vec2[:,1]
+                    z2=vec2[:,2]
+                    
+                    ww=np.exp(-pw2*((nside)**2)*((x2)**2+(y2)**2+(z2-1.0)**2))
+                    idx=np.where((ww**2)>threshold)[0]
+                    nval2=len(idx)
+                    indice2[iv2:iv2+nval2,0]=iii
+                    indice2[iv2:iv2+nval2,1]=hidx[idx]
+                    wwav[iv2:iv2+nval2]=ww[idx]/np.sum(ww[idx])
+                    iv2+=nval2
+    
+                    for l in range(self.NORIENT):
+        
+                        angle=l/4.*np.pi-phi[iii]/180.*np.pi*(z[hidx]>0)-(180.0-phi[iii])/180.*np.pi*(z[hidx]<0)
+                        
+                        #posi=2*(0.5-(z[hidx]<0))
+                        
+                        axes=y2*np.cos(angle)-x2*np.sin(angle)
+                        wresr=ww*np.cos(pw*axes*(nside)*np.pi)
+                        wresi=ww*np.sin(pw*axes*(nside)*np.pi)
+
+                        vnorm=(wresr*wresr+wresi*wresi)
+                        idx=np.where(vnorm>threshold)[0]
+                        
+                        nval=len(idx)
+                        indice[iv:iv+nval,0]=iii*4+l
+                        indice[iv:iv+nval,1]=hidx[idx]
+                        #print([hidx[k] for k in idx])
+                        #print(hp.query_disc(nside, [x[iii],y[iii],z[iii]], np.pi/nside,nest=True))
+                        normr=np.mean(wresr[idx])
+                        normi=np.mean(wresi[idx])
+
+                        val=wresr[idx]-normr+np.complex(0,1)*(wresi[idx]-normi)
+                        val=val/abs(val).sum()
+                        
+                        wav[iv:iv+nval]=val
+                        iv+=nval
+        
+                indice=indice[:iv,:]
+                wav=wav[:iv]
+                indice2=indice2[:iv2,:]
+                wwav=wwav[:iv2]
+                if not self.silent:
+                    print('Kernel Size ',iv/(self.NORIENT*12*nside*nside))
+                """
+                # OLD VERSION OLD VERSION OLD VERSION (3.0)
                 if self.KERNELSZ*self.KERNELSZ>12*nside*nside:
                     l_kernel=3
                     
@@ -1077,7 +1169,7 @@ class FoCUS:
                         w[:,j,i]=wav[:,i,j]
                 wav=w.flatten()
                 wwav=wwav.flatten()
-                
+                """
                 if not self.silent:
                     print('Write FOSCAT_%s_W%d_%d_%d_PIDX.npy'%(TMPFILE_VERSION,self.KERNELSZ**2,self.NORIENT,nside))
                 np.save('%s/FOSCAT_%s_W%d_%d_%d_PIDX.npy'%(self.TEMPLATE_PATH,TMPFILE_VERSION,self.KERNELSZ**2,self.NORIENT,nside),indice)
@@ -1248,10 +1340,10 @@ class FoCUS:
             res=v1/vh
             if calc_var:
                 if self.backend.bk_is_complex(vtmp):
-                    res2=self.backend.bk_complex(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_sqrt(self.backend.bk_imag(v2)/self.backend.bk_real(vh)
-                                                                      -self.backend.bk_imag(res)*self.backend.bk_imag(res)))
+                    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)))
                 else:
                     res2=self.backend.bk_sqrt((v2/vh-res*res)/(vh))
                 return res,res2
@@ -1269,10 +1361,10 @@ class FoCUS:
             res=v1/vh
             if calc_var:
                 if self.backend.bk_is_complex(l_x):
-                    res2=self.backend.bk_complex(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_real(v2)), \
-                                                 self.backend.bk_sqrt((self.backend.bk_imag(v2)/self.backend.bk_real(vh)
-                                                                      -self.backend.bk_imag(res)*self.backend.bk_imag(res))/self.backend.bk_real(v2)))
+                    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))
                 else:
                     res2=self.backend.bk_sqrt((v2/vh-res*res)/(vh))
                 return res,res2
@@ -1368,7 +1460,25 @@ class FoCUS:
                                         padding=self.padding)
 
         return self.backend.bk_reshape(res,shape+[norient])
-    
+
+    def diff_data(self,x,y,is_complex=True,sigma=None):
+        if sigma is None:
+            if is_complex:
+                r=self.backend.bk_square(self.backend.bk_real(x)-self.backend.bk_real(y))
+                i=self.backend.bk_square(self.backend.bk_imag(x)-self.backend.bk_imag(y))
+                return self.backend.bk_reduce_sum(r+i)
+            else:
+                r=self.backend.bk_square(x-y)
+                return self.backend.bk_reduce_sum(r)
+        else:
+            if is_complex:
+                r=self.backend.bk_square((self.backend.bk_real(x)-self.backend.bk_real(y))/sigma)
+                i=self.backend.bk_square((self.backend.bk_imag(x)-self.backend.bk_imag(y))/sigma)
+                return self.backend.bk_reduce_sum(r+i)
+            else:
+                r=self.backend.bk_square((x-y)/sigma)
+                return self.backend.bk_reduce_sum(r)
+        
     # ---------------------------------------------−---------
     def convol(self,in_image,axis=0):
 

{foscat-3.0.35 → foscat-3.0.40}/src/foscat/GCNN.py

@@ -14,6 +14,7 @@ class GCNN:
                  n_chan_out=1,
                  nbatch=1,
                  SEED=1234,
+                 hidden=None,
                  filename=None):
 
         if filename is not None:
@@ -29,7 +30,11 @@ class GCNN:
             self.in_nside=outlist[4] 
             self.nbatch=outlist[1]
             self.n_chan_out=outlist[8]
-        
+            if len(outlist[9])>0:
+                self.hidden=outlist[9]
+            else:
+                self.hidden=None
+                
             self.x=self.scat_operator.backend.bk_cast(outlist[6])
         else:
             self.nscale=nscale
@@ -46,21 +51,33 @@ class GCNN:
             self.KERNELSZ= scat_operator.KERNELSZ
             self.all_type= scat_operator.all_type
             self.in_nside=in_nside
+            self.hidden=hidden
 
             np.random.seed(SEED)
             self.x=scat_operator.backend.bk_cast(np.random.randn(self.get_number_of_weights())/(self.KERNELSZ*self.KERNELSZ))
 
     def save(self,filename):
+
+        if self.hidden is None:
+            tabh=[]
+        else:
+            tabh=self.hidden
+
+        www= self.get_weights()
         
+        if not isinstance(www,np.ndarray):
+            www=www.numpy()
+            
         outlist=[self.chanlist, \
                  self.nbatch, \
                  self.npar, \
                  self.KERNELSZ, \
                  self.in_nside, \
                  self.nscale, \
-                 self.get_weights().numpy(), \
+                 www, \
                  self.all_type, \
-                 self.n_chan_out]
+                 self.n_chan_out, \
+                 tabh]
         
         myout=open("%s.pkl"%(filename),"wb")
         pickle.dump(outlist,myout)
@@ -68,10 +85,19 @@ class GCNN:
     
     def get_number_of_weights(self):
         totnchan=0
+        szk=self.KERNELSZ*self.KERNELSZ
+        if self.hidden is not None:
+            totnchan=totnchan+self.hidden[0]*self.npar
+            for i in range(1,len(self.hidden)):
+                totnchan=totnchan+self.hidden[i]*self.hidden[i-1]
+            totnchan=totnchan+self.hidden[len(self.hidden)-1]*12*self.in_nside**2*self.chanlist[0]
+        else:
+            totnchan=self.npar*12*self.in_nside**2*self.chanlist[0]
+            
         for i in range(self.nscale):
-            totnchan=totnchan+self.chanlist[i]*self.chanlist[i+1]
-        return self.npar*12*self.in_nside**2*self.chanlist[0] \
-            +(totnchan+self.chanlist[i+1]*self.n_chan_out)*self.KERNELSZ*self.KERNELSZ
+            totnchan=totnchan+self.chanlist[i]*self.chanlist[i+1]*szk
+            
+        return totnchan+self.chanlist[i+1]*self.n_chan_out*szk
 
     def set_weights(self,x):
         self.x=x
@@ -83,20 +109,46 @@ class GCNN:
 
         x=self.x
         
-        ww=self.scat_operator.backend.bk_reshape(x[0:self.npar*12*self.in_nside**2*self.chanlist[0]], \
-                                            [self.npar,12*self.in_nside**2*self.chanlist[0]])
 
         if axis==0:
             nval=1
         else:
             nval=param.shape[0]
-            
+        
+        nn=0
         im=self.scat_operator.backend.bk_reshape(param,[nval,self.npar])
-        im=self.scat_operator.backend.bk_matmul(im,ww)
-        im=self.scat_operator.backend.bk_reshape(im,[nval,12*self.in_nside**2,self.chanlist[0]])
-        im=self.scat_operator.backend.bk_relu(im)
+        if self.hidden is not None:
+            ww=self.scat_operator.backend.bk_reshape(x[nn:nn+self.npar*self.hidden[0]], \
+                                                     [self.npar,self.hidden[0]])
+            im=self.scat_operator.backend.bk_matmul(im,ww)
+            im=self.scat_operator.backend.bk_relu(im)
+            nn+=self.npar*self.hidden[0]
+            
+            for i in range(1,len(self.hidden)):
+                ww=self.scat_operator.backend.bk_reshape(x[nn:nn+self.hidden[i]*self.hidden[i-1]], \
+                                                     [self.hidden[i-1],self.hidden[i]])
+                im=self.scat_operator.backend.bk_matmul(im,ww)
+                im=self.scat_operator.backend.bk_relu(im)
+                nn+=self.hidden[i]*self.hidden[i-1]
+            
+            ww=self.scat_operator.backend.bk_reshape(x[nn:nn+self.hidden[len(self.hidden)-1]*12*self.in_nside**2*self.chanlist[0]], \
+                                                     [self.hidden[len(self.hidden)-1],
+                                                      12*self.in_nside**2*self.chanlist[0]])
+            im=self.scat_operator.backend.bk_matmul(im,ww)
+            im=self.scat_operator.backend.bk_reshape(im,[nval,12*self.in_nside**2,self.chanlist[0]])
+            im=self.scat_operator.backend.bk_relu(im)
+            nn+=self.hidden[len(self.hidden)-1]*12*self.in_nside**2*self.chanlist[0]
+            
+        else:
+            ww=self.scat_operator.backend.bk_reshape(x[0:self.npar*12*self.in_nside**2*self.chanlist[0]], \
+                                                     [self.npar,12*self.in_nside**2*self.chanlist[0]])
+            im=self.scat_operator.backend.bk_matmul(im,ww)
+            im=self.scat_operator.backend.bk_reshape(im,[nval,12*self.in_nside**2,self.chanlist[0]])
+            im=self.scat_operator.backend.bk_relu(im)
 
-        nn=self.npar*12*self.chanlist[0]*self.in_nside**2
+            nn=self.npar*12*self.chanlist[0]*self.in_nside**2
+
+        
         for k in range(self.nscale):
             ww=self.scat_operator.backend.bk_reshape(x[nn:nn+self.KERNELSZ*self.KERNELSZ*self.chanlist[k]*self.chanlist[k+1]],
                                                 [self.KERNELSZ*self.KERNELSZ,self.chanlist[k],self.chanlist[k+1]])

{foscat-3.0.35 → foscat-3.0.40}/src/foscat/backend.py

@@ -349,6 +349,15 @@ class foscat_backend:
             return self.backend.reshape(x,[np.prod(np.array(list(x.shape)))])
         if self.BACKEND==self.NUMPY:
             return x.flatten()
+
+    def bk_size(self,x):
+        if self.BACKEND==self.TENSORFLOW:
+            return self.backend.size(x)
+        if self.BACKEND==self.TORCH:
+            return x.numel()
+        
+        if self.BACKEND==self.NUMPY:
+            return x.size
         
     def bk_resize_image(self,x,shape):
         if self.BACKEND==self.TENSORFLOW:
@@ -368,11 +377,14 @@ class foscat_backend:
             xr=self.bk_real(x)
             xi=self.bk_imag(x)
                 
-            r=self.backend.sign(xr)*self.backend.sqrt(self.backend.sign(xr)*xr)
-            i=self.backend.sign(xi)*self.backend.sqrt(self.backend.sign(xi)*xi)
-            return self.bk_complex(r,i)
+            r=self.backend.sign(xr)*self.backend.sqrt(xr*xr)
+            i=self.backend.sign(xi)*self.backend.sqrt(xi*xi)
+            if self.BACKEND==self.TORCH:
+                return r
+            else:
+                return self.bk_complex(r,i)
         else:
-            return self.backend.sign(x)*self.backend.sqrt(self.backend.sign(x)*x)
+            return self.backend.sign(x)*self.backend.sqrt(x*x)
         
     def bk_square_comp(self,x):
         if x.dtype==self.all_cbk_type:
@@ -580,6 +592,13 @@ class foscat_backend:
         
         if self.BACKEND==self.NUMPY:
             return (data.dtype=='complex64' or data.dtype=='complex128')
+
+    def bk_distcomp(self,data):
+        if self.bk_is_complex(data):
+            res=self.bk_square(self.bk_real(data))+self.bk_square(self.bk_imag(data))
+            return res
+        else:
+            return self.bk_square(data)
         
     def bk_norm(self,data):
         if self.bk_is_complex(data):
@@ -727,17 +746,21 @@ class foscat_backend:
         if self.BACKEND==self.TENSORFLOW:
             return self.backend.math.real(data)
         if self.BACKEND==self.TORCH:
-            return self.backend.real(data)
+            return data.real
         if self.BACKEND==self.NUMPY:
-            return self.backend.real(data)
+            return data.real
 
     def bk_imag(self,data):
         if self.BACKEND==self.TENSORFLOW:
             return self.backend.math.imag(data)
         if self.BACKEND==self.TORCH:
-            return self.backend.imag(data)
+            if data.dtype==self.all_cbk_type:
+                return data.imag
+            else:
+                return 0
+            
         if self.BACKEND==self.NUMPY:
-            return self.backend.imag(data)
+            return data.imag
         
     def bk_relu(self,x):
         if self.BACKEND==self.TENSORFLOW:

{foscat-3.0.35 → foscat-3.0.40}/src/foscat/loss_backend_torch.py

@@ -32,30 +32,50 @@ class loss_backend:
         if len(x.shape)>1:
             nx=x.shape[0]
 
-        with torch.cuda.device((operation.gpupos+self.curr_gpu)%operation.ngpu):
-            #print('%s Run [PROC=%04d] on GPU %s'%(loss_function.name,self.mpi_rank,
-            #                          operation.gpulist[(operation.gpupos+self.curr_gpu)%operation.ngpu]))
-            #sys.stdout.flush()
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        if torch.cuda.is_available():
+            with torch.cuda.device((operation.gpupos+self.curr_gpu)%operation.ngpu):
 
-            l_x=x.clone().detach().requires_grad_(True)
+                l_x=x.clone().detach().requires_grad_(True)
+            
+                if nx==1:    
+                    ndata=x.shape[0]
+                else:
+                    ndata=x.shape[0]*x.shape[1]
+                
+                if KEEP_TRACK is not None:
+                    l,linfo=loss_function.eval(l_x,batch,return_all=True)
+                else:
+                    l=loss_function.eval(l_x,batch)
+
+                l.backward()
             
+                g=l_x.grad
+            
+                self.curr_gpu=self.curr_gpu+1
+        else:
+            l_x=x.clone().detach().requires_grad_(True)
+
             if nx==1:    
                 ndata=x.shape[0]
             else:
                 ndata=x.shape[0]*x.shape[1]
-                
+
             if KEEP_TRACK is not None:
                 l,linfo=loss_function.eval(l_x,batch,return_all=True)
             else:
+                """
+                sx=operation.eval(l_x)
+                tmp=(sx.C01-1.0)
+    
+                l=operation.backend.bk_reduce_sum(tmp*tmp) #loss_function.eval(l_x,batch)
+                """
+                
                 l=loss_function.eval(l_x,batch)
 
             l.backward()
             
             g=l_x.grad
-
-            print(g)
-            
-            self.curr_gpu=self.curr_gpu+1   
             
         if KEEP_TRACK is not None:
             return l.detach(),g,linfo

{foscat-3.0.35 → foscat-3.0.40}/src/foscat/scat.py

@@ -1038,7 +1038,7 @@ class funct(FOC.FoCUS):
         return scat(mP00,mS0,mS1,mS2,mS2L,tmp.j1,tmp.j2,backend=self.backend), \
             scat(sP00,sS0,sS1,sS2,sS2L,tmp.j1,tmp.j2,backend=self.backend)
     
-    def eval(self, image1, image2=None,mask=None,Auto=True,s0_off=1E-6,calc_var=False):
+    def eval(self, image1, image2=None,mask=None,Auto=True,s0_off=1E-6,calc_var=False,norm=None):
         # Check input consistency
         if image2 is not None:
             if list(image1.shape)!=list(image2.shape):
@@ -1344,6 +1344,30 @@ class funct(FOC.FoCUS):
                     self.backend.bk_sqrt(self.backend.bk_abs(x.S2)),
                     self.backend.bk_sqrt(self.backend.bk_abs(x.S2L)),x.j1,x.j2,backend=self.backend)
 
+    def reduce_distance(self, x,y, sigma=None):
+        
+        if isinstance(x, scat):
+            if sigma is None:
+                result=self.diff_data(y.S0,x.S0,is_complex=False)
+                result+=self.diff_data(y.S1,x.S1)
+                result+=self.diff_data(y.P00,x.P00)
+                result+=self.diff_data(y.S2,x.S2)
+                result+=self.diff_data(y.S2L,x.S2L)
+            else:
+                result=self.diff_data(y.S0,x.S0,is_complex=False,sigma=sigma.S0)
+                result+=self.diff_data(y.S1,x.S1,sigma=sigma.S1)
+                result+=self.diff_data(y.P00,x.P00,sigma=sigma.P00)
+                result+=self.diff_data(y.S2,x.S2,sigma=sigma.S2)
+                result+=self.diff_data(y.S2L,x.S2L,sigma=sigma.S2L)
+                
+            nval=self.backend.bk_size(x.S0)+self.backend.bk_size(x.P00)+ \
+                  self.backend.bk_size(x.S1)+self.backend.bk_size(x.S2)+self.backend.bk_size(x.S2L)
+            
+            result/=self.backend.bk_cast(nval)
+        else:
+            return self.backend.bk_reduce_sum(x)
+        return result
+
     def reduce_mean(self,x,axis=None):
         if axis is None:
             tmp=self.backend.bk_abs(self.backend.bk_reduce_sum(x.P00))+ \

{foscat-3.0.35 → foscat-3.0.40}/src/foscat/scat_cov.py

@@ -1682,6 +1682,10 @@ class funct(FOC.FoCUS):
                 if image2 is not None:
                     tmpi2=self.ud_grade_2(tmpi2,axis=1)
         return cmat,cmat2
+
+    def div_norm(self,complex_value,float_value):
+        return self.backend.bk_complex(self.backend.bk_real(complex_value)/float_value,
+                                    self.backend.bk_imag(complex_value)/float_value)
     
     def eval(self, image1, image2=None, mask=None, norm=None, Auto=True, calc_var=False,cmat=None,cmat2=None):
         """
@@ -1931,7 +1935,7 @@ class funct(FOC.FoCUS):
                 else:
                     ### Normalize S1
                     if norm is not None:
-                        s1 /= (P1_dic[j3]) ** 0.5
+                        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
@@ -2024,7 +2028,7 @@ class funct(FOC.FoCUS):
                 else:
                     ### Normalize S1
                     if norm is not None:
-                        s1 /= (P1_dic[j3]) ** 0.5
+                        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
@@ -2072,8 +2076,8 @@ class funct(FOC.FoCUS):
                     else:
                         ### Normalize C01 with P00_j [Nbatch, Nmask, Norient_j]
                         if norm is not None:
-                            c01 /= (P1_dic[j2][:, :, None, :] *
-                                    P1_dic[j3][:, :, :, None]) ** 0.5  # [Nbatch, Nmask, Norient3, Norient2]
+                            self.div_norm(c01,(P1_dic[j2][:, :, None, :] *
+                                    P1_dic[j3][:, :, :, None]) ** 0.5)# [Nbatch, Nmask, Norient3, Norient2]
 
                         ### Store C01 as a complex [Nbatch, Nmask, NC01, Norient3, Norient2]
                         if C01 is None:
@@ -2126,10 +2130,10 @@ class funct(FOC.FoCUS):
                     else:
                         ### Normalize C01 and C10 with P00_j [Nbatch, Nmask, Norient_j]
                         if norm is not None:
-                            c01 /= (P2_dic[j2][:, :, None, :] *
-                                    P1_dic[j3][:, :, :, None]) ** 0.5  # [Nbatch, Nmask, Norient3, Norient2]
-                            c10 /= (P1_dic[j2][:, :, None, :] *
-                                    P2_dic[j3][:, :, :, None]) ** 0.5  # [Nbatch, Nmask, Norient3, Norient2]
+                            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]
 
                         ### Store C01 and C10 as a complex [Nbatch, Nmask, NC01, Norient3, Norient2]
                         if C01 is None:
@@ -2172,9 +2176,8 @@ class funct(FOC.FoCUS):
                         else:
                             ### Normalize C11 with P00_j [Nbatch, Nmask, Norient_j]
                             if norm is not None:
-                                c11 /= (P1_dic[j1][:, :, None, None, :] *
-                                        P1_dic[j2][:, :, None, :,
-                                                   None]) ** 0.5  # [Nbatch, Nmask, Norient3, Norient2, Norient1]
+                                self.div_norm(c11,(P1_dic[j1][:, :, None, None, :] *
+                                        P1_dic[j2][:, :, None, :,None]) ** 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
@@ -2207,8 +2210,8 @@ class funct(FOC.FoCUS):
                         else:
                             ### Normalize C11 with P00_j [Nbatch, Nmask, Norient_j]
                             if norm is not None:
-                                c11 /= (P1_dic[j1][:, :, None, None, :] *
-                                        P2_dic[j2][:, :, None, :, None]) ** 0.5  # [Nbatch, Nmask, Norient3, Norient2, Norient1]
+                                self.div_norm(c11,(P1_dic[j1][:, :, None, None, :] *
+                                        P2_dic[j2][:, :, None, :, None]) ** 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
@@ -2394,6 +2397,39 @@ class funct(FOC.FoCUS):
         else:
             return self.backend.bk_reduce_mean(x)
         return result
+    
+        
+    def reduce_distance(self, x,y, sigma=None):
+        
+        if isinstance(x, scat_cov):
+            if sigma is None:
+                result=self.diff_data(y.S0,x.S0,is_complex=False)
+                if x.S1 is not None:
+                    result+=self.diff_data(y.S1,x.S1)
+                if x.C10 is not None:
+                    result+=self.diff_data(y.C10,x.C10)
+                result+=self.diff_data(y.P00,x.P00)
+                result+=self.diff_data(y.C01,x.C01)
+                result+=self.diff_data(y.C11,x.C11)
+            else:
+                result=self.diff_data(y.S0,x.S0,is_complex=False,sigma=sigma.S0)
+                if x.S1 is not None:
+                    result+=self.diff_data(y.S1,x.S1,sigma=sigma.S1)
+                if x.C10 is not None:
+                    result+=self.diff_data(y.C10,x.C10,sigma=sigma.C10)
+                result+=self.diff_data(y.P00,x.P00,sigma=sigma.P00)
+                result+=self.diff_data(y.C01,x.C01,sigma=sigma.C01)
+                result+=self.diff_data(y.C11,x.C11,sigma=sigma.C11)
+            nval=self.backend.bk_size(x.S0)+self.backend.bk_size(x.P00)+ \
+                  self.backend.bk_size(x.C01)+self.backend.bk_size(x.C11)
+            if x.S1 is not None:
+                nval+=self.backend.bk_size(x.S1)
+            if x.C10 is not None:
+                nval+=self.backend.bk_size(x.C10)
+            result/=self.backend.bk_cast(nval)
+        else:
+            return self.backend.bk_reduce_sum(x)
+        return result
 
     def reduce_sum(self, x):
         
@@ -2412,8 +2448,7 @@ class funct(FOC.FoCUS):
         else:
             return self.backend.bk_reduce_sum(x)
         return result
-
-        
+    
     def ldiff(self,sig,x):
 
         if x.S1 is None:

{foscat-3.0.35 → foscat-3.0.40}/src/foscat.egg-info/PKG-INFO

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