QFilter.cc

Go to the documentation of this file.

#include "QFilter.hh"
#include "QEventAssembler.hh"
#include "QEventList.hh"
#include "QBool.hh"
 
Q_BEGIN_NAMESPACE
 
 
QFilter::QFilter() : QBaseModule(QBaseModule::Filter) 
{
}
 
 
void QFilter::Begin(QEventAssembler& eva)
{
    fTotEvents = 0LL;
    fSelEvents = 0LL;
    fSelNeighEvents = 0LL;
    fTotNeighEvents = 0LL;
 
 
    QEvent& ev = eva.GetEvent();
    GetCuts(ev);
 
    std::string logicFlag = GetString("Logic","CASE");
    if(logicFlag == "AND") {
        fLogicFlag = AND; 
    } else if(logicFlag == "OR") {
        fLogicFlag = OR; 
    } else if(logicFlag == "CASE") {
        fLogicFlag = CASE; 
    } else {
        Error("Unknown logic flag, resetting Logic to \"AND\"");
        fLogicFlag = AND; 
    }
 
    fFilterMainEvent = GetBool("FilterMainEvent",true,false);
    fFilterNeighbours = GetBool("FilterNeighbours",false,false);
    fNegate = GetBool("Negate",false,false);
    
    fSave = false;
    fWrite = false;
    if(fFilterMainEvent) {
        fSave = GetBool("Save",true,false);
    } 
    if(fSave) {
        fWrite = GetBool("WriteResult",true,false);
        ev.Add<QBool>("Passed").SetWrite(fWrite);
        std::string alias = GetString("Alias","",false);
        if(alias != "") {
            Debug("Setting alias: Filter_%s",alias.c_str());
            alias = std::string("Filter_") + alias;
            ev.SetAlias("Passed","fValue",alias);
        }
    }
 
    fFirstCall = true;
    SetNeedNeighbours(true); 
    fSkipRequiredNotValid = GetBool("SkipRequiredNotValid",false,false);
    if(fSkipRequiredNotValid) {
        Info("Skipping events with non valid but required objects");
    }
 
}
 
bool QFilter::Process(QEventAssembler& eva, QEventList& neigh, const bool exec, QEventList& oneigh)
{
    // MV FIXME: se si filtrano i neighbours non possono essere recuperati, forse ho fixato
    QEvent& ev = eva.GetEvent();
    QBool thisPassed = false;
    if(!fFilterMainEvent) {
        // we return the result of previous filters
        thisPassed = exec;
        if(!thisPassed) return thisPassed;
    } else {
        fTotEvents++;
        // the neighbours are those filtered by previous filters
        thisPassed = FilterAlgorithm(ev,oneigh,exec);
        if(thisPassed) fSelEvents++;
        if(fSave) {
            WriteHandle<QBool> passedHandle("Passed");
            ev.Get(passedHandle);
            passedHandle.Get() = thisPassed;
        }
    }
    if(thisPassed && fFilterNeighbours) {
        // remove filtered events from the oneigh list
 
        QEventList nneigh,emptyneigh;
        for(int i = 0; i < (int)neigh.Size(); i++) {
            bool oexec = false;
            for(int  j = 0; j < (int)oneigh.Size(); j++) 
                if(&oneigh[j] == &neigh[i]) oexec = true;
            if(FilterAlgorithm(neigh[i],emptyneigh,oexec)) 
                nneigh.Push(&neigh[i]);
        }
        oneigh = nneigh;
        fSelNeighEvents += oneigh.Size();
        fTotNeighEvents += neigh.Size();
    }
 
    return thisPassed;
 
}
 
bool QFilter::FilterAlgorithm(const QEvent& ev, QEventList& neigh, const bool exec)
{
    bool thisPassed = false;
 
    bool globalPassed = exec;
    if(fLogicFlag != AND || globalPassed) {
        bool requiredAreValid = true;
        if(fSkipRequiredNotValid) {
            const std::vector<QEventLabel>& labels = GetRequiredLabels();
            for(size_t  l = 0; l < labels.size(); l++) {
                const char* owner = labels[l].owner.c_str();
                const char* name = labels[l].name.c_str();
                ReadHandle<QObject> rHandle(name);
                ev.Get(owner,rHandle);
                if(!rHandle.IsValid()&& labels[l].owner != fLabel){
                    requiredAreValid = false;
                    l = labels.size();
                }
            }
        }
        if(requiredAreValid) {
            thisPassed = fNegate^Filter(ev,neigh); // xor the filter result with negation
            fExecuted = true;
        }
    }
    // the result of this filter is the combingation of previous filters
    if(fLogicFlag == AND) thisPassed = globalPassed && thisPassed;
    else if(fLogicFlag == OR) thisPassed = globalPassed || thisPassed;
 
    return thisPassed;
}
 
void QFilter::End()
{
 
    Done();
    if(fFilterMainEvent) {
        if(fSelEvents == 0LL) Error("Selected %llu events over %llu", fSelEvents, fTotEvents);
        else Info("Selected %llu events over %llu", fSelEvents, fTotEvents);
    }
    if(fFilterNeighbours) {
        if(fSelNeighEvents == 0LL) Error("Selected %llu neighbours over %llu", fSelNeighEvents, fTotNeighEvents);
        else Info("Selected %llu neighbours over %llu", fSelNeighEvents, fTotNeighEvents);
    }
}
 
bool QFilter::Filter(const QEvent& ev)
{
    Panic("Missing method: \"bool Filter(const QEvent& ev)\" or  \"bool Filter(const QEvent& ev, const QEventList& neigh)\" not implemented");
    return false;
}
 
bool QFilter::Filter(const QEvent& ev, const QEventList& neigh)
{
    // this filter probably implements the method without neighbours
    if(fFirstCall) {
        SetNeedNeighbours(false); 
        fFirstCall = false;
    }
    return Filter(ev);
}
 
 
Q_END_NAMESPACE