MTestModule.cc

Go to the documentation of this file.

#include "MTestModule.hh"
#include "QEvent.hh"
#include "QRawEvent.hh"
#include "QBool.hh"
#include "QError.hh"
#include <iostream>
#include <sstream>
#include <math.h>
#include "QString.hh"
#include "QBaselineData.hh"
#include "QBaseType.hh"
// MV FIXME
//#include "QGuiSession.hh"
#include "QObjectInspector.hh"
 
using namespace Diana;
REGISTER_MODULE(MTestModule)
 
using std::stringstream;
 
Diana::QSequence* MTestModule::fFirstSequence = NULL;
Diana::QSequence* MTestModule::fCurrentSequence = NULL;
int MTestModule::fMyOccurrence = -1;
 
#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());\
}
 
// ctor
MTestModule::MTestModule()
{
/*
    if(fFirstSequence == NULL) fFirstSequence = s;
    if(fFirstSequence == s) fIsFirstSequence = true;
    else fIsFirstSequence = false;
 
    if(fCurrentSequence != s ) {
        fCurrentSequence = s;
        fMyOccurrence = 0;
    }
    else {
        fMyOccurrence++;
    }
    */
    fTestOK=0;
    fTestKO=0;
}
 
// dtor
MTestModule::~MTestModule() 
{
    if(!isEnabled()) return;
    Info("----TEST SUMMARY-----");
    Info("OK: %d", fTestOK);
    if(fTestKO >0)    Error("KO: %d", fTestKO);
 
    if(GetSequence().GetName() == "Test") 
        if(fTestOK !=250137 ) Panic("Expected test %d vs %d",250137,fTestOK);
    if(GetSequence().GetName() == "TestBis") { 
        if(GetOccurrence() == 0  && fTestOK != 7758 ) Panic("Expected test %d vs %d",7758,fTestOK);
        if(GetOccurrence() == 1 && fTestOK != 7619 ) Panic("Expected test %d vs %d",7619,fTestOK);
    }
}
 
// Init method is called before event loop
void MTestModule::Init(QEvent& ev) {
    Info("Init");
 
    if(GetSequence().GetName() == "Test") {
        fMyOccurrence++;
        fIsFirstSequence = true;
    } else {
        fMyOccurrence++;
        fIsFirstSequence = false;
    }
 
    ASSERT_EQUAL(fMyOccurrence,(int)GetOccurrence());
    fIter = GetInt("Iterations",1);
    fWriteEvtNum   = GetBool("WriteEvtNum",false);
    fTestGlobal    = GetBool("TestGlobalQuantities",false);
    fTestEvent     = GetBool("TestEventQuantities",false);
    fTestDefaults   = GetBool("TestRunDataLoader",false);
    testConfigFile = GetBool("TestConfigFile", false);
    fOutputDir = GetString("OutputDir","NODEFAULT");
 
    // test config file
    if(testConfigFile) {
        std::string testStr = GetString("TestString","DianaFramework");
        int testInt = GetInt("TestInt",3);
        double testDouble = GetDouble("TestDouble",3.);
        bool testBool = GetBool("TestBool",true);
        std::vector<int> defaultVectorInt;
        defaultVectorInt.push_back(18);
        defaultVectorInt.push_back(22);
        if(GetOccurrence()==0) {
            std::vector<int> testVectorInt = GetVectorInt("TestVectorInt",defaultVectorInt);
            ASSERT_EQUAL(testStr,"Apollo");
            ASSERT_EQUAL(testInt,5);
            ASSERT_EQUAL(testDouble,66.73);
            ASSERT_EQUAL(testBool,false);
            ASSERT_EQUAL(GetVerbosity(),InfoMsg);
            ASSERT_EQUAL(testVectorInt.size(),3);
            ASSERT_EQUAL(testVectorInt[0],15);
            ASSERT_EQUAL(testVectorInt[1],23);
            ASSERT_EQUAL(testVectorInt[2],147);
        } else {
            std::vector<int> testVectorInt = GetVectorInt("TestVectorInt",defaultVectorInt,false);
            ASSERT_EQUAL(testStr,"60Co");
            ASSERT_EQUAL(testInt,24);
            ASSERT_EQUAL(testDouble,123.45);
            ASSERT_EQUAL(testBool,true);
            ASSERT_EQUAL(GetVerbosity(),DebugMsg);
            ASSERT_EQUAL(testVectorInt.size(),2);
            ASSERT_EQUAL(testVectorInt[0],18);
            ASSERT_EQUAL(testVectorInt[1],22);
        }
    }
 
 
    /*
    if(fTestJump) {
        QError err = JumpToEvent(3);
        if(err != QERR_SUCCESS) Error("Jumping error: %s", err.ToString().c_str());
    }
    */
 
    fGlobalQVector.Resize(20);    
    fGlobalQVectorC.Resize(20);
    // MV FIXME does not work with multiple files
    //    fEventHisto = new TH1D("MyEventHisto","MyEventHisto",10,0,10);
    //   fGlobalHisto = new TH1D("MyGlobalHisto","Global test histo",10,0,10);
 
    if(GetSequence().GetName() == "Test") {
        ev.Add<QInt>("TestInt");
        ev.Add<QInt>("TestInt2");
        ev.Add<QFloat>("TestFloat");
        ev.Add<QBool>("TestBool");
        ev.Add<QDouble>("TestDouble");
        ev.Add<QString>("TestString");
        ev.Add<QVector>("TestVector");
        ev.Add<QVectorC>("TestVectorC");
        ev.Add<QMatrix>("TestMatrix");
        ev.Add<QMatrixC>("TestMatrixC");
        ev.Add<QInt>("NotWrittenInt").SetWrite(false);
    }
    //ev.AuxData().SetTObject("TestHisto",fEventHisto,"save");
 
}
 
