QBaseModule.cc

Go to the documentation of this file.

/* Diana Reconstruction program
 *
 * Author: MP 11/11/05
 * $Id: QBaseModule.cc 93 2006-05-23 13:50:24Z pallas $
 *
 * Class QBaseModule
 *
*/
 
#include "QBaseModule.hh"
#include "QOptions.hh"
#include "QDemangle.hh"
#include "QEventAssembler.hh"
#include "QEventList.hh"
 
Q_BEGIN_NAMESPACE
// ctor
QBaseModule::QBaseModule(Type type)
{
        fOccurrence = 0;
    fEnabled = false;
        verbosity = WarnMsg;
    fNeedNeighbours = false;
    fMessageName = "";
    fName = "";
    fType = type;
}
 
// dtor
QBaseModule::~QBaseModule() {
}
 
 
void QBaseModule::Update(QSequence* s, unsigned int occurrence)
{
    my_sequence = s;
    fOccurrence = occurrence; 
    fName = Demangle(*this,1); 
    std::stringstream name;
    name<<fName;
    if(GetOccurrence() > 0) {
            name<<"."<<GetOccurrence();
    }
    fMessageName = name.str();
 
    QOptions::GetInstance().SetParameter(GetSequence().GetName(),GetName(),GetOccurrence(),"enable",std::string("false"));
 
    fConfig.fSequenceName = my_sequence->GetName();
    fConfig.fOccurrence = GetOccurrence();
    fConfig.fVersionTag = QOptions::GetInstance().GetParameter("General.DIANA_VERSIONTAG").GetString();
    fConfig.fSoftwareRevision = QOptions::GetInstance().GetParameter("General.DIANA_SWREVISION").GetString();
    switch(fType) {
        case Module:
            fConfig.fType = "module";
            break;
        case Filter:
            fConfig.fType = "filter";
            break;
        case Reader:
            fConfig.fType = "reader";
            break;
        case Writer:
            fConfig.fType = "writer";
            break;
        case Driver:
            fConfig.fType = "driver";
            break;
    }
    fConfig.fName = fName;
    fConfig.fLabel = "";
 
}
 
void QBaseModule::BeginBase(QEventAssembler& eva)
{
 
    fLabel = fName;
    std::string extraLabel = GetString("ExtraLabel","",false); 
    if(extraLabel != "") fLabel += std::string("_") + extraLabel;
    fConfig.fLabel = fLabel;
 
    fProcessTime = 0.;
    fProcessCalls = 0ULL;
 
    std::string strVerb = GetString("verbosity","info");
    if ( strVerb == "debug")
        verbosity = DebugMsg;
    else if ( strVerb == "info")
        verbosity = InfoMsg;
    else if ( strVerb == "warning")
        verbosity = WarnMsg;
    else if ( strVerb == "error")
        verbosity = ErrorMsg;
    else if ( strVerb == "panic")
        verbosity = PanicMsg;
    else
        Warn("Invalid value for parameter \"verbosity\"");
 
    SetTimeProfilingOn(GetBool("TimeProfilingOn",false,false));
    if(QOptions::GetInstance().GetBool("General.TimeProfilingOn")) SetTimeProfilingOn(true);
    
    bool overWriteEvent = GetBool("OverWriteEvent",false,false);
    overWriteEvent = overWriteEvent || (GetIteration() > 1);
    if(QOptions::GetInstance().GetBool("General.OverWrite")) overWriteEvent = true;
    my_sequence->GlobalData().SetOwner(fLabel.c_str());
    eva.SetOverWrite(overWriteEvent);
    eva.SetOwner(&fLabel); 
 
    fNeedNeighbours = true;
 
    // erase required labels in the QEvent to keep track which are selected by this module
    std::vector<QEventLabel> prevRequired = eva.GetRequiredLabels();
    std::vector<QEventLabel> empty;
    eva.SetRequiredLabels(empty,false);
    // execute the Begin (Init)
    Begin(eva);
    // Get required labels and restore full list of required lables in the event
    fRequiredLabels = eva.GetRequiredLabels();
    eva.SetRequiredLabels(prevRequired);
    eva.SetRequiredLabels(fRequiredLabels);
 
    eva.SetOwner(0);
    eva.SetOverWrite(false);
 
    my_sequence->GlobalData().SetOwner("");
}
 
