H1Funs.h

Go to the documentation of this file.

#ifndef __H1FUNS_H
#define __H1FUNS_H

#include "jbltools/sfh/FillIterator.h"
#include "jbltools/sfh/FloatFun.h"
#include "jbltools/sfh/IntFun.h"
#include "jbltools/sfh/BaseCut.h"

#include "H1Pointers/H1ClonesArrayPtr.h" 
#include "H1Mods/H1Part.h" 

#include <cassert>
#include <string>
#include <cmath>
#include <iostream>

// A helper class to beak the encapsulation of H1Ptr and access fBranchName
class JBLH1Ptr: public H1Ptr {
  public: 
    const char *getBranchName() const {return fBranchName;}
};

static std::string getH1PtrName (const H1Ptr& ptr) {
  const char *name = reinterpret_cast<const JBLH1Ptr&>(ptr).getBranchName();
  return std::string(name ? name : "");
}



template <class H1SomePtr>
class JBLH1FloatFunIter: public FloatFun {
  public:
    JBLH1FloatFunIter (const char *branchname_,         
                       const FillIterator& iter_        
                      )
      : FloatFun (std::string(branchname_)+'['+iter_.getName()+']'),
        ptr (*new H1SomePtr(branchname_)), 
        iter (iter_)
      { 
        assert (&ptr); 
        assert (&iter);  
      }
    JBLH1FloatFunIter (const H1SomePtr& ptr_,           
                       const FillIterator& iter_,       
                       const char *pointername_ = 0      
                      )
      : FloatFun (getH1PtrName(ptr_)+'['+iter_.getName()+']'),
        ptr (ptr_), 
        iter (iter_)
      { 
        assert (&ptr); 
        assert (&iter);  
        makeName (pointername_);
      }
    Float_FF operator() () const {
      assert (ptr.GetPointer());
      assert (iter() >= 0);
      assert (iter() < ptr.GetEntries());
      return ptr[iter()];
    }
    virtual const FillIterator *getIterator() const { return &iter; }

  protected:
    virtual ~JBLH1FloatFunIter() {}

  private:
    // Data members
    const H1SomePtr& ptr;                  
    const FillIterator& iter;              
};


template <class H1SomePtr>
class JBLH1FloatFun: public FloatFun {
  public:
    explicit JBLH1FloatFun (const char *branchname_,  
                            int index_ = -1           
                           )
      : FloatFun (std::string(branchname_)+(index_>=0 ? (str('[')+str(index_)+']') : std::string(""))),
        ptr (*new H1SomePtr (branchname_)), 
        index (index_ >= 0 ? index_ : 0), 
        branchname (branchname_)
      { 
        assert (&ptr);  
      }
    explicit JBLH1FloatFun (const H1SomePtr& ptr_,         
                            int index_ = -1,               
                            const char *pointername_ = 0   
                            )
      : FloatFun (getH1PtrName(ptr_)
                  +(index_>=0 ? (str('[')+str(index_)+']') : std::string(""))),
        ptr (ptr_), 
        index (index_ >= 0 ? index_ : 0), 
        branchname (getH1PtrName(ptr_))
        
      { 
        assert (&ptr); 
      }
  
    Float_FF operator() () const {
      assert (ptr.GetPointer());
      return ptr[index];
    }
 
    JBLH1FloatFun<H1SomePtr>& operator[] (int index_) {
      return *new JBLH1FloatFun<H1SomePtr> (ptr, index_, branchname.c_str());
    }
 
    JBLH1FloatFunIter<H1SomePtr>& operator[] (const FillIterator& iter_) {
      return *new JBLH1FloatFunIter<H1SomePtr> (ptr, iter_, branchname.c_str());
    }
    
  protected:
    virtual ~JBLH1FloatFun() {}

  private:
    // Data members
    const H1SomePtr& ptr;        
          int        index;      
    std::string      branchname; 
};



