RnoConvert.cxx

Go to the documentation of this file.

 
#include "RnoConvert.h"
#include "Riostream.h"
 
ClassImp(RnoConvert); // Class implementation to enable ROOT I/O

RnoConvert::RnoConvert(const char* name,const char* title) : NcJob(name,title)
{
 
 fSplit=99;
 fBsize=32000;
 fMaxevt=-1;
 fPrintfreq=0;
 fPrintlevel=0;
 fOutfile=0;
 fHdr=0;
 fDs=0;
 fWf=0;
 fComb=0;
 fPed=0;
 fData=0;
 fMinSelectLevel=0;
 fMaxSelectLevel=-1;
}

RnoConvert::~RnoConvert()
{
 
 if (fData)
 {
  delete fData;
  fData=0;
 }
 
 if (fOutfile)
 {
  delete fOutfile;
  fOutfile=0;
 }
}

void RnoConvert::SetMaxEvents(Int_t n)
{
 
 fMaxevt=n;
}

void RnoConvert::SetPrintFreq(Int_t m,Int_t level)
{
 
 if (level<0 || level>2)
 {
  cout << " *" << ClassName() << "::SetPrintFreq* Unsupported input : level=" << level << " --> Print level set to 0." << endl;
  cout << endl;
  level=0;
 }
 
 fPrintfreq=m;
 fPrintlevel=level;
}

void RnoConvert::SetSplitLevel(Int_t split)
{
 
 if (split>=0) fSplit=split;
}

void RnoConvert::SetBufferSize(Int_t bsize)
{
 
 if (bsize>=0) fBsize=bsize;
}

void RnoConvert::AddInputFile(TString file,TString type)
{
 
 // Expand the path name of the provided input file
 file=gSystem->ExpandPathName(file.Data());
 
 if (type!="hdr" && type!="ds" && type!="wf" && type!="combined" && type!="pedestal")
 {
  printf(" *%-s::AddInputFile* Unsupported type : %-s. File %-s not added. \n",ClassName(),type.Data(),file.Data());
  return;
 }
 
 TChain* chain=0;
 if (type=="hdr") chain=fHdr;
 if (type=="ds") chain=fDs;
 if (type=="wf") chain=fWf;
 if (type=="combined") chain=fComb;
 if (type=="pedestal") chain=fPed;
 
 if (!chain)
 {
  if (type!="pedestal")
  {
   chain=new TChain(type.Data());
  }
  else
  {
   chain=new TChain();
  }
  if (type=="hdr") fHdr=chain;
  if (type=="ds") fDs=chain;
  if (type=="wf") fWf=chain;
  if (type=="combined") fComb=chain;
  if (type=="pedestal") fPed=chain;
 }
 
 chain->Add(file.Data());
 
 printf(" *%-s::AddInputFile* Added RNO-G %-s data input file : %-s \n",ClassName(),type.Data(),file.Data());
}

void RnoConvert::SetOutputFile(TFile* ofile)
{
 
 if (fOutfile) delete fOutfile;
 fOutfile=ofile;
}

void RnoConvert::SetOutputFile(TString name)
{
 
 // Expand the path name of the specified output file
 name=gSystem->ExpandPathName(name.Data());
 
 if (fOutfile) delete fOutfile;
 fOutfile=new TFile(name.Data(),"RECREATE","RNO-G data in RnoEvent structure");
}

void RnoConvert::SetSelectLevels(Int_t min,Int_t max)
{
 
 fMinSelectLevel=min;
 fMaxSelectLevel=max;
}

Int_t RnoConvert::GetMinSelectLevel() const
{
 
 return fMinSelectLevel;
}

Int_t RnoConvert::GetMaxSelectLevel() const
{
 
 return fMaxSelectLevel;
}

void RnoConvert::ListInput(TString type,Option_t* opt)
{
 
 if (!fHdr && !fDs && !fWf && !fComb && !fPed)
 {
  printf("\n *%-s::ListInput* No input file of type %-s has been attached. \n",ClassName(),type.Data());
  return;
 }
 
 TString s=opt;
 if (s=="") s="Default";
 
 // Printout for all stored data
 if (type=="*")
 {
  printf("\n *%-s::ListInput* Overview of all the stored input data with option : %-s \n",ClassName(),s.Data());
  if (fHdr) fHdr->Print(opt);
  if (fDs) fDs->Print(opt);
  if (fWf) fWf->Print(opt);
  if (fComb) fComb->Print(opt);
  if (fPed) fPed->Print(opt);
  return;
 }
 
 // Selected printout
 TChain* chain=0;
 if (type=="hdr") chain=fHdr;
 if (type=="ds") chain=fDs;
 if (type=="wf") chain=fWf;
 if (type=="combined") chain=fComb;
 if (type=="pedestal") chain=fPed;
 
 if (chain)
 {
  printf("\n *%-s::ListInput* Overview of the %-s input data with option : %-s \n",ClassName(),type.Data(),s.Data());
  chain->Print(opt);
 }
 else
 {
  printf("\n *%-s::ListInput* No input file of type %-s has been attached. \n",ClassName(),type.Data());
  return;
 }
}

