foscat 3.7.1__tar.gz → 3.7.3__tar.gz

{foscat-3.7.1/src/foscat.egg-info → foscat-3.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: foscat
-Version: 3.7.1
+Version: 3.7.3
 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>
@@ -23,7 +23,6 @@ Requires-Dist: imageio
 Requires-Dist: imagecodecs
 Requires-Dist: matplotlib
 Requires-Dist: numpy
-Requires-Dist: tensorflow
 Requires-Dist: healpy
 Requires-Dist: spherical
 

{foscat-3.7.1 → foscat-3.7.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "foscat"
-version = "3.7.1"
+version = "3.7.3"
 description = "Generate synthetic Healpix or 2D data using Cross Scattering Transform"
 readme = "README.md"
 license = { text = "BSD-3-Clause" }
@@ -17,7 +17,6 @@ dependencies = [
   "imagecodecs",
   "matplotlib",
   "numpy",
-  "tensorflow",
   "healpy",
   "spherical",
 ]

{foscat-3.7.1 → foscat-3.7.3}/src/foscat/FoCUS.py

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

{foscat-3.7.1 → foscat-3.7.3}/src/foscat/backend.py

@@ -1161,6 +1161,23 @@ class foscat_backend:
 
         if self.BACKEND == self.NUMPY:
             return x.astype(out_type)
+            
+    def bk_variable(self,x):
+        if self.BACKEND == self.TENSORFLOW:
+            return self.backend.Variable(x)
+            
+        return self.bk_cast(x)
+        
+    def bk_assign(self,x,y):
+        if self.BACKEND == self.TENSORFLOW:
+            x.assign(y)
+        x=y
+            
+    def bk_constant(self,x):
+        if self.BACKEND == self.TENSORFLOW:
+            return self.backend.constant(x)
+            
+        return self.bk_cast(x)
         
     def to_numpy(self,x):
         if isinstance(x, np.ndarray):

{foscat-3.7.1 → foscat-3.7.3}/src/foscat/scat_cov.py

@@ -2540,7 +2540,9 @@ class funct(FOC.FoCUS):
         -------
         S1, S2, S3, S4 normalized
         """
+        
         return_data = self.return_data
+        
         # Check input consistency
         if image2 is not None:
             if list(image1.shape) != list(image2.shape):
@@ -3806,8 +3808,7 @@ class funct(FOC.FoCUS):
         nside_j3 = nside  # NSIDE start (nside_j3 = nside / 2^j3)
 
         # a remettre comme avant
-        M1_dic={}
-        
+        M1_dic={}       
         M2_dic={}
         
         for j3 in range(Jmax):
@@ -4545,6 +4546,7 @@ class funct(FOC.FoCUS):
             return self.backend.bk_concat([s0]+S1+S2,axis=1),self.backend.bk_concat([vs0]+VS1+VS2,axis=1)
         else:
             return self.backend.bk_concat([s0]+S1+S2,axis=1)
+            
         if not return_data:
             S1 = self.backend.bk_concat(S1, 2)
             S2 = self.backend.bk_concat(S2, 2)
@@ -4836,7 +4838,9 @@ class funct(FOC.FoCUS):
     #
     # ---------------------------------------------------------------------------
     def scattering_cov(
-        self, data, Jmax=None,
+        self, data, 
+        data2=None,
+        Jmax=None,
         if_large_batch=False, 
         S4_criteria=None, 
         use_ref=False, 
@@ -4969,6 +4973,9 @@ class funct(FOC.FoCUS):
         # convert numpy array input into self.backend.bk_ tensors
         data = self.backend.bk_cast(data)
         data_f = self.backend.bk_fftn(data, dim=(-2,-1))
+        if data2 is not None:
+            data2 = self.backend.bk_cast(data2)
+            data2_f = self.backend.bk_fftn(data2, dim=(-2,-1))
         
         # initialize tensors for scattering coefficients
         S2 = self.backend.bk_zeros((N_image,J,L), dtype=data.dtype)
@@ -4979,6 +4986,8 @@ class funct(FOC.FoCUS):
         J_S4={}
         
         S3 = self.backend.bk_zeros((N_image,Ndata_S3,L,L), dtype=data_f.dtype) 
+        if data2 is not None:
+            S3p = self.backend.bk_zeros((N_image,Ndata_S3,L,L), dtype=data_f.dtype)
         S4_pre_norm = self.backend.bk_zeros((N_image,Ndata_S4,L,L,L), dtype=data_f.dtype) 
         S4 = self.backend.bk_zeros((N_image,Ndata_S4,L,L,L), dtype=data_f.dtype) 
         
@@ -4987,39 +4996,22 @@ class funct(FOC.FoCUS):
             S2_sigma = self.backend.bk_zeros((N_image,J,L), dtype=data.dtype)
             S1_sigma = self.backend.bk_zeros((N_image,J,L), dtype=data.dtype)
             S3_sigma = self.backend.bk_zeros((N_image,Ndata_S3,L,L), dtype=data_f.dtype) 
+            if data2 is not None:
+                S3p_sigma = self.backend.bk_zeros((N_image,Ndata_S3,L,L), dtype=data_f.dtype)
             S4_sigma = self.backend.bk_zeros((N_image,Ndata_S4,L,L,L), dtype=data_f.dtype) 
             
         if iso_ang:
             S3_iso = self.backend.bk_zeros((N_image,Ndata_S3,L), dtype=data_f.dtype) 
+            if data2 is not None:
+                S3p_iso = self.backend.bk_zeros((N_image,Ndata_S3,L,L), dtype=data_f.dtype)
+                
             S4_iso = self.backend.bk_zeros((N_image,Ndata_S4,L,L), dtype=data_f.dtype) 
             if get_variance:
                 S3_sigma_iso = self.backend.bk_zeros((N_image,Ndata_S3,L), dtype=data_f.dtype) 
+                if data2 is not None:
+                    S3p_sigma_iso = self.backend.bk_zeros((N_image,Ndata_S3,L), dtype=data_f.dtype) 
                 S4_sigma_iso = self.backend.bk_zeros((N_image,Ndata_S4,L,L), dtype=data_f.dtype) 
             
-        # calculate scattering fields
-        if self.use_2D:
-            if len(data.shape) == 2:
-                I1 = self.backend.bk_ifftn(
-                    data_f[None,None,None,:,:] * filters_set[None,:J,:,:,:], dim=(-2,-1)
-                ).abs()
-            else:
-                I1 = self.backend.bk_ifftn(
-                    data_f[:,None,None,:,:] * filters_set[None,:J,:,:,:], dim=(-2,-1)
-                ).abs()
-        elif self.use_1D:
-            if len(data.shape) == 1:
-                I1 = self.backend.bk_ifftn(
-                    data_f[None,None,None,:] * filters_set[None,:J,:,:], dim=(-1)
-                ).abs()
-            else:
-                I1 = self.backend.bk_ifftn(
-                    data_f[:,None,None,:] * filters_set[None,:J,:,:], dim=(-1)
-                ).abs()
-        else:
-            print('todo')
-    
-        I1_f= self.backend.bk_fftn(I1, dim=(-2,-1))
-        
         #
         if edge: 
             if (M,N,J) not in self.edge_masks:
@@ -5028,12 +5020,87 @@ class funct(FOC.FoCUS):
             edge_mask = edge_mask / edge_mask.mean((-2,-1))[:,:,None,None]
         else: 
             edge_mask = 1
-        S2 = (I1**2 * edge_mask).mean((-2,-1))
-        S1  = (I1 * edge_mask).mean((-2,-1))
+            
+        # calculate scattering fields
+        if data2 is None:
+            if self.use_2D:
+                if len(data.shape) == 2:
+                    I1 = self.backend.bk_ifftn(
+                        data_f[None,None,None,:,:] * filters_set[None,:J,:,:,:], dim=(-2,-1)
+                    ).abs()
+                else:
+                    I1 = self.backend.bk_ifftn(
+                        data_f[:,None,None,:,:] * filters_set[None,:J,:,:,:], dim=(-2,-1)
+                    ).abs()
+            elif self.use_1D:
+                if len(data.shape) == 1:
+                    I1 = self.backend.bk_ifftn(
+                        data_f[None,None,None,:] * filters_set[None,:J,:,:], dim=(-1)
+                    ).abs()
+                else:
+                    I1 = self.backend.bk_ifftn(
+                        data_f[:,None,None,:] * filters_set[None,:J,:,:], dim=(-1)
+                    ).abs()
+            else:
+                print('todo')
+            
+            S2 = (I1**2 * edge_mask).mean((-2,-1))
+            S1  = (I1 * edge_mask).mean((-2,-1))
 
-        if get_variance:
-            S2_sigma = (I1**2 * edge_mask).std((-2,-1))
-            S1_sigma  = (I1 * edge_mask).std((-2,-1))
+            if get_variance:
+                S2_sigma = (I1**2 * edge_mask).std((-2,-1))
+                S1_sigma  = (I1 * edge_mask).std((-2,-1))
+                
+            I1_f= self.backend.bk_fftn(I1, dim=(-2,-1))
+            
+        else: 
+            if self.use_2D:
+                if len(data.shape) == 2:
+                    I1 = self.backend.bk_ifftn(
+                        data_f[None,None,None,:,:] * filters_set[None,:J,:,:,:], dim=(-2,-1)
+                    )
+                    I2 = self.backend.bk_ifftn(
+                        data2_f[None,None,None,:,:] * filters_set[None,:J,:,:,:], dim=(-2,-1)
+                    )
+                else:
+                    I1 = self.backend.bk_ifftn(
+                        data_f[:,None,None,:,:] * filters_set[None,:J,:,:,:], dim=(-2,-1)
+                    )
+                    I2 = self.backend.bk_ifftn(
+                        data2_f[:,None,None,:,:] * filters_set[None,:J,:,:,:], dim=(-2,-1)
+                    )
+            elif self.use_1D:
+                if len(data.shape) == 1:
+                    I1 = self.backend.bk_ifftn(
+                        data_f[None,None,None,:] * filters_set[None,:J,:,:], dim=(-1)
+                    )
+                    I2 = self.backend.bk_ifftn(
+                        data2_f[None,None,None,:] * filters_set[None,:J,:,:], dim=(-1)
+                    )
+                else:
+                    I1 = self.backend.bk_ifftn(
+                        data_f[:,None,None,:] * filters_set[None,:J,:,:], dim=(-1)
+                    )
+                    I2 = self.backend.bk_ifftn(
+                        data2_f[:,None,None,:] * filters_set[None,:J,:,:], dim=(-1)
+                    )
+            else:
+                print('todo')
+            
+            I1=self.backend.bk_real(I1*self.backend.bk_conjugate(I2))
+            
+            S2 = (I1 * edge_mask).mean((-2,-1))
+            if get_variance:
+                S2_sigma = (I1 * edge_mask).std((-2,-1))
+            
+            I1=self.backend.bk_L1(I1)
+            
+            S1  = (I1 * edge_mask).mean((-2,-1))
+
+            if get_variance:
+                S1_sigma  = (I1 * edge_mask).std((-2,-1))
+                
+            I1_f= self.backend.bk_fftn(I1, dim=(-2,-1))
             
         if pseudo_coef != 1:
             I1 = I1**pseudo_coef
@@ -5049,9 +5116,13 @@ class funct(FOC.FoCUS):
             dx3, dy3 = self.get_dxdy(j3,M,N)
             I1_f_small = self.cut_high_k_off(I1_f[:,:j3+1], dx3, dy3) # Nimage, J, L, x, y
             data_f_small = self.cut_high_k_off(data_f, dx3, dy3)
+            if data2 is not None:
+                data2_f_small = self.cut_high_k_off(data2_f, dx3, dy3)
             if edge:
                 I1_small = self.backend.bk_ifftn(I1_f_small, dim=(-2,-1), norm='ortho')
                 data_small = self.backend.bk_ifftn(data_f_small, dim=(-2,-1), norm='ortho')
+                if data2 is not None:
+                    data2_small = self.backend.bk_ifftn(data2_f_small, dim=(-2,-1), norm='ortho')
             wavelet_f3 = self.cut_high_k_off(filters_set[j3], dx3, dy3) # L,x,y
             _, M3, N3 = wavelet_f3.shape
             wavelet_f3_squared = wavelet_f3**2
@@ -5068,15 +5139,17 @@ class funct(FOC.FoCUS):
                 if use_ref:
                     if normalization=='P11':
                         norm_factor_S3 = (ref_S2[:,None,j3,:] * ref_P11[:,j2,j3,:,:]**pseudo_coef)**0.5
-                    if normalization=='S2':
+                    elif normalization=='S2':
                         norm_factor_S3 = (ref_S2[:,None,j3,:] * ref_S2[:,j2,:,None]**pseudo_coef)**0.5
+                    norm_factor_S3 = 1.0
                 else:
                     if normalization=='P11':
                         # [N_image,l2,l3,x,y]
                         P11_temp = (I1_f2_wf3_small.abs()**2).mean((-2,-1)) * fft_factor
                         norm_factor_S3 = (S2[:,None,j3,:] * P11_temp**pseudo_coef)**0.5
-                    if normalization=='S2':
+                    elif normalization=='S2':
                         norm_factor_S3 = (S2[:,None,j3,:] * S2[:,j2,:,None]**pseudo_coef)**0.5
+                    norm_factor_S3 = 1.0
 
                 if not edge:
                     S3[:,Ndata_S3,:,:] = (
@@ -5096,6 +5169,26 @@ class funct(FOC.FoCUS):
                         S3_sigma[:,Ndata_S3,:,:] = (
                             data_small.view(N_image,1,1,M3,N3) * self.backend.bk_conjugate(I12_w3_small)
                             )[...,edge_dx:M3-edge_dx, edge_dy:N3-edge_dy].std((-2,-1)) * fft_factor / norm_factor_S3
+                if data2 is not None:
+                    if not edge:
+                        S3p[:,Ndata_S3,:,:] = (
+                            data2_f_small.view(N_image,1,1,M3,N3) * self.backend.bk_conjugate(I1_f2_wf3_small)
+                        ).mean((-2,-1)) * fft_factor / norm_factor_S3
+                    
+                        if get_variance:
+                            S3p_sigma[:,Ndata_S3,:,:] = (
+                                data2_f_small.view(N_image,1,1,M3,N3) * self.backend.bk_conjugate(I1_f2_wf3_small)
+                            ).std((-2,-1)) * fft_factor / norm_factor_S3
+                    else:
+                    
+                        S3p[:,Ndata_S3,:,:] = (
+                            data2_small.view(N_image,1,1,M3,N3) * self.backend.bk_conjugate(I12_w3_small)
+                        )[...,edge_dx:M3-edge_dx, edge_dy:N3-edge_dy].mean((-2,-1)) * fft_factor / norm_factor_S3
+                        if get_variance:
+                            S3p_sigma[:,Ndata_S3,:,:] = (
+                                data2_small.view(N_image,1,1,M3,N3) * self.backend.bk_conjugate(I12_w3_small)
+                                )[...,edge_dx:M3-edge_dx, edge_dy:N3-edge_dy].std((-2,-1)) * fft_factor / norm_factor_S3
+                                
                 Ndata_S3+=1
                 if j2 <= j3:
                     beg_n=Ndata_S4
@@ -5160,12 +5253,16 @@ class funct(FOC.FoCUS):
                         if use_ref: 
                             P = (ref_S2[:,j3,:,None,None] * ref_S2[:,j2,None,:,None] )**(0.5*pseudo_coef)
                         else: 
-                            P = (S2[:,j3,:,None,None] * S2[:,j2,None,:,None] )**(0.5*pseudo_coef)
+                            P = ((S2[:,j3,:,None,None] * S2[:,j2,None,:,None] )**(0.5*pseudo_coef))
+                        S4[:,beg_n:Ndata_S4,:,:,:]=S4_pre_norm[:,beg_n:Ndata_S4,:,:,:].clone()/(P.clone())
                             
-                        S4[:,beg_n:Ndata_S4,:,:,:]=S4_pre_norm[:,beg_n:Ndata_S4,:,:,:]/P
+                        if get_variance:
+                            S4_sigma[:,beg_n:Ndata_S4,:,:,:] = S4_sigma[:,beg_n:Ndata_S4,:,:,:] / (P)
+                    else:
+                        S4[:,beg_n:Ndata_S4,:,:,:]=S4_pre_norm[:,beg_n:Ndata_S4,:,:,:].clone()
                             
                         if get_variance:
-                            S4_sigma[:,beg_n:Ndata_S4,:,:,:] = S4_sigma[:,beg_n:Ndata_S4,:,:,:] / P
+                            S4_sigma[:,beg_n:Ndata_S4,:,:,:] = S4_sigma[:,beg_n:Ndata_S4,:,:,:]
                             
         """
         # define P11 from diagonals of S4
@@ -5199,9 +5296,13 @@ class funct(FOC.FoCUS):
             for l1 in range(L):
                 for l2 in range(L):
                     S3_iso[...,(l2-l1)%L] += S3[...,l1,l2]
+                    if data2 is not None:
+                        S3p_iso[...,(l2-l1)%L] += S3p[...,l1,l2]
                     for l3 in range(L):
                         S4_iso[...,(l2-l1)%L,(l3-l1)%L] += S4[...,l1,l2,l3]
             S3_iso /= L; S4_iso /= L
+            if data2 is not None:
+                S3p_iso /= L
             
             if get_variance:
                 S2_sigma_iso = S2_sigma.mean(-1)
@@ -5209,9 +5310,13 @@ class funct(FOC.FoCUS):
                 for l1 in range(L):
                     for l2 in range(L):
                         S3_sigma_iso[...,(l2-l1)%L] += S3_sigma[...,l1,l2]
+                        if data2 is not None:
+                            S3p_sigma_iso[...,(l2-l1)%L] += S3p_sigma[...,l1,l2]
                         for l3 in range(L):
                             S4_sigma_iso[...,(l2-l1)%L,(l3-l1)%L] += S4_sigma[...,l1,l2,l3]
                 S3_sigma_iso /= L; S4_sigma_iso /= L
+                if data2 is not None:
+                    S3p_sigma_iso /= L
         
         mean_data=self.backend.bk_zeros((N_image,1), dtype=data.dtype) 
         std_data=self.backend.bk_zeros((N_image,1), dtype=data.dtype) 
@@ -5226,59 +5331,119 @@ class funct(FOC.FoCUS):
                 ref_sigma['S2_sigma']=S2_sigma_iso
                 ref_sigma['S3_sigma']=S3_sigma_iso
                 ref_sigma['S4_sigma']=S4_sigma_iso
+                if data2 is not None:
+                    ref_sigma['S3p_sigma']=S3p_sigma_iso
             else:
                 ref_sigma['std_data']=std_data
                 ref_sigma['S1_sigma']=S1_sigma
                 ref_sigma['S2_sigma']=S2_sigma
                 ref_sigma['S3_sigma']=S3_sigma
                 ref_sigma['S4_sigma']=S4_sigma
+                if data2 is not None:
+                    ref_sigma['S3p_sigma']=S3_sigma
         
-        if iso_ang:
-            if ref_sigma is not None:
-                for_synthesis = self.backend.backend.cat((
-                    mean_data/ref_sigma['std_data'],
-                    std_data/ref_sigma['std_data'],
-                    (S2_iso/ref_sigma['S2_sigma']).reshape((N_image, -1)).log(), 
-                    (S1_iso/ref_sigma['S1_sigma']).reshape((N_image, -1)).log(),
-                    (S3_iso/ref_sigma['S3_sigma']).reshape((N_image, -1)).real, 
-                    (S3_iso/ref_sigma['S3_sigma']).reshape((N_image, -1)).imag,
-                    (S4_iso/ref_sigma['S4_sigma']).reshape((N_image, -1)).real, 
-                    (S4_iso/ref_sigma['S4_sigma']).reshape((N_image, -1)).imag,
-                    ),dim=-1)
+        if data2 is None:
+            if iso_ang:
+                if ref_sigma is not None:
+                    for_synthesis = self.backend.backend.cat((
+                        mean_data/ref_sigma['std_data'],
+                        std_data/ref_sigma['std_data'],
+                        (S2_iso/ref_sigma['S2_sigma']).reshape((N_image, -1)).log(), 
+                        (S1_iso/ref_sigma['S1_sigma']).reshape((N_image, -1)).log(),
+                        (S3_iso/ref_sigma['S3_sigma']).reshape((N_image, -1)).real, 
+                        (S3_iso/ref_sigma['S3_sigma']).reshape((N_image, -1)).imag,
+                        (S4_iso/ref_sigma['S4_sigma']).reshape((N_image, -1)).real, 
+                        (S4_iso/ref_sigma['S4_sigma']).reshape((N_image, -1)).imag,
+                        ),dim=-1)
+                else:
+                    for_synthesis = self.backend.backend.cat((
+                        mean_data/std_data,
+                        std_data,
+                        S2_iso.reshape((N_image, -1)).log(), 
+                        S1_iso.reshape((N_image, -1)).log(),
+                        S3_iso.reshape((N_image, -1)).real, 
+                        S3_iso.reshape((N_image, -1)).imag,
+                        S4_iso.reshape((N_image, -1)).real, 
+                        S4_iso.reshape((N_image, -1)).imag,
+                        ),dim=-1)
             else:
-                for_synthesis = self.backend.backend.cat((
-                    mean_data/std_data,
-                    std_data,
-                    S2_iso.reshape((N_image, -1)).log(), 
-                    S1_iso.reshape((N_image, -1)).log(),
-                    S3_iso.reshape((N_image, -1)).real, 
-                    S3_iso.reshape((N_image, -1)).imag,
-                    S4_iso.reshape((N_image, -1)).real, 
-                    S4_iso.reshape((N_image, -1)).imag,
-                    ),dim=-1)
+                if ref_sigma is not None:
+                    for_synthesis = self.backend.backend.cat((
+                        mean_data/ref_sigma['std_data'],
+                        std_data/ref_sigma['std_data'],
+                        (S2/ref_sigma['S2_sigma']).reshape((N_image, -1)).log(), 
+                        (S1/ref_sigma['S1_sigma']).reshape((N_image, -1)).log(),
+                        (S3/ref_sigma['S3_sigma']).reshape((N_image, -1)).real, 
+                        (S3/ref_sigma['S3_sigma']).reshape((N_image, -1)).imag,
+                        (S4/ref_sigma['S4_sigma']).reshape((N_image, -1)).real, 
+                        (S4/ref_sigma['S4_sigma']).reshape((N_image, -1)).imag,
+                        ),dim=-1)
+                else:
+                    for_synthesis = self.backend.backend.cat((
+                        mean_data/std_data,
+                        std_data,
+                        S2.reshape((N_image, -1)).log(), 
+                        S1.reshape((N_image, -1)).log(),
+                        S3.reshape((N_image, -1)).real, 
+                        S3.reshape((N_image, -1)).imag,
+                        S4.reshape((N_image, -1)).real, 
+                        S4.reshape((N_image, -1)).imag,
+                        ),dim=-1)
         else:
-            if ref_sigma is not None:
-                for_synthesis = self.backend.backend.cat((
-                    mean_data/ref_sigma['std_data'],
-                    std_data/ref_sigma['std_data'],
-                    (S2/ref_sigma['S2_sigma']).reshape((N_image, -1)).log(), 
-                    (S1/ref_sigma['S1_sigma']).reshape((N_image, -1)).log(),
-                    (S3/ref_sigma['S3_sigma']).reshape((N_image, -1)).real, 
-                    (S3/ref_sigma['S3_sigma']).reshape((N_image, -1)).imag,
-                    (S4/ref_sigma['S4_sigma']).reshape((N_image, -1)).real, 
-                    (S4/ref_sigma['S4_sigma']).reshape((N_image, -1)).imag,
-                    ),dim=-1)
+            if iso_ang:
+                if ref_sigma is not None:
+                    for_synthesis = self.backend.backend.cat((
+                        mean_data/ref_sigma['std_data'],
+                        std_data/ref_sigma['std_data'],
+                        (S2_iso/ref_sigma['S2_sigma']).reshape((N_image, -1)), 
+                        (S1_iso/ref_sigma['S1_sigma']).reshape((N_image, -1)),
+                        (S3_iso/ref_sigma['S3_sigma']).reshape((N_image, -1)).real, 
+                        (S3_iso/ref_sigma['S3_sigma']).reshape((N_image, -1)).imag,
+                        (S3p_iso/ref_sigma['S3p_sigma']).reshape((N_image, -1)).real, 
+                        (S3p_iso/ref_sigma['S3p_sigma']).reshape((N_image, -1)).imag,
+                        (S4_iso/ref_sigma['S4_sigma']).reshape((N_image, -1)).real, 
+                        (S4_iso/ref_sigma['S4_sigma']).reshape((N_image, -1)).imag,
+                        ),dim=-1)
+                else:
+                    for_synthesis = self.backend.backend.cat((
+                        mean_data/std_data,
+                        std_data,
+                        S2_iso.reshape((N_image, -1)), 
+                        S1_iso.reshape((N_image, -1)),
+                        S3_iso.reshape((N_image, -1)).real, 
+                        S3_iso.reshape((N_image, -1)).imag,
+                        S3p_iso.reshape((N_image, -1)).real, 
+                        S3p_iso.reshape((N_image, -1)).imag,
+                        S4_iso.reshape((N_image, -1)).real, 
+                        S4_iso.reshape((N_image, -1)).imag,
+                        ),dim=-1)
             else:
-                for_synthesis = self.backend.backend.cat((
-                    mean_data/std_data,
-                    std_data,
-                    S2.reshape((N_image, -1)).log(), 
-                    S1.reshape((N_image, -1)).log(),
-                    S3.reshape((N_image, -1)).real, 
-                    S3.reshape((N_image, -1)).imag,
-                    S4.reshape((N_image, -1)).real, 
-                    S4.reshape((N_image, -1)).imag,
-                    ),dim=-1)
+                if ref_sigma is not None:
+                    for_synthesis = self.backend.backend.cat((
+                        mean_data/ref_sigma['std_data'],
+                        std_data/ref_sigma['std_data'],
+                        (S2/ref_sigma['S2_sigma']).reshape((N_image, -1)), 
+                        (S1/ref_sigma['S1_sigma']).reshape((N_image, -1)),
+                        (S3/ref_sigma['S3_sigma']).reshape((N_image, -1)).real, 
+                        (S3/ref_sigma['S3_sigma']).reshape((N_image, -1)).imag,
+                        (S3p/ref_sigma['S3p_sigma']).reshape((N_image, -1)).real, 
+                        (S3p/ref_sigma['S3p_sigma']).reshape((N_image, -1)).imag,
+                        (S4/ref_sigma['S4_sigma']).reshape((N_image, -1)).real, 
+                        (S4/ref_sigma['S4_sigma']).reshape((N_image, -1)).imag,
+                        ),dim=-1)
+                else:
+                    for_synthesis = self.backend.backend.cat((
+                        mean_data/std_data,
+                        std_data,
+                        S2.reshape((N_image, -1)), 
+                        S1.reshape((N_image, -1)),
+                        S3.reshape((N_image, -1)).real, 
+                        S3.reshape((N_image, -1)).imag,
+                        S3p.reshape((N_image, -1)).real, 
+                        S3p.reshape((N_image, -1)).imag,
+                        S4.reshape((N_image, -1)).real, 
+                        S4.reshape((N_image, -1)).imag,
+                        ),dim=-1)
                 
         if not use_ref: 
             self.ref_scattering_cov_S2=S2

{foscat-3.7.1 → foscat-3.7.3/src/foscat.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: foscat
-Version: 3.7.1
+Version: 3.7.3
 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>
@@ -23,7 +23,6 @@ Requires-Dist: imageio
 Requires-Dist: imagecodecs
 Requires-Dist: matplotlib
 Requires-Dist: numpy
-Requires-Dist: tensorflow
 Requires-Dist: healpy
 Requires-Dist: spherical
 

{foscat-3.7.1 → foscat-3.7.3}/src/foscat.egg-info/requires.txt

@@ -2,6 +2,5 @@ imageio
 imagecodecs
 matplotlib
 numpy
-tensorflow
 healpy
 spherical