Pmm2Reader.cxx

Go to the documentation of this file.

// 
// File Pmm2Reader.cxx
//
#include "Pmm2Reader.h"
#include "HarpoDetReader.h"
#include "Pmm2Event.h"
#include "Pmm2Mes.h"
#include "HarpoDet.h"
#include "BData.h"

#include <TSystem.h>

#include <climits>
#include <cstdio>
#include <arpa/inet.h>
#include <iostream>
#include <cassert>
#include <cstdlib>


using namespace Pmm2;

ClassImp(Pmm2Reader)


Pmm2Reader::Pmm2Reader() : HarpoDetReader()
{
  //  fRunNo = 0;
  fDone = false;
  fError = false;
  fDet = PMM2;
  fRVer  = -1;  // N/A

  //  fInFile = (TString *) NULL;
  fIn = (FILE *) NULL;
  fNevts = 0;
  fNbufs = 0;
  fNdigs = 0;
  fNstats = 0;

  fEvent = (Pmm2Event *) NULL;
  fRunHeader = (HarpoDetHeader *) NULL;

  fRawAnalyse = (HarpoDetAnalyse *) NULL;
  //  fMaxEvents = LONG_MAX;
  fPrevTimeStamp = 0;
  fPrevTimeStamp2 = 0;
  isEventSaved = false;

  fNreset = 1;
  verbose = 0;
}


Pmm2Reader::Pmm2Reader(HarpoConfig *cfg) : HarpoDetReader(cfg)
{
  // Config Function
  fDone = false;
  fError = false;
  fDet = PMM2;


  //  fRunNo = cfg->GetRunNo();
  fInFile = cfg->GetInFile(0);
  fRVer = pBIN;   // Binary clientUDP mode 
  fIn = (FILE *) NULL;
  fNevts = 0;
  //  fMaxEvents = cfg->GetMaxEvents();

  //  TString *FileName = cfg->GetOutFile();
  fNbufs = 0;
  fNdigs = 0;
  fNstats = 0;

  fNreset = 1;
  verbose = cfg->GetVerbose();

  fEvent = (Pmm2Event *) NULL;
  fRunHeader = (HarpoDetHeader *) NULL;

  fRawAnalyse = (HarpoDetAnalyse *) NULL;
  
  // if ( FileName != (TString *) NULL )
  //   SetRootFile(FileName);

  fPrevTimeStamp = 0;
  fPrevTimeStamp2 = 0;
  isEventSaved = false;
  fRawDigi.Clear(); // size 0
}

Pmm2Reader::~Pmm2Reader()
{
  std::fclose(fIn);
  //delete fRunHeader; deleted in ~DetReader
}

// void Pmm2Reader::SetRootFile(TString *name)
// {
//   fNewFileName = name; 
//   fNewFile = new TFile(name->Data(),"RECREATE","HARPO PMM2 Events");
// }

void Pmm2Reader::SetAnalyseFunction(HarpoDetAnalyse *func)
{
  fRawAnalyse = func;
}
  
// Check if we have more digi for new event
Bool_t Pmm2Reader::NextDigi()
{
  if (fRawDigi.Empty() )
    {
    next:
      // Empty List, trigiring Read Next Buffer
      if (NextBuffer()) {
        // ReadBuffer(); // <-- empty function
        if (BuffType != 0) {
          Info(__FUNCTION__,"Pmm2Status Type %d Len %d bytes",BuffType,lHeader.eventSize);
          Pmm2Status *s = new Pmm2Status(lData,lHeader.eventSize);
          static_cast<Pmm2Header *>(fRunHeader)->setTemperature(s->getTemperature());
          // Save only first status block
          if (fNstats == 0 ) {
            static_cast<Pmm2Header *>(fRunHeader)->setStatus(s);
          } else {
            delete s;
          }
          fNstats++;
          goto next;
        }
          
      } else {
        return false; // no more Buffers and Digi
      }
    }
  return (! fRawDigi.Empty()); // We can create new event
}

