MTwoVariablesEnergyFilter.cc

Go to the documentation of this file.

#include "MTwoVariablesEnergyFilter.hh"
#include "QEvent.hh"
#include "QEventList.hh"
#include "QRunData.hh"
#include "QBaseType.hh"
#include "QString.hh"
#include "QPulseInfo.hh"
#include "QHeader.hh"
#include "QInterval.hh"
#include "QRunDataHandle.hh"
#include "QEnergyRangesHandle.hh"
#include "QFrameWorkConfig.hh"
#include <map>
#include <set>
#include <string>
 
using std::map;
using std::set;
using std::string;
 
using namespace Diana;
 
REGISTER_MODULE(MTwoVariablesEnergyFilter)
 
void MTwoVariablesEnergyFilter::GetCuts(const QEvent& ev)
{
 
  // define Energy ranges input (file ore DB, for the moment only file work)        
  fEnergyRangesInput = GetString("EnergyRangesInput", "EnergyRanges.txt");
  fChiSquareRangesInput = GetString("ChiSquareRangesInput", "ChiSquareRanges.txt");
 
  QEnergyRangesHandle eHandle;
  QEnergyRangesHandle csHandle;
  fEnergyRangesName = GetString("EnergyRangesName",eHandle.GetName(),false);
  fChiSquareRangesName = GetString("ChiSquareRangesName",csHandle.GetName(),false);
 
  // define Energy label
  fEnergyLabel = GetString("EnergyLabel","ApplyCalibration@Energy");
  fChiSquareLabel = GetString("ChiSquareLabel","OTAnalysis@FitChiSquare");
 
  // max energy for flat ChiSquare cut
  fChiSquareCutMaxEnergy = GetDouble("ChiSquareCutMaxEnergy",1100);
 
  ev.RequireByLabel<QDouble>(fEnergyLabel);
  ev.RequireByLabel<QDouble>(fChiSquareLabel);
  ev.Require<QPulseInfo>("DAQ","PulseInfo");
  ev.Require<QHeader>("DAQ","Header");
  fBlackList.clear();  
  fChannelList.clear();  
 
}
 
