MSideAmplitude.cc

Go to the documentation of this file.

#include "MSideAmplitude.hh"
#include "QEvent.hh"
#include "QEventList.hh"
#include "QOFData.hh"
#include "QRunDataHandle.hh"
#include "QAveragePulseHandle.hh"
#include "QCOFParametersHandle.hh"
#include "QBaseType.hh"
#include "QVector.hh"
#include "QRawEvent.hh"
#include "QJitter.hh"
#include "QJitterHandle.hh"
#include <cmath>
 
REGISTER_MODULE(MSideAmplitude)
 
using namespace Diana;
using std::string;
 
void MSideAmplitude::Init(QEvent& ev)
{
  ev.Require<QPulseInfo>("DAQ","PulseInfo");
  ev.Require<QHeader>("DAQ","Header");
  ev.Require<QOFData>("COF","OFData");
 
  ev.Add<QDouble>("Amplitude");
  ev.Add<QDouble>("NSigma");
  ev.Add<QInt>("MaximumPosition");
  fSamplesOwner = GetString("SamplesOwner","COF");
  ev.Require<QVector>(fSamplesOwner,"OF");
 
 // get dataset
  GlobalHandle<QInt> dHandle("Dataset");
  GlobalData().Get("",&dHandle,"");
  fDataset = dHandle.Get();
}
 
void MSideAmplitude::Do(QEvent& ev, const QEventList& neighbours)
{
  
  //  const QHeader& header = ev.Get<QHeader>("DAQ","Header");
  const QPulseInfo& pi = ev.Get<QPulseInfo>("DAQ","PulseInfo");
  const int ch_side = pi.GetChannelId();
 
  //  const QOFData& ofData = ev.Get<QOFData>(fSamplesOwner.c_str(),"OFData");
  const QVector& OFSamplesSide = ev.Get<QVector>(fSamplesOwner.c_str(),"OF");
 
  ev.Get<QDouble>("Amplitude") = Q_DOUBLE_DEFAULT;
  ev.Get<QDouble>("NSigma") = Q_DOUBLE_DEFAULT;
  ev.Get<QInt>("MaximumPosition") = Q_INT_DEFAULT;
    
  string InputFilename = GetString("JitterInput","jitter.txt");
  
  for(size_t i = 0;i < neighbours.Size();i++){
    const QPulseInfo& o_pi = neighbours[i].Get<QPulseInfo>("DAQ","PulseInfo");
    const int ch_main = o_pi.GetChannelId();
    const QOFData& o_ofData = neighbours[i].Get<QOFData>("COF","OFData");
    
    const QHeader& headerMain = neighbours[i].Get<QHeader>("DAQ","Header");
    QRunDataHandle rHandleMain(headerMain.GetRun());
    GlobalData().Get("DAQ",&rHandleMain,"");
    const QRunData& MrunData = rHandleMain.Get();
 
    double samplFreq = MrunData.GetChannelRunData(ch_main).fSamplingFrequency;
    double ADC2mV = MrunData.GetChannelRunData(ch_main).fADC2mV;
 
    //    double selFreq;
    //   if(samplFreq > LsamplFreq) selFreq = LsamplFreq;
    //    else selFreq = samplFreq;
 
    // get OF resolution for the side channel from global quantity COFData
 
    QCOFParametersHandle cofHandle;
    QCOFData cofData;
    
    cofHandle.SetDataset(fDataset);
    cofHandle.SetChannel(ch_side);
 
    GlobalData().Get(fSamplesOwner,&cofHandle,"");
    
    if(!cofHandle.IsValid()) {
        Error("Channel %d, has no COFData global quantity: %s",ch_side,cofHandle.GetError().GetDescription().c_str());
        return;      
    }
    else {
      cofData = cofHandle.Get();        
    }
 
    double resomV = cofData.fResolutionmV;
 
    // get jitter for side and main channel
    QJitterHandle jHandleS(ch_side,fDataset);
    QJitter Sjitters;
 
    QJitterHandle jHandleM(ch_main,fDataset);
    QJitter Mjitters;
    
    GlobalData().Get("JitterByCoincidence",&jHandleS,InputFilename);
    GlobalData().Get("JitterByCoincidence",&jHandleM,InputFilename);
    
    if(!jHandleS.IsValid()) {
      if(!fBlackList.count(ch_side)) {
        fBlackList.insert(ch_side);   
        Error("Channel %d, has no jitter. Cannot be synced: %s",ch_side,jHandleS.GetError().GetDescription().c_str());
      }
      return;      
    }
    else if(!jHandleM.IsValid()) {
      if(!fBlackList.count(ch_main)) {
        fBlackList.insert(ch_main);   
        Error("Channel %d, has no jitter. Cannot be synced: %s",ch_main,jHandleM.GetError().GetDescription().c_str());
      }
      return;      
    }
    else {
      Sjitters = jHandleS.Get();        
      Mjitters = jHandleM.Get();        
    }
    // calculates jitter between two channels as jitterMain - jitterSide where jitterMain (Side) is the jitter of chMain (Side) from refCh    
 
    double jitter = Mjitters.fJitter - Sjitters.fJitter;
 
    //    double MainPos = (o_ofData.GetDelay()/1000.)*samplFreq;
    //    int IntMainPos = (int) MainPos;
 
    double NewPos = (o_ofData.GetDelay()/1000.+jitter)*samplFreq;
    int IntNewPos = lround( NewPos );
 
    if(IntNewPos >= 0 && IntNewPos < (int)OFSamplesSide.Size()){
      double sideampl = OFSamplesSide[IntNewPos]*ADC2mV;
      double nsig = ( sideampl )/resomV;
      ev.Get<QDouble>("Amplitude") = sideampl; 
      ev.Get<QDouble>("NSigma") = nsig;
      ev.Get<QInt>("MaximumPosition") = IntNewPos;
    }
  } 
}
 
void MSideAmplitude::Done()
{
 
}