Bool_t Pmm2Reader::NextEvent()
{
  if ( isEventSaved ) {
    isEventSaved = false;
    fEvent = fSaveEvent;
    return true;
  }
  
  Double_t eventTimeStamp = 0;
  if (NextDigi()) {
    // Will compare with TS from first mes in list
    eventTimeStamp = fRawDigi.Front().getTimeStamp();
    //    fPrevTimeStamp = fRawDigi.Front().getTimeStamp();
    fEvent = new Pmm2Event();

    fEvent->SetDet(fDet);
    fEvent->SetRunHeader(fRunHeader);
    // we will emulate header for this mode
    const size_t buffLen = (N_WORD_IN_BLOCK * 4) + sizeof(EventHeader_t);
    fEvent->SetHeader(buffLen,fNevts);
  } else {
    fEvent = NULL;
    return false;
  }
  
  int n_mes = 0;


  Double_t timestamp = 0.;
  Int_t triggerold = -1000;
  // Event Header and Digi
  do {
    fTimeStamp  = fRawDigi.Front().getTimeStamp();
    Double_t ts = 0;
    if( fRVer == pWIN2 || fRVer == pBIN ) {
      ts = fRawDigi.Front().getTimeStamp() + 16777216*Double_t(fRawDigi.Front().getPPS());
    }else{
      ts = fRawDigi.Front().getTimeStamp();
    }
    //    if ( std::abs(Long_t(fTimeStamp - fPrevTimeStamp)) < 2 ) {
    if ( std::abs(Long_t(fTimeStamp - eventTimeStamp)) < 2 ) {
      if(triggerold == -1000) triggerold = fRawDigi.Front().GetNU0();
      Int_t trigger = fRawDigi.Front().GetNU0();
      //      Info("NextEvent","trigger: %d",trigger);

      if(trigger != triggerold) {
        Warning("NextEvent","Trigger types don't match, %d != %d (%g s)",trigger,triggerold,ts*1e-7);
        triggerold = -1;
      }
      Pmm2Mes mes = fRawDigi.GetNext();
      fEvent->AddMes(mes);
      n_mes++;  // Counting Digi added to the event
      timestamp += ts;
    }
    //Info("NextEvent","TimeStamp PMM2: %li",fTimeStamp);
    //  } while (( std::abs(Long_t(fTimeStamp - fPrevTimeStamp)) < 2 ) && NextDigi() );
  } while (( std::abs(Long_t(fTimeStamp - eventTimeStamp)) < 2 ) && NextDigi() );
  fEvent->SetHeader(n_mes,fNevts); // update header , put n_mes in size
  fEvent->SetTriggerType(triggerold);
  fNevts++;  

  if(n_mes) timestamp /= n_mes;
  if(fNevts>1 && timestamp<fPrevTimeStamp - 200 && timestamp<fPrevTimeStamp2 - 200 ){
    // Time stamp type double,  fPrevTimeStamp ULong_t
    Info("NextEvent","Reset Time Stamp (%ld) %g < %ld - 200; < %ld - 200 (%d)",fNevts,timestamp,fPrevTimeStamp,fPrevTimeStamp2,fNreset);
    fNreset--;
  }
  //  if(fNevts%100 == 0) timestamp += 16777216; // FIXME
  if(timestamp){
    fPrevTimeStamp2 = fPrevTimeStamp;
    fPrevTimeStamp = timestamp;
  }
  if(fNreset > 0) timestamp = 0;
  fEvent->SetTimeStamp(timestamp);

  fTimeStamp = fEvent->GetTimeStamp();
  return true;
}
Bool_t Pmm2Reader::NextBuffer()
{
  if (fDone) return false; // EOF after last Event Data read

  // Read modes
  if (fRVer == pTEXT ) {
    // Mode not implemented
    fDone = true;
    fError= true;
    return false;
  } else if (fRVer == pWIN || fRVer == pWIN2) { // Bin mode without header
    
    // we will emulate local header for this mode
    //const size_t buffLen = (N_WORD_IN_BLOCK * 4) + sizeof(EventHeader_t);
    const size_t buffLen = (N_WORD_IN_BLOCK * 4);
    // Full Header ( we just emulate it )
    lHeader.eventSize = buffLen;
    lHeader.eventNumb = fNbufs;  // Buffer sequential number

    // Event Data
    size_t dataLen = lHeader.eventSize; 
    //size_t dataLen = buffLen - sizeof(EventHeader_t);
    if (std::fread(&lData,dataLen, 1, fIn) != 1)
      {
        if(std::feof(fIn)) // Read after EOF
          {
            fDone = true;
          }
        else
          {
            fError = true;
          }
        return false;
      }
    else
      {
        unPackRawDigi();
        fNbufs++;
      }
    } else if (fRVer == pBIN) {
    
    // Read header
     if (std::fread(&lHeader, sizeof(EventHeader_t), 1, fIn) != 1)
       {
        if(std::feof(fIn))
          {
            fDone = true;
          }
        else
          {
            fError = true;
          }
        return false;
       }
    
    // Event Data
     BuffType = ((lHeader.eventSize & 0xFF000000 ) >> 24); 
     lHeader.eventSize &= 0x00FFFFFF;
     //     lHeader.eventSize += 4; // FIXME
     size_t dataLen = lHeader.eventSize; 
    
    
      // std::cout << std::hex << "Pmm2 Evt Header sz " << lHeader.eventSize
      //         << " enum " << lHeader.eventNumb
      //               << " dlen " << dataLen << std::dec << std::endl;  
          
     if (std::fread(&lData,dataLen, 1, fIn) != 1)
       {
         if(std::feof(fIn)) // Read after EOF
           {
             fDone = true;
           }
         else
           {
             fError = true;
           }
         return false;
       }
     if (BuffType == 0) unPackRawDigi();
     fNbufs++;
     return true;
  } else {
    std::cout << "Wrong File Read Mode "<< fRVer << std::endl;
    fDone = true;
    fError= true;
    return false;
  } 
  
  return true;
}

