UserArea/StatTools/tree.h

//////////////////////////////////////////////////////////
// This class has been automatically generated on
// Sun Nov 28 09:48:32 2010 by ROOT version 5.26/00
// from TChain tree/
//////////////////////////////////////////////////////////

#ifndef tree_h
#define tree_h

#include <TROOT.h>
#include <TChain.h>
#include <TFile.h>

class tree {
public :
   TTree          *fChain;   //!pointer to the analyzed TTree or TChain
   Int_t           fCurrent; //!current Tree number in a TChain

   // Declaration of leaf types
   Int_t           eventInfo_run;
   Int_t           eventInfo_lumi;
   Int_t           eventInfo_event;

   struct _MuonInfo{
     int charge;
     float pt;
     float eta;
     float phi;

     float normChiSquare;
     float d0;

     int numValidMuonHits;
     int numValidPixelHits;
     int numValidTrackerHits;
     int numValidStripHits;
     int numSegmentMatches;

     float trackIsoSumPt;

     int isHltMatched;
     char hltPath[128];

   } reco1, reco2;

   Float_t         recoCandMass;
   Float_t         recoCandPt;
   Float_t         recoCandMassCktl;
   Float_t         recoCandPtCktl;
   Int_t           cocktail1_charge;
   Float_t         cocktail1_pt;
   Float_t         cocktail1_eta;
   Float_t         cocktail1_phi;
   Int_t           cocktail2_charge;
   Float_t         cocktail2_pt;
   Float_t         cocktail2_eta;
   Float_t         cocktail2_phi;

   // List of branches
   TBranch        *b_eventInfo;   //!
   TBranch        *b_reco1;   //!
   TBranch        *b_reco2;   //!
   TBranch        *b_recoCandMass;   //!
   TBranch        *b_recoCandPt;   //!
   TBranch        *b_recoCandMassCktl;   //!
   TBranch        *b_recoCandPtCktl;   //!
   TBranch        *b_cocktail1;   //!
   TBranch        *b_cocktail2;   //!

   tree(TTree *tree=0);
   virtual ~tree();
   virtual Int_t    Cut(Long64_t entry);
   virtual Int_t    GetEntry(Long64_t entry);
   virtual Long64_t LoadTree(Long64_t entry);
   virtual void     Init(TTree *tree);
   virtual void     Loop();
   virtual Bool_t   Notify();
   virtual void     Show(Long64_t entry = -1);
};

#endif

#ifdef tree_cxx
tree::tree(TTree *tree)
{
// if parameter tree is not specified (or zero), connect the file
// used to generate this class and read the Tree.
   if (tree == 0) {

#ifdef SINGLE_TREE
      // The following code should be used if you want this class to access
      // a single tree instead of a chain
      TFile *f = (TFile*)gROOT->GetListOfFiles()->FindObject("Memory Directory");
      if (!f) {
         f = new TFile("Memory Directory");
         f->cd("Rint:/");
      }
      tree = (TTree*)gDirectory->Get("tree");

#else // SINGLE_TREE

      // The following code should be used if you want this class to access a chain
      // of trees.
      TChain * chain = new TChain("tree","");
//      chain->Add("dimuons_run132440to147195.root/tree");
//      chain->Add("dimuons_run147196to148058.root/tree");
//      chain->Add("dimuons_run148059to149442.root/tree");
      chain->Add("dimuons_DYToMuMu_M-20_CT10_TuneZ2_7TeV-Fall10.root/tree");
      tree = chain;
#endif // SINGLE_TREE

   }
   Init(tree);
}

tree::~tree()
{
   if (!fChain) return;
   delete fChain->GetCurrentFile();
}

Int_t tree::GetEntry(Long64_t entry)
{
// Read contents of entry.
   if (!fChain) return 0;
   return fChain->GetEntry(entry);
}
Long64_t tree::LoadTree(Long64_t entry)
{
// Set the environment to read one entry
   if (!fChain) return -5;
   Long64_t centry = fChain->LoadTree(entry);
   if (centry < 0) return centry;
   if (!fChain->InheritsFrom(TChain::Class()))  return centry;
   TChain *chain = (TChain*)fChain;
   if (chain->GetTreeNumber() != fCurrent) {
      fCurrent = chain->GetTreeNumber();
      Notify();
   }
   return centry;
}

