HafHistogram/interface/HColumn.h

#ifndef HCOLUMN_H
#define HCOLUMN_H

/** \class HColumn  Ganzhur/HafHistogram/interface/HColumn.h
 *
 * Description:
 * Analysis code of the CMS experiment;
 * Original version is a part of HAF package developed for CMS: UserCode/HAF  
 * Nested class hierarchy to hold information about HTuple columns
 *
 * \author Marcel Kunze,        Ruhr-University Bochum, Germany 
 *
 * \version $Id: HColumn.h,v 1.4 2010/03/05 10:24:31 musella Exp $
 *
 */

#include <assert.h>
#include "TNamed.h"
#include "TString.h"
#include "TVector.h"
#include "TTree.h"
#include "TBranch.h"

#include "TLorentzVector.h"
#include "TVector3.h"
#include "TClonesArray.h"

#ifndef HTRange_HH
#define HTRange_HH

template<class T> 
class HTRange {
        
 public:
    
  HTRange() : 
    fDefined(kFALSE), fLower(0), fUpper(0) 
    {
    }
  
  HTRange(T lower, T upper) : 
    fDefined(kTRUE), fLower(lower), fUpper(upper) 
    {
    }
  
  HTRange(const HTRange<T>& o) :
    fDefined(o.fDefined), fLower(o.fLower), fUpper(o.fUpper)
    {
    }
  
  virtual ~HTRange() {}  
  
  HTRange<T>& operator= (const HTRange<T> &o) 
    {
      if (&o == this) return *this;
      fDefined = o.fDefined ;
      fLower = o.fLower ;
      fUpper = o.fUpper ;
      return *this ;
    }
  
  Bool_t operator()() const { return fDefined ; }
  
  T lower() const { return fLower ; }
  T upper() const { return fUpper ; }
      
private:
    
    Bool_t fDefined ;
    T fLower, fUpper ;
    
};
#endif


#ifndef HTAbsValVector_HH
#define HTAbsValVector_HH

template<class T> 
class HTAbsValVector {
    
 public:
  
  // This must return the number of the stored elements
  virtual size_t length() const = 0 ;
  
  // This provides access to the indifidual elements.
  // Index runs from 0 to length()-1. Here () means that we do not requre 
  // index checking from it, though the real classe may do what they like.
  virtual const T& operator()(size_t i) const = 0;
  virtual T& operator()(size_t i) = 0;
  virtual const T& operator[](size_t i) const = 0;
  virtual T& operator[](size_t i) = 0;
    
};
#endif


#ifndef HTAbsValArray_HH
#define HTAbsValArray_HH

template<class T, size_t N>
class HTValArray : public HTAbsValVector<T> {

 public:

  HTValArray() {}
  HTValArray( const T& v ) ;
  HTValArray( const HTValArray<T,N> &v ) ;

  HTValArray<T,N>& operator=( const HTValArray<T,N> &v ) ;

  virtual size_t length() const ;
  virtual const T& operator()(size_t i) const ;

  T& operator()(size_t i) { return _array[i] ; }
  const T& operator[](size_t i) const {
    assert ( i<N ) ;
    return _array[i] ;
  }
  T& operator[](size_t i) {
    assert ( i<N ) ;
    return _array[i] ;
  }
  
 private:
  
  T _array[N] ;
  
};

template<class T, size_t N>
HTValArray<T,N>::HTValArray( const T& v )
{
  for ( int i = 0 ; i < N ; i ++ ) {
    _array[i] = v ;
  }
}

template<class T, size_t N>
HTValArray<T,N>::HTValArray( const HTValArray<T,N> &v )
{
  for ( int i = 0 ; i < N ; i ++ ) {
    _array[i] = v._array[i] ;
  }
}

template<class T, size_t N>
HTValArray<T,N>&
HTValArray<T,N>::operator=( const HTValArray<T,N> &v )
{
  for ( int i = 0 ; i < N ; i ++ ) {
    _array[i] = v._array[i] ;
  }
  return *this ;
}

template<class T, size_t N>
size_t
HTValArray<T,N>::length() const
{
  return N;
}

template<class T, size_t N>
const T&
HTValArray<T,N>::operator()(size_t i) const
{
  return _array[i] ;
}

#endif  


#ifndef HTValVector_HH
#define HTValVector_HH

using namespace std;
#include <deque>

template<class T>
class HTValVector : public HTAbsValVector<T>
{

 public:
  
