QCrateReceiverBuffer.hh

Go to the documentation of this file.

#ifndef __QCRATERECEIVERBUFFER_HH_
#define __QCRATERECEIVERBUFFER_HH_

#include <string>
#include <vector>
#include <stdexcept>
#include <unistd.h>
#include <iostream>
#include <zlib.h>
#include <math.h> // for round()

#include "QCuore.hh"
#include "QError.hh"
#include "QConnectedSocket.hh"

#define DEFAULT_BUFFER_SIZE    60000 
#define MAX_CHANNEL_FILE_SIZE  20000000 
struct QBufferStructure_t {
   unsigned long fId;                
   unsigned long fNum;               
   unsigned long long fRead;         
   unsigned long long fWrite;        
   unsigned long long fReadFile;     
   unsigned long long fNotProcessed; 
   unsigned long long fNotBuilt;     
   unsigned long fCurrentRun;        
   bool fNotProcessedIsActive;       
   bool fReadPtrIsActive;            
   bool fNotBuiltIsActive;           
   bool fSaveFile;                   
   unsigned long fSamplingRate;     
   long fData[DEFAULT_BUFFER_SIZE]; 
};


class QCrateReceiverBuffer {
public:
   QCrateReceiverBuffer(unsigned long ch, 
                        bool          attach, 
                        bool          OpenFiles, 
                        int           RunNumber=0, 
                        bool          offset_shm=false);
  
   virtual ~QCrateReceiverBuffer();
  
   unsigned long Size() const {return DEFAULT_BUFFER_SIZE;}
   
   char* Start() const
   {return 
       (char*)(&(p_buffer->fData[(p_buffer->fRead) % DEFAULT_BUFFER_SIZE]));}

   inline unsigned long GetNumberOfWords() const 
   {return p_buffer->fNum;}

   bool EnableTriggerPointer();

   void ReleaseTriggerPointer();

   bool EnableBuilderPointer();

   void ReleaseBuilderPointer();

   bool EnableReadPointer();

   void ReleaseReadPointer();

   inline void Release(unsigned int n);
    
   void Add(int n, const long* data);
  
   void AddFromNetwork(QConnectedSocket* cs);

   inline int GetLg() const {return p_buffer->fId;}

   inline int ReadToEnd() const 
   {return DEFAULT_BUFFER_SIZE - 
       (unsigned long)((p_buffer->fRead) % DEFAULT_BUFFER_SIZE);} /* used by DataSender */

   inline void SetProcessed(unsigned int n);

   inline void SetBuilt(unsigned int n);

   //** @brief get number of valid words still to be processed by trigger */
   inline unsigned long GetToBeProcessed() const
   {return (unsigned long)(p_buffer->fWrite - p_buffer->fNotProcessed);}

   inline unsigned long GetToBeBuilt() const
   {return (unsigned long)(p_buffer->fNotProcessed - p_buffer->fNotBuilt);}

   inline unsigned long GetToBeRead() const
   {return (unsigned long)(p_buffer->fReadFile - p_buffer->fRead);}

   inline unsigned long long GetProcessed() const
   {return p_buffer->fNotProcessed;}

   inline unsigned long long GetBuilt() const
   {return p_buffer->fNotBuilt;}

   inline unsigned long long GetRead() const
   {return p_buffer->fRead;}

   inline unsigned long long GetWritten() const
   {return p_buffer->fWrite;}
   
   inline long GetData(unsigned long long index) const;

   inline long GetSample(unsigned long long index) const;

   inline short GetTriggerFlags(unsigned long long index, unsigned long mask=0xF) const
   {return (short)((GetData(index) >> 17) & mask);}
   
   inline void FlagTrigger(unsigned long long index,
                           int                tag);

   inline void SetTriggerEnabled(bool enabled);

   void SetSamplingRate(unsigned long rate) {p_buffer->fSamplingRate = rate;}

   unsigned long GetSamplingRate() const
   {return p_buffer->fSamplingRate;}

   inline long long GetTimeOfSample(unsigned long long index) const;