template <class H1SomePtr>
class JBLH1IntFunIter: public IntFun {
  public:
    JBLH1IntFunIter (const char *branchname_,    
                     const FillIterator& iter_   
                     )
    : IntFun (std::string(branchname_)+'['+iter_.getName()+']'),
      ptr (*new H1SomePtr (branchname_)), 
      iter (iter_)
      { 
        assert (&ptr); 
        assert (&iter); 
      }
    JBLH1IntFunIter (const H1SomePtr& ptr_,      
                     const FillIterator& iter_   
                    )
      : IntFun (getH1PtrName(ptr_)
                +'['+iter_.getName()+']'),
        ptr (ptr_), 
        iter (iter_)
      { 
        assert (&ptr); 
        assert (&iter); 
      } 
    int operator() () const {
      assert (ptr.GetPointer());
      assert (iter() >= 0);
      // assert (iter() < ptr.GetEntries());  // works only for array pointers...
      return ptr[iter()];
    }
 
    virtual const FillIterator *getIterator() const { return &iter; }

  protected:
    virtual ~JBLH1IntFunIter() {}

  private:
    // Data members
    const H1SomePtr&    ptr;                
    const FillIterator& iter;               
};


template <class H1SomePtr>
class JBLH1IntFun: public IntFun {
  public:
    explicit JBLH1IntFun (const char *branchname_,      
                          int index_ = -1                
                         )
      : IntFun (std::string(branchname_)+(index_>=0 ? (str('[')+str(index_)+']') : std::string(""))),
        ptr (*new H1SomePtr (branchname_)), 
        index (index_ >= 0 ? index_ : 0) 
      { assert (&ptr); }
    explicit JBLH1IntFun (const H1SomePtr& ptr_,        
                          int index_ = -1                
                         )
      : IntFun (getH1PtrName(ptr_)
                +(index_>= 0 ? (str('[')+str(index_)+']') : std::string(""))),
        ptr (ptr_), 
        index (index_ >= 0 ? index_ : 0) 
      { 
        assert (&ptr); 
      }
 
    int operator() () const {
      assert (ptr.GetPointer());
      return ptr[index];
    }
 
    JBLH1IntFun<H1SomePtr>& operator[] (int index_) {
      return *new JBLH1IntFun<H1SomePtr> (ptr, index_);
    }
 
    JBLH1IntFunIter<H1SomePtr>& operator[] (const FillIterator& iter_) {
      return *new JBLH1IntFunIter<H1SomePtr> (ptr, iter_);
    }
 
    FloatFun& Float () const {
      return *new JBLH1FloatFun<H1SomePtr> (ptr, index);
    }
 
  protected:
    virtual ~JBLH1IntFun() {};

  private:
    H1SomePtr ptr;                                
    int index;                                    
};


template<class H1SomeArrayPtr = H1ClonesArrayPtr, class ArrayRow = H1Part>
class JBLH1SomeArrayIterator: public FillIterator {
  public:
    JBLH1SomeArrayIterator ()
    : FillIterator(),
      ptr (*new H1SomeArrayPtr), 
      index (0)
    { 
      assert (&ptr); 
      setName (reinterpret_cast<const JBLH1Ptr&>(ptr).getBranchName());
      std::cout << "JBLH1SomeArrayIterator: created '" << getName() 
                << "' from new pointer\n";
    }
    explicit JBLH1SomeArrayIterator (const char *branchname_        
                                      )
    : FillIterator(branchname_),
      ptr (*new H1SomeArrayPtr (branchname_)), 
      index (0)
    { 
      assert (&ptr); 
      std::cout << "JBLH1SomeArrayIterator: created '" << getName() 
                << "' from branch " << branchname_ << "\n";
    }
    explicit JBLH1SomeArrayIterator (const H1SomeArrayPtr& ptr_,   
                                     const char *pointername_ = 0  
                                     )
    : FillIterator(reinterpret_cast<const JBLH1Ptr&>(ptr).getBranchName()),
      ptr (ptr_), index (0)
    { 
      assert (&ptr);  
      std::cerr << "JBLH1SomeArrayIterator: created '" << getName() 
                << "' from a pointer, pointername_='" << pointername_  << "'\n";
    }
    virtual int operator() () const {
      // If this assertions fails, something weird goes on.
      assert (index >= 0);
      // If this assertions fails, and index is 0,
      // then you probably have forgotten to tell an self-filling histogram
      // or set or matrix of histograms that it should use an iterator.
      // You should then give the iterator explicitly, and also
      // check that all your classes derived from IntFun, FloatFun, or BaseCut
      // correctly implement method getIterator.
      assert (index < ptr.GetEntries());
      return index;
    }
    virtual bool next() {
      return (++index < ptr.GetEntries());
    }
    virtual bool reset() {
      return ((index=0) < ptr.GetEntries());
    }
    virtual bool isValid() const {
      return index>=0 && index < ptr.GetEntries();
    }          
 