void  Pmm2Reader::unPackRawDigi()
{  
  
  //size_t blen = (lHeader.eventSize-8)*8; //Read size in bits
  size_t blen = (lHeader.eventSize)*8; //Read size in bits
  //std::cout << "esz " << lHeader.eventSize << " blen " << blen << std::endl;
  assert(blen == 11872);
  
  BData bits(blen,lData);
  // bits.Print();

  

  for (size_t i = 0;i<blen;i += 56) {
    Pmm2Mes udata;
    if( fRVer == pWIN2 || fRVer == pBIN ) {
      udata._ChannelNum=bits.asGray(i,i+3);
      udata._TimeStamp=bits.asGray(i+26,i+49);
      udata._TimeStampSign=0;
      udata._Gain=0;
      udata._FineTime=0;
      udata._TdcRamp=0;
      udata._Charge=bits.asGray(i+4,i+13);
      udata._nu0=bits(i+50,i+55);
      udata._PPSCounter=bits.asGray(i+14,i+25);
      // store in list
      // fRawDigi.Push(udata);
      // fNdigs++;
      
    }else{
      //      Pmm2Mes udata;
      udata._ChannelNum=bits.asGray(i,i+3);
      udata._TimeStamp=bits.asGray(i+4,i+27);
      udata._TimeStampSign=bits(i+28);
      udata._Gain=bits(i+29);
      udata._FineTime=bits.asGray(i+30,i+39);
      udata._TdcRamp=bits(i+40);
      udata._Charge=bits.asGray(i+41,i+50);
      udata._nu0=bits(i+51);
      udata._PPSCounter=bits.asGray(i+52,i+55);
      // store in list
    // fRawDigi.Push(udata);
    // fNdigs++;
    }
    fRawDigi.Push(udata);
    fNdigs++;
    if(gHarpoDebug>1)
      Info("unPackRawDigi","%d %d %d %d",udata._ChannelNum, udata._Charge, udata._PPSCounter, udata._TimeStamp);
  }
  
  //DEBUG std::cout << " **Buff " << fNbufs << " Digi " << fNdigs << std::endl;
  //fRawDigi.print(); 
}

