Note on XCS code from Marcin

    def __init__ ( self, ...)
        self.frame_size = ... (1300,1340)
        self.step_x = ... 130
        self.step_y = ... 134
        self.LLD     = ... 20.
        self.not_zero = 1.0E-9
        self.saturation = 65535
        self.dark - array with pedestals

    def beginjob( self, evt, env ) :
         ...
        for i in range(0,self.frame_size[0],self.step_x):
            for j in range(0,self.frame_size[1],self.step_y):
                fina = path + '/' +fina_gen + '_data_' + str(i) + '_' +str(j) + '.npy'
                self.f_id.append(open(fina, 'w'))
 

    def event( self, evt, env ) :
        ...
                 PI = evt.get(xtc.TypeId.Type.Id_PrincetonFrame)
                 frame = np.array(PI.data()[self.R1:self.R2,self.C1:self.C2], dtype = np.float64)
                 a = np.where(frame >= self.saturation)
                 self.saturated_pixels[a] = 0
                 np.subtract(frame, self.dark, frame)
                 frame[frame < self.LLD] = self.not_zero

        counter = 0
        for i in range(0,self.frame_size[0],self.step_x):
            for j in range(0,self.frame_size[1],self.step_y):
               np.save(self.f_id[counter], frame[i:i+self.step_x,j:j+self.step_y])
               counter += 1

 
   def endjob( self, evt, env ) :
       ...
       counter = 0 
        self.avg_img = self.avg_img/self.calibcycle_counter
        for i in range(0,self.frame_size[0],self.step_x):
            for j in range(0,self.frame_size[1],self.step_y):
                self.f_id[counter].close()
                counter += 1

class img_correlator:
    def __init__ (self,path):
        self.path = path
        self.LLD = 200
        ...
 

    def submit_correlator_jobs(self):
        filenames = os.listdir(self.path)          
        for filename in filenames: 

                  self.correlator_2D(filename)


    def correlator_2D(self, fina):
 
        f_id = open(os.path.join(self.path, fina), 'r')
        data = np.zeros((self.ncols, self.nrows, self.nframes)) # (130,134,500)

        for i in range(self.nframes):
            data[:,:,i] = np.load(f_id)
            data[:,:,i] = data[:,:,i]/ self.monitor[i]
            self.log('Frame ' + str(i) + ' was normalized by ' + str(self.monitor[i]))  
            data[:,:,i][data[:,:,i]<(self.LLD)] = self.notzero
    
        f_id.close()
        s = data.shape
        self.tau = ... tau = [1,2,3,4,5,6,7,8,9,10,12,14,16,20]
       ...

        IP = np.zeros(s,np.float64)
        IF = np.zeros_like(IP)
        G2 = np.zeros_like(IP)
        counter = np.zeros_like(self.tau)

        for t in range(len(self.tau)):
            delta = self.tau[t]
            for i in range(data.shape[2]-delta):

                if (self.monitor[i] >= self.treshold) and (self.monitor[i + delta] >= self.treshold) and (self.monitor[i] <= self.treshold_up) and (self.monitor[i + delta] <= self.treshold_up):                                                                   

                    np.add(G2[:,:,t],np.multiply(data[:,:,i], data[:,:,i+delta]),G2[:,:,t])
                    np.add(IP[:,:,t],data[:,:,i],IP[:,:,t])
                    np.add(IF[:,:,t],data[:,:,i+delta],IF[:,:,t])
                    counter[t] += 1
       ...

        to_be_deleted = []
        for i in range(0,len(self.tau)):
            if counter[i] == 0:
                to_be_deleted.append(i)
        self.tau = np.delete(self.tau,to_be_deleted)
        print "tbd = ", to_be_deleted
        counter = np.delete(counter, to_be_deleted) 
        G2 = np.delete(G2,to_be_deleted, axis = 2)
        IP = np.delete(IP,to_be_deleted, axis = 2)
        IF = np.delete(IF,to_be_deleted, axis = 2)
        for i in range(0,len(self.tau)):
            G2[:,:,i] = G2[:,:,i]/counter[i]
            IP[:,:,i] = IP[:,:,i]/counter[i]
            IF[:,:,i] = IF[:,:,i]/counter[i]
            IP[:,:,i][IP[:,:,i] < self.notzero]  = self.notzero
            IF[:,:,i][IF[:,:,i] < self.notzero]  = self.notzero
       ...

        f_id = open(path_G2, 'w')  
        for i in range(G2.shape[2]):   
            np.save(f_id, G2[:,:,i])
        f_id.close()

        f_id = open(path_IP, 'w') 
        for i in range(IP.shape[2]):   
            np.save(f_id, IP[:,:,i])
        f_id.close()

        f_id = open(path_IF, 'w') 
        for i in range(IF.shape[2]):   
            np.save(f_id, IF[:,:,i])
        f_id.close()