PndSimpleNtuple.cxx

Go to the documentation of this file.

// -------------------------------------------------------------------------------
// ---------                    PndSimpleNtuple                           --------
// -------------------------------------------------------------------------------
//
// Represents a simplified N-Tuple based on a ROOT TTree.
//
// Branches of type double, float, int or bool are created on the fly with the 
// command 
//
//   'Column(TString name, double/float/int/bool value);'
//
// At the end of each event (i.e. when the N-Tuple should be filled) either
//
//   'DumpData()'    or 
//   'AcceptData()' 
//
// has to be called. The method 'AcceptData()' is a conditional fill in case a
// certain precut is fulfilled, which can be set either in the constructor with
//
//   PndSimpleNtuple(TString name, TString title, TString <precut>)
//
// or with the method
//
//   SetPrecut(TString precut)
//
// which can even be changed inbetween. The precut is a TFormula directly based
// on the branches of the TTree.
//
// -------------------------------------------------------------------------------

#include "PndSimpleNtuple.h"

#include "TRegexp.h"
#include <iostream>

using std::cout;
using std::endl;

TString typearr[8] = {"D","F","I","B","D[]","F[]","I[]","B[]"};


// -------------------------------------------------------------------------------

PndSimpleNtuple::PndSimpleNtuple(TString name, TString title, TString precut) :
        fTree(new TTree(name, title)),fTmpTree(new TTree("tmp", "")), fPrecut(precut), fFml(0)
{
        fTree->SetDirectory(0);
        fTmpTree->SetDirectory(0);
};

// ----------------------------------
//          DOUBLE VALUES
// ----------------------------------
void PndSimpleNtuple::Column(const TString &name, double value)
{
        // new branch?
        if (fBrTypes.find(name) == fBrTypes.end())
        {
                fBrTypes[name] = 0;  // type double
                fDValues[name] = value;
                fTree->Branch(name.Data(), &(fDValues[name]), (name+"/D").Data());
                fTmpTree->Branch(name.Data(), &(fDValues[name]), (name+"/D").Data());
        }
        else if ( fBrTypes[name] != 0)
        {
                std::cout<<" - WARNING - Type mismatch of branch '"<<name<<"/"<<typearr[fBrTypes[name]]<<"' with type '"<<typearr[0]<<"'"<<std::endl;
                return;         
        }
        else
                fDValues[name] = value;
}

// ----------------------------------
//          FLOAT VALUES
// ----------------------------------
void PndSimpleNtuple::Column(const TString &name, float value)
{
        // new branch?
        if (fBrTypes.find(name) == fBrTypes.end())
        {
                fBrTypes[name] = 1;  // type double
                fFValues[name] = value;
                fTree->Branch(name.Data(), &(fFValues[name]), (name+"/F").Data());
                fTmpTree->Branch(name.Data(), &(fFValues[name]), (name+"/F").Data());
        }
        else if ( fBrTypes[name] != 1)
        {
                std::cout<<" - WARNING - Type mismatch of branch '"<<name<<"/"<<typearr[fBrTypes[name]]<<"' with type '"<<typearr[1]<<"'"<<std::endl;
                return;         
        }
        else
                fFValues[name] = value;
}

// ----------------------------------
//          INT VALUES
// ----------------------------------
void PndSimpleNtuple::Column(const TString &name, int value)
{
        // new branch?
        if (fBrTypes.find(name) == fBrTypes.end())
        {
                fBrTypes[name] = 2;  // type double
                fIValues[name] = value;
                fTree->Branch(name.Data(), &(fIValues[name]), (name+"/I").Data());
                fTmpTree->Branch(name.Data(), &(fIValues[name]), (name+"/I").Data());
        }
        else if ( fBrTypes[name] != 2)
        {
                std::cout<<" - WARNING - Type mismatch of branch '"<<name<<"/"<<typearr[fBrTypes[name]]<<"' with type '"<<typearr[2]<<"'"<<std::endl;
                return;         
        }
        else
                fIValues[name] = value;
}

// ----------------------------------
//          BOOL VALUES
// ----------------------------------
void PndSimpleNtuple::Column(const TString &name, bool value)
{
        // new branch?
        if (fBrTypes.find(name) == fBrTypes.end())
        {
                fBrTypes[name] = 3;  // type double
                fBValues[name] = value;
                fTree->Branch(name.Data(), &(fBValues[name]), (name+"/B").Data());
                fTmpTree->Branch(name.Data(), &(fBValues[name]), (name+"/B").Data());
        }
        else if ( fBrTypes[name] != 3)
        {
                std::cout<<" - WARNING - Type mismatch of branch '"<<name<<"/"<<typearr[fBrTypes[name]]<<"' with type '"<<typearr[3]<<"'"<<std::endl;
                return;         
        }
        else
                fBValues[name] = value;
}

// ----------------------------------

double PndSimpleNtuple::GetCurrentValue(TString name)
{
        // branch does not exist
        if (fBrTypes.find(name)==fBrTypes.end()) return sqrt(-1.);
        
        int brtype = fBrTypes[name];
        
        switch (brtype) 
        {
                case 0: return fDValues[name]; 
                case 1: return (double) fFValues[name]; 
                case 2: return (double) fIValues[name]; 
                case 3: return (double) fBValues[name]; 
        }
                
        return sqrt(-1);
}

// ----------------------------------

bool PndSimpleNtuple::Accept()
{
        if (fPrecut=="") return true;
        
        if (fFml==0) fFml = new TTreeFormula("fFml", fPrecut, fTmpTree);
        
        fTmpTree->Fill();
        fTmpTree->GetEntry(fTmpTree->GetEntriesFast()-1);
        return fFml->EvalInstance();
}

// ----------------------------------

int PndSimpleNtuple::ShowBranches()
{
        int cnt=0;
        for (auto x: fBrTypes)
        {
                cout <<cnt++<<" : "<<x.first<<"/"<<typearr[x.second]<<endl;
        }
        
        return fBrTypes.size();
}

// ----------------------------------

void PndSimpleNtuple::SetPrecut(TString precut) //{ if (fFml) delete fFml; fFml = 0; if (precut!="") fFml = new TTreeFormula("fFml",precut,fTmpTree);}
{
        if (precut!=fPrecut)
        {
                if (fFml!=0) {delete fFml; fFml=0;}
                fPrecut=precut;
        }
}