TFile* RnoConvert::GetOutputFile()
{
 
 return fOutfile;
}

void RnoConvert::CreateMainChain()
{
 
 if (fData)
 {
  delete fData;
  fData=0;
 }
 
 // Check whether loaded input data exists
 if (!fHdr && !fDs && !fWf && !fComb && !fPed) return;
 
 fData=new TChain("Data");
 
 // Build the total input chain
 Bool_t first=kTRUE;
 
 if (fHdr)
 {
  if (first)
  {
   fData=new TChain("Data");
   fData->Add(fHdr);
   first=kFALSE;
  }
  else
  {
   if (fData) fData->AddFriend(fHdr);
  }
 }
 
 if (fDs)
 {
  if (first)
  {
   fData=new TChain("Data");
   fData->Add(fDs);
   first=kFALSE;
  }
  else
  {
   if (fData) fData->AddFriend(fDs);
  }
 }
 
 if (fWf)
 {
  if (first)
  {
   fData=new TChain("Data");
   fData->Add(fWf);
   first=kFALSE;
  }
  else
  {
   if (fData) fData->AddFriend(fWf);
  }
 }
 
 if (fComb)
 {
  if (first)
  {
   fData=new TChain("Data");
   fData->Add(fComb);
   first=kFALSE;
  }
  else
  {
   if (fData) fData->AddFriend(fComb);
  }
 }
 
 if (fPed)
 {
  if (first)
  {
   fData=new TChain("Data");
   fData->Add(fPed);
   first=kFALSE;
  }
  else
  {
   if (fData) fData->AddFriend(fPed);
  }
 }
}