    inline virtual FloatFun& GetP() const;
    inline virtual FloatFun& GetPt() const;
    inline virtual FloatFun& GetPz() const;
    inline virtual FloatFun& GetE() const;
    inline virtual FloatFun& GetPhi() const;
    inline virtual FloatFun& GetTheta() const;
    inline virtual FloatFun& GetMass() const;
    inline virtual FloatFun& GetCharge() const;
    
    inline const char *getBranchName() const {
      return reinterpret_cast<const JBLH1Ptr&>(ptr).getBranchName();
    }
    
    template <class H1PartSome, class TM>
    inline  FloatFun& Float(TM (H1PartSome::* p_mem)() const,   
                            const char *attribname = "?"        
                           ) const;
    template <class H1PartSome, class TM>
    inline  FloatFun& GetFloatFun(TM (H1PartSome::* p_mem)() const,   
                                  const char *attribname = "?"        
                                 ) const;
    
    template <class H1PartSome, class TM>
    inline  IntFun& Int(TM (H1PartSome::* p_mem)() const,   
                        const char *attribname = "?"        
                       ) const;
    template <class H1PartSome, class TM>
    inline  IntFun& GetIntFun(TM (H1PartSome::* p_mem)() const,   
                              const char *attribname = "?"        
                             ) const;

    template <class H1PartSome, class TM>
    inline  BaseCut& Bool(TM (H1PartSome::* p_mem)() const,   
                          const char *attribname = "?"        
                         ) const;
    template <class H1PartSome, class TM>
    inline  BaseCut& GetBaseCut(TM (H1PartSome::* p_mem)() const,   
                                const char *attribname = "?"        
                               ) const;
        
    const H1SomeArrayPtr& getBranchPointer() const {
      return ptr;
    }
 
  protected:
    virtual ~JBLH1SomeArrayIterator() {}

  private:
    // Data members
    const H1SomeArrayPtr& ptr;       
          int             index;     
};
typedef JBLH1SomeArrayIterator<H1ClonesArrayPtr> JBLH1ClonesArrayIterator;

class JBLH1ClonesArrayEntries: public IntFun {
  public:
    explicit JBLH1ClonesArrayEntries (const char *branchname_        
                                     )
      : IntFun(branchname_),
        ptr (*new H1ClonesArrayPtr (branchname_))
      { 
        assert (&ptr); 
      }
    explicit JBLH1ClonesArrayEntries (const H1ClonesArrayPtr& ptr_   
                                     )
      : IntFun(getH1PtrName(ptr_)),
        ptr (ptr_)
      { 
        assert (&ptr); 
      }
    virtual int operator() () const {return ptr.GetEntries();}
 
  protected:
    virtual ~JBLH1ClonesArrayEntries() {};

  private:
      const H1ClonesArrayPtr& ptr;                        
};