// Doit method is called for each event, getting the event as argument
void MTestModule::Do( QEvent& ev) 
{
 
    const QHeader& header = ev.Get<QHeader>("DAQ","Header");
    QEventLabel hlab("DAQ@Header");
    const QHeader& header2 = ev.GetByLabel<QHeader>(hlab);
    header2.IsValid();
    ev.Get<QHeader>("","Header");
    QInt a = 3;
    QPulse b;
    QObjectInspector insp;
    insp.FindBaseType(&b,"");
 
 
    int eventnum = header.GetEventNumber();
    int readnum = ev.GetReadNumber();
    if(fWriteEvtNum) Info("ReadNumber is %d, EventNumber is %d, Passed %s", 
            readnum, eventnum, 
            //ev.GetFilters().GetPassed() ? "YES" : "NO" );
        "YES");
 
    QError err;
    /*
    if(fTestJump) {
        if(readnum < 5) {
            ReadHandle<QBool> pHandle("Passed");
            ev.Get("FilterTest",pHandle);
            if(pHandle.IsValid()) {
                ASSERT_EQUAL(4,readnum);
            } else {
                ASSERT_EQUAL(3,readnum);
            }
            err= JumpToEvent(5);
        }
        if(err != QERR_SUCCESS) 
            Error("Jumping error: %s, %s", 
                    err.ToString().c_str(), err.GetDescription().c_str());
    }
    */
 
    // initialize vector 
    fEventVector.Resize(eventnum%100+1);
    for(size_t i = 0; i< fEventVector.Size(); i++) {
        fEventVector[i] = (double)i;
    }
        fEventVectorC.SetArray((fEventVector*3.).GetConstArray(),
                (fEventVector*4.).GetConstArray(), fEventVector.Size());
 
        //initialize matrix
        fEventMatrix.Resize(fEventVector.Size(),fEventVector.Size());
        for(size_t i = 0; i< fEventVector.Size(); i++) {
            fEventMatrix.SetCol(i,fEventVector*i);
        }
 
        fEventMatrixC.Resize(fEventVectorC.Size(),fEventVectorC.Size());
        for(size_t i = 0; i< fEventVectorC.Size(); i++) {
            fEventMatrixC.SetCol(i,fEventVectorC*i);
        }
 
   // for(size_t i = 1; i<=10; i++)
   //     fEventHisto->SetBinContent(i,i*eventnum*3);
 
 
//    ev.Get<QBool>("TestRawEvent","TestBoolAddition");
    if(GetSequence().GetName() == "TestBis") {
        ReadHandle<QInt> r1("NotWrittenInt");
        ReadHandle<QInt> r2("TestInt");
        WriteHandle<QInt> r3("NotWrittenInt");
        ev.Get<QInt>("TestModule",r1);
        ev.Get<QInt>("TestModule",r2);
        ev.Get<QInt>(r3);
        ASSERT_EQUAL(r1.IsValid(),false);
        ASSERT_EQUAL(r2.IsValid(),true);
        ASSERT_EQUAL(r3.IsValid(),false);
 
        ASSERT_EQUAL(ev.Get<QInt>("TestModule","TestInt"),eventnum);
        
 
        TestQEvent(ev);
    } 
    // Test aux data
    if(fIsFirstSequence && fTestGlobal) {
        if(readnum == 501) {
            GlobalData().Set("Int1",QInt(1),"CurrentWriter");
        }
    
        if(readnum == 1001) {
            GlobalData().Set("Int2",QInt(2),"CurrentWriter");
        }
        if(readnum == 1501) {
            GlobalData().Set("Int3",QInt(3),"CurrentWriter");
        }
    }
    if(!fIsFirstSequence && fTestGlobal) {
        if(readnum == 501) {
            int a = GlobalData().Get<QInt>("Int1","CurrentReader");
            ASSERT_EQUAL(a,1);
        }
    
        if(readnum == 1001) {
            int a = GlobalData().Get<QInt>("Int2","CurrentReader");
            ASSERT_EQUAL(a,2);
        }
        if(readnum == 1501) {
            int a = GlobalData().Get<QInt>("Int3","CurrentReader");
            ASSERT_EQUAL(a,3);
        }
    }
 
    if(fTestEvent){
        if(GetIteration() == 1) {
            ReadHandle<QInt> r1("NotWrittenInt");
            ReadHandle<QInt> r2("TestInt");
            ev.Get<QInt>("TestModule",r1);
            ev.Get<QInt>("TestModule",r2);
            ASSERT_EQUAL(r1.IsValid(),false);
            ASSERT_EQUAL(r2.IsValid(),false);
            ev.Get<QInt>("TestInt")=eventnum;
            ev.Get<QInt>("TestInt2")=eventnum*2;
            ev.Get<QFloat>("TestFloat")=eventnum*2.;
            ev.Get<QBool>("TestBool")=false;
            ev.Get<QDouble>("TestDouble")=pow(1.00001,eventnum);
            ev.Get<QString>("TestString")="DianaFramework";
            ev.Get<QVector>("TestVector")=fEventVector;
            ev.Get<QVectorC>("TestVectorC")=fEventVectorC;
            ev.Get<QMatrix>("TestMatrix")= fEventMatrix;
            ev.Get<QMatrixC>("TestMatrixC")= fEventMatrixC;
            //ev.AuxData().SetTObject("TestHisto",fEventHisto,"save");
        } else {
            //ev.Get<QInt>("TestModule","TestCrash");
            const QEvent& evr = ev;
            ASSERT_EQUAL(evr.Get<QInt>("TestModule","TestInt"),eventnum);
            ASSERT_EQUAL(evr.Get<QInt>("TestModule","TestInt2"),eventnum*2);
            ASSERT_EQUAL((float)evr.Get<QFloat>("TestModule","TestFloat"),eventnum*2.);
            ASSERT_EQUAL(evr.Get<QBool>("TestModule","TestBool"),false);
            ASSERT_EQUAL(evr.Get<QDouble>("TestModule","TestDouble"),pow(1.00001,eventnum));
            ASSERT_EQUAL(ev.Get<QString>("TestString"), "DianaFramework");
            ReadHandle<QVector> rhandle("TestVector");
            ev.Get("TestModule",rhandle);
            const QVector & testVector = rhandle.Get();
            const QVectorC & testVectorC = evr.Get<QVectorC>("TestModule","TestVectorC");
 
            ASSERT_EQUAL(ev.Get<QMatrix>("TestMatrix").GetNCol(),fEventMatrix.GetNCol());           
            ASSERT_EQUAL(ev.Get<QMatrix>("TestMatrix").GetNRow(),fEventMatrix.GetNRow());
 
            //      std::cout<<"==============================testVectorC.Size()"<<testVectorC.Size()<<std::endl;
            //      std::cout<<"==============================fEventVector.Size()"<<fEventVector.Size()<<std::endl;
            //      std::cout<<"==============================fRe: "<<testVectorC.Re().Size()<<std::endl;
            for(size_t i = 0; i< fEventVector.Size(); i++) {
                ASSERT_EQUAL(testVector[i],(double)i);
                
                ASSERT_EQUAL(testVectorC.Re()[i],testVector[i]*3.);    //qui sbrocca
                ASSERT_EQUAL(testVectorC.Im()[i],testVector[i]*4.);
            }
           // const TH1D* testHisto = (TH1D*) ev.AuxData().GetTObject("TestHisto");
        //    for(size_t i = 1; i <= 10; i++) 
         //       ASSERT_EQUAL(testHisto->GetBinContent(i),fEventHisto->GetBinContent(i));
        }
    }
    if(readnum == 2000 && !fIsFirstSequence && fTestGlobal) {
        ASSERT_EQUAL(true, GlobalData().Get<QBool>("MyGlobalBool",Q_CURRENT_READER));
        const QVector& fileVec2pp =GlobalData().Get<QVector>("MyGlobalVector2",Q_CURRENT_READER);
            const QVector& fileVec2 = fileVec2pp;
            ASSERT_EQUAL(fileVec2.Size(),20);
            for(int i = 0; i < 20; i++) ASSERT_EQUAL(fileVec2[i],  i * 3.);
    }
 
    ReadHandle<QBaselineData> preHandle("BaselineData");
    ev.Get("BaselineModule",preHandle);
    if(fIsFirstSequence && GetIteration() == 1) {
        ASSERT_EQUAL(preHandle.IsValid(),false);
    } else {
        ASSERT_EQUAL(preHandle.IsValid(),true);
    }
    
}
 
