DataTree/interface/TriggerObject.h

//--------------------------------------------------------------------------------------------------
// $Id: TriggerObject.h,v 1.9 2009/05/18 06:29:14 loizides Exp $
//
// TriggerObject
//
// This class holds the HLT trigger object information, ie
// mainly the kinematics and type of trigger. 
// The other classes TriggerObjectBase, and TriggerObjectRel are only used for 
// efficient tree storage and should not used in analysis.
//
// Authors: C.Loizides
//--------------------------------------------------------------------------------------------------

#ifndef MITANA_DATATREE_TRIGGEROBJECT_H
#define MITANA_DATATREE_TRIGGEROBJECT_H

#include <THashTable.h>
#include "MitCommon/DataFormats/interface/Vect4M.h"
#include "MitAna/DataTree/interface/Particle.h"
#include "MitAna/DataTree/interface/TriggerName.h"
#include "MitAna/DataTree/interface/TriggerTable.h"

namespace mithep 
{
  class TriggerObjectBase : public Particle
  {
    public:
      TriggerObjectBase() : fId(0) {}
      TriggerObjectBase(Int_t id, const FourVectorM32 &mom) : fId(id), fMom(mom) {}
      TriggerObjectBase(Int_t id, Double_t pt, Double_t eta, Double_t phi, Double_t mass) : 
        fId(id), fMom(pt,eta,phi,mass) {}

      Int_t                 Id()      const { return fId;                }
      EObjType              ObjType() const { return kTriggerObjectBase; }      

    protected:
      void                  GetMom()  const;

      Int_t                 fId;          //id or physics type (similar to pdgId)
      Vect4M                fMom;         //object momentum

    ClassDef(TriggerObjectBase, 1) // Trigger object base class
  };

  class TriggerObjectRel : public DataObject
  {
    public:
      TriggerObjectRel() : fTrgId(0), fType(0), fObjInd(0), fModInd(0), fFilterInd(0) {}
      TriggerObjectRel(UChar_t id, UChar_t type, Short_t obj, Short_t mod, Short_t fil) : 
        fTrgId(id), fType(type), fObjInd(obj), fModInd(mod), fFilterInd(fil) {}

      UShort_t              FilterInd() const { return fFilterInd;        }
      UShort_t              ModInd()    const { return fModInd;           }
      UShort_t              ObjInd()    const { return fObjInd;           }
      EObjType              ObjType()   const { return kTriggerObjectRef; }      
      UChar_t               TrgId()     const { return fTrgId;            }
      UChar_t               Type()      const { return fType;             }

    protected:
      UChar_t               fTrgId;       //trigger id
      UChar_t               fType;        //object type
      Short_t               fObjInd;      //trigger object index
      Short_t               fModInd;      //module label index
      Short_t               fFilterInd;   //filter label index

    ClassDef(TriggerObjectRel, 1) // Trigger to trigger object relation class
  };

  class TriggerObject : public TriggerObjectBase
  {
    public:
      enum ETriggerObject { // see DataFormats/HLTReco/interface/TriggerTypeDefs.h
        None                  =  0,
        TriggerL1Mu           = -81,
        TriggerL1NoIsoEG      = -82,
        TriggerL1IsoEG        = -83,
        TriggerL1CenJet       = -84,
        TriggerL1ForJet       = -85,
        TriggerL1TauJet       = -86,
        TriggerL1ETM          = -87,
        TriggerL1ETT          = -88,
        TriggerL1HTT          = -89,
        TriggerL1HTM          = -90,
        TriggerL1JetCounts    = -91,
        TriggerL1HfBitCounts  = -92,
        TriggerL1HfRingEtSums = -93,
        TriggerL1TechTrig     = -94,
        TriggerL1Castor       = -95,
        TriggerL1BPTX         = -96,
        TriggerPhoton         = +81,
        TriggerElectron       = +82,
        TriggerMuon           = +83,
        TriggerTau            = +84,
        TriggerJet            = +85,
        TriggerBJet           = +86,
        TriggerMET            = +87,
        TriggerTET            = +88,
        TriggerTHT            = +89,
        TriggerMHT            = +90,
        TriggerTrack          = +91,
        TriggerCluster        = +92,
        TriggerMETSig         = +93,
        TriggerELongit        = +94,
        TriggerMHTSig         = +95,
        TriggerHLongit        = +96
      };