  typedef typename deque<T>::value_type value_type;
  typedef typename deque<T>::pointer pointer;
  typedef typename deque<T>::const_pointer conts_pointer;
  typedef typename deque<T>::iterator iterator;
  typedef typename deque<T>::const_iterator const_iterator;
  typedef typename deque<T>::reference reference;
  typedef typename deque<T>::const_reference const_reference;
  typedef typename deque<T>::size_type size_type;
  typedef typename deque<T>::difference_type difference_type;
  
  HTValVector() : _d() {}
  HTValVector( size_type n ) : _d(n) {}
  HTValVector( const HTValVector<T> &d ) : _d(d._d) {}
  HTValVector( const deque<T> &d ) : _d(d) {}

  virtual ~HTValVector() {}

  virtual HTValVector<T>& operator=(const HTValVector<T>& d) { _d=d._d; return *this; }
  virtual bool operator<(const HTValVector<T>& d) { return _d<d._d; }
  virtual bool operator==(const HTValVector<T>& d) { return _d==d._d; }
  virtual const T& operator()(size_type i) const { return _d[i]; }
  virtual T& operator()(size_type i) { return _d[i]; }
  virtual const T& operator[](size_type i) const { return _d[i]; }
  virtual T& operator[](size_type i) { return _d[i]; }

  virtual size_type size() const { return _d.size(); }
  virtual size_type length() const { return _d.size(); }
  virtual size_type entries() const { return _d.size(); }
  virtual void append(const T& t) { _d.push_back(t); }
  virtual void prepend(const T& t) { _d.push_front(t); }
  virtual bool remove(const T& t) {
    for( iterator i=_d.begin(); i!=_d.end(); ++i ) {      
      if( *i == t ) {
        _d.erase(i);
        return true;
      }
    }
    return false;
  }
  virtual bool contains(const T& t) const {
    for( const_iterator i=_d.begin(); i!=_d.end(); ++i ) {
      if( *i == t ) return true;
    }
    return false;
  }
  virtual bool isEmpty() const { return _d.empty(); }
  virtual void reshape(size_type n) { _d.resize(n); }
  virtual iterator begin() { return _d.begin(); }
  virtual iterator   end() { return _d.end(); }
  virtual void clear() { _d.clear(); }
  
 protected:

  deque<T> _d;

};

#endif


#ifndef HTValOrderedVector_HH
#define HTValOrderedVector_HH

using namespace std;
#include <vector>
#include <deque>

template<class T>
class HTValOrderedVector : public HTValVector<T>
{

 public:

  typedef typename deque<T>::size_type size_type;

  HTValOrderedVector() : HTValVector<T>() {}
  HTValOrderedVector( size_type n ) : HTValVector<T>() {}
  HTValOrderedVector( const HTValOrderedVector<T> &v )
    : HTValVector<T>(v) {}
  HTValOrderedVector( const vector<T> &v ) : HTValVector<T>(v) {}

  virtual ~HTValOrderedVector() {}

  void resize(size_type n) {}

};

#endif 


// Parent class (abstract):
class HColumn : public TNamed {

 public:

  HColumn(const char* l) : 
    TNamed(l,l), fLabel(l), fUseDefValue(0), fPointer(0), fBranch(0) {}
  virtual ~HColumn() {}
  const TString &GetLabel() const { return fLabel; }
  TBranch* GetBrPointer() { return fBranch; }
  void* GetPointer() { return fPointer; }
  void SetPointer(void* p) { fPointer = p; }
  void SetUseDefValue(Int_t b) { fUseDefValue = b; }
  const Int_t & GetUseDefValue() const { return fUseDefValue; }
  virtual void SetDefValue() = 0;
  virtual void SetValue(const void*, HColumn* cp=0) = 0;

 protected:

  TString fLabel;
  Int_t fUseDefValue;
  void* fPointer; //!
  TBranch* fBranch;
  
  ClassDef(HColumn,1) // HColumn
    
};


// Classes for Bool_t:
class BoolColumn : public HColumn {
public:
    BoolColumn(const char*, const Bool_t &, const Bool_t &, TTree*);
    virtual ~BoolColumn() { delete (Bool_t*)fPointer; }
    virtual void SetDefValue() { *(Char_t*)fPointer = fDefValue; }
    virtual void SetValue(const void* p, HColumn* cp=0) { 
        *(Char_t*)fPointer = *(const Bool_t*)p;
    }
private:
    Bool_t fDefValue;
};

