ARA ROOT Test BEd Software

AraEvent/UsefulAraEvent.cxx

#include "UsefulAraEvent.h"
#include "FFTtools.h"
#include "AraGeomTool.h"
#include "TH1.h"
#include <iostream>
#include <fstream>
#include <cstring>
ClassImp(UsefulAraEvent);

UsefulAraEvent::UsefulAraEvent() 
{
   //Default Constructor
  fCalibrator=0;
}

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

UsefulAraEvent::UsefulAraEvent(RawAraEvent *rawEvent, AraCalType::AraCalType_t calType)
  :RawAraEvent(*rawEvent)
{
  fCalibrator=AraEventCalibrator::Instance();
  fCalibrator->calibrateEvent(this,calType);  
}

TGraph *UsefulAraEvent::getGraphFromElecChan(int chan)
{
  if(chan<0 || chan>=NUM_DIGITIZED_CHANNELS)
    return NULL;
  return new TGraph(fNumPoints[chan],fTimes[chan],fVolts[chan]);
}

TGraph *UsefulAraEvent::getGraphFromRFChan(int chan)
{
  if(chan<0 || chan>=RFCHANS_PER_STATION)
    return NULL;
  return new TGraph(fNumPointsRF[chan],fTimesRF[chan],fVoltsRF[chan]);
}

TGraph *UsefulAraEvent::getFFTForRFChan(int chan)
{

   //   static AraGeomTool *fGeomTool = AraGeomTool::Instance();
   TGraph *gr = getGraphFromRFChan(chan);
   if(!gr) return NULL;
   Double_t newX[512],newY[512];
   Double_t intSample=1;
   Int_t maxSamps=256;
   // if(fGeomTool->getNumLabChansForChan(chan)==2) {
   intSample=0.5;
   maxSamps=512;
   //   }
   

   TGraph *grInt = FFTtools::getInterpolatedGraph(gr,intSample);
   

   Int_t numSamps  = grInt->GetN();
   Double_t *xVals = grInt->GetX();
   Double_t *yVals = grInt->GetY();
   for(int i=0;i<maxSamps;i++) {
      if(i<numSamps) {
         newX[i]=xVals[i];
         newY[i]=yVals[i];
      }
      else {
         newX[i]=newX[i-1]+intSample;  
         newY[i]=0;
      }      
  }
   TGraph *grNew = new TGraph(maxSamps,newX,newY);
   TGraph *grFFT = FFTtools::makePowerSpectrumMilliVoltsNanoSecondsdB(grNew);
   delete gr;
   delete grNew;
   delete grInt;
   return grFFT;
}

TH1D *UsefulAraEvent::getFFTHistForRFChan(int chan)
{

   Int_t numBins=256;
   Double_t minX=0.0;
   Double_t maxX=1000.0;
   minX = minX - ( (maxX-minX)/numBins/2.0 ); // adjust histogram edges so that the bin centers
   maxX = maxX + ( (maxX-minX)/numBins/2.0 ); // of the histograms are aligned with graph [add bdf]
   numBins++;
   char histName[180];
   sprintf(histName,"%s_ffthist",this->GetName());
   TH1D *histFFT = new TH1D(histName,histName,numBins,minX,maxX);
   if(fillFFTHistoForRFChan(chan,histFFT)==0)
      return histFFT;
   return NULL;

}
      
int UsefulAraEvent::fillFFTHistoForRFChan(int chan, TH1D *histFFT) 
{

   TGraph *grFFT =getFFTForRFChan(chan);
   if(!grFFT) return -1;
   Double_t *xVals=grFFT->GetX();
   Double_t *yVals=grFFT->GetY();
   Int_t numPoints=grFFT->GetN();
   for(int i=0;i<numPoints;i++) {    
      histFFT->Fill(xVals[i],yVals[i]);
   }
   delete grFFT;
   return 0;

}

int UsefulAraEvent::guessRCO(int chanIndex)
{
  int chip=chanIndex/CHANNELS_PER_CHIP;
  if(chip<0 || chip>=ACTIVE_CHIPS) return -1;
  static int firstTime=1;
  static unsigned int lastEventNumber=0; //random number
  static unsigned int lastUnixTimeUs=0; //random number
  static int fRcoGuess[ACTIVE_CHIPS]={0};
  fCalibrator=AraEventCalibrator::Instance();
  if(lastEventNumber!=this->head.eventNumber || firstTime || lastUnixTimeUs!=this->head.unixTimeUs) {
    fCalibrator->fillRCOGuessArray(this,fRcoGuess);
    lastEventNumber=this->head.eventNumber;
    lastUnixTimeUs=this->head.unixTimeUs;
    firstTime=0;
  }
  return fRcoGuess[chip];    
}