   inline unsigned long long GetSampleOfTime(long long time) const;

   // some info on output stream
   void Dump();

   //
   //SDD FIXME
   // Following 2 methods are for debugging purposes
   // Remember to remove them as soon as they are no more useful
   //
   // set single bit as analyzed by event builder
   inline void SetScanned(unsigned long long i) 
   {p_buffer->fData[(i % DEFAULT_BUFFER_SIZE)] |= (1<<27);}
   // set single bit as analyzed by trigger algorythm
   inline void SetAnalyzed(unsigned long long i)
   {p_buffer->fData[(i % DEFAULT_BUFFER_SIZE)] |= (1<<28);}
   
private:
   inline void Release();

   inline void SetProcessed();

   inline void SetBuilt();

   inline unsigned long GetToBeWritten() const
   {return (unsigned long)(p_buffer->fNotBuilt - p_buffer->fReadFile);}

   void WriteFile();

   void OpenFile();

   void CloseFile(bool last);

   int fHandle;
   int fShmid;                   
   bool fOwn;                    
   QBufferStructure_t *p_buffer; 
   gzFile zFile;                 
   std::string fGzFileName;      
   unsigned int fPartialFile;    
   bool fReadPtrBooked;          
   bool fBuilderPtrBooked;       
   bool fTrgPtrBooked;           
};










//_____________________________________________________________________________
inline void QCrateReceiverBuffer::SetProcessed()
{
   p_buffer->fNotProcessed = p_buffer->fWrite;
  
   // update builder pointer if builder is inactive
   if(!p_buffer->fNotBuiltIsActive) SetBuilt();
}


//_________________register_n_words_as_processed_by_trigger____________________
inline void QCrateReceiverBuffer::SetProcessed(unsigned int n)
{
   // do nothing if no one but QCrateReceiverBuffer itself is expected to 
   // move this pointer
   if(!fTrgPtrBooked) {
      std::cerr << "QCrateReceiverBuffer::SetProcessed(unsigned int) Warning! "
         "trying to move \"trigger pointer\" without having permission!!"
                << std::endl;
      return;
   }

   // check that fNotProcessed ptr remains smaller than fWrite ptr
   if(n > GetToBeProcessed()) {
      n = GetToBeProcessed();
      std::cerr << "QCrateReceiverBuffer::SetProcessed Warning! moving "
         "\"Processed by trigger\" pointer into an inconsistent position "
         "avoided!" << std::endl;
   }

   // actually update pointer
   p_buffer->fNotProcessed+=n;

   // also update fNotBuilt ptr if it is not in use
   if(!p_buffer->fNotBuiltIsActive) SetBuilt();
}


//_____private_method_used_to_update_builder_pointer_when_it_is_not_booked_____
inline void QCrateReceiverBuffer::SetBuilt() 
{
   p_buffer->fNotBuilt = p_buffer->fNotProcessed;

   // also update fRead pointer if it is not in use
   if(!p_buffer->fReadPtrIsActive) Release();
}


//__________________register_n_words_as_processed_by_builder___________________
inline void QCrateReceiverBuffer::SetBuilt(unsigned int n) 
{
   // do nothing if no one but QCrateReceiverBuffer itself is expected to 
   // move this pointer
   if(!fBuilderPtrBooked) {
      std::cerr << "QCrateReceiverBuffer::SetBuilt(unsigned int) Warning! "
         "trying to move \"builder pointer\" without having permission!!" 
                << std::endl;
      return;
   }
    
   // check that fNotBuilt ptr remains smaller than fNotProcessed ptr
   if(n > GetToBeBuilt()) {
      n = GetToBeBuilt();
      std::cerr << "QCrateReceiverBuffer::SetBuilt Warning! moving "
         "\"Processed by Builder\" pointer into an inconsistent position "
         "avoided!" << std::endl;
   }

   // actually update pointer
   p_buffer->fNotBuilt+=n;

   // also update fRead pointer if it is not in use
   if(!p_buffer->fReadPtrIsActive) Release();
}