bool QBaseModule::ProcessBase(QEventAssembler& eva, QEventList& evl, const bool exec, QEventList& oevl)
{
    bool ret;
    if(GetTimeProfilingOn()) {
        my_sequence->GlobalData().SetOwner(fLabel.c_str());
        eva.SetOwner(&fLabel); 
        for(size_t i = 0; i < evl.Size(); i++) { evl[i].SetOwner(&fLabel); }
        ResetTimer();
        fExecuted = false;
        ret = Process(eva,evl,exec,oevl);
        double process_time = GetTimer();
        eva.SetOwner(0);
        for(size_t i = 0; i < evl.Size(); i++) { evl[i].SetOwner(0); }
        my_sequence->GlobalData().SetOwner("");
        if(fExecuted) {
            fProcessCalls++;
            fProcessTime += process_time;
        }
    } else {
        my_sequence->GlobalData().SetOwner(fLabel.c_str());
        eva.SetOwner(&fLabel); 
        for(size_t i = 0; i < evl.Size(); i++) { evl[i].SetOwner(&fLabel); }
        fExecuted = false;
        ret = Process(eva,evl,exec,oevl);
        eva.SetOwner(0);
        for(size_t i = 0; i < evl.Size(); i++) { evl[i].SetOwner(0); }
        my_sequence->GlobalData().SetOwner("");
        if(fExecuted) {
            fProcessCalls++;
        }
    }
    return ret;
}
 
void QBaseModule::EndBase()
{
    if(fProcessCalls == 0) fNeedNeighbours = false;
 
    my_sequence->GlobalData().SetOwner(fLabel.c_str());
    if(GetTimeProfilingOn()) {
      Info("%s",GetTimeProfileReport().c_str());
    }
 
    End();
 
    my_sequence->GlobalData().SetOwner("");
}
 
 
std::string QBaseModule::GetFullPath() const 
{ 
    char occBuf[8];
    snprintf(occBuf,8,"%d",GetOccurrence());
    return GetName() + "." + occBuf;
}
 
double QBaseModule::GetDouble(const std::string& s, double defVal, bool warnCfg) const
{
    double param;
    try {
        param = QOptions::GetInstance().GetDouble(GetSequence().GetName(), GetName(),GetOccurrence(),s);
    }
    catch(std::exception &ex) {
        if(warnCfg) Warn("%s; using default: %f", ex.what(), defVal);
        QOptions::GetInstance().SetParameter(GetSequence().GetName(), GetName(), GetOccurrence(), s, defVal,true);
        param = QOptions::GetInstance().GetDouble(GetSequence().GetName(), GetName(),GetOccurrence(),s);
    }
    UpdateConfigParameters(s);
    return param;
}
 
std::vector<double> QBaseModule::GetVectorDouble(const std::string& s, std::vector<double> defVal, bool warnCfg) const
{
    std::vector<double> param;
    try {
        param = QOptions::GetInstance().GetVectorDouble(GetSequence().GetName(), GetName(),GetOccurrence(),s);
    }
    catch(std::exception &ex) {
        std::stringstream defMsg;
        defMsg<<"{";
        for(size_t i =0; i < defVal.size(); i++) defMsg<<defVal[i]<<",";
        defMsg<<"}";
        if(warnCfg) Warn("%s; using default: %s", ex.what(), defMsg.str().c_str());
        QOptions::GetInstance().SetParameter(GetSequence().GetName(), GetName(), GetOccurrence(), s, defVal,true);
        param = QOptions::GetInstance().GetVectorDouble(GetSequence().GetName(), GetName(),GetOccurrence(),s);
    }
    UpdateConfigParameters(s);
    return param;
}
 
// get a parameter of integer type
int QBaseModule::GetInt(const std::string& s, int defVal, bool warnCfg) const
{
    int param;
    try {
        param = QOptions::GetInstance().GetInt(GetSequence().GetName(), GetName(), GetOccurrence(),s);
    }
    catch(std::exception &ex) {
        if(warnCfg) Warn("%s; using default: %d", ex.what(), defVal);
        QOptions::GetInstance().SetParameter(GetSequence().GetName(), GetName(), GetOccurrence(), s, defVal,true);
        param = QOptions::GetInstance().GetInt(GetSequence().GetName(), GetName(), GetOccurrence(),s);
    }
    UpdateConfigParameters(s);
    return param;
}
 
