QChain.cc

Go to the documentation of this file.

#include "QChain.hh"
#include "QFileList.hh"
#include <iostream>
#include "QTree.hh"
#include <TFile.h>
#include <TChainElement.h>
#include <TFriendElement.h>
#include <TBranch.h>
#include <TLeaf.h>
#include <TList.h>
 
ClassImp(QChain)
 
QChain::QChain() : TChain(QTREE_NAME) 
{
    fSoftwareRevision = "";
    fVersionTag = "";
    fAllLeaves = 0;
    fAllBranches = 0;
    fAllAliases = 0;
}
 
QChain::QChain(const char* name) : TChain(name) 
{
    fSoftwareRevision = "";
    fVersionTag = "";
    fAllLeaves = 0;
    fAllBranches = 0;
    fAllAliases = 0;
}
 
QChain::~QChain()
{
    for(size_t f = 0; f < fFriends.size(); f++) {
        delete fFriends[f];
    }
   ResetLists();
}
 
void QChain::ResetLists()
{
    if(fAllLeaves) delete fAllLeaves;
    if(fAllBranches) delete fAllBranches;
    if(fAllAliases) delete fAllAliases;
    fAllLeaves = 0;
    fAllBranches = 0;
    fAllAliases = 0;
}
 
Int_t QChain::Add(const char* name, Long64_t nentries)
{ 
 
    int res = 0;
    std::string sname(name);
 
    bool firstCall = false;
    if(GetNtrees() == 0) firstCall = true;
 
    std::string fileExtension = "";
    std::string inFile = name;
    size_t dotpos =  inFile.find_last_of(".");
    if(dotpos != std::string::npos)
        fileExtension = inFile.substr( dotpos+1 );
    std::list<std::string> list;
    if(fileExtension == "list") {
        list = QFileList::Read(name,"");
        std::list<std::string>::const_iterator iter = list.begin();
        while(iter != list.end()) {
            res = TChain::Add(iter->c_str(),kBigNumber);
            iter++;
        }
    } else {
        res = TChain::Add(name,kBigNumber);
    }
 
    if(firstCall && res) {
        // get the tree independently otherwise tchain crashes if
        // we get entries on main chain before adding friends
        std::string filename=
          ((TChainElement *)GetListOfFiles()->First())->GetTitle();
 
        TFile* file0 = new TFile(filename.c_str());
        if(!file0 || file0->IsZombie()) return res;
 
        QTree *tree=(QTree *)(file0->GetObjectChecked(GetName(),"QTree"));
 
        if(!tree) return res;
        fSoftwareRevision = tree->GetSoftwareRevision();
        fVersionTag = tree->GetVersionTag();
 
        const char* pulserPath = tree->GetAlias("IsHeater");
        // change alias IsHeater into IsPulser
        if(pulserPath) {
            this->SetAlias("IsPulser",pulserPath);
        }
 
        TList* friends = tree->GetListOfFriends();
        if(friends) {
            TIter nextf(friends);
            while(TFriendElement* afriend = (TFriendElement*)nextf()) {
                QTree* qfriend = dynamic_cast<QTree*>(afriend->GetTree());
                QChain* fchain = new QChain(qfriend->GetName());
                fchain->Add(name);
                fchain->fSoftwareRevision = qfriend->GetSoftwareRevision();
                fchain->fVersionTag = qfriend->GetVersionTag();
                fFriends.push_back(fchain);
                this->AddFriend(qfriend->GetName());
            }
        }
        delete file0;
 
    } else if(!fFriends.empty()) {
        // add new friend trees to friend chains
        for(size_t f = 0; f < fFriends.size(); f++) {
            fFriends[f]->Add(name);
        }
    }
    ResetLists();
    return res;
}
 
TObjArray* QChain::GetListOfAllLeaves()
{
    //  if(fAllLeaves) return fAllLeaves;
    if(fAllLeaves) delete fAllLeaves;
    if(!this->GetListOfLeaves()) return 0;
 
    fAllLeaves = new TObjArray();
    fAllLeaves->SetOwner(0);
 
    TIter nexta(this->GetListOfLeaves());
    while(TObject* leaf = nexta()) {
        fAllLeaves->AddLast(leaf);
    }
 
    for(size_t f = 0; f < fFriends.size(); f++) {
        TObjArray* fleaves = fFriends[f]->GetListOfLeaves();
        if(!fleaves) continue;
        TIter nextb(fleaves);
        while(TLeaf* fleaf = (TLeaf*)nextb()) {
            fAllLeaves->AddLast(fleaf);
        }
    }
    return fAllLeaves;
}
 
 
TList* QChain::GetListOfAllAliases()
{
    if(fAllAliases) return fAllAliases;
 
    if(!this->GetTree()) this->LoadTree(0);
    if(!this->GetTree()) return 0;
 
    TList* aliases = this->GetTree()->GetListOfAliases();
    if(!aliases) return 0;
 
    fAllAliases = new TList;
    fAllAliases->SetOwner(1);
    TIter nexta(aliases);
    while(TObject* alias = nexta()) {
        fAllAliases->Add(alias->Clone());
 
    }
    for(size_t f = 0; f < fFriends.size(); f++) {
        if(!fFriends[f]->GetTree()) fFriends[f]->LoadTree(0);
        if(!fFriends[f]->GetTree()) continue;
        TList* faliases = fFriends[f]->GetTree()->GetListOfAliases();
        if(!faliases) continue;
        TIter nextb(faliases);
        while(TObject* falias = nextb()) {
            fAllAliases->Add(falias->Clone());
        }
    }
    return fAllAliases;
}
 
TObjArray* QChain::GetListOfAllBranches()
{
    //if(fAllBranches) return fAllBranches;
    if(fAllBranches) delete fAllBranches;
    if(!this->GetListOfBranches()) return 0;
 
    fAllBranches = new TObjArray();
    fAllBranches->SetOwner(0);
 
    TIter nexta(this->GetListOfBranches());
    while(TObject* branch = nexta()) {
        fAllBranches->AddLast(branch);
    }
    for(size_t f = 0; f < fFriends.size(); f++) {
        TObjArray* fbranches = fFriends[f]->GetListOfBranches();
        if(!fbranches) continue;
        TIter nextb(fbranches);
        while(TBranch* fbranch = (TBranch*)nextb()) {
            fAllBranches->AddLast(fbranch);
        }
    }
    return fAllBranches;
}