class BoolArrColumn : public HColumn {
public:
    BoolArrColumn(const char*, const HTAbsValVector<Bool_t> &, const Bool_t &, 
        TTree*);
    virtual ~BoolArrColumn() { delete[] (Bool_t*)fPointer; }
    virtual void SetDefValue() { 
        for(Int_t i = 0; i < fMax; ++i) ((Char_t*)fPointer)[i] = fDefValue; 
    }
    virtual void SetValue(const void*, HColumn* cp=0);
private:
    Bool_t fDefValue;
    Int_t fMax;
};

class BoolDynArrColumn : public HColumn {
public:
    BoolDynArrColumn(const char*, const HTAbsValVector<Bool_t> &,
        const Bool_t &, HColumn*, TTree*);
    virtual ~BoolDynArrColumn() { delete[] (Bool_t*)fPointer; }
    virtual void SetDefValue();
    virtual void SetValue(const void*, HColumn* cp=0);
private:
    Bool_t fDefValue;
    HColumn* fIndexPtr;
};

// Classes for Int_t:
class IntColumn : public HColumn {
public:
    IntColumn(const char*, const Int_t &, const Int_t &, TTree*);
    virtual ~IntColumn() { delete (Int_t*)fPointer; }
    virtual void SetDefValue() { *(Int_t*)fPointer = fDefValue; }
    virtual void SetValue(const void* p, HColumn* cp=0) { 
        *(Int_t*)fPointer = *(const Int_t*)p;
    }
private:
    Int_t fDefValue;
};

class IntArrColumn : public HColumn {
public:
    IntArrColumn(const char*, const HTAbsValVector<Int_t> &, const Int_t &, 
        TTree*);
    virtual ~IntArrColumn() { delete[] (Int_t*)fPointer; }
    virtual void SetDefValue() { 
        for(Int_t i = 0; i < fMax; ++i) ((Int_t*)fPointer)[i] = fDefValue; 
    }
    virtual void SetValue(const void*, HColumn* cp=0);
private:
    Int_t fDefValue;
    Int_t fMax;
};

class IntDynArrColumn : public HColumn {
public:
    IntDynArrColumn(const char*, const HTAbsValVector<Int_t> &,
        const Int_t &, HColumn*, TTree*);
    virtual ~IntDynArrColumn() { delete[] (Int_t*)fPointer; }
    virtual void SetDefValue();
    virtual void SetValue(const void*, HColumn* cp=0);
private:
    Int_t fDefValue;
    HColumn* fIndexPtr;
};

// Classes for Float_t:
class FloatColumn : public HColumn {
public:
    FloatColumn(const char*, const Float_t &, const Float_t &, TTree*);
    virtual ~FloatColumn() { delete (Float_t*)fPointer; }
    virtual void SetDefValue() { *(Float_t*)fPointer = fDefValue; }
    virtual void SetValue(const void* p, HColumn* cp=0) { 
        *(Float_t*)fPointer = *(const Float_t*)p; 
    }
private:
    Float_t fDefValue;
};

class FloatArrColumn : public HColumn {
public:
    FloatArrColumn(const char*, const HTAbsValVector<Float_t> &, const Float_t &, 
        TTree*);
    FloatArrColumn(const char*, const TVector &, const Float_t &, 
        TTree*);
    virtual ~FloatArrColumn() { delete[] (Float_t*)fPointer; }
    virtual void SetDefValue() { 
        for(Int_t i = 0; i < fMax; ++i) ((Float_t*)fPointer)[i] = fDefValue; 
    }
    virtual void SetValue(const void*, HColumn* cp=0);
private:
    Float_t fDefValue;
    Int_t fMax;
};

class FloatDynArrColumn : public HColumn {
public:
    FloatDynArrColumn(const char*, const HTAbsValVector<Float_t> &,
        const Float_t &, HColumn*, TTree*);
    FloatDynArrColumn(const char*, const TVector &,
        const Float_t &, HColumn*, TTree*);
    virtual ~FloatDynArrColumn() { delete[] (Float_t*)fPointer; }
    virtual void SetDefValue();
    virtual void SetValue(const void*, HColumn* cp=0);
private:
    Float_t fDefValue;
    HColumn* fIndexPtr;
};

// Classes for Double_t:
class DoubleColumn : public HColumn {
public:
    DoubleColumn(const char*, const Double_t &, const Double_t &, TTree*);
    virtual ~DoubleColumn() { delete (Double_t*)fPointer; }
    virtual void SetDefValue() { *(Double_t*)fPointer = fDefValue; }
    virtual void SetValue(const void* p, HColumn* cp=0) { 
        *(Double_t*)fPointer = *(const Double_t*)p; 
    }
private:
    Double_t fDefValue;
};