void tree::Init(TTree *tree)
{
   // The Init() function is called when the selector needs to initialize
   // a new tree or chain. Typically here the branch addresses and branch
   // pointers of the tree will be set.
   // It is normally not necessary to make changes to the generated
   // code, but the routine can be extended by the user if needed.
   // Init() will be called many times when running on PROOF
   // (once per file to be processed).

   // Set branch addresses and branch pointers
   if (!tree) return;
   fChain = tree;
   fCurrent = -1;
   fChain->SetMakeClass(1);

   fChain->SetBranchAddress("eventInfo", &eventInfo_run, &b_eventInfo);
   fChain->SetBranchAddress("reco1", &reco1, &b_reco1);
   fChain->SetBranchAddress("reco2", &reco2, &b_reco2);
   fChain->SetBranchAddress("recoCandMass", &recoCandMass, &b_recoCandMass);
   fChain->SetBranchAddress("recoCandPt", &recoCandPt, &b_recoCandPt);
   fChain->SetBranchAddress("recoCandMassCktl", &recoCandMassCktl, &b_recoCandMassCktl);
   fChain->SetBranchAddress("recoCandPtCktl", &recoCandPtCktl, &b_recoCandPtCktl);
   fChain->SetBranchAddress("cocktail1", &cocktail1_charge, &b_cocktail1);
   fChain->SetBranchAddress("cocktail2", &cocktail2_charge, &b_cocktail2);
   Notify();
}

Bool_t tree::Notify()
{
   // The Notify() function is called when a new file is opened. This
   // can be either for a new TTree in a TChain or when when a new TTree
   // is started when using PROOF. It is normally not necessary to make changes
   // to the generated code, but the routine can be extended by the
   // user if needed. The return value is currently not used.

   return kTRUE;
}

