BufferGANIL.C

Go to the documentation of this file.

//                                                                                                        //
//  BufferGANIL                                                                                   //
//                                                                                                        //


#include <TObjString.h>
#include "BufferGANIL.h"

#include <iostream>
#include <fstream>
using namespace std;

const Int_t BufferGANIL::BYTE  = 8;
const Int_t BufferGANIL::KBYTE = 1024;
const Int_t BufferGANIL::MBYTE = 1024*1024;
const Int_t BufferGANIL::GBYTE = 1024*1024*1024;

const unsigned short BufferGANIL::fStartEventToken    = 0xFF60;
const unsigned short BufferGANIL::fEndDataBlockToken  = 0xFF00;
::map<UShort_t, TString>* BufferGANIL::fgMap = 0x0;

//__________________________________________________________
BufferGANIL::BufferGANIL(size_t s)
{       
   fBuffer = new Char_t[s];
   fSubEvtIndex = 0;
   fgMap = new ::map<UShort_t, TString>;
}

//__________________________________________________________
BufferGANIL::~BufferGANIL()  
{ 
        if ( fBuffer ) delete fBuffer; fBuffer = NULL; 
   delete fgMap; // not secured
}

//__________________________________________________________
bool BufferGANIL::IsType(const char *type)
{
        if ( strncmp(fBuffer,type,8)  == 0 ) 
           return true;
        return false;
}

//__________________________________________________________
void BufferGANIL::InitTable(Char_t* buffer)
{
        TString tmp;
        // read the buffer and creat the list of parameters
        tmp = ""; char c;
        
        ofstream out1("bufferGANIL.parameter",ios::out);        
        for( size_t i = 0; i < 16*KBYTE-12; i++ ) {
                 c = buffer[12+i]; tmp += c;
                if ( c == 0x0D ) {
                   tmp.ReplaceAll(","," ");
                   out1 << tmp.Data() << endl ;
                   InitTable(tmp);
                   tmp = ""; 
                } // c
        } // i
        out1.close(); 
}

//__________________________________________________________
void BufferGANIL::InitTable(TString& data)
{
   TString tmp(data);
   
   Int_t pos = tmp.First(' ');
   
   TString sIdx = tmp(pos+1, 2);
   
   TString type = tmp(0, pos);
   
   UShort_t idx = (UShort_t)sIdx.Atoi();
   fgMap->insert(pair<UShort_t, TString>(idx, type.Data()));
}

//__________________________________________________________    
const Char_t* BufferGANIL::GetModuleName(UShort_t add)
{
   ::map<UShort_t,TString>::iterator iter = fgMap->find(add);   
   return (iter->second).Data();
}

//__________________________________________________________    
bool BufferGANIL::InitReading()
{
        int magic = 0; bool ok = false;
           
        if ( IsType(" FILEH  ") ) {
                printf("Header file block, set DAQ parameters to 0 \n"); //InitTable();
        }       
   
   if ( IsType(" SCALER ") ) {
          printf("SCALER block\n"); //InitTable();        
   }    
   
        if ( IsType(" COMMENT") ) {
                // printf("Comment block \n ");
        }       
        if ( IsType(" PARAM  ") ) {
           InitTable(fBuffer);
           printf("Parameters block, re-initialisation of DAQ parameters \n"); 
        }       
        if ( IsType(" EVENTH ") ) {
                strncpy(fDate,&fBuffer[37],19);  // new date
                char tmp[6]; 
                strncpy(tmp,&fBuffer[62],6); sscanf(tmp,"%d",&fRun); // new run
                printf("Data block, NEW RUN # %d, written at %s \n",fRun,fDate);
        }
        if ( IsType(" EBYEDAT") ) {
                // read some informations from the block header
           fSubEvtIndex = 32;
           ::memcpy(&fBlock, &fBuffer[8],sizeof(int));
                //printf(" EbyE block %d \n",fBlock);
                                
           ::memcpy(&magic,&fBuffer[12],sizeof(Int_t));
                if ( magic != 0x22061999 ) printf("WARNING WRONG byte ordering for input buffer %x \n",magic);  
                                 
           ::memcpy(&fNbEvents,&fBuffer[22],sizeof(Int_t));
                //printf(" events %d \n",fNbEvents);    
                                
           ::memcpy(&fEventsSize,&fBuffer[28],sizeof(Int_t));
                //printf(" events size %d \n",fEventsSize);
           
                fNbEventsR = 0; fEventsSizeR = 0; ok = true;
        }
        return ok;
}

//_____________________________________________________________________
unsigned short* BufferGANIL::NextEvent(unsigned short &sub_event_size)
{       
   unsigned short start_token = 0;
   unsigned short event_size = 0;
   
        // check if end event token
   ::memcpy(&start_token,&fBuffer[fSubEvtIndex],sizeof(short));
   //printf("token %x \n",start_token);

        if ( start_token != fStartEventToken ) { 
                if ( start_token == fEndDataBlockToken ) fEventsSizeR += 2;
                return NULL; 
        }

   ::memcpy(&event_size,&fBuffer[fSubEvtIndex+2],sizeof(short));event_size -= 2;
        //printf("event size %x \n",event_size);
   
   ::memcpy(&sub_event_size,&fBuffer[fSubEvtIndex+12],sizeof(short));sub_event_size -= 2;
        //printf("event size %d \n",sub_event_size);

   for(unsigned short i = 0; i < sub_event_size; i++ ){::memcpy(&fEvent[i],&fBuffer[fSubEvtIndex+14+i*2],sizeof(short));}
        
        fNbEventsR++; fEventsSizeR += (event_size+2);
   fSubEvtIndex += (event_size+2)*2;

   return fEvent;
}