class DoubleArrColumn : public HColumn {
public:
    DoubleArrColumn(const char*, const HTAbsValVector<Double_t> &, 
        const Double_t &, TTree*);
    virtual ~DoubleArrColumn() { delete[] (Double_t*)fPointer; }
    virtual void SetDefValue() { 
        for(Int_t i = 0; i < fMax; ++i) ((Double_t*)fPointer)[i] = fDefValue; 
    }
    virtual void SetValue(const void*, HColumn* cp=0);
private:
    Double_t fDefValue;
    Int_t fMax;
};

class DoubleDynArrColumn : public HColumn {
public:
    DoubleDynArrColumn(const char*, const HTAbsValVector<Double_t> &,
                      const Double_t &, HColumn*, TTree*);
    virtual ~DoubleDynArrColumn() { delete[] (Double_t*)fPointer; }
    virtual void SetDefValue();
    virtual void SetValue(const void*, HColumn* cp=0);
private:
    Double_t fDefValue;
    HColumn* fIndexPtr;
};

// String column:
class StringColumn : public HColumn {
public:
    StringColumn(const TString &, const TString &, 
        const TString &, TTree*);
    virtual ~StringColumn() { delete[] (TString*)fPointer; }
    virtual void SetDefValue();
    virtual void SetValue(const void*, HColumn* cp=0);
private:
    TString fDefValue;
};

// Classes for generic objects 
template <class T>
class ClassColumn : public HColumn {
public:
        ClassColumn(const char * name, const T& v, const T& d, TTree * t) :
                HColumn(name), fDefValue(d)
                {
                        // Create a new branch:
                        T * p = new T(v);
                        fPointer = p;
                        fBranch = t->Branch(name,p);
                }
        virtual void SetDefValue() { *(T*)fPointer = fDefValue; }
        virtual void SetValue(const void* p, HColumn* cp=0) { *(T*)fPointer = *(const T*)p; }
private:
        T fDefValue;
};

typedef ClassColumn<TLorentzVector> TLorentzColum;
typedef ClassColumn<TVector3>       TVector3Colum;

template <class T>
class ClonesColumn : public HColumn {
public:
        ClonesColumn(const char * name, const HTAbsValVector<T>& v, const T& d, HColumn* inp, TTree* t) :
                HColumn(name), fDefValue(d), fIndexPtr(inp)
                {
                        // Create a new branch:
                        fClones = new TClonesArray(fDefValue.ClassName(),v.length());
                        fPointer = fClones;
                        fBranch = t->Branch(name,&fClones,128000,0);
                        SetValue(&v);
                }
        virtual void SetDefValue() 
                {
                        fClones->Delete();
                        int np = *((Int_t*)(fIndexPtr->GetPointer()));
                        for( Int_t i = 0; i < np; ++i) new( (*fClones)[i] ) T(fDefValue);
                }
        virtual void SetValue(const void* p, HColumn* cp=0) 
                { 
                        const HTAbsValVector<T>& vp = *(const HTAbsValVector<T>*) p;
                        int np = vp.length();
                        if( cp != 0 ) {
                                np = *((Int_t*)(cp->GetPointer()));
                        }
                        fClones->Delete();
                        if( np > (int)vp.length() ) { 
                                SetDefValue(); 
                        } else {
                                for( Int_t i = 0; i < np; ++i) new( (*fClones)[i] ) T(vp(i));
                        }
                }
        
private:
        TClonesArray * fClones;
        T fDefValue;
        HColumn * fIndexPtr;
};

typedef ClonesColumn<TLorentzVector> TLorentzClonesColumn;
typedef ClonesColumn<TVector3>       TVector3ClonesColum;