void   Pmm2Reader::ReadBuffer()
{
  /* Empty Function, all done in NextBuffer */
}

Pmm2Event *Pmm2Reader::GetEvent()
{
  return fEvent;
}

Pmm2Header *Pmm2Reader::GetDetHeader()
{
  return static_cast<Pmm2Header *>(fRunHeader);
}


Bool_t Pmm2Reader::Init()
{
  //  fNreset = 1;
  Long64_t nResets;
  if ( ! gHConfig->Lookup("Pmm2.Nresets",nResets) )
    Info("Constructor","Use default nResets %d",fNreset);
  else{
    fNreset = nResets;
    Info("Constructor","Use nResets %d",fNreset);
  }

  const char * fn = fInFile->Data();
  if ( fInFile->BeginsWith("/" )) { // full path 
    if (verbose) std::cout << " Init " << fn << std::endl;
    if ( gSystem->AccessPathName(fn,kReadPermission) ) {
      perror("Raw File access");
      return false;
    }
  } else {
    if (  gSystem->AccessPathName(fn,kReadPermission) ) // file not exist
      {
        // TODO
        //  TString *DataDir = gHRawCfg->GetDataDir();
        // Not a best way but i can't use config hire
        TString DataDir(gSystem->Getenv("HARPO_DATA_DIR"));

        if ( ! DataDir.EndsWith("/") ) DataDir.Append("/");
        fInFile->Prepend(DataDir);
        fn = fInFile->Data();
        if (verbose)  std::cout << " Guessed " << fn << std::endl;
        if ( gSystem->AccessPathName(fn,kReadPermission) ) {
          perror("Raw File access");
          return false;
        }
      }
  }
    
  fIn = std::fopen(fn,"r");
  if ( fIn != NULL )
    {
      if ( fRVer == pBIN ) {
        fRunHeader = new Pmm2Header(fIn);
        fRunHeader->SetReaderType(fRVer); 
        return (fRunHeader->check());
      } else {
        fRunHeader = new Pmm2Header(); // Empy for TEXT and WIN
        fRunHeader->SetReaderType(fRVer);
        return true;
      }
    }
  else
    { 
      perror("Raw File not open");
      return false;
    }
}
  

Long_t      Pmm2Reader::Loop(Long_t maxevents)
{
  Long_t cnt=0;
  Pmm2Event *evt;

  fRawAnalyse->Init();

  while (NextEvent()) {
    evt = GetEvent();
    fRawAnalyse->ProcessEvent(evt);
    delete evt;
    if (++cnt >= maxevents) break;
  }
  return cnt;

  fRawAnalyse->Save();
  
}

Long_t      Pmm2Reader::Loop()
{
  Long_t maxevents = fMaxEvents;
  return Loop(maxevents);
}

// Bool_t  Pmm2Reader::Find(Long_t eventNo)
// {
//   Long_t cnt=0;
//   Long_t maxevents = fMaxEvents;
//   Bool_t found = false;

//   while (NextEvent()) {
    
//     if ((fEvent->GetHeader())->eventNumb == eventNo) {
//       found = true;
//       break;
//     }
//     SkeepEvent();
//     if (++cnt >= maxevents) break;
//   }
//   return found;
// }
// void  Pmm2Reader::SkeepEvent()
// {
//   //isEventSaved = false;
//   Pmm2Event *evt = GetEvent(); // We need read event data
//   if ( evt != NULL ) delete evt ; // We will not process this event,
//                                   // return NULL  on read arror
// }

// void  Pmm2Reader::PushBack()
// {
//   HarpoDet dt(fPlane);  //TODO do we need this ?
//   fSaveEvent = fEvent;
//   fEvent = NULL; 
//   isEventSaved = true;
//   //DEBUG
//   std::cout << "PushBack " << dt.GetDescription() << " Evt " << fNevts << std::endl;
// }