      TriggerObject() : fTrgId(0), fType(None), fTrigName(0), fModName(0), fFilName(0) {}
      TriggerObject(UChar_t tid, UChar_t type, Int_t id, const FourVectorM32 &mom) : 
        TriggerObjectBase(id,mom), fTrgId(tid), fType(static_cast<ETriggerObject>(type)) {}
      TriggerObject(UChar_t tid, UChar_t type, Int_t id, 
                    Double_t pt, Double_t eta, Double_t phi, Double_t mass) : 
        TriggerObjectBase(id,pt,eta,phi,mass), fTrgId(tid), 
        fType(static_cast<ETriggerObject>(type)) {}

      const char           *FilterName()            const { return fFilName;       }
      ULong_t               Hash()                  const { return fTrgId;         }
      Bool_t                IsHLT()                 const { return fType>0;        }
      Bool_t                IsL1()                  const { return fType<0;        }
      const char           *ModuleName()            const { return fModName;       }
      EObjType              ObjType()               const { return kTriggerObject; }      
      void                  Print(Option_t *opt="") const;
      const char           *TrigName()              const { return fTrigName;      }
      UShort_t              TrgId()                 const { return fTrgId;         }
      ETriggerObject        Type()                  const { return fType;          }
      void                  SetTrigName(const char *n)    { fTrigName = n; }
      void                  SetModuleName(const char *n)  { fModName  = n; }
      void                  SetFilterName(const char *n)  { fFilName  = n; }

    protected:
      UChar_t               fTrgId;       //trigger id
      ETriggerObject        fType;        //object type
      const char           *fTrigName;    //!trigger name
      const char           *fModName;     //!L3 module name
      const char           *fFilName;     //!L3 filter name

    ClassDef(TriggerObject, 2) // Trigger object class
  };

//--------------------------------------------------------------------------------------------------
// TriggerObjectsTable
//
// A convenient THashTable for storage of TriggerObjects (not streamable).
//
// Authors: C.Loizides
//--------------------------------------------------------------------------------------------------
  class TriggerObjectsTable : public THashTable
  {
    private:
      class MyKey : public TObject
      { 
        public:
          MyKey(ULong_t hash) : fHash(hash) {}
          ULong_t Hash() const { return fHash; }
        protected:
          ULong_t fHash; //hash value
      };

    public:
      TriggerObjectsTable(const TriggerTable *table, 
                          Int_t capacity = TCollection::kInitHashTableCapacity, Int_t rehash = 0) :
        THashTable(capacity,rehash), fTriggers(table) {}

      const TList         *GetList(const char *name) const;
      const TList         *GetList(ULong_t id)       const;
      using TCollection::Print;
      void                 Print(Option_t *opt="")   const;
 
    protected:
      const TriggerTable  *fTriggers; //trigger table
  };
}

//--------------------------------------------------------------------------------------------------
inline void mithep::TriggerObjectBase::GetMom() const
{
  // Get momentum values from stored values.

  fCachedMom.SetCoordinates(fMom.Pt(),fMom.Eta(),fMom.Phi(),fMom.M()); 
}

//--------------------------------------------------------------------------------------------------
inline const TList *mithep::TriggerObjectsTable::GetList(const char *name) const
{ 
  // Return list of trigger objects for given trigger name.

  ULong_t id = fTriggers->GetId(name);
  return GetList(id);
}

