NTBaseCut.h

Go to the documentation of this file.

#ifndef __NTBASECUT_H
#define __NTBASECUT_H

#include "jbltools/sfh/BaseCut.h"
#include "jbltools/sfh/IntFun.h"
#include "jbltools/sfh/IntFunPoR.h"
 
#include <TTree.h>    
#include <TBranch.h>    
#include <cstring>   
 
 
// Class NTBaseCut

class NTBaseCut: public BaseCut {
  public:
    NTBaseCut (const std::string& name_       
               );
    
    NTBaseCut (const std::string& name_,      
                const IntFun *iter_     
               );
    NTBaseCut (const std::string& name_,      
                int offset_             
               );
    
    virtual NTBaseCut& operator[] (const IntFunPoR& iter_  
                                  ) const = 0;
    
    virtual NTBaseCut& operator[] (int offset_  
                                 ) const = 0;
    
    virtual const FillIterator *getIterator() const { 
      return iter ? iter->getIterator() : 0; 
    }
    
  protected:  
    virtual ~NTBaseCut() {}
    
    std::string getBaseName() const;

    // Data members
    const IntFun *iter;               
    int offset;                       
};
 
// Class NTBaseCutT

template<class Ntuple, class T = bool> 
class NTBaseCutT: public NTBaseCut {
  public:
    NTBaseCutT (const Ntuple& nt,            
                 const char *branchname,      
                 const IntFunPoR& iter_ = 0   
                ) 
    : NTBaseCut (branchname, iter_.pif)          
    {
      TTree *t = nt.fChain;
      assert (t);
      TBranch *b = t->GetBranch (branchname);
      assert (b);
      branchAddress = reinterpret_cast<T *>(b->GetAddress());
      assert (branchAddress);
    }
    
    NTBaseCutT (const Ntuple& nt,            
                 T Ntuple::* p_mem,           
                 const char *name_ = "?",     
                 const IntFunPoR& iter_ = 0   
                ) 
    : NTBaseCut (name_, iter_.pif)            
    {
      branchAddress = &(nt.*p_mem);
      assert (branchAddress);
    }
  
    NTBaseCutT (const Ntuple& nt,            
                 const char *branchname,      
                 int offset_                  
                ) 
    : NTBaseCut (branchname, offset_)
    {        
      TTree *t = nt.fChain;
      assert (t);
      TBranch *b = t->GetBranch (branchname);
      assert (b);
      branchAddress = reinterpret_cast<T *>(b->GetAddress());
      assert (branchAddress);
    }
    
    NTBaseCutT (const Ntuple& nt,           
                T Ntuple::* p_mem,           
                const char *name_,           
                int offset_                  
               ) 
    : NTBaseCut (name_, offset_)       
    {
      branchAddress = &(nt.*p_mem);
      assert (branchAddress);
    }
    
    NTBaseCutT (const NTBaseCutT<Ntuple, T>& source, 
                 const IntFunPoR& iter_                  
               )
      : NTBaseCut (source.getBaseName(), iter_.pif),
        branchAddress (source.branchAddress)
        {}
    NTBaseCutT (const NTBaseCutT<Ntuple, T>& source, 
                 const int offset_                        
               )
      : NTBaseCut (source.getBaseName(), offset_),
        branchAddress (source.branchAddress)
        {}
    
  
    virtual bool operator() () const {
      int i = (iter) ? (*iter)() : offset;
      return branchAddress[i];
    } 
    
    NTBaseCutT<Ntuple, T>& operator[] (const IntFunPoR& iter_  
                                      ) const {
      return *new NTBaseCutT<Ntuple, T> (*this, iter_);
    }
    
    NTBaseCutT<Ntuple, T>& operator[] (int offset_  
                                      ) const {
      return *new NTBaseCutT<Ntuple, T> (*this, offset_);
    }
 
  protected:  
    virtual ~NTBaseCutT() {}
    
    // Data members
    const T       *branchAddress;     
};

template<class Ntuple, class T> 
NTBaseCutT<Ntuple, T>& ntbasecut (const Ntuple& nt,           
                                    T Ntuple::* p_mem,           
                                    const char *name_ = "?",     
                                    const IntFunPoR& iter_ = 0   
                                   ) {
  return *new NTBaseCutT<Ntuple, T> (nt, p_mem, name_, iter_);
}  
 
template<class Ntuple, class T> 
NTBaseCutT<Ntuple, T>& ntbasecut (const Ntuple& nt,           
                                    T Ntuple::* p_mem,          
                                    const char *name_ = "?",    
                                    int offset_                 
                                   ) {
  return *new NTBaseCutT<Ntuple, T> (nt, p_mem, name_, offset_);
} 
  
/*
 * A very special solution to the problem
 * that a member pointer to an ARRAY of T (i.e., a T[n]) is not equivalent
 * to a pointer to T or anything. Unfortunately, we also cannot
 * use a syntax like "p_mem[0]", because that is forbidden.
 * Therefore we have to use n as template argument explicitely,
 * and use the ugly reinterpret_cast to make a pointer to T out of a 
 * pointer to a T[n].
 */                               
template<class Ntuple, class T, unsigned int n> 
NTBaseCutT<Ntuple, T>& ntbasecut (const Ntuple& nt,           
                                   T (Ntuple::* p_mem)[n],      
                                   const char *name_ = "?",     
                                   const IntFunPoR& iter_ = 0   
                                  ) {
  // p_mem is of type "T[n] Ntuple::*", which is correctly written as "T (Ntuple::*)[n]",
  // now we convert it to type "T Ntuple::*"                                
  T (Ntuple::* p_mem0) = reinterpret_cast<T Ntuple::*>(p_mem);
  return *new NTBaseCutT<Ntuple, T> (nt, p_mem0, name_, iter_);
}                                  

template<class Ntuple, class T, unsigned int n> 
NTBaseCutT<Ntuple, T>& ntbasecut (const Ntuple& nt,            
                                   T (Ntuple::* p_mem)[n],       
                                   const char *name_ = "?",      
                                   int offset_                   
                                  ) {
  // p_mem is of type "T[n] Ntuple::*", which is correctly written as "T (Ntuple::*)[n]",
  // now we convert it to type "T Ntuple::*"                                
  T (Ntuple::* p_mem0) = reinterpret_cast<T Ntuple::*>(p_mem);
  return *new NTBaseCutT<Ntuple, T> (nt, p_mem0, name_, offset_);
}                                  


#endif /* #ifndef __NTBASECUT_H */

---