// Done method is called after event loop
void MTestModule::Done() 
{
    if(fIsFirstSequence && fTestGlobal) {
        if(GetIteration() == 1) {
            // save objects in files
            for(int i = 0; i < 20; i++)
              {
                fGlobalQVector[i] = i * 3.;
                fGlobalQVectorC[i]=QComplex(i*3.,i*3.);
              }
            //for(int i = 1; i <= 10; i++) fGlobalHisto->SetBinContent(i,  i * 3.);
            fGlobalQMatrix.Resize(3,20);
            fGlobalQMatrix.SetRow(0,fGlobalQVector);
            fGlobalQMatrix.SetRow(1,fGlobalQVector*2);
            fGlobalQMatrix.SetRow(2,fGlobalQVector*3);
            fGlobalQMatrixC.Resize(3,20);
            fGlobalQMatrixC.SetRow(0,fGlobalQVectorC);
            fGlobalQMatrixC.SetRow(1,fGlobalQVectorC*2);
            fGlobalQMatrixC.SetRow(2,fGlobalQVectorC*3);
            GlobalData().Set("MyGlobalIntMemory", QInt(3),"");
            GlobalData().Set("MyGlobalDouble", QDouble(3.14) ,fOutputDir +"/testglobal.root");
           // GlobalData().SetDouble("MyGlobalDouble", 3.14,"testglobal");
            GlobalData().Set("MyGlobalString", QString("Hi, this is Marco"),fOutputDir +"/testglobal.root");
            GlobalData().Set("MyGlobalFloat", QDouble(6.28),fOutputDir +"/testglobal.root");
            GlobalData().Set("MyGlobalInt", QInt(1234),fOutputDir +"/testglobal.root");
            GlobalData().Set("MyGlobalIntTxt", QInt(1234),fOutputDir +"/testglobal.txt");
            GlobalData().Set("MyGlobalBool", QBool(true),fOutputDir +"/testglobal.root");
            GlobalData().Set("MyGlobalBoolTxt", QBool(true),fOutputDir +"/testglobal.txt");
            GlobalData().Set("MyGlobalBool2", QBool(false),fOutputDir +"/testglobal.root");
            GlobalData().Set("MyGlobalVector", fGlobalQVector,fOutputDir +"/testglobal.root");
            GlobalData().Set("MyGlobalVector2", fGlobalQVector,fOutputDir +"/testglobal2.root");
            GlobalData().Set("MyGlobalVector2Txt", fGlobalQVector,fOutputDir +"/testglobal2.txt");
            GlobalData().Set("MyGlobalMatrixTxt", fGlobalQMatrix,fOutputDir +"/testglobal3.txt");
            GlobalData().Set("MyGlobalVectorC", fGlobalQVectorC,fOutputDir +"/testglobal.root");
            GlobalData().Set("MyGlobalVectorC2", fGlobalQVectorC,fOutputDir +"/testglobal2.root");
            GlobalData().Set("MyGlobalVectorC2Txt", fGlobalQVectorC,fOutputDir +"/testglobal2.txt");
            //GlobalData().Set("MyGlobalMatrixCTxt", fGlobalQMatrixC,fOutputDir +"/testglobal3.txt");
            //GlobalData().SetTObject("MyGlobalHisto",fGlobalHisto, "testglobal.root");
        } else {
            // check object saved in sequence memory
            ASSERT_EQUAL(3,GlobalData().Get<QInt>("MyGlobalIntMemory",""));
            // Write to the event output file.
            GlobalData().Set("MyGlobalVector2", fGlobalQVector,Q_CURRENT_WRITER);
            GlobalData().Set("MyGlobalVectorC2", fGlobalQVectorC,Q_CURRENT_WRITER);
            GlobalData().Set("MyGlobalBool", QBool(true),Q_CURRENT_WRITER);
        }
    }
 
    if(fTestGlobal && !fIsFirstSequence) { 
        // read objects from files
//       GlobalData().GetDouble("MyGlobalDouble","testglobal");
        ASSERT_EQUAL(3.14, GlobalData().Get<QDouble>("MyGlobalDouble",fOutputDir +"/testglobal.root"));
        ASSERT_EQUAL( GlobalData().Get<QString>("MyGlobalString",fOutputDir +"/testglobal.root"),"Hi, this is Marco");
        ASSERT_EQUAL(6.28, GlobalData().Get<QDouble>("MyGlobalFloat",fOutputDir +"/testglobal.root"));
        ASSERT_EQUAL(1234, GlobalData().Get<QInt>("MyGlobalInt",fOutputDir +"/testglobal.root"));
        GlobalHandle<QInt> gh("MyGlobalIntTxt");
        GlobalData().Get(&gh,fOutputDir +"/testglobal.txt");
        ASSERT_EQUAL(true,gh.IsValid());
        if(gh.IsValid()) {
            ASSERT_EQUAL(1234,gh.Get());
            }
        ASSERT_EQUAL(true, GlobalData().Get<QBool>("MyGlobalBool",fOutputDir +"/testglobal.root"));
        GlobalHandle<QBool> ghb("MyGlobalBoolTxt");
        GlobalData().Get(&ghb,fOutputDir +"/testglobal.txt");
        ASSERT_EQUAL(true,ghb.IsValid());
        if(ghb.IsValid()) {
            ASSERT_EQUAL(true,ghb.Get());
        }
 
        ASSERT_EQUAL(false, GlobalData().Get<QBool>("MyGlobalBool2",fOutputDir +"/testglobal.root"));
        const QVector& fileVecp = GlobalData().Get<QVector>("MyGlobalVector",fOutputDir +"/testglobal.root");
 
        const QVector& fileVec = fileVecp;
        ASSERT_EQUAL(fileVec.Size(),20);
        for(int i = 0; i < 20; i++) ASSERT_EQUAL(fileVec[i],  i * 3.);
 
        const QVector& fileVec2p = GlobalData().Get<QVector>("MyGlobalVector2",fOutputDir +"/testglobal2.root");
        const QVector& fileVec2 = fileVec2p;
        ASSERT_EQUAL(fileVec2.Size(),20);
        for(int i = 0; i < 20; i++) ASSERT_EQUAL(fileVec2[i],  i * 3.);
 
        const QVector& fileVec2Txtp =GlobalData().Get<QVector>("MyGlobalVector2Txt",fOutputDir +"/testglobal2.txt");
        const QVector& fileVec2Txt = fileVec2Txtp;
        ASSERT_EQUAL(fileVec2Txt.Size(),20);
        for(int i = 0; i < 20; i++) ASSERT_EQUAL(fileVec2Txt[i],  i * 3.);
 
        const QMatrix& fileMatrixTxtp =GlobalData().Get<QMatrix>("MyGlobalMatrixTxt",fOutputDir +"/testglobal3.txt");
        ASSERT_EQUAL(fileMatrixTxtp.GetNRow(),3);
        ASSERT_EQUAL(fileMatrixTxtp.GetNCol(),20);
        for(int i = 0; i < 3; i++) 
            for(int j = 0; j < 20;j++) 
                ASSERT_EQUAL(fileMatrixTxtp.GetRow(i)[j], ((fileVec2Txtp)*double(i+1))[j]);
 
        //const TH1D* fileHisto =(const TH1D*)GlobalData().GetTObject("MyGlobalHisto","test/testglobal.root");
        //for(int i = 1; i <= 10; i++) ASSERT_EQUAL(fileHisto->GetBinContent(i),i*3);
 
    }
 
    if(GetIteration() < fIter) {
        Info("Ending iteration %d",GetIteration());
        SetRunAgain(true);
    } else {
        SetRunAgain(false);
    }
 
    QError err(QERR_SUCCESS,__FILE__,__LINE__,"QError test");
    Info("QError: %s, %s",err.ToString().c_str(),err.GetDescription().c_str());
    fMyOccurrence = -1;
}
 
 
void MTestModule::TestQEvent(const QEvent& ev)
{
/*
    QEvent * newEv = new  QEvent(ev);
    delete newEv;
    QEvent ev2(ev);
    ASSERT_EQUAL(ev2.Get<QInt>("TestModule","TestInt"),ev.Get<QInt>("TestModule","TestInt"));
    const  QVector& vec= ev.Get<QVector>("TestModule","TestVector");
    const  QVector& vec2= ev2.Get<QVector>("TestModule","TestVector");
    ASSERT_EQUAL(vec.Size(),vec2.Size());
*/
}