MRootNtpDumper.cc

Go to the documentation of this file.

#include "MRootNtpDumper.hh"
#include "QEvent.hh"
#include "QAliases.hh"
#include "QObjectInspector.hh"
#include "QEventInspector.hh"
#include <TFile.h>
#include <TTree.h>
#include <sstream>
 
using namespace Diana;
 
REGISTER_MODULE(MRootNtpDumper)
 
MRootNtpDumper::MRootNtpDumper() : QFileWriter(".root")
{
    // called once in a sequence
}
 
MRootNtpDumper::~MRootNtpDumper()
{
    // called once in a sequence
}
 
void MRootNtpDumper::Require(const Diana::QEventInspector& evi)
{
    Debug("Requiring QObjects");
    QAliases aliases = evi.GetAliases();
    std::string AliasFileName = GetString("AliasFileName","cfg/aliases.txt");
    if(AliasFileName != "") {
        Debug("Adding aliases from %s",AliasFileName.c_str());
        QError err = aliases.FillFromFile(AliasFileName);
        if(err != QERR_SUCCESS) {
            std::stringstream str;
            str<<err;
            Error("%s",str.str().c_str());
        }
    }
    std::string CustomAliasFileName = GetString("CustomAliasFileName","",false);
    if(CustomAliasFileName != "") {
        Debug("Adding aliases from %s",CustomAliasFileName.c_str());
        QError err = aliases.FillFromFile(CustomAliasFileName);
        if(err != QERR_SUCCESS) {
            std::stringstream str;
            str<<err;
            Error("%s",str.str().c_str());
        }
    }
 
    fAliasMap = aliases.Get() ;
    if(fAliasMap.empty()) Warn("Alias list is empty");
    fAddPackedNeighbours = GetBool("AddPackedNeighbours",false,false);
    std::string neighboursPrefix;
    if(fAddPackedNeighbours) {
        neighboursPrefix = GetString("NeighboursPrefix","N",false);
    }
 
    std::map<std::string,QAliases::AliasInfo>::iterator aliasIter = fAliasMap.begin();
    for(;aliasIter != fAliasMap.end();aliasIter++) {
        std::string alias = aliasIter->first;
        //Debug("Alias %s:",alias.c_str());
        if(GetBool("Alias:"+alias,false,false)) {
            std::string path = aliasIter->second.fPath;
            QEventLabel label = aliasIter->second.fLabel;
            QObject** peventData = evi.Get(label.owner.c_str(),label.name.c_str());
            if(!peventData) continue;
            QObject* eventData = (*peventData);
            if(!eventData) continue;
 
            QObjectInspector insp;
            QObjectInspector::MemberInfo memberInfo = insp.FindBaseType(eventData,path.c_str());
            std::string type = memberInfo.fBranchType;
            void* addr = memberInfo.fAddress;
            if(type == "Unknown"){
                Error("Cannot handle type %s (variable %s)",type.c_str(),alias.c_str());
            } else {
                std::string brvariable = alias + "/" + type; 
                AliasBranch branch;
                branch.name = alias;
                branch.address = addr;
                branch.type = brvariable.c_str();
                eventData->SetIsRequired();
                fAliasBranches.push_back(branch);
                if(fAddPackedNeighbours) {
                    int nneigh = GetInt("MaximumNumberOfNeighbours",2);
                    if(nneigh < 1) Panic("MaximumNumberOfNeighbours = %d not allowed",nneigh);
                    for(int n = 0; n < nneigh; n++) {
                        std::stringstream neighowner;
                        neighowner<<neighboursPrefix<<n+1<<"_"<<label.owner;
                        QEventLabel nLabel;
                        nLabel.owner = neighowner.str();
                        nLabel.name = label.name;
                        peventData = evi.Get(nLabel.owner.c_str(),nLabel.name.c_str());
                        if(!peventData) continue;
                        QObject* eventData = (*peventData);
                        if(!eventData) continue;
                        memberInfo = insp.FindBaseType(eventData,path.c_str());
                        branch.address = memberInfo.fAddress;
                        std::stringstream nbranchAlias;
                        nbranchAlias<<neighboursPrefix<<n+1<<"_"<<alias;
                        branch.name = nbranchAlias.str();
                        brvariable = nbranchAlias.str() + "/" + type;
                        branch.type = brvariable.c_str();
                        eventData->SetIsRequired();
                        fAliasBranches.push_back(branch);
                    }
                }
            }
        }
    }
 
    std::vector<QEventLabel> evDataLabels = evi.GetWriteLabels();
    std::vector<QEventLabel>::const_iterator evLabelIter = evDataLabels.begin();
    while(evLabelIter != evDataLabels.end()) {
        QEventLabel label = *evLabelIter;
        QObject** peventData = evi.Get(label.owner.c_str(),label.name.c_str());
        QObject* eventData = (*peventData);
 
        std::string labelstr = label.GetStringLabel();
        bool process = false;
        if(GetBool(std::string("Member:") + labelstr,false,false)) {
            process = true;
        } else if(fAddPackedNeighbours && !neighboursPrefix.empty()
                && labelstr[0] == neighboursPrefix[0]) {
            int pos = labelstr.find_first_of("_");
            QVdt num(labelstr.substr(1,pos-1));
            std::string rest = labelstr.substr(pos+1,std::string::npos);
            if(num.GetType() == QVdt::Int_QVdt && GetBool(std::string("Member:") + rest,false,false)) process = true;
 
        }
        if(process){
            std::string brnamestr = labelstr + ".";
            Branch branch;
            branch.name = brnamestr;
            branch.type = eventData->GetName();
            branch.address = peventData;
            eventData->SetIsRequired();
            fBranches.push_back(branch);
 
            std::map<std::string, std::string> branchAliasMap = aliases.Find(label);
            std::map<std::string, std::string>::const_iterator iter = branchAliasMap.begin();
            while(iter != branchAliasMap.end()) {
                std::string path;
                if(iter->second =="") {
                    path = labelstr;
                } else {
                    path = labelstr+std::string(".")+iter->second;
                }
                fBranchAliasMap[iter->first] = path;
                iter++;
            }
 
        }
 
        evLabelIter++;
    }
 
 
}
 