void RnoConvert::Exec(Option_t* opt)
{
 
 // Create the main input data chain for processing
 CreateMainChain();
 
 if (!fData)
 {
  cout << " *" << ClassName() << "::Exec* No data input file(s) specified." << endl;
  return;
 }
 
 // Create output tree if necessary
 TTree* otree=0;
 if (fOutfile)
 {
  otree=new TTree("T","RNO-G data converted to RnoEvent structures");
  otree->SetDirectory(fOutfile);
 }
 
 // An initial RNO-G detector structure
 RnoDetector det;
 
 // Create the RnoEvent structure
 RnoEvent* evt=new RnoEvent();
 evt->SetOwner(1);
 
 // Branch in the tree for the event structure
 if (otree) otree->Branch("Events","RnoEvent",&evt,fBsize,fSplit); 
 
 // Initialise the job working environment
 SetMainObject(evt);
 
 // Some output for the user's convenience
 cout << endl;
 cout << " *" << ClassName() << "::Exec* Overview of scheduled processing." << endl;
 cout << " ***" << endl;
 cout << " *** Start processing of job " << GetName() << " ***" << endl;
 cout << " ***" << endl;
 cout << " Maximum number of events to be processed : " << fMaxevt << " (<0 means all events)" << endl;
 cout << " Print frequency : " << fPrintfreq << " (<=0 means no printout)" << endl;
 cout << " Print level     : " << fPrintlevel << endl;
 if (fOutfile)
 {
  cout << " RnoEvent output file : " << fOutfile->GetName() << endl;
  cout << " Output characteristics : splitlevel = " << fSplit << " buffersize = " << fBsize << endl;
  cout << " Required event selection level interval for output : [" << fMinSelectLevel << "," << fMaxSelectLevel << "]" << endl;
 }
 cout << endl;
 
 ListEnvironment();
 
 // The number of entries in the input chain
 Int_t nen=fData->GetEntries();
 
 // Check for the maximum number of events to be processed
 if (fMaxevt>-1 && nen>fMaxevt) nen=fMaxevt;

 // Variables in the RNO-G data tree //
 
 // Header info
 Int_t run=0;
 Int_t event=0;
 Int_t station=0;
 Double_t trigtime=0;
 
 // DAQ info
 NcDevice daq("DAQ","DAQ status");
 daq.AddNamedSlot("RADIANT-update");
 daq.AddNamedSlot("FLOWER-update");
 daq.AddNamedSlot("Sampling-rate");
 
 // Trigger info
 NcTagger trigger("Trigger","Trigger tags");
 
 // The waveforms of all channels are provided as Short_t radiant_data[24][2048]
 // but will be readout linearly and stored as an NcSample for each channel, as indicated below. 
 NcSample signal("Signals","Radiant signals");
 signal.SetStoreMode(1);
 
 // The pedestals of all channels are provided as UShort_t pedestals[24][4096]
 // but will be readout linearly and stored as an NcSample for each channel, as indicated below. 
 NcSample pedestal("Pedestals","Pedestal values");
 pedestal.SetStoreMode(1);

 // Loop over the entries in the input data chain //
 
 TLeaf* lx=0;
 TLeaf* lradiant=0;  // Pointer to the Radiant waveform data
 TLeaf* lpedestal=0; // Pointer to the Pedestal waveform data
 Int_t idx=0;
 Int_t nsamples=0; // The sampling buffer length
 NcDevice* devx=0;
 Int_t idsample=0; // Index for the NcSample in the NcDevice storage
 TString name="";
 TString namex1="";
 TString namex2="";
 TString namex3="";
 Float_t value=0;
 Int_t ivalue=0;
 Bool_t flag=kFALSE;
 Int_t iradiant=0; // RADIANT firmware update sequence number
 Int_t iflower=0;  // FLOWER firmware update sequence number
 Float_t fsample;  // The DAQ sampling rate in Hz
 Int_t nwritten=0; // The number of events written to output
 Int_t perc=0;     // Percentage of the number of processed events
 
 for (Int_t ient=0; ient<nen; ient++)
 {
  // Reset the detector structure
  det.Reset();
  idsample=0;
 
  fData->GetEntry(ient);
 
  // Loop over all the leaves and extract the relevant data for this entry.
  // This approach makes the functionality independent of the Tree/Branch structure.
  run=0;
  event=0;
  station=0;
  trigtime=0;
  nsamples=0;
  trigger.Reset();
  lradiant=0;
  lpedestal=0;
  TIterator* iter=fData->GetIteratorOnAllLeaves();
  while((lx=(TLeaf*)iter->Next()))
  {
   name=lx->GetName();
 
   // Header data
   if (!run && name=="run_number") run=lx->GetValue();
   if (!event && name=="event_number") event=lx->GetValue();
   if (!station && name=="station_number") station=lx->GetValue();
   if (!trigtime && name=="trigger_time") trigtime=lx->GetValue();
   if (!trigtime && name=="when") trigtime=lx->GetValue(); // In case of a pedestal data file
   if (!nsamples && name=="buffer_length") nsamples=lx->GetValue();
 
   // Trigger data
   if (name.Contains("trigger_info"))
   {
    name.ReplaceAll("trigger_info.","");
    value=lx->GetValue();
    ivalue=TMath::Nint(value);
    namex1="";
    namex2="";
    namex3="";
 
    // The low threshold time window and number of coincidences
    if (name.Contains("lt_info.window")) namex1="lt-window";
    if (name.Contains("lt_info.num_coinc")) namex1="lt-ncoinc";
 
    if (namex1!="")
    {
     trigger.AddNamedSlot(namex1);
     trigger.SetSignal(value,namex1);
     continue;
    }
 
    // The various radiant (=surface) time windows and number of coincidences
    if (name.Contains("radiant_info.RF_window"))
    {
     namex1="LPDA-up-window";
     namex2="LPDA-down-window";
     value=lx->GetValue(0);
     trigger.AddNamedSlot(namex1);
     trigger.SetSignal(value,namex1);
     value=lx->GetValue(1);
     trigger.AddNamedSlot(namex2);
     trigger.SetSignal(value,namex2);
     continue;
    }
    if (name.Contains("radiant_info.RF_ncoinc"))
    {
     namex1="LPDA-up-ncoinc";
     namex2="LPDA-down-ncoinc";
     value=lx->GetValue(0);
     trigger.AddNamedSlot(namex1);
     trigger.SetSignal(value,namex1);
     value=lx->GetValue(1);
     trigger.AddNamedSlot(namex2);
     trigger.SetSignal(value,namex2);
     continue;
    }
 
    // The actual trigger tags
    if (name.Contains("_trigger"))
    {
     // Settings of the various radiant (=surface) triggers
     if (name.Contains("which_radiant"))
     {
      namex1="LPDA-up_trigger";
      namex2="LPDA-down_trigger";
      namex3="radiant-unknown_trigger";
      if (ivalue<-100) // None of the surface triggers
      {
       trigger.SetPass(namex1,kFALSE);
       trigger.SetPass(namex2,kFALSE);
       trigger.SetPass(namex3,kFALSE);
      }
      if (ivalue==-1) // Unknown radiant trigger
      {
       trigger.SetPass(namex1,kFALSE);
       trigger.SetPass(namex2,kFALSE);
       trigger.SetPass(namex3,kTRUE);
      }
      if (ivalue==0) // Only upward surface trigger
      {
       trigger.SetPass(namex1,kTRUE);
       trigger.SetPass(namex2,kFALSE);
       trigger.SetPass(namex3,kFALSE);
      }
      if (ivalue==1) // Only downward surface trigger
      {
       trigger.SetPass(namex1,kFALSE);
       trigger.SetPass(namex2,kTRUE);
       trigger.SetPass(namex3,kFALSE);
      }
     }
     else
     {
      flag=kFALSE;
      if (ivalue) flag=kTRUE;
      trigger.SetPass(name,flag);
     }
    }
   } // End of trigger data
 
   // Pointers to the waveform data
   if (name=="radiant_data") lradiant=lx;
   if (name=="pedestals") lpedestal=lx;
  } // End of loop over the leaves
 
  // Create this station in the detector structure
  RnoStation* stax=det.GetStation(station,kTRUE);
 
  if (!stax) break;
 
  // DAQ info
  iradiant=2;    // The RADIANT update version
  iflower=0;     // The FLOWER update version
  fsample=3.2e9; // The sampling rate in Hz
  if (station==11)
  {
   if (run<571) iradiant=1;
   if (run<474) iradiant=0;
   if (run>=571) iradiant=2;
  }
  if (station==21)
  {
   if (run<753) iradiant=1;
   if (run<646) iradiant=0;
  }
  if (station==22)
  {
   if (run<656) iradiant=1;
   if (run<574) iradiant=0;
  }
 
  daq.SetSignal(iradiant,"RADIANT-update");
  daq.SetSignal(iflower,"FLOWER-update");
  daq.SetSignal(fsample,"Sampling-rate");
 
  stax->AddDevice(daq);
 
  stax->AddDevice(trigger);
 
  // Readout the signal waveforms of all Radiant channels
  if (!nsamples) nsamples=2048;
  lx=lradiant;
  if (lx)
  {
   idsample++;
   idx=0;
   for (Int_t i=0; i<24; i++)
   {
    // Access the corresponding channel of this station
    name="Ch";
    name+=i;
    devx=stax->GetDevice(name,kTRUE);
 
    if (!devx) continue;
 
    signal.Reset();
    signal.SetNames("ADC");
    for (Int_t j=0; j<nsamples; j++)
    {
     // Retrieve the value of radiant[i][j]
     value=lx->GetValue(idx);
     signal.Enter(value);
     idx++;
    }
    devx->SetSample(&signal,idsample);
   }
  }
 
  // Readout the pedestals of all Radiant channels
  nsamples=4096;
  lx=lpedestal;
  if (lx)
  {
   idsample++;
   idx=0;
   for (Int_t i=0; i<24; i++)
   {
    // Access the corresponding channel of this station
    name="Ch";
    name+=i;
    devx=stax->GetDevice(name,kTRUE);
 
    if (!devx) continue;
 
    pedestal.Reset();
    pedestal.SetNames("ADC");
    for (Int_t j=0; j<nsamples; j++)
    {
     // Retrieve the value of pedestals[i][j]
     value=lx->GetValue(idx);
     pedestal.Enter(value);
     idx++;
    }
    devx->SetSample(&pedestal,idsample);
   }
  }
 
  // Transfer the RNO-G data into the RnoEvent structure
  evt->Reset();
  evt->SetUnixTime(trigtime,"A");
  evt->SetRunNumber(run);
  evt->SetEventNumber(event);
  evt->SetDetector(det);
  UInt_t id=station+100*run;
  evt->SetUniqueID(id);
 
  // Invoke all available sub-tasks (if any)
  CleanTasks();
  ExecuteTasks(GetName());
 
  // Provide a printout every "Printfreq" events
  if (fPrintfreq>0)
  {
   if ((!(ient%fPrintfreq) || (ient+1)==nen))
   {
    perc=100*(ient+1)/nen;
    if (fPrintlevel==0 || fPrintlevel==2)
    {
     cout << " *** Processed input entry : " << ient << " run : " << run << " event : " << event << " (" << perc << "%)" << endl;
    }
    if (fPrintlevel>0)
    {
     evt->HeaderData();
     cout << endl;
    }
   }
  }
 
  // Write the event to the output file (if the event select level is o.k.)
  Int_t select=evt->GetSelectLevel();
  if (select<fMinSelectLevel) continue;
  if (fMaxSelectLevel>=fMinSelectLevel && select>fMaxSelectLevel) continue;
 
  if (otree) otree->Fill();
  nwritten++;
 } // End of loop over the entries
 
 // Flush possible memory resident data to the output file
 if (fOutfile)
 {
  fOutfile->Write();
  cout << endl;
  cout << " *" << ClassName() << "::Exec* Number of (selected) events written to output : " << nwritten << endl;
 }
 
 // Remove the RnoEvent object from the environment
 // and delete it as well
 if (evt)
 {
  RemoveObject(evt);
  delete evt;
 }
 
 // Delete the input data chain
 if (fData)
 {
  delete fData;
  fData=0;
 }
}