#endif
Revision:	1.1
Committed:	Wed Sep 29 15:44:21 2010 UTC (14 years, 7 months ago) by yjlee
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	HafHistogram tool
#	User	Rev	Content
1	yjlee	1.1	#ifndef HCOLUMN_H
2			#define HCOLUMN_H
3
4			/** \class HColumn Ganzhur/HafHistogram/interface/HColumn.h
5			*
6			* Description:
7			* Analysis code of the CMS experiment;
8			* Original version is a part of HAF package developed for CMS: UserCode/HAF
9			* Nested class hierarchy to hold information about HTuple columns
10			*
11			* \author Marcel Kunze, Ruhr-University Bochum, Germany
12			*
13			* \version $Id: HColumn.h,v 1.4 2010/03/05 10:24:31 musella Exp $
14			*
15			*/
16
17			#include <assert.h>
18			#include "TNamed.h"
19			#include "TString.h"
20			#include "TVector.h"
21			#include "TTree.h"
22			#include "TBranch.h"
23
24			#include "TLorentzVector.h"
25			#include "TVector3.h"
26			#include "TClonesArray.h"
27
28			#ifndef HTRange_HH
29			#define HTRange_HH
30
31			template<class T>
32			class HTRange {
33
34			public:
35
36			HTRange() :
37			fDefined(kFALSE), fLower(0), fUpper(0)
38			{
39			}
40
41			HTRange(T lower, T upper) :
42			fDefined(kTRUE), fLower(lower), fUpper(upper)
43			{
44			}
45
46			HTRange(const HTRange<T>& o) :
47			fDefined(o.fDefined), fLower(o.fLower), fUpper(o.fUpper)
48			{
49			}
50
51			virtual ~HTRange() {}
52
53			HTRange<T>& operator= (const HTRange<T> &o)
54			{
55			if (&o == this) return *this;
56			fDefined = o.fDefined ;
57			fLower = o.fLower ;
58			fUpper = o.fUpper ;
59			return *this ;
60			}
61
62			Bool_t operator()() const { return fDefined ; }
63
64			T lower() const { return fLower ; }
65			T upper() const { return fUpper ; }
66
67			private:
68
69			Bool_t fDefined ;
70			T fLower, fUpper ;
71
72			};
73			#endif
74
75
76			#ifndef HTAbsValVector_HH
77			#define HTAbsValVector_HH
78
79			template<class T>
80			class HTAbsValVector {
81
82			public:
83
84			// This must return the number of the stored elements
85			virtual size_t length() const = 0 ;
86
87			// This provides access to the indifidual elements.
88			// Index runs from 0 to length()-1. Here () means that we do not requre
89			// index checking from it, though the real classe may do what they like.
90			virtual const T& operator()(size_t i) const = 0;
91			virtual T& operator()(size_t i) = 0;
92			virtual const T& operator[](size_t i) const = 0;
93			virtual T& operator[](size_t i) = 0;
94
95			};
96			#endif
97
98
99			#ifndef HTAbsValArray_HH
100			#define HTAbsValArray_HH
101
102			template<class T, size_t N>
103			class HTValArray : public HTAbsValVector<T> {
104
105			public:
106
107			HTValArray() {}
108			HTValArray( const T& v ) ;
109			HTValArray( const HTValArray<T,N> &v ) ;
110
111			HTValArray<T,N>& operator=( const HTValArray<T,N> &v ) ;
112
113			virtual size_t length() const ;
114			virtual const T& operator()(size_t i) const ;
115
116			T& operator()(size_t i) { return _array[i] ; }
117			const T& operator[](size_t i) const {
118			assert ( i<N ) ;
119			return _array[i] ;
120			}
121			T& operator[](size_t i) {
122			assert ( i<N ) ;
123			return _array[i] ;
124			}
125
126			private:
127
128			T _array[N] ;
129
130			};
131
132			template<class T, size_t N>
133			HTValArray<T,N>::HTValArray( const T& v )
134			{
135			for ( int i = 0 ; i < N ; i ++ ) {
136			_array[i] = v ;
137			}
138			}
139
140			template<class T, size_t N>
141			HTValArray<T,N>::HTValArray( const HTValArray<T,N> &v )
142			{
143			for ( int i = 0 ; i < N ; i ++ ) {
144			_array[i] = v._array[i] ;
145			}
146			}
147
148			template<class T, size_t N>
149			HTValArray<T,N>&
150			HTValArray<T,N>::operator=( const HTValArray<T,N> &v )
151			{
152			for ( int i = 0 ; i < N ; i ++ ) {
153			_array[i] = v._array[i] ;
154			}
155			return *this ;
156			}
157
158			template<class T, size_t N>
159			size_t
160			HTValArray<T,N>::length() const
161			{
162			return N;
163			}
164
165			template<class T, size_t N>
166			const T&
167			HTValArray<T,N>::operator()(size_t i) const
168			{
169			return _array[i] ;
170			}
171
172			#endif
173
174
175			#ifndef HTValVector_HH
176			#define HTValVector_HH
177
178			using namespace std;
179			#include <deque>
180
181			template<class T>
182			class HTValVector : public HTAbsValVector<T>
183			{
184
185			public:
186
187			typedef typename deque<T>::value_type value_type;
188			typedef typename deque<T>::pointer pointer;
189			typedef typename deque<T>::const_pointer conts_pointer;
190			typedef typename deque<T>::iterator iterator;
191			typedef typename deque<T>::const_iterator const_iterator;
192			typedef typename deque<T>::reference reference;
193			typedef typename deque<T>::const_reference const_reference;
194			typedef typename deque<T>::size_type size_type;
195			typedef typename deque<T>::difference_type difference_type;
196
197			HTValVector() : _d() {}
198			HTValVector( size_type n ) : _d(n) {}
199			HTValVector( const HTValVector<T> &d ) : _d(d._d) {}
200			HTValVector( const deque<T> &d ) : _d(d) {}
201
202			virtual ~HTValVector() {}
203
204			virtual HTValVector<T>& operator=(const HTValVector<T>& d) { _d=d._d; return *this; }
205			virtual bool operator<(const HTValVector<T>& d) { return _d<d._d; }
206			virtual bool operator==(const HTValVector<T>& d) { return _d==d._d; }
207			virtual const T& operator()(size_type i) const { return _d[i]; }
208			virtual T& operator()(size_type i) { return _d[i]; }
209			virtual const T& operator[](size_type i) const { return _d[i]; }
210			virtual T& operator[](size_type i) { return _d[i]; }
211
212			virtual size_type size() const { return _d.size(); }
213			virtual size_type length() const { return _d.size(); }
214			virtual size_type entries() const { return _d.size(); }
215			virtual void append(const T& t) { _d.push_back(t); }
216			virtual void prepend(const T& t) { _d.push_front(t); }
217			virtual bool remove(const T& t) {
218			for( iterator i=_d.begin(); i!=_d.end(); ++i ) {
219			if( *i == t ) {
220			_d.erase(i);
221			return true;
222			}
223			}
224			return false;
225			}
226			virtual bool contains(const T& t) const {
227			for( const_iterator i=_d.begin(); i!=_d.end(); ++i ) {
228			if( *i == t ) return true;
229			}
230			return false;
231			}
232			virtual bool isEmpty() const { return _d.empty(); }
233			virtual void reshape(size_type n) { _d.resize(n); }
234			virtual iterator begin() { return _d.begin(); }
235			virtual iterator end() { return _d.end(); }
236			virtual void clear() { _d.clear(); }
237
238			protected:
239
240			deque<T> _d;
241
242			};
243
244			#endif
245
246
247			#ifndef HTValOrderedVector_HH
248			#define HTValOrderedVector_HH
249
250			using namespace std;
251			#include <vector>
252			#include <deque>
253
254			template<class T>
255			class HTValOrderedVector : public HTValVector<T>
256			{
257
258			public:
259
260			typedef typename deque<T>::size_type size_type;
261
262			HTValOrderedVector() : HTValVector<T>() {}
263			HTValOrderedVector( size_type n ) : HTValVector<T>() {}
264			HTValOrderedVector( const HTValOrderedVector<T> &v )
265			: HTValVector<T>(v) {}
266			HTValOrderedVector( const vector<T> &v ) : HTValVector<T>(v) {}
267
268			virtual ~HTValOrderedVector() {}
269
270			void resize(size_type n) {}
271
272			};
273
274			#endif
275
276
277			// Parent class (abstract):
278			class HColumn : public TNamed {
279
280			public:
281
282			HColumn(const char* l) :
283			TNamed(l,l), fLabel(l), fUseDefValue(0), fPointer(0), fBranch(0) {}
284			virtual ~HColumn() {}
285			const TString &GetLabel() const { return fLabel; }
286			TBranch* GetBrPointer() { return fBranch; }
287			void* GetPointer() { return fPointer; }
288			void SetPointer(void* p) { fPointer = p; }
289			void SetUseDefValue(Int_t b) { fUseDefValue = b; }
290			const Int_t & GetUseDefValue() const { return fUseDefValue; }
291			virtual void SetDefValue() = 0;
292			virtual void SetValue(const void, HColumn cp=0) = 0;
293
294			protected:
295
296			TString fLabel;
297			Int_t fUseDefValue;
298			void* fPointer; //!
299			TBranch* fBranch;
300
301			ClassDef(HColumn,1) // HColumn
302
303			};
304
305
306			// Classes for Bool_t:
307			class BoolColumn : public HColumn {
308			public:
309			BoolColumn(const char, const Bool_t &, const Bool_t &, TTree);
310			virtual ~BoolColumn() { delete (Bool_t*)fPointer; }
311			virtual void SetDefValue() { (Char_t)fPointer = fDefValue; }
312			virtual void SetValue(const void* p, HColumn* cp=0) {
313			(Char_t)fPointer = (const Bool_t)p;
314			}
315			private:
316			Bool_t fDefValue;
317			};
318
319			class BoolArrColumn : public HColumn {
320			public:
321			BoolArrColumn(const char*, const HTAbsValVector<Bool_t> &, const Bool_t &,
322			TTree*);
323			virtual ~BoolArrColumn() { delete[] (Bool_t*)fPointer; }
324			virtual void SetDefValue() {
325			for(Int_t i = 0; i < fMax; ++i) ((Char_t*)fPointer)[i] = fDefValue;
326			}
327			virtual void SetValue(const void, HColumn cp=0);
328			private:
329			Bool_t fDefValue;
330			Int_t fMax;
331			};
332
333			class BoolDynArrColumn : public HColumn {
334			public:
335			BoolDynArrColumn(const char*, const HTAbsValVector<Bool_t> &,
336			const Bool_t &, HColumn, TTree);
337			virtual ~BoolDynArrColumn() { delete[] (Bool_t*)fPointer; }
338			virtual void SetDefValue();
339			virtual void SetValue(const void, HColumn cp=0);
340			private:
341			Bool_t fDefValue;
342			HColumn* fIndexPtr;
343			};
344
345			// Classes for Int_t:
346			class IntColumn : public HColumn {
347			public:
348			IntColumn(const char, const Int_t &, const Int_t &, TTree);
349			virtual ~IntColumn() { delete (Int_t*)fPointer; }
350			virtual void SetDefValue() { (Int_t)fPointer = fDefValue; }
351			virtual void SetValue(const void* p, HColumn* cp=0) {
352			(Int_t)fPointer = (const Int_t)p;
353			}
354			private:
355			Int_t fDefValue;
356			};
357
358			class IntArrColumn : public HColumn {
359			public:
360			IntArrColumn(const char*, const HTAbsValVector<Int_t> &, const Int_t &,
361			TTree*);
362			virtual ~IntArrColumn() { delete[] (Int_t*)fPointer; }
363			virtual void SetDefValue() {
364			for(Int_t i = 0; i < fMax; ++i) ((Int_t*)fPointer)[i] = fDefValue;
365			}
366			virtual void SetValue(const void, HColumn cp=0);
367			private:
368			Int_t fDefValue;
369			Int_t fMax;
370			};
371
372			class IntDynArrColumn : public HColumn {
373			public:
374			IntDynArrColumn(const char*, const HTAbsValVector<Int_t> &,
375			const Int_t &, HColumn, TTree);
376			virtual ~IntDynArrColumn() { delete[] (Int_t*)fPointer; }
377			virtual void SetDefValue();
378			virtual void SetValue(const void, HColumn cp=0);
379			private:
380			Int_t fDefValue;
381			HColumn* fIndexPtr;
382			};
383
384			// Classes for Float_t:
385			class FloatColumn : public HColumn {
386			public:
387			FloatColumn(const char, const Float_t &, const Float_t &, TTree);
388			virtual ~FloatColumn() { delete (Float_t*)fPointer; }
389			virtual void SetDefValue() { (Float_t)fPointer = fDefValue; }
390			virtual void SetValue(const void* p, HColumn* cp=0) {
391			(Float_t)fPointer = (const Float_t)p;
392			}
393			private:
394			Float_t fDefValue;
395			};
396
397			class FloatArrColumn : public HColumn {
398			public:
399			FloatArrColumn(const char*, const HTAbsValVector<Float_t> &, const Float_t &,
400			TTree*);
401			FloatArrColumn(const char*, const TVector &, const Float_t &,
402			TTree*);
403			virtual ~FloatArrColumn() { delete[] (Float_t*)fPointer; }
404			virtual void SetDefValue() {
405			for(Int_t i = 0; i < fMax; ++i) ((Float_t*)fPointer)[i] = fDefValue;
406			}
407			virtual void SetValue(const void, HColumn cp=0);
408			private:
409			Float_t fDefValue;
410			Int_t fMax;
411			};
412
413			class FloatDynArrColumn : public HColumn {
414			public:
415			FloatDynArrColumn(const char*, const HTAbsValVector<Float_t> &,
416			const Float_t &, HColumn, TTree);
417			FloatDynArrColumn(const char*, const TVector &,
418			const Float_t &, HColumn, TTree);
419			virtual ~FloatDynArrColumn() { delete[] (Float_t*)fPointer; }
420			virtual void SetDefValue();
421			virtual void SetValue(const void, HColumn cp=0);
422			private:
423			Float_t fDefValue;
424			HColumn* fIndexPtr;
425			};
426
427			// Classes for Double_t:
428			class DoubleColumn : public HColumn {
429			public:
430			DoubleColumn(const char, const Double_t &, const Double_t &, TTree);
431			virtual ~DoubleColumn() { delete (Double_t*)fPointer; }
432			virtual void SetDefValue() { (Double_t)fPointer = fDefValue; }
433			virtual void SetValue(const void* p, HColumn* cp=0) {
434			(Double_t)fPointer = (const Double_t)p;
435			}
436			private:
437			Double_t fDefValue;
438			};
439
440			class DoubleArrColumn : public HColumn {
441			public:
442			DoubleArrColumn(const char*, const HTAbsValVector<Double_t> &,
443			const Double_t &, TTree*);
444			virtual ~DoubleArrColumn() { delete[] (Double_t*)fPointer; }
445			virtual void SetDefValue() {
446			for(Int_t i = 0; i < fMax; ++i) ((Double_t*)fPointer)[i] = fDefValue;
447			}
448			virtual void SetValue(const void, HColumn cp=0);
449			private:
450			Double_t fDefValue;
451			Int_t fMax;
452			};
453
454			class DoubleDynArrColumn : public HColumn {
455			public:
456			DoubleDynArrColumn(const char*, const HTAbsValVector<Double_t> &,
457			const Double_t &, HColumn, TTree);
458			virtual ~DoubleDynArrColumn() { delete[] (Double_t*)fPointer; }
459			virtual void SetDefValue();
460			virtual void SetValue(const void, HColumn cp=0);
461			private:
462			Double_t fDefValue;
463			HColumn* fIndexPtr;
464			};
465
466			// String column:
467			class StringColumn : public HColumn {
468			public:
469			StringColumn(const TString &, const TString &,
470			const TString &, TTree*);
471			virtual ~StringColumn() { delete[] (TString*)fPointer; }
472			virtual void SetDefValue();
473			virtual void SetValue(const void, HColumn cp=0);
474			private:
475			TString fDefValue;
476			};
477
478			// Classes for generic objects
479			template <class T>
480			class ClassColumn : public HColumn {
481			public:
482			ClassColumn(const char * name, const T& v, const T& d, TTree * t) :
483			HColumn(name), fDefValue(d)
484			{
485			// Create a new branch:
486			T * p = new T(v);
487			fPointer = p;
488			fBranch = t->Branch(name,p);
489			}
490			virtual void SetDefValue() { (T)fPointer = fDefValue; }
491			virtual void SetValue(const void* p, HColumn* cp=0) { (T)fPointer = (const T)p; }
492			private:
493			T fDefValue;
494			};
495
496			typedef ClassColumn<TLorentzVector> TLorentzColum;
497			typedef ClassColumn<TVector3> TVector3Colum;
498
499			template <class T>
500			class ClonesColumn : public HColumn {
501			public:
502			ClonesColumn(const char * name, const HTAbsValVector<T>& v, const T& d, HColumn* inp, TTree* t) :
503			HColumn(name), fDefValue(d), fIndexPtr(inp)
504			{
505			// Create a new branch:
506			fClones = new TClonesArray(fDefValue.ClassName(),v.length());
507			fPointer = fClones;
508			fBranch = t->Branch(name,&fClones,128000,0);
509			SetValue(&v);
510			}
511			virtual void SetDefValue()
512			{
513			fClones->Delete();
514			int np = ((Int_t)(fIndexPtr->GetPointer()));
515			for( Int_t i = 0; i < np; ++i) new( (*fClones)[i] ) T(fDefValue);
516			}
517			virtual void SetValue(const void* p, HColumn* cp=0)
518			{
519			const HTAbsValVector<T>& vp = (const HTAbsValVector<T>) p;
520			int np = vp.length();
521			if( cp != 0 ) {
522			np = ((Int_t)(cp->GetPointer()));
523			}
524			fClones->Delete();
525			if( np > (int)vp.length() ) {
526			SetDefValue();
527			} else {
528			for( Int_t i = 0; i < np; ++i) new( (*fClones)[i] ) T(vp(i));
529			}
530			}
531
532			private:
533			TClonesArray * fClones;
534			T fDefValue;
535			HColumn * fIndexPtr;
536			};
537
538			typedef ClonesColumn<TLorentzVector> TLorentzClonesColumn;
539			typedef ClonesColumn<TVector3> TVector3ClonesColum;
540
541
542			#endif