void MRootNtpDumper::Open(const std::string& filename, const QEventInspector& evi)
{
    // Get parameters from cfg
    // and open file filename
    fFileName = filename;
 
    fRootOutput = new TFile(filename.c_str(),"RECREATE");
    std::string treeDescription = GetString("Description", "Diana NTP",false);
    fTree = new TTree(GetString("TreeName","qtree",false).c_str(),treeDescription.c_str());
 
    std::string saveMesg = "";
    // Aliases
    for(size_t i = 0; i < fAliasBranches.size(); i++) {
        AliasBranch branch = fAliasBranches[i];
        TBranch* br = fTree->Branch(branch.name.c_str(),branch.address,branch.type.c_str());
        if(br) {
            Debug("Adding alias branch %s of type %s",branch.name.c_str(),branch.type.c_str());
            saveMesg += branch.name + " ";
        }
        else Error("Cannot handle variable %s",branch.name.c_str());
 
    }
    bool saveSomething = false;
    if(!saveMesg.empty()) {
        Info("Saving aliases: %s",saveMesg.c_str());
        saveSomething = true;
    }
 
    // branches
    saveMesg = "";
    for(size_t i = 0; i < fBranches.size(); i++) {
        Branch branch = fBranches[i];
        Debug("Adding branch %s of type %s",branch.name.c_str(),branch.type.c_str());
        saveMesg += branch.name + " ";
        fTree->Branch(branch.name.c_str(),branch.type.c_str(),branch.address);
    }
 
    if(!saveMesg.empty()) {
        Info("Saving full members: %s",saveMesg.c_str());
        saveSomething = true;
    }
 
    if(!saveSomething) {
        Error("Nothing is going to be written");
        return;
    }
 
    std::map<std::string,std::string>::const_iterator branchAliasIter = fBranchAliasMap.begin();
 
    while(branchAliasIter != fBranchAliasMap.end()) {
        const char* al = branchAliasIter->first.c_str();
        const char* ap = branchAliasIter->second.c_str();
        Debug("Adding alias %s for %s",al,ap);
        fTree->SetAlias(al,ap);
        branchAliasIter++;
    }
 
 
}
 
 
void MRootNtpDumper::Dump(const QEventInspector& evi)
{
    fTree->Fill(); 
 
    return;
}
 
void MRootNtpDumper::Close()
{
    // close file
    if(fRootOutput) {
        fRootOutput->Write();
        fRootOutput->Close();
        delete fRootOutput;
        fTree = NULL;
        fRootOutput = NULL;
    }
}