MTestNeighbours.cc

Go to the documentation of this file.

#include "MTestNeighbours.hh"
#include "QEvent.hh"
#include "QEventList.hh"
#include "QRawEvent.hh"
#include "QBool.hh"
#include <sstream>
#include <cmath>
 
using namespace Diana;
 
std::map<unsigned int, std::vector<int> > MTestNeighbours::fNeighMap;
 
REGISTER_MODULE(MTestNeighbours)
 
using std::stringstream;
#define ASSERT_EQUAL(x,y)\
if(x==y) fTestOK++;\
else {\
fTestKO++;\
stringstream difference;\
difference<<x<<" vs "<<y;\
Error("Test failed: file %s; line %d: %s", __FILE__ , __LINE__,difference.str().c_str());\
}
 
 
 
void MTestNeighbours::Init(QEvent& ev)
{
    // called before event loop
 
    if(GetIteration() == 1) {
        fTestOK=0ULL;
        fTestKO=0ULL;
    }
 
    if(GetSequence().GetName() == "TestNeigh") {
        ev.Add<QBool>("UpdateNeighbour");
 
    } else if (GetSequence().GetName() == "TestNeighFilter" && GetOccurrence() == 1){
        if(GetIteration() == 1) {
            bool present = true;
            try {
                ev.RequireByLabel<QBool>("TestNeighbours@VariableIsPresent");
            } catch (...) {
                present = false;
            }
            ASSERT_EQUAL(present,false);
            ev.Add<QBool>("VariableIsPresent");
            SetRunAgain(true);
        } else {
            ev.RequireByLabel<QBool>("TestNeighbours@VariableIsPresent");
            ASSERT_EQUAL(1,1);
        }
    }
    fTime = 0ULL;
    fPrevTime = 0ULL;
    ev.Require<QPulseInfo>("DAQ","PulseInfo");
 
 
}
 
void MTestNeighbours::Do(QEvent& ev, const QEventList& neighbours)
{
    if(GetSequence().GetName() == "TestNeighFilter") {
        static int passed = 0;
        if(GetOccurrence() == 0) {
            passed = 0;
            for(size_t i = 0 ;  i < neighbours.Size(); i++) {
                const QEvent& other = neighbours[i];
                const QPulseInfo& pInfo = other.Get<QPulseInfo>("","PulseInfo");
                bool IsNoise = pInfo.GetIsNoise();
                if(IsNoise) passed++;
            }
            return;
        }  
        int newPassed = 0;
        for(size_t i = 0 ;  i < neighbours.Size(); i++) {
            newPassed++;
            const QEvent& other = neighbours[i];
            const QPulseInfo& pInfo = other.Get<QPulseInfo>("DAQ","PulseInfo");
            bool IsNoise = pInfo.GetIsNoise();
            ASSERT_EQUAL(IsNoise,true);
 
        }
        ASSERT_EQUAL(passed,newPassed);
 
        // Check that objects are disabled
        ReadHandle<QPulse> readHandle("Pulse");
        ev.Get("DAQ",readHandle);
        return;
    }
    // called event by event
    const QHeader& header = ev.Get<QHeader>("DAQ","Header");
    const int eventnumber = ev.GetReadNumber();
    const unsigned long long time = header.GetTime().GetFromStartRunNs();
    const int hevnum = header.GetEventNumber();
    if(GetIteration() == 2) {
        fEventMap[eventnumber].fEventNumber = hevnum;
        fEventMap[eventnumber].fTime = time;
        return; 
    } else if(GetSequence().GetName() == "TimeSort") {
        return;
    } else if(GetSequence().GetName() == "TestNeigh") {
        std::vector<int> thNeigh = fNeighMap[hevnum];
        ASSERT_EQUAL(thNeigh.size(),neighbours.Size());
        std::vector<int> neigh;
        for(size_t n = 0; n < neighbours.Size(); n++) {
            const QEvent& other = neighbours[n];
            const QHeader& o_header = other.Get<QHeader>("DAQ","Header");
            neigh.push_back(o_header.GetEventNumber());
        }
        std::sort(thNeigh.begin(),thNeigh.end());
        std::sort(neigh.begin(),neigh.end());
        ASSERT_EQUAL(thNeigh.size(),neigh.size());
        for(size_t n = 0; n < neigh.size() && n<thNeigh.size(); n++) {
            ASSERT_EQUAL(neigh[n],thNeigh[n]);
        }
    }
 
    ev.Get<QBool>("UpdateNeighbour") = true;
 
    if(fTime != 0ULL) {
        ASSERT_EQUAL(time,fTime);
    }
    for(size_t i = 0 ;  i < neighbours.Size(); i++) {
        const QEvent& other = neighbours[i];
        const QHeader& o_header = other.Get<QHeader>("DAQ","Header");
        const unsigned long long o_time = o_header.GetTime().GetFromStartRunNs();
        const int o_eventnumber = other.GetReadNumber();
        ReadHandle<QBool> un("UpdateNeighbour");
        other.Get<QBool>(GetName().c_str(),un);
        double diff;
        if(o_eventnumber < eventnumber) {
            ASSERT_EQUAL(un.IsValid(),true);
            ASSERT_EQUAL((o_time <= time),true);
            diff = time - o_time;
            fTime = 0ULL;
            if(o_eventnumber == (eventnumber - 1)) {
                ASSERT_EQUAL(o_time,fPrevTime);
            }
        } else if(o_eventnumber > eventnumber) {
            if(o_eventnumber == (eventnumber + 1)) {
                fTime = o_time;
            }
            ASSERT_EQUAL(un.IsValid(),false);
            ASSERT_EQUAL((o_time >= time),true);
            diff = o_time - time;
        } else {
            diff = 0;
            ASSERT_EQUAL(0,1);
        }
        diff /= -1.e09;
 
        ASSERT_EQUAL((fabs(diff) < 1.000),true);
    }
 
    fPrevTime = time;
}
 
