ARA ROOT v3.13 Software

calibration/antCalib/generateDeltaTs.cxx

//Includes
#include <iostream>
#include <fstream>

//AraRoot Includes
#include "RawIcrrStationEvent.h"
#include "RawAtriStationEvent.h"
#include "UsefulAraStationEvent.h"
#include "UsefulIcrrStationEvent.h"
#include "UsefulAtriStationEvent.h"
#include "AraGeomTool.h"
#include "AraEventCalibrator.h"
#include "FFTtools.h"

//ROOT Includes
#include "TTree.h"
#include "TFile.h"
#include "TGraph.h"
#include "TTimeStamp.h"
#include "TSystem.h"

#include <map>

RawIcrrStationEvent *rawIcrrEvPtr=0;
RawAtriStationEvent *rawAtriEvPtr=0;
RawAraStationEvent *rawEvPtr=0;
UsefulIcrrStationEvent *realIcrrEvPtr=0;
UsefulAtriStationEvent *realAtriEvPtr=0;
UsefulAraStationEvent *realEvPtr=0;

void usage(char **argv) 
{  
  std::cout << "Usage\n" << argv[0] << " <input file>\n";
  std::cout << "e.g.\n" << argv[0] << " http://www.hep.ucl.ac.uk/uhen/ara/monitor/root/run1841/event1841.root\n";  
}




int main(int argc, char **argv) {
  if(argc<2) {
    usage(argv);
    return -1;
  }


  TFile *fp = TFile::Open(argv[1]);
  if(!fp) {
    std::cerr << "Can't open file\n";
    return -1;
  }
  TTree *eventTree = (TTree*) fp->Get("eventTree");
  if(!eventTree) {
    std::cerr << "Can't find eventTree\n";
    return -1;
  }
   
  //Now check the electronics type of the station


  int isIcrrEvent=0;
  int isAtriEvent=0;

  Int_t runNumber;
  //Check an event in the run Tree and see if it is station1 or TestBed (stationId<2)
  eventTree->SetBranchAddress("event",&rawEvPtr);
  eventTree->SetBranchAddress("run",&runNumber);
  eventTree->GetEntry(0);

  if((rawEvPtr->stationId)<2){
    isIcrrEvent=1;
    isAtriEvent=0;
  }
  else{
    isIcrrEvent=0;
    isAtriEvent=1; 
  }
  eventTree->ResetBranchAddresses();

  //Now set the appropriate branch addresses
  //The Icrr case
  if(isIcrrEvent){

    eventTree->SetBranchAddress("event", &rawIcrrEvPtr);
    rawEvPtr=rawIcrrEvPtr;
    std::cerr << "Set Branch address to Icrr\n";

  }
  //The Atri case
  else{

    eventTree->SetBranchAddress("event", &rawAtriEvPtr);
    rawEvPtr=rawAtriEvPtr;
    std::cerr << "Set Branch address to Atri\n";

  }

  //Now we set up out run list
  Long64_t numEntries=eventTree->GetEntries();
  Long64_t starEvery=numEntries/80;
  if(starEvery==0) starEvery++;

  //jpd print to screen some info
  std::cerr << "isAtri " << isAtriEvent << " isIcrr " << isIcrrEvent << " number of entries is " <<  numEntries << std::endl;

  eventTree->GetEntry(0);

  //Pedestal fun
  if(argc>2) {
    std::ifstream PedList(argv[2]);    
    int pedRun,lastPedRun=-1;
    char pedFileName[FILENAME_MAX];
    char lastPedFileName[FILENAME_MAX];
    while(PedList >> pedRun >> pedFileName) {
      if(pedRun>runNumber) {
        //Take the last guy
        if(lastPedRun==-1) {
          lastPedRun=pedRun;
          strncpy(lastPedFileName,pedFileName,FILENAME_MAX);
        }         
        break;
      }
      lastPedRun=pedRun;
      strncpy(lastPedFileName,pedFileName,FILENAME_MAX);
    }
    //Got the pedestal run
    AraEventCalibrator::Instance()->setAtriPedFile(lastPedFileName, rawAtriEvPtr->stationId);    
  }


  //  numEntries=200;
  for(Long64_t event=0;event<numEntries;event++) {
    if(event%starEvery==0) {
      std::cerr << "*";       
    }

    //This line gets the RawIcrr or RawAtri Event
    eventTree->GetEntry(event);

    //Here we create a useful event Either an Icrr or Atri event
    Int_t eventNumber=event;
    Int_t unixTime=1;

    Double_t triggerTime=0;

    if(isIcrrEvent){
      if(realIcrrEvPtr) delete realIcrrEvPtr;
      realIcrrEvPtr = new UsefulIcrrStationEvent(rawIcrrEvPtr, AraCalType::kLatestCalib);
      realEvPtr=realIcrrEvPtr;
      eventNumber=rawIcrrEvPtr->head.eventNumber;
      unixTime=rawIcrrEvPtr->head.unixTime;
      triggerTime=rawIcrrEvPtr->getRubidiumTriggerTimeInSec();
    }
    else if(isAtriEvent){
      if(realAtriEvPtr) delete realAtriEvPtr;
      realAtriEvPtr = new UsefulAtriStationEvent(rawAtriEvPtr, AraCalType::kLatestCalib);
      realEvPtr=realAtriEvPtr;
      eventNumber=rawAtriEvPtr->eventNumber;
      unixTime=rawAtriEvPtr->unixTime;
      triggerTime=rawAtriEvPtr->timeStamp;
    }
    int isSoftTrig=0;
    if(rawAtriEvPtr->numReadoutBlocks<80) isSoftTrig=1;
    int isCalPulser=0;
    if(rawAtriEvPtr->isCalpulserEvent()) isCalPulser=1;
    if(!isCalPulser) continue;


    Int_t numChannels=realEvPtr->getNumRFChannels();

    TGraph *gr[100]={0};


    for( int i=0; i<numChannels; ++i ) {

    }
  }
  std::cerr << "\n";


}

---

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