// Returns properties of objects in a collection pointed at by an H1ClonesArrayPtr
template <class H1TObject=H1Part, class TM=Double_t>
class JBLH1TObjectFloatFun: public FloatFun {
  public:
    JBLH1TObjectFloatFun(const char *branchname_,               
                         const FillIterator& iter_,             
                         TM (H1TObject::* p_mem_)() const = 0,  
                         const char *attribname_ = "?"          
                        )
      : FloatFun (std::string(branchname_)+'['+iter_.getName()+"]."+ (attribname_ ? attribname_ : "")),
        ptr (*new H1ClonesArrayPtr (branchname_)), 
        iter (iter_), 
        p_mem (p_mem_)
      {
        assert (&ptr); 
        assert (&iter);  
      }
    JBLH1TObjectFloatFun(const H1ClonesArrayPtr& ptr_,              
                         const FillIterator& iter_ ,                  
                         TM (H1TObject::* p_mem_)() const = 0,    
                         const char *attribname_ = "?"            
                )
      : FloatFun (getH1PtrName(ptr_)
                  +'['+iter_.getName()+"]."+ (attribname_ ? attribname_ : "")),
        ptr (ptr_), 
        iter (iter_), 
        p_mem (p_mem_)
      {
        assert (&ptr); 
        assert (&iter);  
      }
    template <class H1SomeArrayPtr, class ArrayRow>
    JBLH1TObjectFloatFun (const JBLH1SomeArrayIterator<H1SomeArrayPtr, ArrayRow>& iter_,    
                                TM (H1TObject::* p_mem_)() const,                           
                          const char *attribname_ = "?"                                      
                               )
      : FloatFun (std::string(iter_.getBranchName())+'['+iter_.getName()+"]."+ (attribname_ ? attribname_ : "")),
        ptr (iter_.getBranchPointer()), 
        iter (iter_), 
        p_mem (p_mem_)
      {
        assert (&ptr); 
        assert (&iter);  
      }
    virtual const FillIterator *getIterator() const { return &iter; }
    
    virtual Float_FF operator() () const {
      assert (p_mem);
      if (H1TObject *h1part = dynamic_cast<H1TObject *>(ptr[iter()])) {
        return (h1part->*p_mem)();
      }
      // If this assertion fails, then you have tried to apply a
      // member function to an object that does not have that function,
      // e.g. you try to use H1PartSelTrack::isCentral for H1PartJPsi.
      assert (0);
      return 0;
    }
    
  protected:
    virtual ~JBLH1TObjectFloatFun() {}

  protected:
    // Data members
    const H1ClonesArrayPtr& ptr;              
    const FillIterator& iter;                 
          TM (H1TObject::* p_mem)() const;    
};

// Returns properties of objects in a collection pointed at by an H1ClonesArrayPtr
template <class H1TObject=H1Part, class TM=Int_t>
class JBLH1TObjectIntFun: public IntFun {
  public:
    JBLH1TObjectIntFun(const char *branchname_,               
                       const FillIterator& iter_,             
                       TM (H1TObject::* p_mem_)() const = 0,  
                       const char *attribname_ = "?"          
                      )
      : IntFun (std::string(branchname_)+'['+iter_.getName()+"]."+ (attribname_ ? attribname_ : "")),
        ptr (*new H1ClonesArrayPtr (branchname_)), 
        iter (iter_), 
        p_mem (p_mem_)
      {}
    JBLH1TObjectIntFun(const H1ClonesArrayPtr& ptr_,              
                       const FillIterator& iter_ ,                
                       TM (H1TObject::* p_mem_)() const = 0,      
                       const char *attribname_ = "?"              
                )
      : IntFun (getH1PtrName(ptr_)+'['+iter_.getName()+"]."+ (attribname_ ? attribname_ : "")),
        ptr (ptr_), 
        iter (iter_), 
        p_mem (p_mem_)
      {}
    template <class H1SomeArrayPtr, class ArrayRow>
    JBLH1TObjectIntFun (const JBLH1SomeArrayIterator<H1SomeArrayPtr, ArrayRow>& iter_,    
                                TM (H1TObject::* p_mem_)() const,                         
                        const char *attribname_ = "?"                                    
                       )
      : IntFun (std::string(iter_.getBranchName())+'['+iter_.getName()+"]."+ (attribname_ ? attribname_ : "")),
        ptr (iter_.getBranchPointer()), iter (iter_), p_mem (p_mem_)
      {}
    virtual const FillIterator *getIterator() const { return &iter; }
    
