MEnergyFilter.cc

Go to the documentation of this file.

#include "MEnergyFilter.hh"
#include "QEvent.hh"
#include "QRawEvent.hh"
#include "QRunData.hh"
#include "QBaseType.hh"
#include "QString.hh"
#include "QPulseInfo.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(MEnergyFilter)
 
    void MEnergyFilter::GetCuts(const Diana::QEvent& ev)
{
    // define Energy ranges input (file ore DB, for the moment only file work)
    fRangesInput = GetString("EnergyRangesInput", "EnergyRanges.txt");
 
    // define Energy ranges output (file ore DB, for the moment only file work)
    fRangesOutput = GetString("EnergyRangesOutput","" );
 
    QEnergyRangesHandle eHandle;
    fRangesName = GetString("EnergyRangesName",eHandle.GetName(),false);
    fRangesOwner = GetString("EnergyRangesOwner","User",false);
 
    // define Energy label
    fEnergyLabel = GetString("EnergyLabel","ApplyCalibration@Energy");
 
    ev.RequireByLabel<QDouble>(fEnergyLabel);
    ev.Require<QPulseInfo>("DAQ","PulseInfo");
    ev.Require<QHeader>("DAQ","Header");
    fBlackList.clear();
    fChannelList.clear();
    fHandles.clear();
}
 
 
bool MEnergyFilter::Filter(const Diana::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(fRangesName);
    eHandle.SetChannel(channel);
    GlobalData().Get(fRangesOwner,&eHandle,fRangesInput);
    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,fRangesInput);
    }
 
    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);
    }
 
    if(fBlackList.count(channel)) {
        // cfg defined range, to be applied to channels for which no energy range is defined in the file
        fEnergyRange.SetMax(fEnergyMax);
        fEnergyRange.SetMin(fEnergyMin);
    }
    else fEnergyRange = eHandle.Get();
 
    // if output is given dump the energy ranges on file or DB
    if(!fRangesOutput.empty() && !fChannelList.count(channel)) {
        QEnergyRangesHandle* eHandleDs = new QEnergyRangesHandle(fRangesName);
        eHandleDs->SetCalibVersion(GetConfig().fVersionTag);
        eHandleDs->SetChannel(channel);
        eHandleDs->SetDataset(fDataset);
        eHandleDs->Set(fEnergyRange);
 
 
        GlobalHandle<QString> clabelh("CalibrationLabel");
        clabelh.SetDataset(fDataset);
        clabelh.SetChannel(channel);
        GlobalData().Get(fEnergyLabel.owner,&clabelh,"CurrentReader");
        if(clabelh.IsValid()) {
            eHandleDs->SetCalibLabel(clabelh.Get());
        } else {
            eHandleDs->SetCalibLabel("");
        }
        fHandles.insert(eHandleDs);
        fChannelList.insert(channel);
    }
 
    // get energy of event
    const double energy = ev.GetByLabel<QDouble>(fEnergyLabel);
    bool passed = false;
    if (fEnergyRange.Contains(energy)) passed = true;
 
    return passed;
 
}
 
void MEnergyFilter::Done()
{
    if(fRangesOutput.empty()) return;
    std::set<QEnergyRangesHandle*>::iterator iter =  fHandles.begin();
    while(iter != fHandles.end()) {
        QEnergyRangesHandle* handle = *iter;
        // get amplitude version (new)
        QModuleConfig mconf;
        GlobalHandle<QFrameWorkConfig> fwcHandle("Config");
        GlobalData().Get("Diana",&fwcHandle,"");
        QError err = QERR_SUCCESS;
        if(!fwcHandle.IsValid()) {
            err = fwcHandle.GetError();
        } else if(!handle->GetCalibLabel().empty()){
            QEventLabel eLabel(handle->GetCalibLabel());
            err = fwcHandle.Get().GetModuleByLabel(eLabel.GetOwner(),mconf);
        }
        if(fRangesOutput =="DB" && err != QERR_SUCCESS) Error("%s",err.GetDescription().c_str());
 
        const std::string& versiontag = mconf.fVersionTag;
        handle->SetCalibVersion(versiontag);
 
        GlobalData().Set(handle,fRangesOutput);
        delete handle;
        iter++;
    }
}