//--------------------------------------------------------------------------------------------------
inline const TList *mithep::TriggerObjectsTable::GetList(ULong_t id) const
{ 
  // Return list of trigger objects for given trigger id (bit).

  MyKey key(id); 
  return const_cast<const TList*>(GetListForObject(&key)); 
}
#endif
Revision:	1.10
Committed:	Fri Jul 10 13:49:39 2009 UTC (15 years, 9 months ago) by loizides
Content type:	text/plain
Branch:	MAIN
Changes since 1.9:	+38 -24 lines
Log Message:	Prepare for new L1/HLT info
#	User	Rev	Content
1	loizides	1.1	//--------------------------------------------------------------------------------------------------
2	loizides	1.10	// $Id: TriggerObject.h,v 1.9 2009/05/18 06:29:14 loizides Exp $
3	loizides	1.1	//
4			// TriggerObject
5			//
6	loizides	1.2	// This class holds the HLT trigger object information, ie
7			// mainly the kinematics and type of trigger.
8			// The other classes TriggerObjectBase, and TriggerObjectRel are only used for
9			// efficient tree storage and should not used in analysis.
10	loizides	1.1	//
11			// Authors: C.Loizides
12			//--------------------------------------------------------------------------------------------------
13
14			#ifndef MITANA_DATATREE_TRIGGEROBJECT_H
15			#define MITANA_DATATREE_TRIGGEROBJECT_H
16
17	loizides	1.2	#include <THashTable.h>
18	loizides	1.7	#include "MitCommon/DataFormats/interface/Vect4M.h"
19	loizides	1.1	#include "MitAna/DataTree/interface/Particle.h"
20	loizides	1.2	#include "MitAna/DataTree/interface/TriggerName.h"
21	loizides	1.8	#include "MitAna/DataTree/interface/TriggerTable.h"
22	loizides	1.1
23			namespace mithep
24			{
25			class TriggerObjectBase : public Particle
26			{
27			public:
28	loizides	1.2	TriggerObjectBase() : fId(0) {}
29	loizides	1.4	TriggerObjectBase(Int_t id, const FourVectorM32 &mom) : fId(id), fMom(mom) {}
30	loizides	1.2	TriggerObjectBase(Int_t id, Double_t pt, Double_t eta, Double_t phi, Double_t mass) :
31	loizides	1.4	fId(id), fMom(pt,eta,phi,mass) {}
32	loizides	1.1
33	loizides	1.9	Int_t Id() const { return fId; }
34	loizides	1.5	EObjType ObjType() const { return kTriggerObjectBase; }
35	loizides	1.1
36			protected:
37	loizides	1.6	void GetMom() const;
38
39	loizides	1.2	Int_t fId; //id or physics type (similar to pdgId)
40	loizides	1.7	Vect4M fMom; //object momentum
41	loizides	1.1
42			ClassDef(TriggerObjectBase, 1) // Trigger object base class
43			};
44
45			class TriggerObjectRel : public DataObject
46			{
47			public:
48	loizides	1.2	TriggerObjectRel() : fTrgId(0), fType(0), fObjInd(0), fModInd(0), fFilterInd(0) {}
49			TriggerObjectRel(UChar_t id, UChar_t type, Short_t obj, Short_t mod, Short_t fil) :
50			fTrgId(id), fType(type), fObjInd(obj), fModInd(mod), fFilterInd(fil) {}
51	loizides	1.1
52	loizides	1.9	UShort_t FilterInd() const { return fFilterInd; }
53			UShort_t ModInd() const { return fModInd; }
54			UShort_t ObjInd() const { return fObjInd; }
55	loizides	1.5	EObjType ObjType() const { return kTriggerObjectRef; }
56	loizides	1.9	UChar_t TrgId() const { return fTrgId; }
57			UChar_t Type() const { return fType; }
58	loizides	1.1
59			protected:
60	loizides	1.2	UChar_t fTrgId; //trigger id
61	loizides	1.1	UChar_t fType; //object type
62	loizides	1.2	Short_t fObjInd; //trigger object index
63	loizides	1.1	Short_t fModInd; //module label index
64			Short_t fFilterInd; //filter label index
65
66			ClassDef(TriggerObjectRel, 1) // Trigger to trigger object relation class
67			};
68
69			class TriggerObject : public TriggerObjectBase
70			{
71			public:
72			enum ETriggerObject { // see DataFormats/HLTReco/interface/TriggerTypeDefs.h
73	loizides	1.10	None = 0,
74			TriggerL1Mu = -81,
75			TriggerL1NoIsoEG = -82,
76			TriggerL1IsoEG = -83,
77			TriggerL1CenJet = -84,
78			TriggerL1ForJet = -85,
79			TriggerL1TauJet = -86,
80			TriggerL1ETM = -87,
81			TriggerL1ETT = -88,
82			TriggerL1HTT = -89,
83			TriggerL1HTM = -90,
84			TriggerL1JetCounts = -91,
85			TriggerL1HfBitCounts = -92,
86			TriggerL1HfRingEtSums = -93,
87			TriggerL1TechTrig = -94,
88			TriggerL1Castor = -95,
89			TriggerL1BPTX = -96,
90			TriggerPhoton = +81,
91			TriggerElectron = +82,
92			TriggerMuon = +83,
93			TriggerTau = +84,
94			TriggerJet = +85,
95			TriggerBJet = +86,
96			TriggerMET = +87,
97			TriggerTET = +88,
98			TriggerTHT = +89,
99			TriggerMHT = +90,
100			TriggerTrack = +91,
101			TriggerCluster = +92,
102			TriggerMETSig = +93,
103			TriggerELongit = +94,
104			TriggerMHTSig = +95,
105			TriggerHLongit = +96
106	loizides	1.1	};
107
108	loizides	1.2	TriggerObject() : fTrgId(0), fType(None), fTrigName(0), fModName(0), fFilName(0) {}
109			TriggerObject(UChar_t tid, UChar_t type, Int_t id, const FourVectorM32 &mom) :
110			TriggerObjectBase(id,mom), fTrgId(tid), fType(static_cast<ETriggerObject>(type)) {}
111	loizides	1.6	TriggerObject(UChar_t tid, UChar_t type, Int_t id,
112	loizides	1.1	Double_t pt, Double_t eta, Double_t phi, Double_t mass) :
113	loizides	1.2	TriggerObjectBase(id,pt,eta,phi,mass), fTrgId(tid),
114			fType(static_cast<ETriggerObject>(type)) {}
115	loizides	1.1
116	loizides	1.10	const char *FilterName() const { return fFilName; }
117	loizides	1.9	ULong_t Hash() const { return fTrgId; }
118	loizides	1.10	Bool_t IsHLT() const { return fType>0; }
119			Bool_t IsL1() const { return fType<0; }
120	loizides	1.9	const char *ModuleName() const { return fModName; }
121	loizides	1.6	EObjType ObjType() const { return kTriggerObject; }
122	loizides	1.2	void Print(Option_t *opt="") const;
123	loizides	1.9	const char *TrigName() const { return fTrigName; }
124			UShort_t TrgId() const { return fTrgId; }
125			ETriggerObject Type() const { return fType; }
126	loizides	1.6	void SetTrigName(const char *n) { fTrigName = n; }
127	loizides	1.9	void SetModuleName(const char *n) { fModName = n; }
128			void SetFilterName(const char *n) { fFilName = n; }
129	loizides	1.1
130			protected:
131	loizides	1.2	UChar_t fTrgId; //trigger id
132	loizides	1.1	ETriggerObject fType; //object type
133	loizides	1.2	const char *fTrigName; //!trigger name
134			const char *fModName; //!L3 module name
135			const char *fFilName; //!L3 filter name
136	loizides	1.1
137	loizides	1.10	ClassDef(TriggerObject, 2) // Trigger object class
138	loizides	1.1	};
139	loizides	1.2
140			//--------------------------------------------------------------------------------------------------
141			// TriggerObjectsTable
142			//
143			// A convenient THashTable for storage of TriggerObjects (not streamable).
144			//
145			// Authors: C.Loizides
146			//--------------------------------------------------------------------------------------------------
147			class TriggerObjectsTable : public THashTable
148			{
149			private:
150			class MyKey : public TObject
151			{
152			public:
153			MyKey(ULong_t hash) : fHash(hash) {}
154			ULong_t Hash() const { return fHash; }
155			protected:
156			ULong_t fHash; //hash value
157			};
158
159			public:
160			TriggerObjectsTable(const TriggerTable *table,
161			Int_t capacity = TCollection::kInitHashTableCapacity, Int_t rehash = 0) :
162			THashTable(capacity,rehash), fTriggers(table) {}
163
164	loizides	1.3	const TList GetList(const char name) const;
165			const TList *GetList(ULong_t id) const;
166	loizides	1.2	using TCollection::Print;
167	loizides	1.3	void Print(Option_t *opt="") const;
168	loizides	1.2
169			protected:
170	loizides	1.7	const TriggerTable *fTriggers; //trigger table
171	loizides	1.2	};
172			}
173
174			//--------------------------------------------------------------------------------------------------
175	loizides	1.6	inline void mithep::TriggerObjectBase::GetMom() const
176			{
177			// Get momentum values from stored values.
178
179			fCachedMom.SetCoordinates(fMom.Pt(),fMom.Eta(),fMom.Phi(),fMom.M());
180			}
181
182			//--------------------------------------------------------------------------------------------------
183	loizides	1.3	inline const TList mithep::TriggerObjectsTable::GetList(const char name) const
184	loizides	1.2	{
185	loizides	1.3	// Return list of trigger objects for given trigger name.
186	loizides	1.2
187			ULong_t id = fTriggers->GetId(name);
188	loizides	1.3	return GetList(id);
189	loizides	1.2	}
190
191			//--------------------------------------------------------------------------------------------------
192			inline const TList *mithep::TriggerObjectsTable::GetList(ULong_t id) const
193			{
194			// Return list of trigger objects for given trigger id (bit).
195
196			MyKey key(id);
197			return const_cast<const TList*>(GetListForObject(&key));
198	loizides	1.1	}
199			#endif