MSideCoincidence.cc

Go to the documentation of this file.

#include "MSideCoincidence.hh"
#include "QEvent.hh"
#include "QEventList.hh"
#include "QRawEvent.hh"
#include "QBaseType.hh"
#include "QCoincidenceData.hh"
#include "QOFData.hh"
#include "QRunDataHandle.hh"
#include "QDetChannelCollectionHandle.hh"
#include <cmath>
 
REGISTER_MODULE(MSideCoincidence)
 
using std::vector;
using std::string;
using namespace Diana;
 
void MSideCoincidence::Init(QEvent& ev)
{
  fNSigma = GetDouble("NumberOfSigma",3,false);
  fSideAmplitudeOwner = GetString("SideAmplitudeOwner","SideAmplitude",false);
  fMainEnergyOwner = GetString("MainEnergyOwner","ApplyCalibration",false);
  fSideEnergyOwner = GetString("SideEnergyOwner","ApplyCalibration_Sync",false);
 
  ev.Add<QCoincidenceData>("CoincidenceData");
  ev.Add<QDouble>("TotalEnergy");
  fThisRun = -1;
 
  ev.Require<QHeader>("DAQ","Header");  
  ev.Require<QPulseInfo>("DAQ","PulseInfo");
  
  ev.RequireByLabel<QDouble>(QEventLabel(fSideAmplitudeOwner.c_str(),"Amplitude"));
  ev.RequireByLabel<QDouble>(QEventLabel(fSideEnergyOwner.c_str(),"Energy"));
  ev.RequireByLabel<QDouble>(QEventLabel(fMainEnergyOwner.c_str(),"Energy"));
  ev.RequireByLabel<QDouble>(QEventLabel(fSideAmplitudeOwner.c_str(),"NSigma"));
}
 
void MSideCoincidence::Do(QEvent& ev, const QEventList& neighbours)
{
  const QHeader& hdr = ev.Get<QHeader>("DAQ","Header");
  const int run = hdr.GetRun();
  
  const QPulseInfo& pi = ev.Get<QPulseInfo>("DAQ","PulseInfo");
  const int chan = pi.GetChannelId();
 
  if(fThisRun != run) {
    fThisRun = run;
    QRunDataHandle rHandle(fThisRun);
    GlobalData().Get("DAQ",&rHandle,"");
    fRunData = rHandle.Get();
  }
 
  // position of main event
 
  int tower = -1;
  int floor = -1;
  int position = -1;
 
  QDetChannelCollectionHandle dccHandle;
  dccHandle.SetRun(run);
  GlobalData().Get("",&dccHandle,"");
  
  tower = dccHandle.Get().Get(chan).fTd.fTdTower;
  floor = dccHandle.Get().Get(chan).fTd.fTdFloor;
  position = dccHandle.Get().Get(chan).fTd.fTdPos;
 
  QCoincidenceData& coincData = ev.Get<QCoincidenceData>("CoincidenceData");
  double tot_ene = ev.GetByLabel<QDouble>(QEventLabel(fMainEnergyOwner.c_str(),"Energy"));
  
  coincData.fMultiplicity = 1;
  coincData.fCoincidentChannels.clear();
  //  const double time = GetTime(ev);
  //  ev.Get<QDouble>("Time") = time;
 
  // start loop on neighbours (side)
 
  for(size_t i = 0; i < neighbours.Size(); i++) {
    const QDouble& n_energy = neighbours[i].GetByLabel<QDouble>(QEventLabel(fSideEnergyOwner.c_str(),"Energy"));
    const QDouble& n_nsigma = neighbours[i].GetByLabel<QDouble>(QEventLabel(fSideAmplitudeOwner.c_str(),"NSigma"));
 
    int n_tower = -1; 
    int n_floor = -1; 
    int n_position = -1;
    
    if (n_nsigma>fNSigma)
      {
        const QPulseInfo& n_pi = neighbours[i].Get<QPulseInfo>("","PulseInfo");
        //      const double n_time = GetTime(neighbours[i]);
        const int n_channel = n_pi.GetChannelId();
 
        //      const double deltaT = n_time - time;
 
        n_tower = dccHandle.Get().Get(n_channel).fTd.fTdTower;
        n_floor = dccHandle.Get().Get(n_channel).fTd.fTdFloor;
        n_position = dccHandle.Get().Get(n_channel).fTd.fTdPos;
 
        QCoincidentChannel cc;
        cc.fChannelId = n_channel;
        //        cc.fDeltaT = deltaT;
        cc.fEnergy = n_energy;
 
        cc.fDeltaTower = n_tower-tower;
        cc.fDeltaFloor = n_floor-floor;
        cc.fDeltaPosition = n_position-position;
 
        cc.fEventNumber = neighbours[i].Get<QHeader>("DAQ","Header").GetEventNumber();
        coincData.fCoincidentChannels.push_back(cc);
 
        coincData.fMultiplicity++;
        tot_ene += n_energy;
      }
  }
  ev.Get<QDouble>("TotalEnergy") = tot_ene;
}
 
void MSideCoincidence::Done()
{
  // called at the end of the event loop
 
}
 
double MSideCoincidence::GetTime(const QEvent& ev)
{
    const QHeader& header = ev.Get<QHeader>("DAQ","Header");
    const QPulseInfo& pi = ev.Get<QPulseInfo>("DAQ","PulseInfo");
    double time = double(header.GetTime().GetFromStartRunNs())/1e09; 
 
    const QOFData& of = ev.Get<QOFData>("COF","OFData");
    double samplingFrequency = fRunData.GetChannelRunData(pi.GetChannelId()).fSamplingFrequency;
    time += of.GetDelay()/1000 - double(pi.GetMasterSample().GetSampleIndex())/samplingFrequency;
    
    return time;
}