void MTestNeighbours::Done()
{
 
   if(GetIteration() == 2 && GetSequence().GetName() == "TestNeighFilter" && GetOccurrence() == 1) {
       Info("----TEST SUMMARY-----");
       Info("OK: %d", fTestOK);
       if(fTestKO >0 )    Error("KO: %d", fTestKO);
       if(fTestOK != 18689*2) Panic("Expected test %d vs %d",18689*2,fTestOK);
   } 
 
   if(GetIteration() == 2) {
       std::map<unsigned int, EventInfo>::const_iterator iter = fEventMap.begin();
       while(iter != fEventMap.end()) {
           const double thisTime = iter->second.fTime;
            const unsigned int thisEventNumber = iter->second.fEventNumber;
 
            std::map<unsigned int, EventInfo>::const_iterator oiter = fEventMap.begin();
            fNeighMap[thisEventNumber].clear();
            while(oiter != fEventMap.end()) {
                const double otherTime = oiter->second.fTime;
                const unsigned int otherEventNumber = oiter->second.fEventNumber;
                if(fabs(thisTime-otherTime)/1.e09 < 1.000 && thisEventNumber != otherEventNumber) {
                    fNeighMap[thisEventNumber].push_back(otherEventNumber);
                }
                oiter++;
            }
            iter++;
 
        }
        return;
    } else if(GetSequence().GetName() == "TestNeigh"  && GetOccurrence() == 0) {
        Info("----TEST SUMMARY-----");
        Info("OK: %d", fTestOK);
        if(fTestKO > 0 ) Error("KO: %d", fTestKO);
        if(fTestOK != 142632) Panic("Expected test %d vs %d",142632,fTestOK);
    } else if( GetSequence().GetName() == "TestNeighFilter" && GetOccurrence() == 1) {
        Info("----TEST SUMMARY-----");
        Info("OK: %d", fTestOK);
        if(fTestKO > 0 ) Error("KO: %d", fTestKO);
        if(fTestOK != 18689) Panic("Expected test %d vs %d",18689,fTestOK);
    }
    // called at the end of the event loop
}