std::vector<int> QBaseModule::GetVectorInt(const std::string& s, std::vector<int> defVal, bool warnCfg) const
{
    std::vector<int> param;
    try {
        param = QOptions::GetInstance().GetVectorInt(GetSequence().GetName(), GetName(),GetOccurrence(),s);
    }
    catch(std::exception &ex) {
        std::stringstream defMsg;
        defMsg<<"{";
        for(size_t i =0; i < defVal.size(); i++) defMsg<<defVal[i]<<",";
        defMsg<<"}";
 
        if(warnCfg) Warn("%s; using default: %s", ex.what(), defMsg.str().c_str());
        QOptions::GetInstance().SetParameter(GetSequence().GetName(), GetName(), GetOccurrence(), s, defVal,true);
        param = QOptions::GetInstance().GetVectorInt(GetSequence().GetName(), GetName(),GetOccurrence(),s);
    }
    UpdateConfigParameters(s);
    return param;
}
 
 
 
bool QBaseModule::GetBool(const std::string& s, bool defVal, bool warnCfg) const
{
    bool param;
    try{
        param =  QOptions::GetInstance().GetBool(GetSequence().GetName(), GetName(),  GetOccurrence(),s);
    }
    catch(std::exception &ex) {
        if(warnCfg) Warn("%s; using default: %s", ex.what(), (defVal ? "true" : "false") );
        QOptions::GetInstance().SetParameter(GetSequence().GetName(), GetName(), GetOccurrence(), s, defVal,true);
        param =  QOptions::GetInstance().GetBool(GetSequence().GetName(), GetName(),  GetOccurrence(),s);
    }
    UpdateConfigParameters(s);
    return param;
}
std::vector<bool> QBaseModule::GetVectorBool(const std::string& s, std::vector<bool> defVal, bool warnCfg) const
{
    std::vector<bool> param;
    try {
        param = QOptions::GetInstance().GetVectorBool(GetSequence().GetName(), GetName(),GetOccurrence(),s);
    }
    catch(std::exception &ex) {
        std::stringstream defMsg;
        std::vector<int> boolToInt;
        defMsg<<"{";
        for(size_t i =0; i < defVal.size(); i++) {
            defMsg<<defVal[i]<<",";
            boolToInt.push_back(defVal[i]);
            }
        defMsg<<"}";
 
        if(warnCfg) Warn("%s; using default: %s", ex.what(), defMsg.str().c_str());
        QOptions::GetInstance().SetParameter(GetSequence().GetName(), GetName(), GetOccurrence(), s, boolToInt,true);
        param = QOptions::GetInstance().GetVectorBool(GetSequence().GetName(), GetName(),GetOccurrence(),s);
    }
    UpdateConfigParameters(s);
    return param;
}
 
 
 
 
const std::string& QBaseModule::GetString(const std::string& s, const std::string& defVal, bool warnCfg) const
{
    const std::string* param;
    try {
        param = &QOptions::GetInstance().GetString(GetSequence().GetName(), GetName(), GetOccurrence(),s);
 
    }
    catch(std::exception &ex) {
        if(warnCfg) Warn("%s; using default: %s", ex.what(), defVal.c_str() );
        QOptions::GetInstance().SetParameter(GetSequence().GetName(), GetName(), GetOccurrence(), s, defVal,true);
        param = &QOptions::GetInstance().GetString(GetSequence().GetName(), GetName(), GetOccurrence(),s);
    }
    UpdateConfigParameters(s);
    return *param;
}
 
std::vector<std::string> QBaseModule::GetVectorString(const std::string& s, std::vector<std::string> defVal, bool warnCfg) const
{
    std::vector<std::string> param;
    try {
        param = QOptions::GetInstance().GetVectorString(GetSequence().GetName(), GetName(),GetOccurrence(),s);
    }
    catch(std::exception &ex) {
        std::stringstream defMsg;
        defMsg<<"{";
        for(size_t i =0; i < defVal.size(); i++) defMsg<<defVal[i]<<",";
        defMsg<<"}";
 
        if(warnCfg) Warn("%s; using default: %s", ex.what(), defMsg.str().c_str());
        QOptions::GetInstance().SetParameter(GetSequence().GetName(), GetName(), GetOccurrence(), s, defVal,true);
        param = QOptions::GetInstance().GetVectorString(GetSequence().GetName(), GetName(),GetOccurrence(),s);
    }
    UpdateConfigParameters(s);
    return param;
}
 
void QBaseModule::UpdateConfigParameters(const std::string& p) const
{
        fConfig.fParameters[p] = QOptions::GetInstance().GetParameter(GetSequence().GetName(), GetName(),GetOccurrence(), p).GetString();
}
 
 
Q_END_NAMESPACE