    virtual int operator() () const {
      assert (p_mem);
      if (H1TObject *h1part = dynamic_cast<H1TObject *>(ptr[iter()])) {
        return (h1part->*p_mem)();
      }
      // If this assertion fails, then you have tried to apply a
      // member function to an object that does not have that function,
      // e.g. you try to use H1PartSelTrack::isCentral for H1PartJPsi.
      assert (0);
      return 0;
    }
  protected:
    virtual ~JBLH1TObjectIntFun() {};

  protected:
    // Data members
    const H1ClonesArrayPtr& ptr;              
    const FillIterator& iter;                 
          TM (H1TObject::* p_mem)() const;    
};

// Returns properties of objects in a collection pointed at by an H1ClonesArrayPtr
template <class H1TObject=H1Part, class TM=Bool_t>
class JBLH1TObjectBaseCut: public BaseCut {
  public:
    JBLH1TObjectBaseCut(const char *branchname_,               
                        const FillIterator& iter_,             
                        TM (H1TObject::* p_mem_)() const = 0,  
                        const char *attribname_ = "?"          
                       )
      : BaseCut (std::string(branchname_)+'['+iter_.getName()+"]."+ (attribname_ ? attribname_ : "")),
        ptr (*new H1ClonesArrayPtr (branchname_)), 
        iter (iter_), 
        p_mem (p_mem_)
      {}
    JBLH1TObjectBaseCut (const H1ClonesArrayPtr& ptr_,           
                         const FillIterator& iter_ ,             
                         TM (H1TObject::* p_mem_)() const = 0,   
                         const char *attribname_ = "?"          
                )
      : IntFun (getH1PtrName(ptr_)+'['+iter_.getName()+"]."+ (attribname_ ? attribname_ : "")),
        ptr (ptr_), 
        iter (iter_), 
        p_mem (p_mem_)
      {}
    template <class H1SomeArrayPtr>
    JBLH1TObjectBaseCut (const JBLH1SomeArrayIterator<H1SomeArrayPtr>& iter_,    
                                TM (H1TObject::* p_mem_)() const,                
                         const char *attribname_ = "?"                           
                        )
      : FloatFun (std::string(iter_.getBranchName())+'['+iter_.getName()+"]."+ (attribname_ ? attribname_ : "")),
        ptr (iter_.getBranchPointer()), 
        iter (iter_), 
        p_mem (p_mem_)
      {}
    virtual const FillIterator *getIterator() const { return &iter; }
    
    virtual bool operator() () const {
      assert (p_mem);
      if (H1TObject *h1part = dynamic_cast<H1TObject *>(ptr[iter()])) {
        return (h1part->*p_mem)();
      }
      // If this assertion fails, then you have tried to apply a
      // member function to an object that does not have that function,
      // e.g. you try to use H1PartSelTrack::isCentral for H1PartJPsi.
      assert (0);
      return 0;
    }
  protected:
    virtual ~JBLH1TObjectBaseCut() {};

  protected:
    // Data members
    const H1ClonesArrayPtr& ptr;              
    const FillIterator& iter;                 
          TM (H1TObject::* p_mem)() const;    
};


// Implementation of inline methods
template<class H1SomeArrayPtr, class ArrayRow>
FloatFun& JBLH1SomeArrayIterator<H1SomeArrayPtr, ArrayRow>::GetP() const {
  return *new JBLH1TObjectFloatFun<ArrayRow> (*this, &ArrayRow::GetP, "P");
}   
   
template<class H1SomeArrayPtr, class ArrayRow>
FloatFun& JBLH1SomeArrayIterator<H1SomeArrayPtr, ArrayRow>::GetPt() const {
  return *new JBLH1TObjectFloatFun<ArrayRow> (*this, &ArrayRow::GetPt, "Pt");
}   
        
template<class H1SomeArrayPtr, class ArrayRow>
FloatFun& JBLH1SomeArrayIterator<H1SomeArrayPtr, ArrayRow>::GetPz() const {
  return *new JBLH1TObjectFloatFun<ArrayRow> (*this, &ArrayRow::GetPz, "Pz");
}   
        
