foscat 3.2.0__py3-none-any.whl → 3.3.1__py3-none-any.whl

foscat/CircSpline.py

@@ -1,54 +1,75 @@
-import math
+import numpy as np
 
 
 class CircSpline:
     def __init__(self, nodes, degree=3):
         """
-        Initialize the circular spline with the given number of nodes and degree.
+        Initializes the Spline1D instance.
+
+        Parameters:
+        - nodes (int): The number of nodes in the spline.
+        - degree (int): The degree of the spline. Default is 3.
         """
         self.degree = degree
         self.nodes = nodes
-        self.norm = [self._compute_norm(i) for i in range(degree + 1)]
-
-    def _compute_norm(self, i):
+        
+        
+    def cubic_spline_function(self,x):
         """
-        Compute normalization factor for the ith element.
+        Evaluate the cubic spline basis function.
+    
+        Args:
+            x (float or array): Input value(s) to evaluate the spline basis function.
+    
+        Returns:
+            float or array: Result of the cubic spline basis function.
         """
-        return (
-            pow(-1, i)
-            * (self.degree + 1)
-            / (math.factorial(self.degree + 1 - i) * math.factorial(i))
-        )
+        return -2 * x**3 + 3 * x**2
 
-    def yplus(self, x):
-        """
-        Compute yplus value for a given x based on the spline's degree.
-        """
-        if x < 0.0:
-            return 0.0
-        if self.degree == 0:
-            return 0.5 if x == 0.0 else 1.0
-        return pow(x, self.degree)
 
-    def calculate(self, x):
+    def eval(self,x):
         """
-        Calculate circular spline values for a given x.
+        Compute a 3rd-degree cubic spline with 4-point support.
+    
+        Args:
+            x (float or array): Input value(s) to compute the spline.
+
+        Returns:
+            indices (array): Indices of the spline support points.
+            coefficients (array): Normalized spline coefficients.
         """