TGraph *UsefulAraEvent::getFFTForClock(int clock_number)
{

   if ( (clock_number<0) || ( clock_number>2) ) {
      return NULL;
   }

   int channel_number = clock_number*9+8;
   //   static AraGeomTool *fGeomTool = AraGeomTool::Instance();
   TGraph *gr = getGraphFromElecChan(channel_number);
   if(!gr) return NULL;
   Double_t newX[512],newY[512];
   Double_t intSample=1.0;
   Int_t maxSamps=256;
   intSample = 0.5;                   /* interpolation spacing in ns                */
   maxSamps  = 512;                   /* number of samples in interpolated waveform */

   TGraph *grInt = FFTtools::getInterpolatedGraph(gr,intSample);

   Int_t numSamps  = grInt->GetN();
   Double_t *xVals = grInt->GetX();
   Double_t *yVals = grInt->GetY();
// printf("UsefulAraEvent::getFFTForClock() - intSample = %f - maxSamps = %d - numSamps = %d [%d]\n",intSample,maxSamps,numSamps,grInt->GetN());
   for(int i=0;i<maxSamps;i++) {
//    if ( i<numSamps ) {
//       printf("UsefulAraEvent::getFFTForClock() - i = %d - (x,y) = %.2f,%.2f",i,xVals[i],yVals[i]);
//    } else {
//       printf("UsefulAraEvent::getFFTForClock() - i = %d - i>numSamps ",i);
//    }
      if( i<numSamps ) {
//       printf(" - use point\n");
         newX[i]=xVals[i];
         newY[i]=yVals[i];
      }
      else {
         newX[i]=newX[i-1]+intSample; 
         newY[i]=0;
//       printf(" - zero fill - (x,y) = %.2f,%.2f - previous_x = %.2f\n",newX[i],newY[i],newX[i-1]);
      }
   }
   TGraph *grNew = new TGraph(maxSamps,newX,newY);
   TGraph *grFFT = FFTtools::makePowerSpectrumMilliVoltsNanoSecondsdB(grNew);
   delete gr;
   delete grNew;
   delete grInt;
   return grFFT;

} // end of function UsefulAraEvent::getFFTForClock()

TH1D *UsefulAraEvent::getFFTHistForClock(int clock_number)
{

   Int_t numBins=256;
   Double_t minX=0.0;
   Double_t maxX=1000.0;   
   minX = minX - ( (maxX-minX)/numBins/2.0 ); // adjust histogram edges so that the bin centers
   maxX = maxX + ( (maxX-minX)/numBins/2.0 ); // of the histograms are aligned with graph [add bdf]
   numBins++;
   char histName[180];
   sprintf(histName,"%s_clock_%2.2dffthist",this->GetName(),clock_number);
   TH1D *histFFT = new TH1D(histName,histName,numBins,minX,maxX);
   if(fillFFTHistoForClock(clock_number,histFFT)==0)
      return histFFT;
   return NULL;
  
}
      
int UsefulAraEvent::fillFFTHistoForClock(int clock_number, TH1D *histFFT) 
{
   TGraph *grFFT = getFFTForClock(clock_number);
   if(!grFFT) return -1;
   Double_t *xVals=grFFT->GetX();
   Double_t *yVals=grFFT->GetY();
   Int_t numPoints=grFFT->GetN();
   for(int i=0;i<numPoints;i++) {    
      histFFT->Fill(xVals[i],yVals[i]);
   }
   delete grFFT;
   return 0;
}

bool UsefulAraEvent::isCalPulserEvent( )
{

   bool retcode = false;

   AraTriggerMonitor *trig = &(this->trig);
   unsigned short msw_clock_counter = trig->rovdd[0];
   unsigned short lsw_clock_counter = trig->rovdd[1];

// printf("UsefulAraEvent::isCalPulserEvent() - DEBUG - %d %d",msw_clock_counter,lsw_clock_counter);
   if ( ( msw_clock_counter == 0 ) &&                                                                /* Rb peak is at msw=0 && lsw=5801+/-5 */
        ( TMath::Abs(lsw_clock_counter-5801) < 5 ) ) {
//    printf(" <- is cal pulser\n");
      retcode = true;
   } else {
//    printf(" <- is *not* cal pulser\n");
      retcode = false;
   }

   return retcode;

} // end of UsefulAraEvent::isCalPulserEvent() member function

---

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