template<class H1SomeArrayPtr, class ArrayRow>
FloatFun& JBLH1SomeArrayIterator<H1SomeArrayPtr, ArrayRow>::GetE() const {
  return *new JBLH1TObjectFloatFun<ArrayRow> (*this, &ArrayRow::GetE, "E");
}   
        
template<class H1SomeArrayPtr, class ArrayRow>
FloatFun& JBLH1SomeArrayIterator<H1SomeArrayPtr, ArrayRow>::GetPhi() const {
  return *new JBLH1TObjectFloatFun<ArrayRow> (*this, &ArrayRow::GetPhi, "Phi");
}   
   
template<class H1SomeArrayPtr, class ArrayRow>
FloatFun& JBLH1SomeArrayIterator<H1SomeArrayPtr, ArrayRow>::GetTheta() const {
  return *new JBLH1TObjectFloatFun<ArrayRow> (*this, &ArrayRow::GetTheta, "Theta");
}   
        
template<class H1SomeArrayPtr, class ArrayRow>
FloatFun& JBLH1SomeArrayIterator<H1SomeArrayPtr, ArrayRow>::GetMass() const {
  return *new JBLH1TObjectFloatFun<ArrayRow> (*this, &ArrayRow::GetMass, "Mass");
}   
        
template<class H1SomeArrayPtr, class ArrayRow>
FloatFun& JBLH1SomeArrayIterator<H1SomeArrayPtr, ArrayRow>::GetCharge() const {
  return *new JBLH1TObjectFloatFun<ArrayRow, Float_t> (*this, &ArrayRow::GetCharge, "Charge");
}   
        
template <class H1SomeArrayPtr, class ArrayRow>
template <class H1PartSome, class TM>
FloatFun& JBLH1SomeArrayIterator<H1SomeArrayPtr, ArrayRow>::Float(TM (H1PartSome::* p_mem)() const, const char *attribname) const {
  return *new JBLH1TObjectFloatFun<H1PartSome, TM> (*this, p_mem, attribname);
}   
template <class H1SomeArrayPtr, class ArrayRow>
template <class H1PartSome, class TM>
FloatFun& JBLH1SomeArrayIterator<H1SomeArrayPtr, ArrayRow>::GetFloatFun(TM (H1PartSome::* p_mem)() const, const char *attribname) const {
  return *new JBLH1TObjectFloatFun<H1PartSome, TM> (*this, p_mem, attribname);
}   
        
template <class H1SomeArrayPtr, class ArrayRow>
template <class H1PartSome, class TM>
IntFun& JBLH1SomeArrayIterator<H1SomeArrayPtr, ArrayRow>::Int(TM (H1PartSome::* p_mem)() const, const char *attribname) const {
  return *new JBLH1TObjectIntFun<H1PartSome, TM> (*this, p_mem, attribname);
}   
template <class H1SomeArrayPtr, class ArrayRow>
template <class H1PartSome, class TM>
IntFun& JBLH1SomeArrayIterator<H1SomeArrayPtr, ArrayRow>::GetIntFun(TM (H1PartSome::* p_mem)() const, const char *attribname) const {
  return *new JBLH1TObjectIntFun<H1PartSome, TM> (*this, p_mem, attribname);
}   
        
template <class H1SomeArrayPtr, class ArrayRow>
template <class H1PartSome, class TM>
BaseCut& JBLH1SomeArrayIterator<H1SomeArrayPtr, ArrayRow>::Bool(TM (H1PartSome::* p_mem)() const, const char *attribname) const {
  return *new JBLH1TObjectBaseCut<H1PartSome, TM> (*this, p_mem, attribname);
}   
template <class H1SomeArrayPtr, class ArrayRow>
template <class H1PartSome, class TM>
BaseCut& JBLH1SomeArrayIterator<H1SomeArrayPtr, ArrayRow>::GetBaseCut(TM (H1PartSome::* p_mem)() const, const char *attribname) const {
  return *new JBLH1TObjectBaseCut<H1PartSome, TM> (*this, p_mem, attribname);
}   


#endif /* #ifndef __H1FUNS_H */ 

---