//bool MTwoVariablesEnergyFilter::Filter(const QEvent& ev, const QEventList& neighbours)
bool MTwoVariablesEnergyFilter::Filter(const QEvent& ev)
{
 
  // perform selection: true if the event passes the cuts
  const QPulseInfo& pi = ev.Get<QPulseInfo>("DAQ","PulseInfo");
  const QHeader& header = ev.Get<QHeader>("DAQ","Header");
  const int run = header.GetRun();
 
  if(run != fRunData.fNumber) {
    QRunDataHandle rHandle(run);
    GlobalData().Get<QRunData>("",&rHandle,"");
    fRunData = rHandle.Get();
 
    // get dataset
    GlobalHandle<QInt> dHandle("Dataset");
    GlobalData().Get("",&dHandle,"");
    fDataset = dHandle.Get();
  }
 
  // get channel of event
  const int& channel = pi.GetChannelId();
  fEnergyRange.Clear();
 
 
  // get energy ranges for that channel
  QEnergyRangesHandle eHandle(fEnergyRangesName);
  eHandle.SetChannel(channel);
  GlobalData().Get("User",&eHandle,fEnergyRangesInput);
  if(!eHandle.IsValid()) {
    eHandle.SetCalibVersion(GetConfig().fVersionTag);
    eHandle.SetDataset(fDataset);
    GlobalHandle<QString> clabelh("CalibrationLabel");
    clabelh.SetDataset(fDataset);
    clabelh.SetChannel(channel);
    GlobalData().Get(fEnergyLabel.owner,&clabelh,"CurrentReader");
    if(clabelh.IsValid()) {
      eHandle.SetCalibLabel(clabelh.Get());
    } else {
      eHandle.SetCalibLabel("");
    }
    GlobalData().Get("EnergyFilter",&eHandle,fEnergyRangesInput);
  }
 
  if(!eHandle.IsValid() && !fBlackList.count(channel))
    {
      fEnergyMin = GetDouble("EnergyMin",0);
      fEnergyMax = GetDouble("EnergyMax",100000);
      Info("Channel %d has no energy range: %s. Using [%f,%f]",channel,eHandle.GetError().GetDescription().c_str(),fEnergyMin,fEnergyMax);
      fBlackList.insert(channel);
    }
  if(eHandle.IsValid() && !fBlackList.count(channel)
     && eHandle.Get().GetMax() < eHandle.Get().GetMin()) {
 
    fEnergyMin = GetDouble("EnergyMin",0);
    fEnergyMax = GetDouble("EnergyMax",100000);
    Error("Channel %d has wrong energy range. fMin = %f; fMax = %f. Using [%f,%f]",channel,eHandle.Get().GetMin(),eHandle.Get().GetMax(),fEnergyMin,fEnergyMax);
    fBlackList.insert(channel);
  }
 
    // cfg defined range, to be applied to channels for which no energy range is defined in the file                                                                                                      
  if(fBlackList.count(channel)) {
    fEnergyRange.SetMax(fEnergyMax);
    fEnergyRange.SetMin(fEnergyMin);
  }
  else fEnergyRange = eHandle.Get();
 
 
  // get energy of the event 
  const double energy = ev.GetByLabel<QDouble>(fEnergyLabel);
 
 
  bool passed = false;
 
  // if energy is in the desired range check the ChiSquare
  if(fEnergyRange.Contains(energy)){
 
    // get ChiSquare ranges for that channel
    QEnergyRangesHandle csHandle(fChiSquareRangesName);
    csHandle.SetChannel(channel);
    GlobalData().Get("User",&csHandle,fChiSquareRangesInput);
    
    if(!csHandle.IsValid()) {
      //csHandle.SetCalibVersion(GetConfig().fVersionTag);
      csHandle.SetDataset(fDataset);
      GlobalHandle<QString> cslabelh("ChiSquareLabel");
      cslabelh.SetDataset(fDataset);
      cslabelh.SetChannel(channel);
      GlobalData().Get(fChiSquareLabel.owner,&cslabelh,"CurrentReader");
      if(cslabelh.IsValid()) {
        csHandle.SetCalibLabel(cslabelh.Get());
      } else {
        csHandle.SetCalibLabel("");
      }
      GlobalData().Get("EnergyFilter",&csHandle,fChiSquareRangesInput);
    }
    
 
    if(!csHandle.IsValid() && !fBlackList.count(channel))
      {
        fChiSquareMin = GetDouble("ChiSquareMin",0);
        fChiSquareMax = GetDouble("ChiSquareMax",3);
        Info("Channel %d has no ChiSquare range: %s. Using [%f,%f]",channel,csHandle.GetError().GetDescription().c_str(),fChiSquareMin,fChiSquareMax);
        fBlackList.insert(channel);
      }
    if(csHandle.IsValid() && !fBlackList.count(channel)
       && csHandle.Get().GetMax() < csHandle.Get().GetMin()) {
 
      fChiSquareMin = GetDouble("ChiSquareMin",0);
      fChiSquareMax = GetDouble("ChiSquareMax",3);
      Error("Channel %d has wrong ChiSquare range. fMin = %f; fMax = %f. Using [%f,%f]",channel,csHandle.Get().GetMin(),csHandle.Get().GetMax(),fChiSquareMin,fChiSquareMax);
      fBlackList.insert(channel);
    }
 
    // cfg defined range, to be applied to channels for which no ChiSquare range is defined in the file
    if(fBlackList.count(channel)) {
      fChiSquareRange.SetMax(fChiSquareMax);
      fChiSquareRange.SetMin(fChiSquareMin);
    }
    else fChiSquareRange = csHandle.Get();
 
 
    // get ChiSquare of the event
    const double ChiSquare = ev.GetByLabel<QDouble>(fChiSquareLabel);
 
 
    if((energy <= fChiSquareCutMaxEnergy  && fChiSquareRange.Contains(ChiSquare)) || energy > fChiSquareCutMaxEnergy) passed = true;
 
  }
 
  return passed;
 
 
}
/*
void MTwoVariablesEnergyFilter::Done(){
 
  return;
 
}
*/