void tree::Show(Long64_t entry)
{
// Print contents of entry.
// If entry is not specified, print current entry
   if (!fChain) return;
   fChain->Show(entry);
}
Int_t tree::Cut(Long64_t entry)
{
// This function may be called from Loop.
// returns  1 if entry is accepted.
// returns -1 otherwise.
   return 1;
}
#endif // #ifdef tree_cxx
Revision:	1.1
Committed:	Wed Dec 8 10:57:13 2010 UTC (14 years, 4 months ago) by kkotov
Content type:	text/plain
Branch:	MAIN
CVS Tags:	V2012-H-02, V2012-01-00, V2011-01-01, V2011-01-00, AnnaDimuon, V01-00-01, V01-00-00, HEAD
Log Message:	* empty log message *
#	User	Rev	Content
1	kkotov	1.1	//////////////////////////////////////////////////////////
2			// This class has been automatically generated on
3			// Sun Nov 28 09:48:32 2010 by ROOT version 5.26/00
4			// from TChain tree/
5			//////////////////////////////////////////////////////////
6
7			#ifndef tree_h
8			#define tree_h
9
10			#include <TROOT.h>
11			#include <TChain.h>
12			#include <TFile.h>
13
14			class tree {
15			public :
16			TTree *fChain; //!pointer to the analyzed TTree or TChain
17			Int_t fCurrent; //!current Tree number in a TChain
18
19			// Declaration of leaf types
20			Int_t eventInfo_run;
21			Int_t eventInfo_lumi;
22			Int_t eventInfo_event;
23
24			struct _MuonInfo{
25			int charge;
26			float pt;
27			float eta;
28			float phi;
29
30			float normChiSquare;
31			float d0;
32
33			int numValidMuonHits;
34			int numValidPixelHits;
35			int numValidTrackerHits;
36			int numValidStripHits;
37			int numSegmentMatches;
38
39			float trackIsoSumPt;
40
41			int isHltMatched;
42			char hltPath[128];
43
44			} reco1, reco2;
45
46			Float_t recoCandMass;
47			Float_t recoCandPt;
48			Float_t recoCandMassCktl;
49			Float_t recoCandPtCktl;
50			Int_t cocktail1_charge;
51			Float_t cocktail1_pt;
52			Float_t cocktail1_eta;
53			Float_t cocktail1_phi;
54			Int_t cocktail2_charge;
55			Float_t cocktail2_pt;
56			Float_t cocktail2_eta;
57			Float_t cocktail2_phi;
58
59			// List of branches
60			TBranch *b_eventInfo; //!
61			TBranch *b_reco1; //!
62			TBranch *b_reco2; //!
63			TBranch *b_recoCandMass; //!
64			TBranch *b_recoCandPt; //!
65			TBranch *b_recoCandMassCktl; //!
66			TBranch *b_recoCandPtCktl; //!
67			TBranch *b_cocktail1; //!
68			TBranch *b_cocktail2; //!
69
70			tree(TTree *tree=0);
71			virtual ~tree();
72			virtual Int_t Cut(Long64_t entry);
73			virtual Int_t GetEntry(Long64_t entry);
74			virtual Long64_t LoadTree(Long64_t entry);
75			virtual void Init(TTree *tree);
76			virtual void Loop();
77			virtual Bool_t Notify();
78			virtual void Show(Long64_t entry = -1);
79			};
80
81			#endif
82
83			#ifdef tree_cxx
84			tree::tree(TTree *tree)
85			{
86			// if parameter tree is not specified (or zero), connect the file
87			// used to generate this class and read the Tree.
88			if (tree == 0) {
89
90			#ifdef SINGLE_TREE
91			// The following code should be used if you want this class to access
92			// a single tree instead of a chain
93			TFile f = (TFile)gROOT->GetListOfFiles()->FindObject("Memory Directory");
94			if (!f) {
95			f = new TFile("Memory Directory");
96			f->cd("Rint:/");
97			}
98			tree = (TTree*)gDirectory->Get("tree");
99
100			#else // SINGLE_TREE
101
102			// The following code should be used if you want this class to access a chain
103			// of trees.
104			TChain * chain = new TChain("tree","");
105			// chain->Add("dimuons_run132440to147195.root/tree");
106			// chain->Add("dimuons_run147196to148058.root/tree");
107			// chain->Add("dimuons_run148059to149442.root/tree");
108			chain->Add("dimuons_DYToMuMu_M-20_CT10_TuneZ2_7TeV-Fall10.root/tree");
109			tree = chain;
110			#endif // SINGLE_TREE
111
112			}
113			Init(tree);
114			}
115
116			tree::~tree()
117			{
118			if (!fChain) return;
119			delete fChain->GetCurrentFile();
120			}
121
122			Int_t tree::GetEntry(Long64_t entry)
123			{
124			// Read contents of entry.
125			if (!fChain) return 0;
126			return fChain->GetEntry(entry);
127			}
128			Long64_t tree::LoadTree(Long64_t entry)
129			{
130			// Set the environment to read one entry
131			if (!fChain) return -5;
132			Long64_t centry = fChain->LoadTree(entry);
133			if (centry < 0) return centry;
134			if (!fChain->InheritsFrom(TChain::Class())) return centry;
135			TChain chain = (TChain)fChain;
136			if (chain->GetTreeNumber() != fCurrent) {
137			fCurrent = chain->GetTreeNumber();
138			Notify();
139			}
140			return centry;
141			}
142
143			void tree::Init(TTree *tree)
144			{
145			// The Init() function is called when the selector needs to initialize
146			// a new tree or chain. Typically here the branch addresses and branch
147			// pointers of the tree will be set.
148			// It is normally not necessary to make changes to the generated
149			// code, but the routine can be extended by the user if needed.
150			// Init() will be called many times when running on PROOF
151			// (once per file to be processed).
152
153			// Set branch addresses and branch pointers
154			if (!tree) return;
155			fChain = tree;
156			fCurrent = -1;
157			fChain->SetMakeClass(1);
158
159			fChain->SetBranchAddress("eventInfo", &eventInfo_run, &b_eventInfo);
160			fChain->SetBranchAddress("reco1", &reco1, &b_reco1);
161			fChain->SetBranchAddress("reco2", &reco2, &b_reco2);
162			fChain->SetBranchAddress("recoCandMass", &recoCandMass, &b_recoCandMass);
163			fChain->SetBranchAddress("recoCandPt", &recoCandPt, &b_recoCandPt);
164			fChain->SetBranchAddress("recoCandMassCktl", &recoCandMassCktl, &b_recoCandMassCktl);
165			fChain->SetBranchAddress("recoCandPtCktl", &recoCandPtCktl, &b_recoCandPtCktl);
166			fChain->SetBranchAddress("cocktail1", &cocktail1_charge, &b_cocktail1);
167			fChain->SetBranchAddress("cocktail2", &cocktail2_charge, &b_cocktail2);
168			Notify();
169			}
170
171			Bool_t tree::Notify()
172			{
173			// The Notify() function is called when a new file is opened. This
174			// can be either for a new TTree in a TChain or when when a new TTree
175			// is started when using PROOF. It is normally not necessary to make changes
176			// to the generated code, but the routine can be extended by the
177			// user if needed. The return value is currently not used.
178
179			return kTRUE;
180			}
181
182			void tree::Show(Long64_t entry)
183			{
184			// Print contents of entry.
185			// If entry is not specified, print current entry
186			if (!fChain) return;
187			fChain->Show(entry);
188			}
189			Int_t tree::Cut(Long64_t entry)
190			{
191			// This function may be called from Loop.
192			// returns 1 if entry is accepted.
193			// returns -1 otherwise.
194			return 1;
195			}
196			#endif // #ifdef tree_cxx