MCOFBiComponent.cc

Go to the documentation of this file.

#include "MCOFBiComponent.hh"
#include "QEvent.hh"
#include "QEventList.hh"
#include "QRawEvent.hh"
#include "QBaseModule.hh"
#include "QSampleInfo.hh"
#include "QRunDataHandle.hh"
#include "QBaseType.hh"
#include "QBaselineData.hh"
#include "QTObjectHandle.hh"
#include "QAveragePulseHandle.hh"
#include "QAverageNoiseHandle.hh"
#include "QBiComponentOptimumFilter.hh"
 
REGISTER_MODULE(MCOFBiComponent)
 
using namespace Diana;
 
void MCOFBiComponent::Init(QEvent& ev)
{
  fAvgNoiseInput = GetString("AvgNoiseInput","");
  fAvgPulseInputHomeMade = GetString("AvgPulseInput","");
  
  fAvgPulseSlowOwner = GetString("AvgPulseSlowOwner","AveragePulses",true);
  fAvgPulseFastOwner = GetString("AvgPulseFastOwner","AveragePulses",true);
  fAvgNoiseOwner = GetString("AvgNoiseOwner","NoiseAvgPowerSpectrum",false);
  fMaxJitter = GetInt("MaxJitter",15);
 
  fDebugOn = GetBool("DebugOn",false,false);
  fInterpolationOn = GetBool("InterpolationOn",true,true);
  fUseDiff = GetBool("UseDiff",true,true);
  fTomV = GetBool("ConvertTomV",true,false);
  
  ev.Add<QDouble>("AmplitudeSlow");
  ev.Add<QDouble>("AmplitudeFast");
  ev.Add<QDouble>("Integral");
 
  ev.Add<QDouble>("ChiSquare");
  ev.Add<QDouble>("Jitter");
 
  if(fDebugOn){
    ev.Add<QVector>("FitFunction");
    ev.Add<QVector>("FilteredSlow");
    ev.Add<QVector>("FilteredFast");
  }
  fPulseLabel = GetString("PulseLabel","DAQ@Pulse",false);
  ev.RequireByLabel<QPulse>(fPulseLabel);
  ev.Require<QPulseInfo>("DAQ","PulseInfo");
  ev.Require<QHeader>("DAQ","Header");
 
}
 
//void MCOFBiComponent::Do(QEvent& ev, const QEventList& neighbours)
void MCOFBiComponent::Do(QEvent& ev)
{
     const QPulseInfo& pulseInfo = ev.Get<QPulseInfo>("DAQ","PulseInfo");
     const QHeader& header = ev.Get<QHeader>("DAQ","Header");
     const int chan = pulseInfo.GetChannelId();
 
     QRunDataHandle rHandle(header.GetRun());
     GlobalData().Get("",&rHandle,"");
 
     const QRunData& runData = rHandle.Get();
     const QChannelRunData& channelRunData = runData.GetChannelRunData(chan);
     double samplingFreq = channelRunData.fSamplingFrequency;
     double ADC2mV = 1;
     if(fTomV) ADC2mV = channelRunData.fADC2mV;
 
 
     if(fMap.find(chan) == fMap.end()) {
 
         GlobalHandle<QInt> dHandle("Dataset");
         GlobalData().Get("",&dHandle,"");
 
 
         fMap[chan].BlackSheep = false;
 
         QAverageNoiseHandle AVG_Noise_Handle(chan);
         AVG_Noise_Handle.SetDataset(dHandle.Get());
         GlobalData().Get(fAvgNoiseOwner,&AVG_Noise_Handle,fAvgNoiseInput);
         if(!AVG_Noise_Handle.IsValid()) {
             Warn("%s. Channel %d will not be processed",AVG_Noise_Handle.GetError().GetDescription().c_str(),chan);
             fMap[chan].BlackSheep = true;
         }
         QAveragePulseHandle AVG_Pulse_Slow_Handle(chan);
         AVG_Pulse_Slow_Handle.SetDataset(dHandle.Get());
         GlobalData().Get(fAvgPulseSlowOwner,&AVG_Pulse_Slow_Handle,fAvgPulseInputHomeMade);
         if(!fMap[chan].BlackSheep && !AVG_Pulse_Slow_Handle.IsValid()) {
             Warn("%s. Channel %d will not be processed",AVG_Pulse_Slow_Handle.GetError().GetDescription().c_str(),chan);
             fMap[chan].BlackSheep = true;
         }
         QAveragePulseHandle AVG_Pulse_Fast_Handle(chan);
         AVG_Pulse_Fast_Handle.SetDataset(dHandle.Get());
         GlobalData().Get(fAvgPulseFastOwner,&AVG_Pulse_Fast_Handle,fAvgPulseInputHomeMade);
         if(!fMap[chan].BlackSheep && !AVG_Pulse_Fast_Handle.IsValid()) {
             Warn("%s. Channel %d will not be processed",AVG_Pulse_Fast_Handle.GetError().GetDescription().c_str(),chan);
             fMap[chan].BlackSheep = true;
         }
         if(!fMap[chan].BlackSheep) {
 
             fMap[chan].ADC2Time = 1000./samplingFreq; //ms
 
             QVector avg_noise = AVG_Noise_Handle.Get();
             QVector avg_pulse_slow = AVG_Pulse_Slow_Handle.Get();
             QVector avg_pulse_fast = AVG_Pulse_Fast_Handle.Get();
 
             fMap[chan].of2 = new QBiComponentOptimumFilter(avg_pulse_fast, avg_pulse_slow, avg_noise, fMaxJitter, fUseDiff);
         }
     }
 
     if (fMap[chan].BlackSheep) return;
     const QPulse& rawPulse = ev.GetByLabel<QPulse>(fPulseLabel);
 
     const QVector& Samples = rawPulse.GetSamples();
     QError err = fMap[chan].of2->Filter(Samples);
     if(err!=QERR_SUCCESS) return;
 
     double a1, a2,integral, jitter;
 
     if(fInterpolationOn){
         err = fMap[chan].of2->GetInterpolated(jitter,a1,a2,integral);
         if(err!=QERR_SUCCESS) return;
     } else {
         jitter = fMap[chan].of2->GetJitterAtMinimum();
         fMap[chan].of2->GetAmplitude(a1,a2,integral);
 
     }  
     ev.Get<QDouble>("AmplitudeFast") = a1*ADC2mV;
     ev.Get<QDouble>("AmplitudeSlow") = a2*ADC2mV;
     ev.Get<QDouble>("Integral") = integral*ADC2mV/samplingFreq;
 
     ev.Get<QDouble>("ChiSquare") = fMap[chan].of2->GetChiSquareAtMinimium();
     ev.Get<QDouble>("Jitter") = jitter*fMap[chan].ADC2Time;
 
     if(fDebugOn){
         QVector AP1f, AP2f;
         fMap[chan].of2->GetFiltered(AP1f,AP2f);
         ev.Get<QVector>("FilteredSlow") = AP2f;
         ev.Get<QVector>("FilteredFast") = AP1f;
         ev.Get<QVector>("FitFunction") = fMap[chan].of2->GetFitFunction(jitter,a1,a2);
     }
}  
 
 
void MCOFBiComponent::Done()
{
    /* This method is called at the end of the event loop. 
     * Here you can:
     *
     * 1) Operate on the sequence execution parameters(see QBaseModule.hh).
     *
     * 2) Read/Write global data.
     */
}