// throw away all useless words from circular buffer
inline void QCrateReceiverBuffer::Release() 
{
   // update number of valid words
   p_buffer->fNum -= GetToBeRead();

   // move read pointer
   p_buffer->fRead += GetToBeRead();
}


// throw away n words from circular buffer
inline void QCrateReceiverBuffer::Release(unsigned int n)
{
   // return if we have no permission to move fRead ptr
   if(!fReadPtrBooked) {
      std::cerr << "QCrateReceiverBuffer::Release(unsigned int) Warning: "
         "trying to move read pointer without having permission." << std::endl;
      return;
   }
  
   // check that read pointer remain smaller than the fNotBuilt pointer
   if(n > GetToBeRead())
   {
      std::cerr << "QCrateReceiverBuffer::Release Warning! avoided "
         "inconsistent moving of \"read\" pointer for channel " 
                << p_buffer->fId << ". requested: " << n 
                << ", allowed: " << GetToBeRead() << std::endl;
      n = GetToBeRead();
   }
  
   // actually increase fRead pointer
   p_buffer->fRead += n;

   // update number of valid words
   p_buffer->fNum -= n;
}


// flag trigger bts for data samples between start and stop according to 
// trigger tag
inline void QCrateReceiverBuffer::FlagTrigger(unsigned long long index,
                                              int                tag) 
{
   if(index < p_buffer->fRead || index > p_buffer->fWrite)
   {
      QError err(QERR_SHMEM_INVALID_INDEX);
      err.SetDescription("In FlagTrigger(): index out of bounds");
      throw err;
   }

   int position = 16+tag;
   unsigned long circularIndex = (unsigned long)(index % DEFAULT_BUFFER_SIZE);
   p_buffer->fData[circularIndex] |= (1 << position);
   
}





//_____________return_time_associated_to_a_given_sample______________
inline long long QCrateReceiverBuffer::GetTimeOfSample(unsigned long long index)
   const
{
   const unsigned long s2Ns = 1000000000;
   long long time = (s2Ns * index / p_buffer->fSamplingRate);
   if(index < p_buffer->fRead || index > p_buffer->fWrite) time *= -1;
   return time;
}


//_____________________________GetSampleOfTime()_______________________________
inline unsigned long long QCrateReceiverBuffer::GetSampleOfTime(long long time)
   const
{
   // return 0 if requested sample has negative time
   if(time < 0) return 0;
   const unsigned long s2Ns = 1000000000;
   return (unsigned long long)(time * p_buffer->fSamplingRate / s2Ns);
}

//__________________________GetData()__________________________________________
inline long QCrateReceiverBuffer::GetData(unsigned long long index) const
{
   unsigned long long lastValid = ((p_buffer->fWrite)>DEFAULT_BUFFER_SIZE)?
      (p_buffer->fWrite)-DEFAULT_BUFFER_SIZE:0;
   if(index < lastValid || index > p_buffer->fWrite)
   {
      QError err(QERR_SHMEM_INVALID_INDEX);
      char errMsg[300];
      sprintf(errMsg,"In GetData(): requested buffer index (%lld) is out of "
              "bounds (%lld - %lld)", index, lastValid, p_buffer->fWrite);
      err.SetDescription(errMsg);
      throw err;
   }
   unsigned long circular_index=(unsigned long)(index % DEFAULT_BUFFER_SIZE); 
   return p_buffer->fData[circular_index];
}

//________________________________GetSample()__________________________________
inline long QCrateReceiverBuffer::GetSample(unsigned long long index) const
{
   const long dataMask = 0x8001FFFF;
   long sample = GetData(index) & dataMask;

   if(sample >> 31) sample |= 0x7FFE0000;

   return sample;
}


//_______________________set_trigger_enable/disable_flag_______________________
inline void QCrateReceiverBuffer::SetTriggerEnabled(bool enabled)
{ 
   // determine bit to be flagged
   int position = 25;
   if(enabled) position++;

   // flag data
   p_buffer->fData[(p_buffer->fWrite % DEFAULT_BUFFER_SIZE) - 1] |= 
      1L << position;
  
   return;
}

#endif

---