-        y = [0] * self.nodes
-        for i in range(self.nodes + self.degree // 2 + 1):
-            tmp = 0
-            tx = self.nodes * math.fmod(x, 2 * math.pi) / (math.pi * 2) - i
-            for j in range(self.degree + 1):
-                tmp += self.norm[j] * self.yplus(tx - j + (self.degree + 1) // 2)
-            if tmp < 0:
-                tmp = 0.0
-            y[i % self.nodes] += tmp
-        for i in range(self.degree // 2):
-            tmp = 0
-            tx = self.nodes * math.fmod(x, 2 * math.pi) / (math.pi * 2) + 1 + i
-            for j in range(self.degree + 1):
-                tmp += self.norm[j] * self.yplus(tx - j + (self.degree + 1) // 2)
-            if tmp < 0:
-                tmp = 0.0
-            y[self.nodes - 1 - i] += tmp
-        return y
+        N=self.nodes
+        
+        if isinstance(x, float):
+            # Single scalar input
+            base_idx = int(x * (N))
+            indices = np.zeros([4], dtype="int")
+            coefficients = np.zeros([4])
+        else:
+            # Array input
+            base_idx = (x * (N)).astype("int")
+            indices = np.zeros([4, x.shape[0]], dtype="int")
+            coefficients = np.zeros([4, x.shape[0]])
+
+        # Compute the fractional part of the input
+        fractional_part = x * (N) - base_idx
+
+        # Compute spline coefficients for 4 support points
+        coefficients[3] = self.cubic_spline_function(fractional_part / 2) / 2
+        coefficients[2] = self.cubic_spline_function(0.5 + fractional_part / 2) / 2
+        coefficients[1] = self.cubic_spline_function(1 - fractional_part / 2) / 2
+        coefficients[0] = self.cubic_spline_function(0.5 - fractional_part / 2) / 2
+
+        # Assign indices for the support points
+        indices[3] = (base_idx + 3)%N
+        indices[2] = (base_idx + 2)%N
+        indices[1] = (base_idx + 1)%N
+        indices[0] = base_idx
+
+        # Adjust indices to start from 0
+        indices = indices - 1
+        # Square coefficients and normalize
+        coefficients = coefficients * coefficients
+        coefficients /= np.sum(coefficients, axis=0)
+
+        return indices, coefficients

foscat/FoCUS.py

@@ -38,7 +38,7 @@ class FoCUS:
         mpi_rank=0,
     ):
 
-        self.__version__ = "3.2.0"
+        self.__version__ = "3.3.0"
         # P00 coeff for normalization for scat_cov
         self.TMPFILE_VERSION = TMPFILE_VERSION
         self.P1_dic = None
@@ -2193,7 +2193,7 @@ class FoCUS:
                         + ishape[axis + 2 :],
                     )
 
-            return self.backend.bk_reshape(res, in_image.shape+[self.NORIENT])
+            return self.backend.bk_reshape(res, in_image.shape + [self.NORIENT])
         elif self.use_1D:
             ishape = list(in_image.shape)
             if len(ishape) < axis + 1:
@@ -2265,7 +2265,7 @@ class FoCUS:
                         res, ishape[0:axis] + [res.shape[1]] + ishape[axis + 1 :]
                     )
 
-            return self.backend.bk_reshape(res, in_image.shape+[self.NORIENT])
+            return self.backend.bk_reshape(res, in_image.shape + [self.NORIENT])
 
         else:
             nside = int(np.sqrt(image.shape[axis] // 12))

foscat/Softmax.py

@@ -1,4 +1,4 @@
-#import tensorflow as tf
+# import tensorflow as tf
 from tensorflow.keras.layers import Dense, Softmax
 from tensorflow.keras.models import Sequential
 

foscat/Spline1D.py

@@ -1,46 +1,92 @@
+import numpy as np
+
 class Spline1D:
     def __init__(self, nodes, degree=3):
+        """
+        Initializes the Spline1D instance.
+
+        Parameters:
+        - nodes (int): The number of nodes in the spline.
+        - degree (int): The degree of the spline. Default is 3.
+        """
         self.degree = degree
         self.nodes = nodes
-        self.norm = [0] * (self.degree + 1)
-        for i in range(self.degree + 1):
-            self.norm[i] = (
-                pow(-1, i)
-                * (self.degree + 1)
-                / (self._fact_spline(self.degree + 1 - i) * self._fact_spline(i))
-            )
-
-    def _fact_spline(self, x):
-        if x <= 1:
-            return 1
-        return x * self._fact_spline(x - 1)
-
-    def yplus_spline1d(self, x):
-        if x < 0.0:
-            return 0.0
-        if self.degree == 0:
-            if x == 0.0:
-                return 0.5
-            else:
-                return 1.0
-        return pow(x, self.degree)
-
-    def calculate(self, x):
-        y = [0] * self.nodes
-        for i in range(self.nodes):
-            tmp = 0
-            tx = (self.nodes - 1) * x - i
-            if x < 0:
-                tx = -i
-            if x > 1.0:
-                tx = (self.nodes - 1) - i
-            for j in range(self.degree + 1):
-                tmp += self.norm[j] * self.yplus_spline1d(
-                    tx - j + (self.degree + 1) / 2
-                )
-            if tmp < 0:
-                tmp = 0.0
-            y[i] += tmp
-        total = sum(y)
-        y = [yi / total for yi in y]
-        return y
+        
+        
+    def cubic_spline_function(self,x):
+        """
+        Evaluate the cubic spline basis function.
+    
+        Args:
+            x (float or array): Input value(s) to evaluate the spline basis function.
+    
+        Returns:
+            float or array: Result of the cubic spline basis function.
+        """
+        return -2 * x**3 + 3 * x**2
+
+
+    def eval(self,x):
+        """
+        Compute a 3rd-degree cubic spline with 4-point support.
+    
+        Args:
+            x (float or array): Input value(s) to compute the spline.
+
+        Returns:
+            indices (array): Indices of the spline support points.
+            coefficients (array): Normalized spline coefficients.
+        """
+        N=self.nodes
+        
+        if isinstance(x, float):
+            # Single scalar input
+            base_idx = int(x * (N-1))
+            indices = np.zeros([4], dtype="int")
+            coefficients = np.zeros([4])
+        else:
+            # Array input
+            base_idx = (x * (N-1)).astype("int")
+            indices = np.zeros([4, x.shape[0]], dtype="int")
+            coefficients = np.zeros([4, x.shape[0]])
+
+        # Compute the fractional part of the input
+        fractional_part = x * (N-1) - base_idx
+
+        # Compute spline coefficients for 4 support points
+        coefficients[3] = self.cubic_spline_function(fractional_part / 2) / 2
+        coefficients[2] = self.cubic_spline_function(0.5 + fractional_part / 2) / 2
+        coefficients[1] = self.cubic_spline_function(1 - fractional_part / 2) / 2
+        coefficients[0] = self.cubic_spline_function(0.5 - fractional_part / 2) / 2
+
+        # Assign indices for the support points
+        indices[3] = base_idx + 3
+        indices[2] = base_idx + 2
+        indices[1] = base_idx + 1
+        indices[0] = base_idx
+
+        # Handle boundary conditions
+        if isinstance(x, float):
+            if indices[0] == 0:
+                indices[0] = 1
+            if indices[1] == 0:
+                indices[1] = 1
+            if indices[2] == N + 1:
+                indices[2] = N
+            if indices[3] == N + 1:
+                indices[3] = N
+            if indices[3] == N + 2:
+                indices[3] = N
+        else:
+            indices[0, indices[0] == 0] = 1
+            indices[1, indices[1] == 0] = 1
+            indices[2, indices[2] >= N + 1] = N
+            indices[3, indices[3] >= N + 1] = N
+
+        # Adjust indices to start from 0
+        indices = indices - 1
+        # Square coefficients and normalize
+        coefficients = coefficients * coefficients
+        coefficients /= np.sum(coefficients, axis=0)
+
+        return indices, coefficients

foscat/Synthesis.py

@@ -18,7 +18,7 @@ class Loss:
         batch=None,
         batch_data=None,
         batch_update=None,
-        info_callback=False
+        info_callback=False,
     ):
 
         self.loss_function = function
@@ -29,6 +29,7 @@ class Loss:
         self.batch_data = batch_data
         self.batch_update = batch_update
         self.info = info_callback
+        self.id_loss = 0
 
     def eval(self, x, batch, return_all=False):
         if self.batch is None:
@@ -46,7 +47,12 @@ class Loss:
             else:
                 return self.loss_function(x, batch, self.scat_operator, self.args)
 
-
+    def set_id_loss(self,id_loss):
+        self.id_loss = id_loss
+        
+    def get_id_loss(self,id_loss):
+        return self.id_loss
+    
 class Synthesis:
     def __init__(
         self,
@@ -60,6 +66,10 @@ class Synthesis:
 
         self.loss_class = loss_list
         self.number_of_loss = len(loss_list)
+        
+        for k in range(self.number_of_loss):
+            self.loss_class[k].set_id_loss(k)
+            
         self.__iteration__ = 1234
         self.nlog = 0
         self.m_dw, self.v_dw = 0.0, 0.0
@@ -109,7 +119,7 @@ class Synthesis:
                         "nvidia-smi | awk '$2==\"N/A\"{print substr($9,1,length($9)-3),substr($11,1,length($11)-3),substr($13,1,length($13)-1)}' > smi_tmp.txt"
                     )
                 except:
-                    print('No nvidia GPU: Impossible to trace')
+                    print("No nvidia GPU: Impossible to trace")
                     self.nogpu = 1
 
     def stop_synthesis(self):
@@ -203,7 +213,9 @@ class Synthesis:
                     )
                     self.last_info = self.KEEP_TRACK(linfo, self.mpi_rank, add=True)
                 else:
-                    l_loss, g = self.bk.loss(x, l_batch, self.loss_class[k], self.KEEP_TRACK)
+                    l_loss, g = self.bk.loss(
+                        x, l_batch, self.loss_class[k], self.KEEP_TRACK
+                    )
 
                 if g_tot is None:
                     g_tot = g
@@ -213,7 +225,9 @@ class Synthesis:
                 l_tot = l_tot + l_loss.numpy()
 
                 if self.l_log[self.mpi_rank * self.MAXNUMLOSS + k] == -1:
-                    self.l_log[self.mpi_rank * self.MAXNUMLOSS + k] = l_loss.numpy() / nstep
+                    self.l_log[self.mpi_rank * self.MAXNUMLOSS + k] = (
+                        l_loss.numpy() / nstep
+                    )
                 else:
                     self.l_log[self.mpi_rank * self.MAXNUMLOSS + k] = (
                         self.l_log[self.mpi_rank * self.MAXNUMLOSS + k]
@@ -346,7 +360,7 @@ class Synthesis:
             except:
                 print("Error: unable to start thread for GPU survey")
 
-        #start = time.time()
+        # start = time.time()
 
         if self.mpi_size > 1:
             num_loss = np.zeros([1], dtype="int32")
@@ -385,7 +399,7 @@ class Synthesis:
 
         self.noise_idx = None
 
-        #for k in range(self.number_of_loss):
+        # for k in range(self.number_of_loss):
         #    if self.loss_class[k].batch is not None:
         #        l_batch = self.loss_class[k].batch(
         #            self.loss_class[k].batch_data, 0, init=True
@@ -397,7 +411,7 @@ class Synthesis:
 
         maxitt = NUM_EPOCHS
 
-#        start_x = x.copy()
+        #        start_x = x.copy()
 
         for iteration in range(NUM_STEP_BIAS):
 
@@ -422,7 +436,7 @@ class Synthesis:
                         self.loss_class[k].batch_update(
                             self.loss_class[k].batch_data, omap
                         )
-                    #if self.loss_class[k].batch is not None:
+                    # if self.loss_class[k].batch is not None:
                     #    l_batch = self.loss_class[k].batch(
                     #        self.loss_class[k].batch_data, 0, init=True
                     #    )

foscat/alm.py

@@ -0,0 +1,140 @@
+import healpy as hp
+import numpy as np
+
+class alm():
+
+    def __init__(self,backend=None,lmax=24,limit_range=1E7):
+        self._logtab={}
+        self.lmax=0
+        for k in range(1,2*lmax+1):
+            self._logtab[k]=np.log(k) 
+        self._limit_range=1/limit_range
+        self._log_limit_range=np.log(limit_range)
+        if backend is None:
+            import foscat.scat_cov as sc
+            self.sc=sc.funct()
+            self.backend=self.sc.backend
+        else:
+            self.backend=backend.backend
+    
+    def log(self,v):
+        #return np.log(v)
+        if isinstance(v,np.ndarray):
+            return np.array([self.log(k) for k in v])
+        if v<self.lmax*2+1:
+            return self._logtab[v]
+        else:
+            self._logtab[v]=np.log(v)
+        return self._logtab[v]
+
+    # Fonction pour calculer la double factorielle
+    def double_factorial_log(self,n):
+        if n <= 0:
+            return 0.0
+        result = 0.0
+        for i in range(n, 0, -2):
+            result += self.log(i)
+        return result
+
+    # Calcul des P_{lm}(x) pour tout l inclus dans [m,lmax]
+    def compute_legendre_m(self,x,m,lmax):
+        # Étape 1 : Calcul de P_{mm}(x)
+        if m == 0:
+            Pmm = 1.0
+        else:
+            Pmm = (-1)**m * (1 - x**2)**(m/2)
+        
+        result=np.zeros([lmax-m+1,x.shape[0]])
+        ratio=np.zeros([lmax-m+1,1])
+        
+        # Si l == m, c'est directement P_{mm}
+        result[0]=Pmm
+        ratio[0,0]= self.double_factorial_log(2*m - 1)-0.5*np.sum(self.log(1+np.arange(2*m)))
+    
+        if m == lmax:
+            return result*np.exp(ratio)*np.sqrt((2*(np.arange(lmax-m+1)-m))/(4*np.pi)).reshape(lmax+1-m,1)
+    
+        # Étape 2 : Calcul de P_{l+1, m}(x)
+        result[1] = x * (2*m + 1) * result[0]
+
+        ratio[1,0]=ratio[0,0]-0.5*self.log(2*m+1)
+    
+        # Étape 3 : Récurence pour l > m + 1
+        for l in range(m + 2, lmax+1):
+            result[l-m] = ((2*l - 1) * x * result[l-m-1] - (l + m - 1) *  result[l-m-2]) / (l - m)
+            ratio[l-m,0] = 0.5*self.log(l-m)-0.5*self.log(l+m)+ratio[l-m-1,0]
+            if np.max(abs(result[l-m]))>self._limit_range:
+                result[l-m-1]*=self._limit_range
+                result[l-m]*=self._limit_range
+                ratio[l-m-1,0]+=self._log_limit_range
+                ratio[l-m,0]+=self._log_limit_range
+        
+        return result*np.exp(ratio)*(np.sqrt(4*np.pi*(2*(np.arange(lmax-m+1)+m)+1))).reshape(lmax+1-m,1)
+    
+    def comp_tf(self,im,ph):
+        nside=int(np.sqrt(im.shape[0]//12))
+        n=0
+        ii=0
+        ft_im=[]
+        for k in range(nside-1):
+            N=4*(k+1)
+            ft_im.append(self.backend.bk_fft(im[n:n+N])[:N//2+1]*np.exp(-1J*np.arange(N//2+1)/N*ph[n]))
+            ft_im.append(self.backend.bk_zeros((3*nside-N//2-1),dtype=self.backend.all_cbk_type))
+            n+=N
+            ii+=1
+        for k in range(2*nside+1):
+            N=4*nside
+            ft_im.append(self.backend.bk_fft(im[n:n+N])[:N//2+1]*np.exp(-1J*np.arange(N//2+1)/N*ph[n]))
+            ft_im.append(self.backend.bk_zeros((3*nside-N//2-1),dtype=self.backend.all_cbk_type))
+            n+=N
+            ii+=1
+        for k in range(nside-1):
+            N=4*(nside-1-k)
+            ft_im.append(self.backend.bk_fft(im[n:n+N])[:N//2+1]*np.exp(-1J*np.arange(N//2+1)/N*ph[n]))
+            ft_im.append(self.backend.bk_zeros((3*nside-N//2-1),dtype=self.backend.all_cbk_type))
+            n+=N
+            ii+=1
+        return self.backend.bk_reshape(self.backend.bk_concat(ft_im,axis=0),[4*nside-1,3*nside])
+
+    def anafast(self,im,map2=None,nest=True):
+        nside=int(np.sqrt(im.shape[0]//12))
+        th,ph=hp.pix2ang(nside,np.arange(12*nside*nside))
+        if nest:
+            idx=hp.ring2nest(nside,np.arange(12*nside**2))
+            ft_im=self.comp_tf(self.backend.bk_complex(im[idx],0*im),ph)
+            if map2 is not None:
+                ft_im2=self.comp_tf(self.backend.bk_complex(map2[idx],0*im),ph)
+        else:
+            ft_im=self.comp_tf(self.backend.bk_complex(im,0*im),ph)
+            if map2 is not None:
+                ft_im2=self.comp_tf(self.backend.bk_complex(map2,0*im),ph)
+            
+        co_th=np.cos(np.unique(th))
+
+        lmax=3*nside-1
+    
+        cl2=None
+        cl2_L1=None
+        for m in range(lmax+1):
+            plm=self.compute_legendre_m(co_th,m,3*nside-1)/(12*nside**2)
+            
+            tmp=self.backend.bk_reduce_sum(plm*ft_im[:,m],1)
+            
+            if map2 is not None:
+                tmp2=self.backend.bk_reduce_sum(plm*ft_im2[:,m],1)
+            else:
+                tmp2=tmp
+                
+            tmp=self.backend.bk_real((tmp*self.backend.bk_conjugate(tmp2)))
+            if cl2 is None:
+                cl2=tmp
+                cl2_l1=self.backend.bk_L1(tmp)
+            else:
+                tmp=self.backend.bk_concat([self.backend.bk_zeros((m),dtype=self.backend.all_bk_type),tmp],axis=0)
+                cl2+=2*tmp
+                cl2_l1+=2*self.backend.bk_L1(tmp)
+        cl2=cl2*(1+np.clip((np.arange(cl2.shape[0])-2*nside)/(3*nside),0,1))/(2*np.arange(cl2.shape[0])+1)* \
+            (1+np.clip((np.arange(cl2.shape[0])-2.4*nside)/(2.5*nside),0,1))
+        cl2_l1=cl2_l1*(1+np.clip((np.arange(cl2.shape[0])-2*nside)/(3*nside),0,1))/(2*np.arange(cl2.shape[0])+1)* \
+            (1+np.clip((np.arange(cl2.shape[0])-2.4*nside)/(2.5*nside),0,1))
+        return cl2,cl2_l1

foscat/backend.py

@@ -189,18 +189,18 @@ class foscat_backend:
                 tmp[:, :, 0, k * 2 + 1] = np.cos((x.T) * (k + 1))
                 tmp[:, :, 0, k * 2 + 2] = np.sin((x.T) * (k + 1))
                 for l_orient in range(nharm):
-                    tmp[:, :, k * 2 + 1, l_orient * 2 + 1] = np.cos(x * (k + 1)) * np.cos(
-                        (x.T) * (l_orient + 1)
-                    )
-                    tmp[:, :, k * 2 + 2, l_orient * 2 + 1] = np.sin(x * (k + 1)) * np.cos(
-                        (x.T) * (l_orient + 1)
-                    )
-                    tmp[:, :, k * 2 + 1, l_orient * 2 + 2] = np.cos(x * (k + 1)) * np.sin(
-                        (x.T) * (l_orient + 1)
-                    )
-                    tmp[:, :, k * 2 + 2, l_orient * 2 + 2] = np.sin(x * (k + 1)) * np.sin(
-                        (x.T) * (l_orient + 1)
-                    )
+                    tmp[:, :, k * 2 + 1, l_orient * 2 + 1] = np.cos(
+                        x * (k + 1)
+                    ) * np.cos((x.T) * (l_orient + 1))
+                    tmp[:, :, k * 2 + 2, l_orient * 2 + 1] = np.sin(
+                        x * (k + 1)
+                    ) * np.cos((x.T) * (l_orient + 1))
+                    tmp[:, :, k * 2 + 1, l_orient * 2 + 2] = np.cos(
+                        x * (k + 1)
+                    ) * np.sin((x.T) * (l_orient + 1))
+                    tmp[:, :, k * 2 + 2, l_orient * 2 + 2] = np.sin(
+                        x * (k + 1)
+                    ) * np.sin((x.T) * (l_orient + 1))
 
             self._fft_2_orient[(norient, nharm, imaginary)] = self.bk_cast(
                 self.constant(
@@ -424,7 +424,10 @@ class foscat_backend:
                 for l_orient in range(w.shape[3]):
                     for j in range(res.shape[0]):
                         tmp = self.scipy.signal.convolve2d(
-                            x[j, :, :, k], w[:, :, k, l_orient], mode="same", boundary="symm"
+                            x[j, :, :, k],
+                            w[:, :, k, l_orient],
+                            mode="same",
+                            boundary="symm",
                         )
                         res[j, :, :, l_orient] += tmp
                         del tmp
@@ -549,13 +552,13 @@ class foscat_backend:
             xi = self.bk_imag(x)
 
             r = self.backend.sign(xr) * self.backend.sqrt(self.backend.sign(xr) * xr)
-            #return r
+            # return r
             i = self.backend.sign(xi) * self.backend.sqrt(self.backend.sign(xi) * xi)
-            
-            if self.BACKEND==self.TORCH:
+
+            if self.BACKEND == self.TORCH:
                 return r
             else:
-                return self.bk_complex(r,i)
+                return self.bk_complex(r, i)
         else:
             return self.backend.sign(x) * self.backend.sqrt(self.backend.sign(x) * x)
 
@@ -730,21 +733,21 @@ class foscat_backend:
     def bk_reduce_std(self, data, axis=None):
         if axis is None:
             if self.BACKEND == self.TENSORFLOW:
-                r=self.backend.math.reduce_std(data)
+                r = self.backend.math.reduce_std(data)
             if self.BACKEND == self.TORCH:
-                r=self.backend.std(data)
+                r = self.backend.std(data)
             if self.BACKEND == self.NUMPY:
-                r=np.std(data)
-            return self.bk_complex(r,0*r)
+                r = np.std(data)
+            return self.bk_complex(r, 0 * r)
         else:
             if self.BACKEND == self.TENSORFLOW:
-                r=self.backend.math.reduce_std(data, axis=axis)
+                r = self.backend.math.reduce_std(data, axis=axis)
             if self.BACKEND == self.TORCH:
-                r=self.backend.std(data, axis)
+                r = self.backend.std(data, axis)
             if self.BACKEND == self.NUMPY:
-                r=np.std(data, axis)
+                r = np.std(data, axis)
         if self.bk_is_complex(data):
-            return self.bk_complex(r,0*r)
+            return self.bk_complex(r, 0 * r)
         else:
             return r
 
@@ -922,6 +925,22 @@ class foscat_backend:
             else:
                 return np.concatenate(data, axis=axis)
 
+    def bk_zeros(self, shape,dtype=None):
+        if self.BACKEND == self.TENSORFLOW:
+            return self.backend.zeros(shape,dtype=dtype)
+        if self.BACKEND == self.TORCH:
+            return self.backend.zeros(shape,dtype=dtype)
+        if self.BACKEND == self.NUMPY:
+            return np.zeros(shape,dtype=dtype)
+        
+    def bk_fft(self, data):
+        if self.BACKEND == self.TENSORFLOW:
+            return self.backend.signal.fft(data)
+        if self.BACKEND == self.TORCH:
+            return self.backend.fft(data)
+        if self.BACKEND == self.NUMPY:
+            return self.backend.fft.fft(data)
+        
     def bk_conjugate(self, data):
 
         if self.BACKEND == self.TENSORFLOW:

foscat/backend_tens.py

@@ -24,9 +24,10 @@ class foscat_backend_tens:
             operation.gpulist[(operation.gpupos + self.curr_gpu) % operation.ngpu]
         ):
             print(
-                "%s Run [PROC=%04d] on GPU %s"
+                "%s Run %d [PROC=%04d] on GPU %s"
                 % (
                     loss_function.name,
+                    loss_function.id_loss,
                     self.mpi_rank,
                     operation.gpulist[
                         (operation.gpupos + self.curr_gpu) % operation.ngpu

foscat/loss_backend_torch.py

@@ -43,7 +43,6 @@ class loss_backend:
         else:
             l_x = x.clone().detach().requires_grad_(True)
 
-
             if KEEP_TRACK is not None:
                 l_loss, linfo = loss_function.eval(l_x, batch, return_all=True)
             else: