ARA ROOT v3.13 Software

AraEvent/RawAtriStationEvent.cxx

#include "RawAtriStationEvent.h"
#include <iostream>
#include <fstream>
#include <cstring>
#include "TMath.h"
ClassImp(RawAtriStationEvent);

RawAtriStationEvent::RawAtriStationEvent()   
{  
  //Default Constructor
}

RawAtriStationEvent::~RawAtriStationEvent() {
   //Default Destructor
}


RawAtriStationEvent::RawAtriStationEvent(AraStationEventHeader_t *hdPtr, char *dataBuffer) // Assignment constructor
  :RawAraStationEvent(&(hdPtr->gHdr))
{
  

   unixTime=hdPtr->unixTime;
   unixTimeUs=hdPtr->unixTimeUs;
   eventNumber=hdPtr->eventNumber;
   ppsNumber=hdPtr->ppsNumber;
   numStationBytes=hdPtr->numBytes;
   versionId=hdPtr->versionNumber;
   timeStamp=hdPtr->timeStamp;
   timeStamp ^= (timeStamp >> 1);
   timeStamp ^= (timeStamp >> 2);
   timeStamp ^= (timeStamp >> 4);
   timeStamp ^= (timeStamp >> 8);
   timeStamp ^= (timeStamp >> 16);


   eventId=hdPtr->eventId;
   //   std::cerr << eventNumber << "\t" << versionId << "\t" << ppsNumber << "\t" << timeStamp << "\t" << eventId << std::endl;
   numReadoutBlocks=hdPtr->numReadoutBlocks; 
   
   for(int trig=0;trig<MAX_TRIG_BLOCKS;trig++) {
     triggerInfo[trig]=hdPtr->triggerInfo[trig];
     triggerBlock[trig]=hdPtr->triggerBlock[trig];
   }

   int uptoByte=0;
   //   std::cerr << "numReadoutBlocks " << numReadoutBlocks << "\n";
   for(int block=0;block<numReadoutBlocks;block++) {
     AraStationEventBlockHeader_t *blkPtr = (AraStationEventBlockHeader_t*)&dataBuffer[uptoByte];     
     uptoByte+=sizeof(AraStationEventBlockHeader_t);
     AraStationEventBlockChannel_t *chanPtr = (AraStationEventBlockChannel_t*)&dataBuffer[uptoByte];
     RawAtriStationBlock blocky(blkPtr,chanPtr);
     blockVec.push_back(blocky);
     int numChan=blocky.getNumChannels();

     // std::cout << "block " << block << " numChan " << numChan 
     //                <<  " irsBlockNumber " << (blkPtr->irsBlockNumber&0x1ff)
     //                << " channelMask " << blkPtr->channelMask << "\t"
     //                << " uptoByte " << uptoByte << "\n";
     // numChan=8; //HArd wire for testing
     uptoByte+=sizeof(AraStationEventBlockChannel_t)*numChan;
   }
   //   std::cerr << sizeof(AraStationEventHeader_t) << "\n";
   if(uptoByte!=int(numStationBytes))    
     std::cerr << "Error assigned " << uptoByte <<  " bytes out of " << numStationBytes << "\n";
}

RawAtriStationEvent::RawAtriStationEvent(AraStationEventHeader_t *hdPtr, char *dataBuffer, AraStationId_t forcedStationId) // Assignment constructor
  :RawAraStationEvent(&(hdPtr->gHdr))
{
  //JPD The same as above but forcing the stationId value
  stationId = forcedStationId;

  
  unixTime=hdPtr->unixTime;
  unixTimeUs=hdPtr->unixTimeUs;
  eventNumber=hdPtr->eventNumber;
  versionId=hdPtr->versionNumber;
  ppsNumber=hdPtr->ppsNumber;
  numStationBytes=hdPtr->numBytes;
  //   std::cerr << eventNumber << "\t" << ppsNumber << "\t" << numStationBytes;
   timeStamp=hdPtr->timeStamp;
   timeStamp ^= (timeStamp >> 1);
   timeStamp ^= (timeStamp >> 2);
   timeStamp ^= (timeStamp >> 4);
   timeStamp ^= (timeStamp >> 8);
   timeStamp ^= (timeStamp >> 16);



   eventId=hdPtr->eventId;
   numReadoutBlocks=hdPtr->numReadoutBlocks; 
   
   for(int trig=0;trig<MAX_TRIG_BLOCKS;trig++) {
     triggerInfo[trig]=hdPtr->triggerInfo[trig];
     triggerBlock[trig]=hdPtr->triggerBlock[trig];
   }

   int uptoByte=0;
   //   std::cerr << "numReadoutBlocks " << numReadoutBlocks << "\n";
   for(int block=0;block<numReadoutBlocks;block++) {
     AraStationEventBlockHeader_t *blkPtr = (AraStationEventBlockHeader_t*)&dataBuffer[uptoByte];     
     uptoByte+=sizeof(AraStationEventBlockHeader_t);
     AraStationEventBlockChannel_t *chanPtr = (AraStationEventBlockChannel_t*)&dataBuffer[uptoByte];
     RawAtriStationBlock blocky(blkPtr,chanPtr);
     blockVec.push_back(blocky);
     int numChan=blocky.getNumChannels();

     // std::cout << "block " << block << " numChan " << numChan 
     //                <<  " irsBlockNumber " << (blkPtr->irsBlockNumber&0x1ff)
     //                << " channelMask " << blkPtr->channelMask << "\t"
     //                << " uptoByte " << uptoByte << "\n";
     // numChan=8; //HArd wire for testing
     uptoByte+=sizeof(AraStationEventBlockChannel_t)*numChan;
   }
   //   std::cerr << sizeof(AraStationEventHeader_t) << "\n";
   if(uptoByte!=int(numStationBytes))    
     std::cerr << "Error assigned " << uptoByte <<  " bytes out of " << numStationBytes << "\n";
}

Int_t RawAtriStationEvent::getFirstCapArray(Int_t dda)
{

  for(int i=0;i<DDA_PER_ATRI;i++){
    int this_dda = this->blockVec.at(i).getDda();
    if(this_dda==dda) return this->blockVec.at(i).getCapArray();
  }  
  return -1;
  

}



bool RawAtriStationEvent::isCalpulserEvent(){
  Int_t pulserTime=0;

  if(stationId==ARA_STATION1B) pulserTime=254;
  else if(stationId==ARA_STATION2) pulserTime=245;
  else if(stationId==ARA_STATION3) pulserTime=245;
  else return false;

  if(TMath::Abs((Int_t)timeStamp-pulserTime)<1e4){
    return true;
  }
  else{
    return false;
  }
}


Bool_t RawAtriStationEvent::isTrigType(Int_t bit){
  if(bit >= MAX_TRIG_BLOCKS ){
    fprintf(stderr, "%s -- bit %i too high!\n", __FUNCTION__, bit);
    return kFALSE;
  }
  if(triggerInfo[bit]) return kTRUE;
  else return kFALSE;


}

Bool_t RawAtriStationEvent::isTriggerChanHigh(Int_t bit){
  if(!isRFTrigger() || bit >= 16) return kFALSE;
  if(triggerInfo[0] & (1<<bit)) return kTRUE;
  else return kFALSE;
  
}

Int_t RawAtriStationEvent::numTriggerChansHigh(){

  Int_t numChans=0;
  for(Int_t i=0;i<16;i++){
    if(isTriggerChanHigh(i)) numChans++;
  }
  return numChans;

}

---

UCL HEP Home   

UHE Neutrino Home   

ARA ROOT Software

Main  

Download  

Branches

3.13  

3.12  

3.11  

3.10  

3.9  

3.8  

3.7  

3.6  

3.5  

3.4  

3.3  

3.2  

TestBed