ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/FGolf/rf/CMS2.h
Revision: 1.1
Committed: Wed Dec 23 17:33:24 2009 UTC (15 years, 4 months ago) by benhoob
Content type: text/plain
Branch: MAIN
CVS Tags: HEAD
Log Message: 
*** empty log message ***

File Contents

# User Rev Content
1 benhoob 1.1 // -*- C++ -*-
2     #ifndef CMS2_H
3     #define CMS2_H
4     #include "Math/LorentzVector.h"
5     #include "Math/Point3D.h"
6     #include "TMath.h"
7     #include "TBranch.h"
8     #include "TTree.h"
9     #include "TH1F.h"
10     #include "TFile.h"
11     #include <vector>
12    
13     #define PARANOIA
14    
15     using namespace std;
16     class CMS2 {
17     private:
18     protected:
19     unsigned int index;
20     TString evt_CMS2tag_;
21     TBranch *evt_CMS2tag_branch;
22     bool evt_CMS2tag_isLoaded;
23     TString evt_dataset_;
24     TBranch *evt_dataset_branch;
25     bool evt_dataset_isLoaded;
26     vector<double> els_inner_positionx_;
27     TBranch *els_inner_positionx_branch;
28     bool els_inner_positionx_isLoaded;
29     vector<double> els_inner_positiony_;
30     TBranch *els_inner_positiony_branch;
31     bool els_inner_positiony_isLoaded;
32     vector<double> els_inner_positionz_;
33     TBranch *els_inner_positionz_branch;
34     bool els_inner_positionz_isLoaded;
35     float evt_bs_Xwidth_;
36     TBranch *evt_bs_Xwidth_branch;
37     bool evt_bs_Xwidth_isLoaded;
38     float evt_bs_XwidthErr_;
39     TBranch *evt_bs_XwidthErr_branch;
40     bool evt_bs_XwidthErr_isLoaded;
41     float evt_bs_Ywidth_;
42     TBranch *evt_bs_Ywidth_branch;
43     bool evt_bs_Ywidth_isLoaded;
44     float evt_bs_YwidthErr_;
45     TBranch *evt_bs_YwidthErr_branch;
46     bool evt_bs_YwidthErr_isLoaded;
47     float evt_bs_dxdz_;
48     TBranch *evt_bs_dxdz_branch;
49     bool evt_bs_dxdz_isLoaded;
50     float evt_bs_dxdzErr_;
51     TBranch *evt_bs_dxdzErr_branch;
52     bool evt_bs_dxdzErr_isLoaded;
53     float evt_bs_dydz_;
54     TBranch *evt_bs_dydz_branch;
55     bool evt_bs_dydz_isLoaded;
56     float evt_bs_dydzErr_;
57     TBranch *evt_bs_dydzErr_branch;
58     bool evt_bs_dydzErr_isLoaded;
59     float evt_bs_sigmaZ_;
60     TBranch *evt_bs_sigmaZ_branch;
61     bool evt_bs_sigmaZ_isLoaded;
62     float evt_bs_sigmaZErr_;
63     TBranch *evt_bs_sigmaZErr_branch;
64     bool evt_bs_sigmaZErr_isLoaded;
65     float evt_bs_xErr_;
66     TBranch *evt_bs_xErr_branch;
67     bool evt_bs_xErr_isLoaded;
68     float evt_bs_yErr_;
69     TBranch *evt_bs_yErr_branch;
70     bool evt_bs_yErr_isLoaded;
71     float evt_bs_zErr_;
72     TBranch *evt_bs_zErr_branch;
73     bool evt_bs_zErr_isLoaded;
74     float evt_bField_;
75     TBranch *evt_bField_branch;
76     bool evt_bField_isLoaded;
77     ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > evt_bsp4_;
78     TBranch *evt_bsp4_branch;
79     bool evt_bsp4_isLoaded;
80     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > els_p4_;
81     TBranch *els_p4_branch;
82     bool els_p4_isLoaded;
83     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > els_p4In_;
84     TBranch *els_p4In_branch;
85     bool els_p4In_isLoaded;
86     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > els_p4Out_;
87     TBranch *els_p4Out_branch;
88     bool els_p4Out_isLoaded;
89     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > els_trk_p4_;
90     TBranch *els_trk_p4_branch;
91     bool els_trk_p4_isLoaded;
92     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > els_vertex_p4_;
93     TBranch *els_vertex_p4_branch;
94     bool els_vertex_p4_isLoaded;
95     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > mus_fitdefault_p4_;
96     TBranch *mus_fitdefault_p4_branch;
97     bool mus_fitdefault_p4_isLoaded;
98     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > mus_fitfirsthit_p4_;
99     TBranch *mus_fitfirsthit_p4_branch;
100     bool mus_fitfirsthit_p4_isLoaded;
101     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > mus_fitpicky_p4_;
102     TBranch *mus_fitpicky_p4_branch;
103     bool mus_fitpicky_p4_isLoaded;
104     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > mus_fittev_p4_;
105     TBranch *mus_fittev_p4_branch;
106     bool mus_fittev_p4_isLoaded;
107     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > mus_gfit_outerPos_p4_;
108     TBranch *mus_gfit_outerPos_p4_branch;
109     bool mus_gfit_outerPos_p4_isLoaded;
110     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > mus_gfit_p4_;
111     TBranch *mus_gfit_p4_branch;
112     bool mus_gfit_p4_isLoaded;
113     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > mus_gfit_vertex_p4_;
114     TBranch *mus_gfit_vertex_p4_branch;
115     bool mus_gfit_vertex_p4_isLoaded;
116     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > mus_p4_;
117     TBranch *mus_p4_branch;
118     bool mus_p4_isLoaded;
119     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > mus_trk_p4_;
120     TBranch *mus_trk_p4_branch;
121     bool mus_trk_p4_isLoaded;
122     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > mus_vertex_p4_;
123     TBranch *mus_vertex_p4_branch;
124     bool mus_vertex_p4_isLoaded;
125     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > scs_p4_;
126     TBranch *scs_p4_branch;
127     bool scs_p4_isLoaded;
128     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > scs_pos_p4_;
129     TBranch *scs_pos_p4_branch;
130     bool scs_pos_p4_isLoaded;
131     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > scs_vtx_p4_;
132     TBranch *scs_vtx_p4_branch;
133     bool scs_vtx_p4_isLoaded;
134     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > trks_outer_p4_;
135     TBranch *trks_outer_p4_branch;
136     bool trks_outer_p4_isLoaded;
137     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > trks_trk_p4_;
138     TBranch *trks_trk_p4_branch;
139     bool trks_trk_p4_isLoaded;
140     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > trks_vertex_p4_;
141     TBranch *trks_vertex_p4_branch;
142     bool trks_vertex_p4_isLoaded;
143     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > vtxs_position_;
144     TBranch *vtxs_position_branch;
145     bool vtxs_position_isLoaded;
146     vector<float> evt_covMatrix_;
147     TBranch *evt_covMatrix_branch;
148     bool evt_covMatrix_isLoaded;
149     vector<float> twrs_ecalTime_;
150     TBranch *twrs_ecalTime_branch;
151     bool twrs_ecalTime_isLoaded;
152     vector<float> twrs_emEnergy_;
153     TBranch *twrs_emEnergy_branch;
154     bool twrs_emEnergy_isLoaded;
155     vector<float> twrs_emEt_;
156     TBranch *twrs_emEt_branch;
157     bool twrs_emEt_isLoaded;
158     vector<float> twrs_emEtcorr_;
159     TBranch *twrs_emEtcorr_branch;
160     bool twrs_emEtcorr_isLoaded;
161     vector<float> twrs_eta_;
162     TBranch *twrs_eta_branch;
163     bool twrs_eta_isLoaded;
164     vector<float> twrs_etcorr_;
165     TBranch *twrs_etcorr_branch;
166     bool twrs_etcorr_isLoaded;
167     vector<float> twrs_hadEnergy_;
168     TBranch *twrs_hadEnergy_branch;
169     bool twrs_hadEnergy_isLoaded;
170     vector<float> twrs_hadEt_;
171     TBranch *twrs_hadEt_branch;
172     bool twrs_hadEt_isLoaded;
173     vector<float> twrs_hadEtcorr_;
174     TBranch *twrs_hadEtcorr_branch;
175     bool twrs_hadEtcorr_isLoaded;
176     vector<float> twrs_hcalTime_;
177     TBranch *twrs_hcalTime_branch;
178     bool twrs_hcalTime_isLoaded;
179     vector<float> twrs_outerEnergy_;
180     TBranch *twrs_outerEnergy_branch;
181     bool twrs_outerEnergy_isLoaded;
182     vector<float> twrs_outerEt_;
183     TBranch *twrs_outerEt_branch;
184     bool twrs_outerEt_isLoaded;
185     vector<float> twrs_outerEtcorr_;
186     TBranch *twrs_outerEtcorr_branch;
187     bool twrs_outerEtcorr_isLoaded;
188     vector<float> twrs_pcorr_;
189     TBranch *twrs_pcorr_branch;
190     bool twrs_pcorr_isLoaded;
191     vector<float> twrs_phi_;
192     TBranch *twrs_phi_branch;
193     bool twrs_phi_isLoaded;
194     vector<float> els_ecalJuraIso_;
195     TBranch *els_ecalJuraIso_branch;
196     bool els_ecalJuraIso_isLoaded;
197     vector<float> els_ecalJuraTowerIso_;
198     TBranch *els_ecalJuraTowerIso_branch;
199     bool els_ecalJuraTowerIso_isLoaded;
200     vector<float> els_hcalConeIso_;
201     TBranch *els_hcalConeIso_branch;
202     bool els_hcalConeIso_isLoaded;
203     vector<float> els_chi2_;
204     TBranch *els_chi2_branch;
205     bool els_chi2_isLoaded;
206     vector<float> els_d0_;
207     TBranch *els_d0_branch;
208     bool els_d0_isLoaded;
209     vector<float> els_d0Err_;
210     TBranch *els_d0Err_branch;
211     bool els_d0Err_isLoaded;
212     vector<float> els_d0corr_;
213     TBranch *els_d0corr_branch;
214     bool els_d0corr_isLoaded;
215     vector<float> els_dEtaIn_;
216     TBranch *els_dEtaIn_branch;
217     bool els_dEtaIn_isLoaded;
218     vector<float> els_dEtaOut_;
219     TBranch *els_dEtaOut_branch;
220     bool els_dEtaOut_isLoaded;
221     vector<float> els_dPhiIn_;
222     TBranch *els_dPhiIn_branch;
223     bool els_dPhiIn_isLoaded;
224     vector<float> els_dPhiInPhiOut_;
225     TBranch *els_dPhiInPhiOut_branch;
226     bool els_dPhiInPhiOut_isLoaded;
227     vector<float> els_dPhiOut_;
228     TBranch *els_dPhiOut_branch;
229     bool els_dPhiOut_isLoaded;
230     vector<float> els_e1x5_;
231     TBranch *els_e1x5_branch;
232     bool els_e1x5_isLoaded;
233     vector<float> els_e2x5Max_;
234     TBranch *els_e2x5Max_branch;
235     bool els_e2x5Max_isLoaded;
236     vector<float> els_e3x3_;
237     TBranch *els_e3x3_branch;
238     bool els_e3x3_isLoaded;
239     vector<float> els_e5x5_;
240     TBranch *els_e5x5_branch;
241     bool els_e5x5_isLoaded;
242     vector<float> els_eMax_;
243     TBranch *els_eMax_branch;
244     bool els_eMax_isLoaded;
245     vector<float> els_eOverPIn_;
246     TBranch *els_eOverPIn_branch;
247     bool els_eOverPIn_isLoaded;
248     vector<float> els_eSC_;
249     TBranch *els_eSC_branch;
250     bool els_eSC_isLoaded;
251     vector<float> els_eSCPresh_;
252     TBranch *els_eSCPresh_branch;
253     bool els_eSCPresh_isLoaded;
254     vector<float> els_eSCRaw_;
255     TBranch *els_eSCRaw_branch;
256     bool els_eSCRaw_isLoaded;
257     vector<float> els_eSeed_;
258     TBranch *els_eSeed_branch;
259     bool els_eSeed_isLoaded;
260     vector<float> els_eSeedOverPIn_;
261     TBranch *els_eSeedOverPIn_branch;
262     bool els_eSeedOverPIn_isLoaded;
263     vector<float> els_eSeedOverPOut_;
264     TBranch *els_eSeedOverPOut_branch;
265     bool els_eSeedOverPOut_isLoaded;
266     vector<float> els_ecalEnergy_;
267     TBranch *els_ecalEnergy_branch;
268     bool els_ecalEnergy_isLoaded;
269     vector<float> els_ecalEnergyError_;
270     TBranch *els_ecalEnergyError_branch;
271     bool els_ecalEnergyError_isLoaded;
272     vector<float> els_ecalIso_;
273     TBranch *els_ecalIso_branch;
274     bool els_ecalIso_isLoaded;
275     vector<float> els_ecalIso04_;
276     TBranch *els_ecalIso04_branch;
277     bool els_ecalIso04_isLoaded;
278     vector<float> els_egamma_looseId_;
279     TBranch *els_egamma_looseId_branch;
280     bool els_egamma_looseId_isLoaded;
281     vector<float> els_egamma_robustHighEnergy_;
282     TBranch *els_egamma_robustHighEnergy_branch;
283     bool els_egamma_robustHighEnergy_isLoaded;
284     vector<float> els_egamma_robustLooseId_;
285     TBranch *els_egamma_robustLooseId_branch;
286     bool els_egamma_robustLooseId_isLoaded;
287     vector<float> els_egamma_robustTightId_;
288     TBranch *els_egamma_robustTightId_branch;
289     bool els_egamma_robustTightId_isLoaded;
290     vector<float> els_egamma_tightId_;
291     TBranch *els_egamma_tightId_branch;
292     bool els_egamma_tightId_isLoaded;
293     vector<float> els_electronMomentumError_;
294     TBranch *els_electronMomentumError_branch;
295     bool els_electronMomentumError_isLoaded;
296     vector<float> els_etaErr_;
297     TBranch *els_etaErr_branch;
298     bool els_etaErr_isLoaded;
299     vector<float> els_etaSC_;
300     TBranch *els_etaSC_branch;
301     bool els_etaSC_isLoaded;
302     vector<float> els_fBrem_;
303     TBranch *els_fBrem_branch;
304     bool els_fBrem_isLoaded;
305     vector<float> els_hOverE_;
306     TBranch *els_hOverE_branch;
307     bool els_hOverE_isLoaded;
308     vector<float> els_hcalIso_;
309     TBranch *els_hcalIso_branch;
310     bool els_hcalIso_isLoaded;
311     vector<float> els_hcalIso04_;
312     TBranch *els_hcalIso04_branch;
313     bool els_hcalIso04_isLoaded;
314     vector<float> els_layer1_charge_;
315     TBranch *els_layer1_charge_branch;
316     bool els_layer1_charge_isLoaded;
317     vector<float> els_ndof_;
318     TBranch *els_ndof_branch;
319     bool els_ndof_isLoaded;
320     vector<float> els_phiErr_;
321     TBranch *els_phiErr_branch;
322     bool els_phiErr_isLoaded;
323     vector<float> els_phiSC_;
324     TBranch *els_phiSC_branch;
325     bool els_phiSC_isLoaded;
326     vector<float> els_ptErr_;
327     TBranch *els_ptErr_branch;
328     bool els_ptErr_isLoaded;
329     vector<float> els_sigmaEtaEta_;
330     TBranch *els_sigmaEtaEta_branch;
331     bool els_sigmaEtaEta_isLoaded;
332     vector<float> els_sigmaIEtaIEta_;
333     TBranch *els_sigmaIEtaIEta_branch;
334     bool els_sigmaIEtaIEta_isLoaded;
335     vector<float> els_sigmaIPhiIPhi_;
336     TBranch *els_sigmaIPhiIPhi_branch;
337     bool els_sigmaIPhiIPhi_isLoaded;
338     vector<float> els_sigmaPhiPhi_;
339     TBranch *els_sigmaPhiPhi_branch;
340     bool els_sigmaPhiPhi_isLoaded;
341     vector<float> els_tkIso_;
342     TBranch *els_tkIso_branch;
343     bool els_tkIso_isLoaded;
344     vector<float> els_tkIso04_;
345     TBranch *els_tkIso04_branch;
346     bool els_tkIso04_isLoaded;
347     vector<float> els_trackMomentumError_;
348     TBranch *els_trackMomentumError_branch;
349     bool els_trackMomentumError_isLoaded;
350     vector<float> els_trkdr_;
351     TBranch *els_trkdr_branch;
352     bool els_trkdr_isLoaded;
353     vector<float> els_trkshFrac_;
354     TBranch *els_trkshFrac_branch;
355     bool els_trkshFrac_isLoaded;
356     vector<float> els_z0_;
357     TBranch *els_z0_branch;
358     bool els_z0_isLoaded;
359     vector<float> els_z0Err_;
360     TBranch *els_z0Err_branch;
361     bool els_z0Err_isLoaded;
362     vector<float> els_z0corr_;
363     TBranch *els_z0corr_branch;
364     bool els_z0corr_isLoaded;
365     vector<float> mus_caloCompatibility_;
366     TBranch *mus_caloCompatibility_branch;
367     bool mus_caloCompatibility_isLoaded;
368     vector<float> mus_chi2_;
369     TBranch *mus_chi2_branch;
370     bool mus_chi2_isLoaded;
371     vector<float> mus_d0_;
372     TBranch *mus_d0_branch;
373     bool mus_d0_isLoaded;
374     vector<float> mus_d0Err_;
375     TBranch *mus_d0Err_branch;
376     bool mus_d0Err_isLoaded;
377     vector<float> mus_d0corr_;
378     TBranch *mus_d0corr_branch;
379     bool mus_d0corr_isLoaded;
380     vector<float> mus_e_em_;
381     TBranch *mus_e_em_branch;
382     bool mus_e_em_isLoaded;
383     vector<float> mus_e_emS9_;
384     TBranch *mus_e_emS9_branch;
385     bool mus_e_emS9_isLoaded;
386     vector<float> mus_e_had_;
387     TBranch *mus_e_had_branch;
388     bool mus_e_had_isLoaded;
389     vector<float> mus_e_hadS9_;
390     TBranch *mus_e_hadS9_branch;
391     bool mus_e_hadS9_isLoaded;
392     vector<float> mus_e_ho_;
393     TBranch *mus_e_ho_branch;
394     bool mus_e_ho_isLoaded;
395     vector<float> mus_e_hoS9_;
396     TBranch *mus_e_hoS9_branch;
397     bool mus_e_hoS9_isLoaded;
398     vector<float> mus_etaErr_;
399     TBranch *mus_etaErr_branch;
400     bool mus_etaErr_isLoaded;
401     vector<float> mus_gfit_chi2_;
402     TBranch *mus_gfit_chi2_branch;
403     bool mus_gfit_chi2_isLoaded;
404     vector<float> mus_gfit_d0_;
405     TBranch *mus_gfit_d0_branch;
406     bool mus_gfit_d0_isLoaded;
407     vector<float> mus_gfit_d0Err_;
408     TBranch *mus_gfit_d0Err_branch;
409     bool mus_gfit_d0Err_isLoaded;
410     vector<float> mus_gfit_d0corr_;
411     TBranch *mus_gfit_d0corr_branch;
412     bool mus_gfit_d0corr_isLoaded;
413     vector<float> mus_gfit_ndof_;
414     TBranch *mus_gfit_ndof_branch;
415     bool mus_gfit_ndof_isLoaded;
416     vector<float> mus_gfit_qoverp_;
417     TBranch *mus_gfit_qoverp_branch;
418     bool mus_gfit_qoverp_isLoaded;
419     vector<float> mus_gfit_qoverpError_;
420     TBranch *mus_gfit_qoverpError_branch;
421     bool mus_gfit_qoverpError_isLoaded;
422     vector<float> mus_gfit_z0_;
423     TBranch *mus_gfit_z0_branch;
424     bool mus_gfit_z0_isLoaded;
425     vector<float> mus_gfit_z0Err_;
426     TBranch *mus_gfit_z0Err_branch;
427     bool mus_gfit_z0Err_isLoaded;
428     vector<float> mus_gfit_z0corr_;
429     TBranch *mus_gfit_z0corr_branch;
430     bool mus_gfit_z0corr_isLoaded;
431     vector<float> mus_iso03_emEt_;
432     TBranch *mus_iso03_emEt_branch;
433     bool mus_iso03_emEt_isLoaded;
434     vector<float> mus_iso03_hadEt_;
435     TBranch *mus_iso03_hadEt_branch;
436     bool mus_iso03_hadEt_isLoaded;
437     vector<float> mus_iso03_hoEt_;
438     TBranch *mus_iso03_hoEt_branch;
439     bool mus_iso03_hoEt_isLoaded;
440     vector<float> mus_iso03_sumPt_;
441     TBranch *mus_iso03_sumPt_branch;
442     bool mus_iso03_sumPt_isLoaded;
443     vector<float> mus_iso05_emEt_;
444     TBranch *mus_iso05_emEt_branch;
445     bool mus_iso05_emEt_isLoaded;
446     vector<float> mus_iso05_hadEt_;
447     TBranch *mus_iso05_hadEt_branch;
448     bool mus_iso05_hadEt_isLoaded;
449     vector<float> mus_iso05_hoEt_;
450     TBranch *mus_iso05_hoEt_branch;
451     bool mus_iso05_hoEt_isLoaded;
452     vector<float> mus_iso05_sumPt_;
453     TBranch *mus_iso05_sumPt_branch;
454     bool mus_iso05_sumPt_isLoaded;
455     vector<float> mus_iso_ecalvetoDep_;
456     TBranch *mus_iso_ecalvetoDep_branch;
457     bool mus_iso_ecalvetoDep_isLoaded;
458     vector<float> mus_iso_hcalvetoDep_;
459     TBranch *mus_iso_hcalvetoDep_branch;
460     bool mus_iso_hcalvetoDep_isLoaded;
461     vector<float> mus_iso_hovetoDep_;
462     TBranch *mus_iso_hovetoDep_branch;
463     bool mus_iso_hovetoDep_isLoaded;
464     vector<float> mus_iso_trckvetoDep_;
465     TBranch *mus_iso_trckvetoDep_branch;
466     bool mus_iso_trckvetoDep_isLoaded;
467     vector<float> mus_ndof_;
468     TBranch *mus_ndof_branch;
469     bool mus_ndof_isLoaded;
470     vector<float> mus_phiErr_;
471     TBranch *mus_phiErr_branch;
472     bool mus_phiErr_isLoaded;
473     vector<float> mus_ptErr_;
474     TBranch *mus_ptErr_branch;
475     bool mus_ptErr_isLoaded;
476     vector<float> mus_qoverp_;
477     TBranch *mus_qoverp_branch;
478     bool mus_qoverp_isLoaded;
479     vector<float> mus_qoverpError_;
480     TBranch *mus_qoverpError_branch;
481     bool mus_qoverpError_isLoaded;
482     vector<float> mus_timeAtIpInOut_;
483     TBranch *mus_timeAtIpInOut_branch;
484     bool mus_timeAtIpInOut_isLoaded;
485     vector<float> mus_timeAtIpInOutErr_;
486     TBranch *mus_timeAtIpInOutErr_branch;
487     bool mus_timeAtIpInOutErr_isLoaded;
488     vector<float> mus_timeAtIpOutIn_;
489     TBranch *mus_timeAtIpOutIn_branch;
490     bool mus_timeAtIpOutIn_isLoaded;
491     vector<float> mus_timeAtIpOutInErr_;
492     TBranch *mus_timeAtIpOutInErr_branch;
493     bool mus_timeAtIpOutInErr_isLoaded;
494     vector<float> mus_vertexphi_;
495     TBranch *mus_vertexphi_branch;
496     bool mus_vertexphi_isLoaded;
497     vector<float> mus_z0_;
498     TBranch *mus_z0_branch;
499     bool mus_z0_isLoaded;
500     vector<float> mus_z0Err_;
501     TBranch *mus_z0Err_branch;
502     bool mus_z0Err_isLoaded;
503     vector<float> mus_z0corr_;
504     TBranch *mus_z0corr_branch;
505     bool mus_z0corr_isLoaded;
506     vector<float> scs_clustersSize_;
507     TBranch *scs_clustersSize_branch;
508     bool scs_clustersSize_isLoaded;
509     vector<float> scs_crystalsSize_;
510     TBranch *scs_crystalsSize_branch;
511     bool scs_crystalsSize_isLoaded;
512     vector<float> scs_e1x3_;
513     TBranch *scs_e1x3_branch;
514     bool scs_e1x3_isLoaded;
515     vector<float> scs_e1x5_;
516     TBranch *scs_e1x5_branch;
517     bool scs_e1x5_isLoaded;
518     vector<float> scs_e2x2_;
519     TBranch *scs_e2x2_branch;
520     bool scs_e2x2_isLoaded;
521     vector<float> scs_e2x5Max_;
522     TBranch *scs_e2x5Max_branch;
523     bool scs_e2x5Max_isLoaded;
524     vector<float> scs_e3x1_;
525     TBranch *scs_e3x1_branch;
526     bool scs_e3x1_isLoaded;
527     vector<float> scs_e3x2_;
528     TBranch *scs_e3x2_branch;
529     bool scs_e3x2_isLoaded;
530     vector<float> scs_e3x3_;
531     TBranch *scs_e3x3_branch;
532     bool scs_e3x3_isLoaded;
533     vector<float> scs_e4x4_;
534     TBranch *scs_e4x4_branch;
535     bool scs_e4x4_isLoaded;
536     vector<float> scs_e5x5_;
537     TBranch *scs_e5x5_branch;
538     bool scs_e5x5_isLoaded;
539     vector<float> scs_energy_;
540     TBranch *scs_energy_branch;
541     bool scs_energy_isLoaded;
542     vector<float> scs_eta_;
543     TBranch *scs_eta_branch;
544     bool scs_eta_isLoaded;
545     vector<float> scs_hoe_;
546     TBranch *scs_hoe_branch;
547     bool scs_hoe_isLoaded;
548     vector<float> scs_phi_;
549     TBranch *scs_phi_branch;
550     bool scs_phi_isLoaded;
551     vector<float> scs_preshowerEnergy_;
552     TBranch *scs_preshowerEnergy_branch;
553     bool scs_preshowerEnergy_isLoaded;
554     vector<float> scs_rawEnergy_;
555     TBranch *scs_rawEnergy_branch;
556     bool scs_rawEnergy_isLoaded;
557     vector<float> scs_sigmaEtaEta_;
558     TBranch *scs_sigmaEtaEta_branch;
559     bool scs_sigmaEtaEta_isLoaded;
560     vector<float> scs_sigmaEtaPhi_;
561     TBranch *scs_sigmaEtaPhi_branch;
562     bool scs_sigmaEtaPhi_isLoaded;
563     vector<float> scs_sigmaIEtaIEta_;
564     TBranch *scs_sigmaIEtaIEta_branch;
565     bool scs_sigmaIEtaIEta_isLoaded;
566     vector<float> scs_sigmaIEtaIPhi_;
567     TBranch *scs_sigmaIEtaIPhi_branch;
568     bool scs_sigmaIEtaIPhi_isLoaded;
569     vector<float> scs_sigmaIPhiIPhi_;
570     TBranch *scs_sigmaIPhiIPhi_branch;
571     bool scs_sigmaIPhiIPhi_isLoaded;
572     vector<float> scs_sigmaPhiPhi_;
573     TBranch *scs_sigmaPhiPhi_branch;
574     bool scs_sigmaPhiPhi_isLoaded;
575     vector<float> trks_chi2_;
576     TBranch *trks_chi2_branch;
577     bool trks_chi2_isLoaded;
578     vector<float> trks_d0_;
579     TBranch *trks_d0_branch;
580     bool trks_d0_isLoaded;
581     vector<float> trks_d0Err_;
582     TBranch *trks_d0Err_branch;
583     bool trks_d0Err_isLoaded;
584     vector<float> trks_d0corr_;
585     TBranch *trks_d0corr_branch;
586     bool trks_d0corr_isLoaded;
587     vector<float> trks_d0corrPhi_;
588     TBranch *trks_d0corrPhi_branch;
589     bool trks_d0corrPhi_isLoaded;
590     vector<float> trks_etaErr_;
591     TBranch *trks_etaErr_branch;
592     bool trks_etaErr_isLoaded;
593     vector<float> trks_ndof_;
594     TBranch *trks_ndof_branch;
595     bool trks_ndof_isLoaded;
596     vector<float> trks_phiErr_;
597     TBranch *trks_phiErr_branch;
598     bool trks_phiErr_isLoaded;
599     vector<float> trks_ptErr_;
600     TBranch *trks_ptErr_branch;
601     bool trks_ptErr_isLoaded;
602     vector<float> trks_tkIso_;
603     TBranch *trks_tkIso_branch;
604     bool trks_tkIso_isLoaded;
605     vector<float> trks_vertexphi_;
606     TBranch *trks_vertexphi_branch;
607     bool trks_vertexphi_isLoaded;
608     vector<float> trks_z0_;
609     TBranch *trks_z0_branch;
610     bool trks_z0_isLoaded;
611     vector<float> trks_z0Err_;
612     TBranch *trks_z0Err_branch;
613     bool trks_z0Err_isLoaded;
614     vector<float> trks_z0corr_;
615     TBranch *trks_z0corr_branch;
616     bool trks_z0corr_isLoaded;
617     vector<float> trks_elsdr_;
618     TBranch *trks_elsdr_branch;
619     bool trks_elsdr_isLoaded;
620     vector<float> trks_elsshFrac_;
621     TBranch *trks_elsshFrac_branch;
622     bool trks_elsshFrac_isLoaded;
623     vector<float> vtxs_chi2_;
624     TBranch *vtxs_chi2_branch;
625     bool vtxs_chi2_isLoaded;
626     vector<float> vtxs_ndof_;
627     TBranch *vtxs_ndof_branch;
628     bool vtxs_ndof_isLoaded;
629     vector<float> vtxs_xError_;
630     TBranch *vtxs_xError_branch;
631     bool vtxs_xError_isLoaded;
632     vector<float> vtxs_yError_;
633     TBranch *vtxs_yError_branch;
634     bool vtxs_yError_isLoaded;
635     vector<float> vtxs_zError_;
636     TBranch *vtxs_zError_branch;
637     bool vtxs_zError_isLoaded;
638     vector<vector<float> > trks_residualX_;
639     TBranch *trks_residualX_branch;
640     bool trks_residualX_isLoaded;
641     vector<vector<float> > trks_residualY_;
642     TBranch *trks_residualY_branch;
643     bool trks_residualY_isLoaded;
644     vector<vector<float> > vtxs_covMatrix_;
645     TBranch *vtxs_covMatrix_branch;
646     bool vtxs_covMatrix_isLoaded;
647     int evt_bsType_;
648     TBranch *evt_bsType_branch;
649     bool evt_bsType_isLoaded;
650     vector<int> els_category_;
651     TBranch *els_category_branch;
652     bool els_category_isLoaded;
653     vector<int> els_charge_;
654     TBranch *els_charge_branch;
655     bool els_charge_isLoaded;
656     vector<int> els_class_;
657     TBranch *els_class_branch;
658     bool els_class_isLoaded;
659     vector<int> els_fiduciality_;
660     TBranch *els_fiduciality_branch;
661     bool els_fiduciality_isLoaded;
662     vector<int> els_layer1_det_;
663     TBranch *els_layer1_det_branch;
664     bool els_layer1_det_isLoaded;
665     vector<int> els_layer1_layer_;
666     TBranch *els_layer1_layer_branch;
667     bool els_layer1_layer_isLoaded;
668     vector<int> els_layer1_sizerphi_;
669     TBranch *els_layer1_sizerphi_branch;
670     bool els_layer1_sizerphi_isLoaded;
671     vector<int> els_layer1_sizerz_;
672     TBranch *els_layer1_sizerz_branch;
673     bool els_layer1_sizerz_isLoaded;
674     vector<int> els_lostHits_;
675     TBranch *els_lostHits_branch;
676     bool els_lostHits_isLoaded;
677     vector<int> els_lost_pixelhits_;
678     TBranch *els_lost_pixelhits_branch;
679     bool els_lost_pixelhits_isLoaded;
680     vector<int> els_nSeed_;
681     TBranch *els_nSeed_branch;
682     bool els_nSeed_isLoaded;
683     vector<int> els_sccharge_;
684     TBranch *els_sccharge_branch;
685     bool els_sccharge_isLoaded;
686     vector<int> els_trkidx_;
687     TBranch *els_trkidx_branch;
688     bool els_trkidx_isLoaded;
689     vector<int> els_type_;
690     TBranch *els_type_branch;
691     bool els_type_isLoaded;
692     vector<int> els_validHits_;
693     TBranch *els_validHits_branch;
694     bool els_validHits_isLoaded;
695     vector<int> els_valid_pixelhits_;
696     TBranch *els_valid_pixelhits_branch;
697     bool els_valid_pixelhits_isLoaded;
698     vector<int> mus_charge_;
699     TBranch *mus_charge_branch;
700     bool mus_charge_isLoaded;
701     vector<int> mus_gfit_validHits_;
702     TBranch *mus_gfit_validHits_branch;
703     bool mus_gfit_validHits_isLoaded;
704     vector<int> mus_gfit_validSTAHits_;
705     TBranch *mus_gfit_validSTAHits_branch;
706     bool mus_gfit_validSTAHits_isLoaded;
707     vector<int> mus_gfit_validSiHits_;
708     TBranch *mus_gfit_validSiHits_branch;
709     bool mus_gfit_validSiHits_isLoaded;
710     vector<int> mus_goodmask_;
711     TBranch *mus_goodmask_branch;
712     bool mus_goodmask_isLoaded;
713     vector<int> mus_iso03_ntrk_;
714     TBranch *mus_iso03_ntrk_branch;
715     bool mus_iso03_ntrk_isLoaded;
716     vector<int> mus_iso05_ntrk_;
717     TBranch *mus_iso05_ntrk_branch;
718     bool mus_iso05_ntrk_isLoaded;
719     vector<int> mus_lostHits_;
720     TBranch *mus_lostHits_branch;
721     bool mus_lostHits_isLoaded;
722     vector<int> mus_nmatches_;
723     TBranch *mus_nmatches_branch;
724     bool mus_nmatches_isLoaded;
725     vector<int> mus_pid_TM2DCompatibilityLoose_;
726     TBranch *mus_pid_TM2DCompatibilityLoose_branch;
727     bool mus_pid_TM2DCompatibilityLoose_isLoaded;
728     vector<int> mus_pid_TM2DCompatibilityTight_;
729     TBranch *mus_pid_TM2DCompatibilityTight_branch;
730     bool mus_pid_TM2DCompatibilityTight_isLoaded;
731     vector<int> mus_pid_TMLastStationLoose_;
732     TBranch *mus_pid_TMLastStationLoose_branch;
733     bool mus_pid_TMLastStationLoose_isLoaded;
734     vector<int> mus_pid_TMLastStationTight_;
735     TBranch *mus_pid_TMLastStationTight_branch;
736     bool mus_pid_TMLastStationTight_isLoaded;
737     vector<int> mus_timeDirection_;
738     TBranch *mus_timeDirection_branch;
739     bool mus_timeDirection_isLoaded;
740     vector<int> mus_timeNumStationsUsed_;
741     TBranch *mus_timeNumStationsUsed_branch;
742     bool mus_timeNumStationsUsed_isLoaded;
743     vector<int> mus_trk_charge_;
744     TBranch *mus_trk_charge_branch;
745     bool mus_trk_charge_isLoaded;
746     vector<int> mus_trkidx_;
747     TBranch *mus_trkidx_branch;
748     bool mus_trkidx_isLoaded;
749     vector<int> mus_type_;
750     TBranch *mus_type_branch;
751     bool mus_type_isLoaded;
752     vector<int> mus_validHits_;
753     TBranch *mus_validHits_branch;
754     bool mus_validHits_isLoaded;
755     vector<int> scs_elsidx_;
756     TBranch *scs_elsidx_branch;
757     bool scs_elsidx_isLoaded;
758     vector<int> trks_algo_;
759     TBranch *trks_algo_branch;
760     bool trks_algo_isLoaded;
761     vector<int> trks_charge_;
762     TBranch *trks_charge_branch;
763     bool trks_charge_isLoaded;
764     vector<int> trks_lostHits_;
765     TBranch *trks_lostHits_branch;
766     bool trks_lostHits_isLoaded;
767     vector<int> trks_qualityMask_;
768     TBranch *trks_qualityMask_branch;
769     bool trks_qualityMask_isLoaded;
770     vector<int> trks_validHits_;
771     TBranch *trks_validHits_branch;
772     bool trks_validHits_isLoaded;
773     vector<int> trks_elsidx_;
774     TBranch *trks_elsidx_branch;
775     bool trks_elsidx_isLoaded;
776     vector<int> trk_musidx_;
777     TBranch *trk_musidx_branch;
778     bool trk_musidx_isLoaded;
779     vector<int> vtxs_isFake_;
780     TBranch *vtxs_isFake_branch;
781     bool vtxs_isFake_isLoaded;
782     vector<int> vtxs_isValid_;
783     TBranch *vtxs_isValid_branch;
784     bool vtxs_isValid_isLoaded;
785     vector<int> vtxs_tracksSize_;
786     TBranch *vtxs_tracksSize_branch;
787     bool vtxs_tracksSize_isLoaded;
788     vector<vector<int> > trks_hit_substructure_;
789     TBranch *trks_hit_substructure_branch;
790     bool trks_hit_substructure_isLoaded;
791     vector<vector<int> > trks_hit_type_;
792     TBranch *trks_hit_type_branch;
793     bool trks_hit_type_isLoaded;
794     unsigned int evt_ntwrs_;
795     TBranch *evt_ntwrs_branch;
796     bool evt_ntwrs_isLoaded;
797     unsigned int evt_nels_;
798     TBranch *evt_nels_branch;
799     bool evt_nels_isLoaded;
800     unsigned int evt_event_;
801     TBranch *evt_event_branch;
802     bool evt_event_isLoaded;
803     unsigned int evt_lumiBlock_;
804     TBranch *evt_lumiBlock_branch;
805     bool evt_lumiBlock_isLoaded;
806     unsigned int evt_run_;
807     TBranch *evt_run_branch;
808     bool evt_run_isLoaded;
809     unsigned int evt_nscs_;
810     TBranch *evt_nscs_branch;
811     bool evt_nscs_isLoaded;
812     unsigned int evt_nvtxs_;
813     TBranch *evt_nvtxs_branch;
814     bool evt_nvtxs_isLoaded;
815     vector<unsigned int> twrs_numBadEcalCells_;
816     TBranch *twrs_numBadEcalCells_branch;
817     bool twrs_numBadEcalCells_isLoaded;
818     vector<unsigned int> twrs_numBadHcalCells_;
819     TBranch *twrs_numBadHcalCells_branch;
820     bool twrs_numBadHcalCells_isLoaded;
821     vector<unsigned int> twrs_numProblematicEcalCells_;
822     TBranch *twrs_numProblematicEcalCells_branch;
823     bool twrs_numProblematicEcalCells_isLoaded;
824     vector<unsigned int> twrs_numProblematicHcalCells_;
825     TBranch *twrs_numProblematicHcalCells_branch;
826     bool twrs_numProblematicHcalCells_isLoaded;
827     vector<unsigned int> twrs_numRecoveredEcalCells_;
828     TBranch *twrs_numRecoveredEcalCells_branch;
829     bool twrs_numRecoveredEcalCells_isLoaded;
830     vector<unsigned int> twrs_numRecoveredHcalCells_;
831     TBranch *twrs_numRecoveredHcalCells_branch;
832     bool twrs_numRecoveredHcalCells_isLoaded;
833     float evt_scale1fb_;
834     TBranch *evt_scale1fb_branch;
835     bool evt_scale1fb_isLoaded;
836     float evt_xsec_excl_;
837     TBranch *evt_xsec_excl_branch;
838     bool evt_xsec_excl_isLoaded;
839     float evt_xsec_incl_;
840     TBranch *evt_xsec_incl_branch;
841     bool evt_xsec_incl_isLoaded;
842     float evt_kfactor_;
843     TBranch *evt_kfactor_branch;
844     bool evt_kfactor_isLoaded;
845     int evt_nEvts_;
846     TBranch *evt_nEvts_branch;
847     bool evt_nEvts_isLoaded;
848     float evt_filt_eff_;
849     TBranch *evt_filt_eff_branch;
850     bool evt_filt_eff_isLoaded;
851     public:
852     int ScanChain(class TChain* chain, int nEvents=-1, std::string skimFilePrefix="");
853     void Init(TTree *tree) {
854     evt_bsp4_branch = 0;
855     if (tree->GetAlias("evt_bsp4") != 0) {
856     evt_bsp4_branch = tree->GetBranch(tree->GetAlias("evt_bsp4"));
857     evt_bsp4_branch->SetAddress(&evt_bsp4_);
858     }
859     if(evt_bsp4_branch == 0 ) {
860     cout << "Branch evt_bsp4 does not exist." << endl;
861     }
862     els_p4_branch = 0;
863     if (tree->GetAlias("els_p4") != 0) {
864     els_p4_branch = tree->GetBranch(tree->GetAlias("els_p4"));
865     els_p4_branch->SetAddress(&els_p4_);
866     }
867     if(els_p4_branch == 0 ) {
868     cout << "Branch els_p4 does not exist." << endl;
869     }
870     els_p4In_branch = 0;
871     if (tree->GetAlias("els_p4In") != 0) {
872     els_p4In_branch = tree->GetBranch(tree->GetAlias("els_p4In"));
873     els_p4In_branch->SetAddress(&els_p4In_);
874     }
875     if(els_p4In_branch == 0 ) {
876     cout << "Branch els_p4In does not exist." << endl;
877     }
878     els_p4Out_branch = 0;
879     if (tree->GetAlias("els_p4Out") != 0) {
880     els_p4Out_branch = tree->GetBranch(tree->GetAlias("els_p4Out"));
881     els_p4Out_branch->SetAddress(&els_p4Out_);
882     }
883     if(els_p4Out_branch == 0 ) {
884     cout << "Branch els_p4Out does not exist." << endl;
885     }
886     els_trk_p4_branch = 0;
887     if (tree->GetAlias("els_trk_p4") != 0) {
888     els_trk_p4_branch = tree->GetBranch(tree->GetAlias("els_trk_p4"));
889     els_trk_p4_branch->SetAddress(&els_trk_p4_);
890     }
891     if(els_trk_p4_branch == 0 ) {
892     cout << "Branch els_trk_p4 does not exist." << endl;
893     }
894     els_vertex_p4_branch = 0;
895     if (tree->GetAlias("els_vertex_p4") != 0) {
896     els_vertex_p4_branch = tree->GetBranch(tree->GetAlias("els_vertex_p4"));
897     els_vertex_p4_branch->SetAddress(&els_vertex_p4_);
898     }
899     if(els_vertex_p4_branch == 0 ) {
900     cout << "Branch els_vertex_p4 does not exist." << endl;
901     }
902     mus_fitdefault_p4_branch = 0;
903     if (tree->GetAlias("mus_fitdefault_p4") != 0) {
904     mus_fitdefault_p4_branch = tree->GetBranch(tree->GetAlias("mus_fitdefault_p4"));
905     mus_fitdefault_p4_branch->SetAddress(&mus_fitdefault_p4_);
906     }
907     if(mus_fitdefault_p4_branch == 0 ) {
908     cout << "Branch mus_fitdefault_p4 does not exist." << endl;
909     }
910     mus_fitfirsthit_p4_branch = 0;
911     if (tree->GetAlias("mus_fitfirsthit_p4") != 0) {
912     mus_fitfirsthit_p4_branch = tree->GetBranch(tree->GetAlias("mus_fitfirsthit_p4"));
913     mus_fitfirsthit_p4_branch->SetAddress(&mus_fitfirsthit_p4_);
914     }
915     if(mus_fitfirsthit_p4_branch == 0 ) {
916     cout << "Branch mus_fitfirsthit_p4 does not exist." << endl;
917     }
918     mus_fitpicky_p4_branch = 0;
919     if (tree->GetAlias("mus_fitpicky_p4") != 0) {
920     mus_fitpicky_p4_branch = tree->GetBranch(tree->GetAlias("mus_fitpicky_p4"));
921     mus_fitpicky_p4_branch->SetAddress(&mus_fitpicky_p4_);
922     }
923     if(mus_fitpicky_p4_branch == 0 ) {
924     cout << "Branch mus_fitpicky_p4 does not exist." << endl;
925     }
926     mus_fittev_p4_branch = 0;
927     if (tree->GetAlias("mus_fittev_p4") != 0) {
928     mus_fittev_p4_branch = tree->GetBranch(tree->GetAlias("mus_fittev_p4"));
929     mus_fittev_p4_branch->SetAddress(&mus_fittev_p4_);
930     }
931     if(mus_fittev_p4_branch == 0 ) {
932     cout << "Branch mus_fittev_p4 does not exist." << endl;
933     }
934     mus_gfit_outerPos_p4_branch = 0;
935     if (tree->GetAlias("mus_gfit_outerPos_p4") != 0) {
936     mus_gfit_outerPos_p4_branch = tree->GetBranch(tree->GetAlias("mus_gfit_outerPos_p4"));
937     mus_gfit_outerPos_p4_branch->SetAddress(&mus_gfit_outerPos_p4_);
938     }
939     if(mus_gfit_outerPos_p4_branch == 0 ) {
940     cout << "Branch mus_gfit_outerPos_p4 does not exist." << endl;
941     }
942     mus_gfit_p4_branch = 0;
943     if (tree->GetAlias("mus_gfit_p4") != 0) {
944     mus_gfit_p4_branch = tree->GetBranch(tree->GetAlias("mus_gfit_p4"));
945     mus_gfit_p4_branch->SetAddress(&mus_gfit_p4_);
946     }
947     if(mus_gfit_p4_branch == 0 ) {
948     cout << "Branch mus_gfit_p4 does not exist." << endl;
949     }
950     mus_gfit_vertex_p4_branch = 0;
951     if (tree->GetAlias("mus_gfit_vertex_p4") != 0) {
952     mus_gfit_vertex_p4_branch = tree->GetBranch(tree->GetAlias("mus_gfit_vertex_p4"));
953     mus_gfit_vertex_p4_branch->SetAddress(&mus_gfit_vertex_p4_);
954     }
955     if(mus_gfit_vertex_p4_branch == 0 ) {
956     cout << "Branch mus_gfit_vertex_p4 does not exist." << endl;
957     }
958     mus_p4_branch = 0;
959     if (tree->GetAlias("mus_p4") != 0) {
960     mus_p4_branch = tree->GetBranch(tree->GetAlias("mus_p4"));
961     mus_p4_branch->SetAddress(&mus_p4_);
962     }
963     if(mus_p4_branch == 0 ) {
964     cout << "Branch mus_p4 does not exist." << endl;
965     }
966     mus_trk_p4_branch = 0;
967     if (tree->GetAlias("mus_trk_p4") != 0) {
968     mus_trk_p4_branch = tree->GetBranch(tree->GetAlias("mus_trk_p4"));
969     mus_trk_p4_branch->SetAddress(&mus_trk_p4_);
970     }
971     if(mus_trk_p4_branch == 0 ) {
972     cout << "Branch mus_trk_p4 does not exist." << endl;
973     }
974     mus_vertex_p4_branch = 0;
975     if (tree->GetAlias("mus_vertex_p4") != 0) {
976     mus_vertex_p4_branch = tree->GetBranch(tree->GetAlias("mus_vertex_p4"));
977     mus_vertex_p4_branch->SetAddress(&mus_vertex_p4_);
978     }
979     if(mus_vertex_p4_branch == 0 ) {
980     cout << "Branch mus_vertex_p4 does not exist." << endl;
981     }
982     scs_p4_branch = 0;
983     if (tree->GetAlias("scs_p4") != 0) {
984     scs_p4_branch = tree->GetBranch(tree->GetAlias("scs_p4"));
985     scs_p4_branch->SetAddress(&scs_p4_);
986     }
987     if(scs_p4_branch == 0 ) {
988     cout << "Branch scs_p4 does not exist." << endl;
989     }
990     scs_pos_p4_branch = 0;
991     if (tree->GetAlias("scs_pos_p4") != 0) {
992     scs_pos_p4_branch = tree->GetBranch(tree->GetAlias("scs_pos_p4"));
993     scs_pos_p4_branch->SetAddress(&scs_pos_p4_);
994     }
995     if(scs_pos_p4_branch == 0 ) {
996     cout << "Branch scs_pos_p4 does not exist." << endl;
997     }
998     scs_vtx_p4_branch = 0;
999     if (tree->GetAlias("scs_vtx_p4") != 0) {
1000     scs_vtx_p4_branch = tree->GetBranch(tree->GetAlias("scs_vtx_p4"));
1001     scs_vtx_p4_branch->SetAddress(&scs_vtx_p4_);
1002     }
1003     if(scs_vtx_p4_branch == 0 ) {
1004     cout << "Branch scs_vtx_p4 does not exist." << endl;
1005     }
1006     trks_outer_p4_branch = 0;
1007     if (tree->GetAlias("trks_outer_p4") != 0) {
1008     trks_outer_p4_branch = tree->GetBranch(tree->GetAlias("trks_outer_p4"));
1009     trks_outer_p4_branch->SetAddress(&trks_outer_p4_);
1010     }
1011     if(trks_outer_p4_branch == 0 ) {
1012     cout << "Branch trks_outer_p4 does not exist." << endl;
1013     }
1014     trks_trk_p4_branch = 0;
1015     if (tree->GetAlias("trks_trk_p4") != 0) {
1016     trks_trk_p4_branch = tree->GetBranch(tree->GetAlias("trks_trk_p4"));
1017     trks_trk_p4_branch->SetAddress(&trks_trk_p4_);
1018     }
1019     if(trks_trk_p4_branch == 0 ) {
1020     cout << "Branch trks_trk_p4 does not exist." << endl;
1021     }
1022     trks_vertex_p4_branch = 0;
1023     if (tree->GetAlias("trks_vertex_p4") != 0) {
1024     trks_vertex_p4_branch = tree->GetBranch(tree->GetAlias("trks_vertex_p4"));
1025     trks_vertex_p4_branch->SetAddress(&trks_vertex_p4_);
1026     }
1027     if(trks_vertex_p4_branch == 0 ) {
1028     cout << "Branch trks_vertex_p4 does not exist." << endl;
1029     }
1030     vtxs_position_branch = 0;
1031     if (tree->GetAlias("vtxs_position") != 0) {
1032     vtxs_position_branch = tree->GetBranch(tree->GetAlias("vtxs_position"));
1033     vtxs_position_branch->SetAddress(&vtxs_position_);
1034     }
1035     if(vtxs_position_branch == 0 ) {
1036     cout << "Branch vtxs_position does not exist." << endl;
1037     }
1038     tree->SetMakeClass(1);
1039     evt_CMS2tag_branch = 0;
1040     if (tree->GetAlias("evt_CMS2tag") != 0) {
1041     evt_CMS2tag_branch = tree->GetBranch(tree->GetAlias("evt_CMS2tag"));
1042     evt_CMS2tag_branch->SetAddress(&evt_CMS2tag_);
1043     }
1044     if(evt_CMS2tag_branch == 0 ) {
1045     cout << "Branch evt_CMS2tag does not exist." << endl;
1046     }
1047     evt_dataset_branch = 0;
1048     if (tree->GetAlias("evt_dataset") != 0) {
1049     evt_dataset_branch = tree->GetBranch(tree->GetAlias("evt_dataset"));
1050     evt_dataset_branch->SetAddress(&evt_dataset_);
1051     }
1052     if(evt_dataset_branch == 0 ) {
1053     cout << "Branch evt_dataset does not exist." << endl;
1054     }
1055     els_inner_positionx_branch = 0;
1056     if (tree->GetAlias("els_inner_positionx") != 0) {
1057     els_inner_positionx_branch = tree->GetBranch(tree->GetAlias("els_inner_positionx"));
1058     els_inner_positionx_branch->SetAddress(&els_inner_positionx_);
1059     }
1060     if(els_inner_positionx_branch == 0 ) {
1061     cout << "Branch els_inner_positionx does not exist." << endl;
1062     }
1063     els_inner_positiony_branch = 0;
1064     if (tree->GetAlias("els_inner_positiony") != 0) {
1065     els_inner_positiony_branch = tree->GetBranch(tree->GetAlias("els_inner_positiony"));
1066     els_inner_positiony_branch->SetAddress(&els_inner_positiony_);
1067     }
1068     if(els_inner_positiony_branch == 0 ) {
1069     cout << "Branch els_inner_positiony does not exist." << endl;
1070     }
1071     els_inner_positionz_branch = 0;
1072     if (tree->GetAlias("els_inner_positionz") != 0) {
1073     els_inner_positionz_branch = tree->GetBranch(tree->GetAlias("els_inner_positionz"));
1074     els_inner_positionz_branch->SetAddress(&els_inner_positionz_);
1075     }
1076     if(els_inner_positionz_branch == 0 ) {
1077     cout << "Branch els_inner_positionz does not exist." << endl;
1078     }
1079     evt_bs_Xwidth_branch = 0;
1080     if (tree->GetAlias("evt_bs_Xwidth") != 0) {
1081     evt_bs_Xwidth_branch = tree->GetBranch(tree->GetAlias("evt_bs_Xwidth"));
1082     evt_bs_Xwidth_branch->SetAddress(&evt_bs_Xwidth_);
1083     }
1084     if(evt_bs_Xwidth_branch == 0 ) {
1085     cout << "Branch evt_bs_Xwidth does not exist." << endl;
1086     }
1087     evt_bs_XwidthErr_branch = 0;
1088     if (tree->GetAlias("evt_bs_XwidthErr") != 0) {
1089     evt_bs_XwidthErr_branch = tree->GetBranch(tree->GetAlias("evt_bs_XwidthErr"));
1090     evt_bs_XwidthErr_branch->SetAddress(&evt_bs_XwidthErr_);
1091     }
1092     if(evt_bs_XwidthErr_branch == 0 ) {
1093     cout << "Branch evt_bs_XwidthErr does not exist." << endl;
1094     }
1095     evt_bs_Ywidth_branch = 0;
1096     if (tree->GetAlias("evt_bs_Ywidth") != 0) {
1097     evt_bs_Ywidth_branch = tree->GetBranch(tree->GetAlias("evt_bs_Ywidth"));
1098     evt_bs_Ywidth_branch->SetAddress(&evt_bs_Ywidth_);
1099     }
1100     if(evt_bs_Ywidth_branch == 0 ) {
1101     cout << "Branch evt_bs_Ywidth does not exist." << endl;
1102     }
1103     evt_bs_YwidthErr_branch = 0;
1104     if (tree->GetAlias("evt_bs_YwidthErr") != 0) {
1105     evt_bs_YwidthErr_branch = tree->GetBranch(tree->GetAlias("evt_bs_YwidthErr"));
1106     evt_bs_YwidthErr_branch->SetAddress(&evt_bs_YwidthErr_);
1107     }
1108     if(evt_bs_YwidthErr_branch == 0 ) {
1109     cout << "Branch evt_bs_YwidthErr does not exist." << endl;
1110     }
1111     evt_bs_dxdz_branch = 0;
1112     if (tree->GetAlias("evt_bs_dxdz") != 0) {
1113     evt_bs_dxdz_branch = tree->GetBranch(tree->GetAlias("evt_bs_dxdz"));
1114     evt_bs_dxdz_branch->SetAddress(&evt_bs_dxdz_);
1115     }
1116     if(evt_bs_dxdz_branch == 0 ) {
1117     cout << "Branch evt_bs_dxdz does not exist." << endl;
1118     }
1119     evt_bs_dxdzErr_branch = 0;
1120     if (tree->GetAlias("evt_bs_dxdzErr") != 0) {
1121     evt_bs_dxdzErr_branch = tree->GetBranch(tree->GetAlias("evt_bs_dxdzErr"));
1122     evt_bs_dxdzErr_branch->SetAddress(&evt_bs_dxdzErr_);
1123     }
1124     if(evt_bs_dxdzErr_branch == 0 ) {
1125     cout << "Branch evt_bs_dxdzErr does not exist." << endl;
1126     }
1127     evt_bs_dydz_branch = 0;
1128     if (tree->GetAlias("evt_bs_dydz") != 0) {
1129     evt_bs_dydz_branch = tree->GetBranch(tree->GetAlias("evt_bs_dydz"));
1130     evt_bs_dydz_branch->SetAddress(&evt_bs_dydz_);
1131     }
1132     if(evt_bs_dydz_branch == 0 ) {
1133     cout << "Branch evt_bs_dydz does not exist." << endl;
1134     }
1135     evt_bs_dydzErr_branch = 0;
1136     if (tree->GetAlias("evt_bs_dydzErr") != 0) {
1137     evt_bs_dydzErr_branch = tree->GetBranch(tree->GetAlias("evt_bs_dydzErr"));
1138     evt_bs_dydzErr_branch->SetAddress(&evt_bs_dydzErr_);
1139     }
1140     if(evt_bs_dydzErr_branch == 0 ) {
1141     cout << "Branch evt_bs_dydzErr does not exist." << endl;
1142     }
1143     evt_bs_sigmaZ_branch = 0;
1144     if (tree->GetAlias("evt_bs_sigmaZ") != 0) {
1145     evt_bs_sigmaZ_branch = tree->GetBranch(tree->GetAlias("evt_bs_sigmaZ"));
1146     evt_bs_sigmaZ_branch->SetAddress(&evt_bs_sigmaZ_);
1147     }
1148     if(evt_bs_sigmaZ_branch == 0 ) {
1149     cout << "Branch evt_bs_sigmaZ does not exist." << endl;
1150     }
1151     evt_bs_sigmaZErr_branch = 0;
1152     if (tree->GetAlias("evt_bs_sigmaZErr") != 0) {
1153     evt_bs_sigmaZErr_branch = tree->GetBranch(tree->GetAlias("evt_bs_sigmaZErr"));
1154     evt_bs_sigmaZErr_branch->SetAddress(&evt_bs_sigmaZErr_);
1155     }
1156     if(evt_bs_sigmaZErr_branch == 0 ) {
1157     cout << "Branch evt_bs_sigmaZErr does not exist." << endl;
1158     }
1159     evt_bs_xErr_branch = 0;
1160     if (tree->GetAlias("evt_bs_xErr") != 0) {
1161     evt_bs_xErr_branch = tree->GetBranch(tree->GetAlias("evt_bs_xErr"));
1162     evt_bs_xErr_branch->SetAddress(&evt_bs_xErr_);
1163     }
1164     if(evt_bs_xErr_branch == 0 ) {
1165     cout << "Branch evt_bs_xErr does not exist." << endl;
1166     }
1167     evt_bs_yErr_branch = 0;
1168     if (tree->GetAlias("evt_bs_yErr") != 0) {
1169     evt_bs_yErr_branch = tree->GetBranch(tree->GetAlias("evt_bs_yErr"));
1170     evt_bs_yErr_branch->SetAddress(&evt_bs_yErr_);
1171     }
1172     if(evt_bs_yErr_branch == 0 ) {
1173     cout << "Branch evt_bs_yErr does not exist." << endl;
1174     }
1175     evt_bs_zErr_branch = 0;
1176     if (tree->GetAlias("evt_bs_zErr") != 0) {
1177     evt_bs_zErr_branch = tree->GetBranch(tree->GetAlias("evt_bs_zErr"));
1178     evt_bs_zErr_branch->SetAddress(&evt_bs_zErr_);
1179     }
1180     if(evt_bs_zErr_branch == 0 ) {
1181     cout << "Branch evt_bs_zErr does not exist." << endl;
1182     }
1183     evt_bField_branch = 0;
1184     if (tree->GetAlias("evt_bField") != 0) {
1185     evt_bField_branch = tree->GetBranch(tree->GetAlias("evt_bField"));
1186     evt_bField_branch->SetAddress(&evt_bField_);
1187     }
1188     if(evt_bField_branch == 0 ) {
1189     cout << "Branch evt_bField does not exist." << endl;
1190     }
1191     evt_covMatrix_branch = 0;
1192     if (tree->GetAlias("evt_covMatrix") != 0) {
1193     evt_covMatrix_branch = tree->GetBranch(tree->GetAlias("evt_covMatrix"));
1194     evt_covMatrix_branch->SetAddress(&evt_covMatrix_);
1195     }
1196     if(evt_covMatrix_branch == 0 ) {
1197     cout << "Branch evt_covMatrix does not exist." << endl;
1198     }
1199     twrs_ecalTime_branch = 0;
1200     if (tree->GetAlias("twrs_ecalTime") != 0) {
1201     twrs_ecalTime_branch = tree->GetBranch(tree->GetAlias("twrs_ecalTime"));
1202     twrs_ecalTime_branch->SetAddress(&twrs_ecalTime_);
1203     }
1204     if(twrs_ecalTime_branch == 0 ) {
1205     cout << "Branch twrs_ecalTime does not exist." << endl;
1206     }
1207     twrs_emEnergy_branch = 0;
1208     if (tree->GetAlias("twrs_emEnergy") != 0) {
1209     twrs_emEnergy_branch = tree->GetBranch(tree->GetAlias("twrs_emEnergy"));
1210     twrs_emEnergy_branch->SetAddress(&twrs_emEnergy_);
1211     }
1212     if(twrs_emEnergy_branch == 0 ) {
1213     cout << "Branch twrs_emEnergy does not exist." << endl;
1214     }
1215     twrs_emEt_branch = 0;
1216     if (tree->GetAlias("twrs_emEt") != 0) {
1217     twrs_emEt_branch = tree->GetBranch(tree->GetAlias("twrs_emEt"));
1218     twrs_emEt_branch->SetAddress(&twrs_emEt_);
1219     }
1220     if(twrs_emEt_branch == 0 ) {
1221     cout << "Branch twrs_emEt does not exist." << endl;
1222     }
1223     twrs_emEtcorr_branch = 0;
1224     if (tree->GetAlias("twrs_emEtcorr") != 0) {
1225     twrs_emEtcorr_branch = tree->GetBranch(tree->GetAlias("twrs_emEtcorr"));
1226     twrs_emEtcorr_branch->SetAddress(&twrs_emEtcorr_);
1227     }
1228     if(twrs_emEtcorr_branch == 0 ) {
1229     cout << "Branch twrs_emEtcorr does not exist." << endl;
1230     }
1231     twrs_eta_branch = 0;
1232     if (tree->GetAlias("twrs_eta") != 0) {
1233     twrs_eta_branch = tree->GetBranch(tree->GetAlias("twrs_eta"));
1234     twrs_eta_branch->SetAddress(&twrs_eta_);
1235     }
1236     if(twrs_eta_branch == 0 ) {
1237     cout << "Branch twrs_eta does not exist." << endl;
1238     }
1239     twrs_etcorr_branch = 0;
1240     if (tree->GetAlias("twrs_etcorr") != 0) {
1241     twrs_etcorr_branch = tree->GetBranch(tree->GetAlias("twrs_etcorr"));
1242     twrs_etcorr_branch->SetAddress(&twrs_etcorr_);
1243     }
1244     if(twrs_etcorr_branch == 0 ) {
1245     cout << "Branch twrs_etcorr does not exist." << endl;
1246     }
1247     twrs_hadEnergy_branch = 0;
1248     if (tree->GetAlias("twrs_hadEnergy") != 0) {
1249     twrs_hadEnergy_branch = tree->GetBranch(tree->GetAlias("twrs_hadEnergy"));
1250     twrs_hadEnergy_branch->SetAddress(&twrs_hadEnergy_);
1251     }
1252     if(twrs_hadEnergy_branch == 0 ) {
1253     cout << "Branch twrs_hadEnergy does not exist." << endl;
1254     }
1255     twrs_hadEt_branch = 0;
1256     if (tree->GetAlias("twrs_hadEt") != 0) {
1257     twrs_hadEt_branch = tree->GetBranch(tree->GetAlias("twrs_hadEt"));
1258     twrs_hadEt_branch->SetAddress(&twrs_hadEt_);
1259     }
1260     if(twrs_hadEt_branch == 0 ) {
1261     cout << "Branch twrs_hadEt does not exist." << endl;
1262     }
1263     twrs_hadEtcorr_branch = 0;
1264     if (tree->GetAlias("twrs_hadEtcorr") != 0) {
1265     twrs_hadEtcorr_branch = tree->GetBranch(tree->GetAlias("twrs_hadEtcorr"));
1266     twrs_hadEtcorr_branch->SetAddress(&twrs_hadEtcorr_);
1267     }
1268     if(twrs_hadEtcorr_branch == 0 ) {
1269     cout << "Branch twrs_hadEtcorr does not exist." << endl;
1270     }
1271     twrs_hcalTime_branch = 0;
1272     if (tree->GetAlias("twrs_hcalTime") != 0) {
1273     twrs_hcalTime_branch = tree->GetBranch(tree->GetAlias("twrs_hcalTime"));
1274     twrs_hcalTime_branch->SetAddress(&twrs_hcalTime_);
1275     }
1276     if(twrs_hcalTime_branch == 0 ) {
1277     cout << "Branch twrs_hcalTime does not exist." << endl;
1278     }
1279     twrs_outerEnergy_branch = 0;
1280     if (tree->GetAlias("twrs_outerEnergy") != 0) {
1281     twrs_outerEnergy_branch = tree->GetBranch(tree->GetAlias("twrs_outerEnergy"));
1282     twrs_outerEnergy_branch->SetAddress(&twrs_outerEnergy_);
1283     }
1284     if(twrs_outerEnergy_branch == 0 ) {
1285     cout << "Branch twrs_outerEnergy does not exist." << endl;
1286     }
1287     twrs_outerEt_branch = 0;
1288     if (tree->GetAlias("twrs_outerEt") != 0) {
1289     twrs_outerEt_branch = tree->GetBranch(tree->GetAlias("twrs_outerEt"));
1290     twrs_outerEt_branch->SetAddress(&twrs_outerEt_);
1291     }
1292     if(twrs_outerEt_branch == 0 ) {
1293     cout << "Branch twrs_outerEt does not exist." << endl;
1294     }
1295     twrs_outerEtcorr_branch = 0;
1296     if (tree->GetAlias("twrs_outerEtcorr") != 0) {
1297     twrs_outerEtcorr_branch = tree->GetBranch(tree->GetAlias("twrs_outerEtcorr"));
1298     twrs_outerEtcorr_branch->SetAddress(&twrs_outerEtcorr_);
1299     }
1300     if(twrs_outerEtcorr_branch == 0 ) {
1301     cout << "Branch twrs_outerEtcorr does not exist." << endl;
1302     }
1303     twrs_pcorr_branch = 0;
1304     if (tree->GetAlias("twrs_pcorr") != 0) {
1305     twrs_pcorr_branch = tree->GetBranch(tree->GetAlias("twrs_pcorr"));
1306     twrs_pcorr_branch->SetAddress(&twrs_pcorr_);
1307     }
1308     if(twrs_pcorr_branch == 0 ) {
1309     cout << "Branch twrs_pcorr does not exist." << endl;
1310     }
1311     twrs_phi_branch = 0;
1312     if (tree->GetAlias("twrs_phi") != 0) {
1313     twrs_phi_branch = tree->GetBranch(tree->GetAlias("twrs_phi"));
1314     twrs_phi_branch->SetAddress(&twrs_phi_);
1315     }
1316     if(twrs_phi_branch == 0 ) {
1317     cout << "Branch twrs_phi does not exist." << endl;
1318     }
1319     els_ecalJuraIso_branch = 0;
1320     if (tree->GetAlias("els_ecalJuraIso") != 0) {
1321     els_ecalJuraIso_branch = tree->GetBranch(tree->GetAlias("els_ecalJuraIso"));
1322     els_ecalJuraIso_branch->SetAddress(&els_ecalJuraIso_);
1323     }
1324     if(els_ecalJuraIso_branch == 0 ) {
1325     cout << "Branch els_ecalJuraIso does not exist." << endl;
1326     }
1327     els_ecalJuraTowerIso_branch = 0;
1328     if (tree->GetAlias("els_ecalJuraTowerIso") != 0) {
1329     els_ecalJuraTowerIso_branch = tree->GetBranch(tree->GetAlias("els_ecalJuraTowerIso"));
1330     els_ecalJuraTowerIso_branch->SetAddress(&els_ecalJuraTowerIso_);
1331     }
1332     if(els_ecalJuraTowerIso_branch == 0 ) {
1333     cout << "Branch els_ecalJuraTowerIso does not exist." << endl;
1334     }
1335     els_hcalConeIso_branch = 0;
1336     if (tree->GetAlias("els_hcalConeIso") != 0) {
1337     els_hcalConeIso_branch = tree->GetBranch(tree->GetAlias("els_hcalConeIso"));
1338     els_hcalConeIso_branch->SetAddress(&els_hcalConeIso_);
1339     }
1340     if(els_hcalConeIso_branch == 0 ) {
1341     cout << "Branch els_hcalConeIso does not exist." << endl;
1342     }
1343     els_chi2_branch = 0;
1344     if (tree->GetAlias("els_chi2") != 0) {
1345     els_chi2_branch = tree->GetBranch(tree->GetAlias("els_chi2"));
1346     els_chi2_branch->SetAddress(&els_chi2_);
1347     }
1348     if(els_chi2_branch == 0 ) {
1349     cout << "Branch els_chi2 does not exist." << endl;
1350     }
1351     els_d0_branch = 0;
1352     if (tree->GetAlias("els_d0") != 0) {
1353     els_d0_branch = tree->GetBranch(tree->GetAlias("els_d0"));
1354     els_d0_branch->SetAddress(&els_d0_);
1355     }
1356     if(els_d0_branch == 0 ) {
1357     cout << "Branch els_d0 does not exist." << endl;
1358     }
1359     els_d0Err_branch = 0;
1360     if (tree->GetAlias("els_d0Err") != 0) {
1361     els_d0Err_branch = tree->GetBranch(tree->GetAlias("els_d0Err"));
1362     els_d0Err_branch->SetAddress(&els_d0Err_);
1363     }
1364     if(els_d0Err_branch == 0 ) {
1365     cout << "Branch els_d0Err does not exist." << endl;
1366     }
1367     els_d0corr_branch = 0;
1368     if (tree->GetAlias("els_d0corr") != 0) {
1369     els_d0corr_branch = tree->GetBranch(tree->GetAlias("els_d0corr"));
1370     els_d0corr_branch->SetAddress(&els_d0corr_);
1371     }
1372     if(els_d0corr_branch == 0 ) {
1373     cout << "Branch els_d0corr does not exist." << endl;
1374     }
1375     els_dEtaIn_branch = 0;
1376     if (tree->GetAlias("els_dEtaIn") != 0) {
1377     els_dEtaIn_branch = tree->GetBranch(tree->GetAlias("els_dEtaIn"));
1378     els_dEtaIn_branch->SetAddress(&els_dEtaIn_);
1379     }
1380     if(els_dEtaIn_branch == 0 ) {
1381     cout << "Branch els_dEtaIn does not exist." << endl;
1382     }
1383     els_dEtaOut_branch = 0;
1384     if (tree->GetAlias("els_dEtaOut") != 0) {
1385     els_dEtaOut_branch = tree->GetBranch(tree->GetAlias("els_dEtaOut"));
1386     els_dEtaOut_branch->SetAddress(&els_dEtaOut_);
1387     }
1388     if(els_dEtaOut_branch == 0 ) {
1389     cout << "Branch els_dEtaOut does not exist." << endl;
1390     }
1391     els_dPhiIn_branch = 0;
1392     if (tree->GetAlias("els_dPhiIn") != 0) {
1393     els_dPhiIn_branch = tree->GetBranch(tree->GetAlias("els_dPhiIn"));
1394     els_dPhiIn_branch->SetAddress(&els_dPhiIn_);
1395     }
1396     if(els_dPhiIn_branch == 0 ) {
1397     cout << "Branch els_dPhiIn does not exist." << endl;
1398     }
1399     els_dPhiInPhiOut_branch = 0;
1400     if (tree->GetAlias("els_dPhiInPhiOut") != 0) {
1401     els_dPhiInPhiOut_branch = tree->GetBranch(tree->GetAlias("els_dPhiInPhiOut"));
1402     els_dPhiInPhiOut_branch->SetAddress(&els_dPhiInPhiOut_);
1403     }
1404     if(els_dPhiInPhiOut_branch == 0 ) {
1405     cout << "Branch els_dPhiInPhiOut does not exist." << endl;
1406     }
1407     els_dPhiOut_branch = 0;
1408     if (tree->GetAlias("els_dPhiOut") != 0) {
1409     els_dPhiOut_branch = tree->GetBranch(tree->GetAlias("els_dPhiOut"));
1410     els_dPhiOut_branch->SetAddress(&els_dPhiOut_);
1411     }
1412     if(els_dPhiOut_branch == 0 ) {
1413     cout << "Branch els_dPhiOut does not exist." << endl;
1414     }
1415     els_e1x5_branch = 0;
1416     if (tree->GetAlias("els_e1x5") != 0) {
1417     els_e1x5_branch = tree->GetBranch(tree->GetAlias("els_e1x5"));
1418     els_e1x5_branch->SetAddress(&els_e1x5_);
1419     }
1420     if(els_e1x5_branch == 0 ) {
1421     cout << "Branch els_e1x5 does not exist." << endl;
1422     }
1423     els_e2x5Max_branch = 0;
1424     if (tree->GetAlias("els_e2x5Max") != 0) {
1425     els_e2x5Max_branch = tree->GetBranch(tree->GetAlias("els_e2x5Max"));
1426     els_e2x5Max_branch->SetAddress(&els_e2x5Max_);
1427     }
1428     if(els_e2x5Max_branch == 0 ) {
1429     cout << "Branch els_e2x5Max does not exist." << endl;
1430     }
1431     els_e3x3_branch = 0;
1432     if (tree->GetAlias("els_e3x3") != 0) {
1433     els_e3x3_branch = tree->GetBranch(tree->GetAlias("els_e3x3"));
1434     els_e3x3_branch->SetAddress(&els_e3x3_);
1435     }
1436     if(els_e3x3_branch == 0 ) {
1437     cout << "Branch els_e3x3 does not exist." << endl;
1438     }
1439     els_e5x5_branch = 0;
1440     if (tree->GetAlias("els_e5x5") != 0) {
1441     els_e5x5_branch = tree->GetBranch(tree->GetAlias("els_e5x5"));
1442     els_e5x5_branch->SetAddress(&els_e5x5_);
1443     }
1444     if(els_e5x5_branch == 0 ) {
1445     cout << "Branch els_e5x5 does not exist." << endl;
1446     }
1447     els_eMax_branch = 0;
1448     if (tree->GetAlias("els_eMax") != 0) {
1449     els_eMax_branch = tree->GetBranch(tree->GetAlias("els_eMax"));
1450     els_eMax_branch->SetAddress(&els_eMax_);
1451     }
1452     if(els_eMax_branch == 0 ) {
1453     cout << "Branch els_eMax does not exist." << endl;
1454     }
1455     els_eOverPIn_branch = 0;
1456     if (tree->GetAlias("els_eOverPIn") != 0) {
1457     els_eOverPIn_branch = tree->GetBranch(tree->GetAlias("els_eOverPIn"));
1458     els_eOverPIn_branch->SetAddress(&els_eOverPIn_);
1459     }
1460     if(els_eOverPIn_branch == 0 ) {
1461     cout << "Branch els_eOverPIn does not exist." << endl;
1462     }
1463     els_eSC_branch = 0;
1464     if (tree->GetAlias("els_eSC") != 0) {
1465     els_eSC_branch = tree->GetBranch(tree->GetAlias("els_eSC"));
1466     els_eSC_branch->SetAddress(&els_eSC_);
1467     }
1468     if(els_eSC_branch == 0 ) {
1469     cout << "Branch els_eSC does not exist." << endl;
1470     }
1471     els_eSCPresh_branch = 0;
1472     if (tree->GetAlias("els_eSCPresh") != 0) {
1473     els_eSCPresh_branch = tree->GetBranch(tree->GetAlias("els_eSCPresh"));
1474     els_eSCPresh_branch->SetAddress(&els_eSCPresh_);
1475     }
1476     if(els_eSCPresh_branch == 0 ) {
1477     cout << "Branch els_eSCPresh does not exist." << endl;
1478     }
1479     els_eSCRaw_branch = 0;
1480     if (tree->GetAlias("els_eSCRaw") != 0) {
1481     els_eSCRaw_branch = tree->GetBranch(tree->GetAlias("els_eSCRaw"));
1482     els_eSCRaw_branch->SetAddress(&els_eSCRaw_);
1483     }
1484     if(els_eSCRaw_branch == 0 ) {
1485     cout << "Branch els_eSCRaw does not exist." << endl;
1486     }
1487     els_eSeed_branch = 0;
1488     if (tree->GetAlias("els_eSeed") != 0) {
1489     els_eSeed_branch = tree->GetBranch(tree->GetAlias("els_eSeed"));
1490     els_eSeed_branch->SetAddress(&els_eSeed_);
1491     }
1492     if(els_eSeed_branch == 0 ) {
1493     cout << "Branch els_eSeed does not exist." << endl;
1494     }
1495     els_eSeedOverPIn_branch = 0;
1496     if (tree->GetAlias("els_eSeedOverPIn") != 0) {
1497     els_eSeedOverPIn_branch = tree->GetBranch(tree->GetAlias("els_eSeedOverPIn"));
1498     els_eSeedOverPIn_branch->SetAddress(&els_eSeedOverPIn_);
1499     }
1500     if(els_eSeedOverPIn_branch == 0 ) {
1501     cout << "Branch els_eSeedOverPIn does not exist." << endl;
1502     }
1503     els_eSeedOverPOut_branch = 0;
1504     if (tree->GetAlias("els_eSeedOverPOut") != 0) {
1505     els_eSeedOverPOut_branch = tree->GetBranch(tree->GetAlias("els_eSeedOverPOut"));
1506     els_eSeedOverPOut_branch->SetAddress(&els_eSeedOverPOut_);
1507     }
1508     if(els_eSeedOverPOut_branch == 0 ) {
1509     cout << "Branch els_eSeedOverPOut does not exist." << endl;
1510     }
1511     els_ecalEnergy_branch = 0;
1512     if (tree->GetAlias("els_ecalEnergy") != 0) {
1513     els_ecalEnergy_branch = tree->GetBranch(tree->GetAlias("els_ecalEnergy"));
1514     els_ecalEnergy_branch->SetAddress(&els_ecalEnergy_);
1515     }
1516     if(els_ecalEnergy_branch == 0 ) {
1517     cout << "Branch els_ecalEnergy does not exist." << endl;
1518     }
1519     els_ecalEnergyError_branch = 0;
1520     if (tree->GetAlias("els_ecalEnergyError") != 0) {
1521     els_ecalEnergyError_branch = tree->GetBranch(tree->GetAlias("els_ecalEnergyError"));
1522     els_ecalEnergyError_branch->SetAddress(&els_ecalEnergyError_);
1523     }
1524     if(els_ecalEnergyError_branch == 0 ) {
1525     cout << "Branch els_ecalEnergyError does not exist." << endl;
1526     }
1527     els_ecalIso_branch = 0;
1528     if (tree->GetAlias("els_ecalIso") != 0) {
1529     els_ecalIso_branch = tree->GetBranch(tree->GetAlias("els_ecalIso"));
1530     els_ecalIso_branch->SetAddress(&els_ecalIso_);
1531     }
1532     if(els_ecalIso_branch == 0 ) {
1533     cout << "Branch els_ecalIso does not exist." << endl;
1534     }
1535     els_ecalIso04_branch = 0;
1536     if (tree->GetAlias("els_ecalIso04") != 0) {
1537     els_ecalIso04_branch = tree->GetBranch(tree->GetAlias("els_ecalIso04"));
1538     els_ecalIso04_branch->SetAddress(&els_ecalIso04_);
1539     }
1540     if(els_ecalIso04_branch == 0 ) {
1541     cout << "Branch els_ecalIso04 does not exist." << endl;
1542     }
1543     els_egamma_looseId_branch = 0;
1544     if (tree->GetAlias("els_egamma_looseId") != 0) {
1545     els_egamma_looseId_branch = tree->GetBranch(tree->GetAlias("els_egamma_looseId"));
1546     els_egamma_looseId_branch->SetAddress(&els_egamma_looseId_);
1547     }
1548     if(els_egamma_looseId_branch == 0 ) {
1549     cout << "Branch els_egamma_looseId does not exist." << endl;
1550     }
1551     els_egamma_robustHighEnergy_branch = 0;
1552     if (tree->GetAlias("els_egamma_robustHighEnergy") != 0) {
1553     els_egamma_robustHighEnergy_branch = tree->GetBranch(tree->GetAlias("els_egamma_robustHighEnergy"));
1554     els_egamma_robustHighEnergy_branch->SetAddress(&els_egamma_robustHighEnergy_);
1555     }
1556     if(els_egamma_robustHighEnergy_branch == 0 ) {
1557     cout << "Branch els_egamma_robustHighEnergy does not exist." << endl;
1558     }
1559     els_egamma_robustLooseId_branch = 0;
1560     if (tree->GetAlias("els_egamma_robustLooseId") != 0) {
1561     els_egamma_robustLooseId_branch = tree->GetBranch(tree->GetAlias("els_egamma_robustLooseId"));
1562     els_egamma_robustLooseId_branch->SetAddress(&els_egamma_robustLooseId_);
1563     }
1564     if(els_egamma_robustLooseId_branch == 0 ) {
1565     cout << "Branch els_egamma_robustLooseId does not exist." << endl;
1566     }
1567     els_egamma_robustTightId_branch = 0;
1568     if (tree->GetAlias("els_egamma_robustTightId") != 0) {
1569     els_egamma_robustTightId_branch = tree->GetBranch(tree->GetAlias("els_egamma_robustTightId"));
1570     els_egamma_robustTightId_branch->SetAddress(&els_egamma_robustTightId_);
1571     }
1572     if(els_egamma_robustTightId_branch == 0 ) {
1573     cout << "Branch els_egamma_robustTightId does not exist." << endl;
1574     }
1575     els_egamma_tightId_branch = 0;
1576     if (tree->GetAlias("els_egamma_tightId") != 0) {
1577     els_egamma_tightId_branch = tree->GetBranch(tree->GetAlias("els_egamma_tightId"));
1578     els_egamma_tightId_branch->SetAddress(&els_egamma_tightId_);
1579     }
1580     if(els_egamma_tightId_branch == 0 ) {
1581     cout << "Branch els_egamma_tightId does not exist." << endl;
1582     }
1583     els_electronMomentumError_branch = 0;
1584     if (tree->GetAlias("els_electronMomentumError") != 0) {
1585     els_electronMomentumError_branch = tree->GetBranch(tree->GetAlias("els_electronMomentumError"));
1586     els_electronMomentumError_branch->SetAddress(&els_electronMomentumError_);
1587     }
1588     if(els_electronMomentumError_branch == 0 ) {
1589     cout << "Branch els_electronMomentumError does not exist." << endl;
1590     }
1591     els_etaErr_branch = 0;
1592     if (tree->GetAlias("els_etaErr") != 0) {
1593     els_etaErr_branch = tree->GetBranch(tree->GetAlias("els_etaErr"));
1594     els_etaErr_branch->SetAddress(&els_etaErr_);
1595     }
1596     if(els_etaErr_branch == 0 ) {
1597     cout << "Branch els_etaErr does not exist." << endl;
1598     }
1599     els_etaSC_branch = 0;
1600     if (tree->GetAlias("els_etaSC") != 0) {
1601     els_etaSC_branch = tree->GetBranch(tree->GetAlias("els_etaSC"));
1602     els_etaSC_branch->SetAddress(&els_etaSC_);
1603     }
1604     if(els_etaSC_branch == 0 ) {
1605     cout << "Branch els_etaSC does not exist." << endl;
1606     }
1607     els_fBrem_branch = 0;
1608     if (tree->GetAlias("els_fBrem") != 0) {
1609     els_fBrem_branch = tree->GetBranch(tree->GetAlias("els_fBrem"));
1610     els_fBrem_branch->SetAddress(&els_fBrem_);
1611     }
1612     if(els_fBrem_branch == 0 ) {
1613     cout << "Branch els_fBrem does not exist." << endl;
1614     }
1615     els_hOverE_branch = 0;
1616     if (tree->GetAlias("els_hOverE") != 0) {
1617     els_hOverE_branch = tree->GetBranch(tree->GetAlias("els_hOverE"));
1618     els_hOverE_branch->SetAddress(&els_hOverE_);
1619     }
1620     if(els_hOverE_branch == 0 ) {
1621     cout << "Branch els_hOverE does not exist." << endl;
1622     }
1623     els_hcalIso_branch = 0;
1624     if (tree->GetAlias("els_hcalIso") != 0) {
1625     els_hcalIso_branch = tree->GetBranch(tree->GetAlias("els_hcalIso"));
1626     els_hcalIso_branch->SetAddress(&els_hcalIso_);
1627     }
1628     if(els_hcalIso_branch == 0 ) {
1629     cout << "Branch els_hcalIso does not exist." << endl;
1630     }
1631     els_hcalIso04_branch = 0;
1632     if (tree->GetAlias("els_hcalIso04") != 0) {
1633     els_hcalIso04_branch = tree->GetBranch(tree->GetAlias("els_hcalIso04"));
1634     els_hcalIso04_branch->SetAddress(&els_hcalIso04_);
1635     }
1636     if(els_hcalIso04_branch == 0 ) {
1637     cout << "Branch els_hcalIso04 does not exist." << endl;
1638     }
1639     els_layer1_charge_branch = 0;
1640     if (tree->GetAlias("els_layer1_charge") != 0) {
1641     els_layer1_charge_branch = tree->GetBranch(tree->GetAlias("els_layer1_charge"));
1642     els_layer1_charge_branch->SetAddress(&els_layer1_charge_);
1643     }
1644     if(els_layer1_charge_branch == 0 ) {
1645     cout << "Branch els_layer1_charge does not exist." << endl;
1646     }
1647     els_ndof_branch = 0;
1648     if (tree->GetAlias("els_ndof") != 0) {
1649     els_ndof_branch = tree->GetBranch(tree->GetAlias("els_ndof"));
1650     els_ndof_branch->SetAddress(&els_ndof_);
1651     }
1652     if(els_ndof_branch == 0 ) {
1653     cout << "Branch els_ndof does not exist." << endl;
1654     }
1655     els_phiErr_branch = 0;
1656     if (tree->GetAlias("els_phiErr") != 0) {
1657     els_phiErr_branch = tree->GetBranch(tree->GetAlias("els_phiErr"));
1658     els_phiErr_branch->SetAddress(&els_phiErr_);
1659     }
1660     if(els_phiErr_branch == 0 ) {
1661     cout << "Branch els_phiErr does not exist." << endl;
1662     }
1663     els_phiSC_branch = 0;
1664     if (tree->GetAlias("els_phiSC") != 0) {
1665     els_phiSC_branch = tree->GetBranch(tree->GetAlias("els_phiSC"));
1666     els_phiSC_branch->SetAddress(&els_phiSC_);
1667     }
1668     if(els_phiSC_branch == 0 ) {
1669     cout << "Branch els_phiSC does not exist." << endl;
1670     }
1671     els_ptErr_branch = 0;
1672     if (tree->GetAlias("els_ptErr") != 0) {
1673     els_ptErr_branch = tree->GetBranch(tree->GetAlias("els_ptErr"));
1674     els_ptErr_branch->SetAddress(&els_ptErr_);
1675     }
1676     if(els_ptErr_branch == 0 ) {
1677     cout << "Branch els_ptErr does not exist." << endl;
1678     }
1679     els_sigmaEtaEta_branch = 0;
1680     if (tree->GetAlias("els_sigmaEtaEta") != 0) {
1681     els_sigmaEtaEta_branch = tree->GetBranch(tree->GetAlias("els_sigmaEtaEta"));
1682     els_sigmaEtaEta_branch->SetAddress(&els_sigmaEtaEta_);
1683     }
1684     if(els_sigmaEtaEta_branch == 0 ) {
1685     cout << "Branch els_sigmaEtaEta does not exist." << endl;
1686     }
1687     els_sigmaIEtaIEta_branch = 0;
1688     if (tree->GetAlias("els_sigmaIEtaIEta") != 0) {
1689     els_sigmaIEtaIEta_branch = tree->GetBranch(tree->GetAlias("els_sigmaIEtaIEta"));
1690     els_sigmaIEtaIEta_branch->SetAddress(&els_sigmaIEtaIEta_);
1691     }
1692     if(els_sigmaIEtaIEta_branch == 0 ) {
1693     cout << "Branch els_sigmaIEtaIEta does not exist." << endl;
1694     }
1695     els_sigmaIPhiIPhi_branch = 0;
1696     if (tree->GetAlias("els_sigmaIPhiIPhi") != 0) {
1697     els_sigmaIPhiIPhi_branch = tree->GetBranch(tree->GetAlias("els_sigmaIPhiIPhi"));
1698     els_sigmaIPhiIPhi_branch->SetAddress(&els_sigmaIPhiIPhi_);
1699     }
1700     if(els_sigmaIPhiIPhi_branch == 0 ) {
1701     cout << "Branch els_sigmaIPhiIPhi does not exist." << endl;
1702     }
1703     els_sigmaPhiPhi_branch = 0;
1704     if (tree->GetAlias("els_sigmaPhiPhi") != 0) {
1705     els_sigmaPhiPhi_branch = tree->GetBranch(tree->GetAlias("els_sigmaPhiPhi"));
1706     els_sigmaPhiPhi_branch->SetAddress(&els_sigmaPhiPhi_);
1707     }
1708     if(els_sigmaPhiPhi_branch == 0 ) {
1709     cout << "Branch els_sigmaPhiPhi does not exist." << endl;
1710     }
1711     els_tkIso_branch = 0;
1712     if (tree->GetAlias("els_tkIso") != 0) {
1713     els_tkIso_branch = tree->GetBranch(tree->GetAlias("els_tkIso"));
1714     els_tkIso_branch->SetAddress(&els_tkIso_);
1715     }
1716     if(els_tkIso_branch == 0 ) {
1717     cout << "Branch els_tkIso does not exist." << endl;
1718     }
1719     els_tkIso04_branch = 0;
1720     if (tree->GetAlias("els_tkIso04") != 0) {
1721     els_tkIso04_branch = tree->GetBranch(tree->GetAlias("els_tkIso04"));
1722     els_tkIso04_branch->SetAddress(&els_tkIso04_);
1723     }
1724     if(els_tkIso04_branch == 0 ) {
1725     cout << "Branch els_tkIso04 does not exist." << endl;
1726     }
1727     els_trackMomentumError_branch = 0;
1728     if (tree->GetAlias("els_trackMomentumError") != 0) {
1729     els_trackMomentumError_branch = tree->GetBranch(tree->GetAlias("els_trackMomentumError"));
1730     els_trackMomentumError_branch->SetAddress(&els_trackMomentumError_);
1731     }
1732     if(els_trackMomentumError_branch == 0 ) {
1733     cout << "Branch els_trackMomentumError does not exist." << endl;
1734     }
1735     els_trkdr_branch = 0;
1736     if (tree->GetAlias("els_trkdr") != 0) {
1737     els_trkdr_branch = tree->GetBranch(tree->GetAlias("els_trkdr"));
1738     els_trkdr_branch->SetAddress(&els_trkdr_);
1739     }
1740     if(els_trkdr_branch == 0 ) {
1741     cout << "Branch els_trkdr does not exist." << endl;
1742     }
1743     els_trkshFrac_branch = 0;
1744     if (tree->GetAlias("els_trkshFrac") != 0) {
1745     els_trkshFrac_branch = tree->GetBranch(tree->GetAlias("els_trkshFrac"));
1746     els_trkshFrac_branch->SetAddress(&els_trkshFrac_);
1747     }
1748     if(els_trkshFrac_branch == 0 ) {
1749     cout << "Branch els_trkshFrac does not exist." << endl;
1750     }
1751     els_z0_branch = 0;
1752     if (tree->GetAlias("els_z0") != 0) {
1753     els_z0_branch = tree->GetBranch(tree->GetAlias("els_z0"));
1754     els_z0_branch->SetAddress(&els_z0_);
1755     }
1756     if(els_z0_branch == 0 ) {
1757     cout << "Branch els_z0 does not exist." << endl;
1758     }
1759     els_z0Err_branch = 0;
1760     if (tree->GetAlias("els_z0Err") != 0) {
1761     els_z0Err_branch = tree->GetBranch(tree->GetAlias("els_z0Err"));
1762     els_z0Err_branch->SetAddress(&els_z0Err_);
1763     }
1764     if(els_z0Err_branch == 0 ) {
1765     cout << "Branch els_z0Err does not exist." << endl;
1766     }
1767     els_z0corr_branch = 0;
1768     if (tree->GetAlias("els_z0corr") != 0) {
1769     els_z0corr_branch = tree->GetBranch(tree->GetAlias("els_z0corr"));
1770     els_z0corr_branch->SetAddress(&els_z0corr_);
1771     }
1772     if(els_z0corr_branch == 0 ) {
1773     cout << "Branch els_z0corr does not exist." << endl;
1774     }
1775     mus_caloCompatibility_branch = 0;
1776     if (tree->GetAlias("mus_caloCompatibility") != 0) {
1777     mus_caloCompatibility_branch = tree->GetBranch(tree->GetAlias("mus_caloCompatibility"));
1778     mus_caloCompatibility_branch->SetAddress(&mus_caloCompatibility_);
1779     }
1780     if(mus_caloCompatibility_branch == 0 ) {
1781     cout << "Branch mus_caloCompatibility does not exist." << endl;
1782     }
1783     mus_chi2_branch = 0;
1784     if (tree->GetAlias("mus_chi2") != 0) {
1785     mus_chi2_branch = tree->GetBranch(tree->GetAlias("mus_chi2"));
1786     mus_chi2_branch->SetAddress(&mus_chi2_);
1787     }
1788     if(mus_chi2_branch == 0 ) {
1789     cout << "Branch mus_chi2 does not exist." << endl;
1790     }
1791     mus_d0_branch = 0;
1792     if (tree->GetAlias("mus_d0") != 0) {
1793     mus_d0_branch = tree->GetBranch(tree->GetAlias("mus_d0"));
1794     mus_d0_branch->SetAddress(&mus_d0_);
1795     }
1796     if(mus_d0_branch == 0 ) {
1797     cout << "Branch mus_d0 does not exist." << endl;
1798     }
1799     mus_d0Err_branch = 0;
1800     if (tree->GetAlias("mus_d0Err") != 0) {
1801     mus_d0Err_branch = tree->GetBranch(tree->GetAlias("mus_d0Err"));
1802     mus_d0Err_branch->SetAddress(&mus_d0Err_);
1803     }
1804     if(mus_d0Err_branch == 0 ) {
1805     cout << "Branch mus_d0Err does not exist." << endl;
1806     }
1807     mus_d0corr_branch = 0;
1808     if (tree->GetAlias("mus_d0corr") != 0) {
1809     mus_d0corr_branch = tree->GetBranch(tree->GetAlias("mus_d0corr"));
1810     mus_d0corr_branch->SetAddress(&mus_d0corr_);
1811     }
1812     if(mus_d0corr_branch == 0 ) {
1813     cout << "Branch mus_d0corr does not exist." << endl;
1814     }
1815     mus_e_em_branch = 0;
1816     if (tree->GetAlias("mus_e_em") != 0) {
1817     mus_e_em_branch = tree->GetBranch(tree->GetAlias("mus_e_em"));
1818     mus_e_em_branch->SetAddress(&mus_e_em_);
1819     }
1820     if(mus_e_em_branch == 0 ) {
1821     cout << "Branch mus_e_em does not exist." << endl;
1822     }
1823     mus_e_emS9_branch = 0;
1824     if (tree->GetAlias("mus_e_emS9") != 0) {
1825     mus_e_emS9_branch = tree->GetBranch(tree->GetAlias("mus_e_emS9"));
1826     mus_e_emS9_branch->SetAddress(&mus_e_emS9_);
1827     }
1828     if(mus_e_emS9_branch == 0 ) {
1829     cout << "Branch mus_e_emS9 does not exist." << endl;
1830     }
1831     mus_e_had_branch = 0;
1832     if (tree->GetAlias("mus_e_had") != 0) {
1833     mus_e_had_branch = tree->GetBranch(tree->GetAlias("mus_e_had"));
1834     mus_e_had_branch->SetAddress(&mus_e_had_);
1835     }
1836     if(mus_e_had_branch == 0 ) {
1837     cout << "Branch mus_e_had does not exist." << endl;
1838     }
1839     mus_e_hadS9_branch = 0;
1840     if (tree->GetAlias("mus_e_hadS9") != 0) {
1841     mus_e_hadS9_branch = tree->GetBranch(tree->GetAlias("mus_e_hadS9"));
1842     mus_e_hadS9_branch->SetAddress(&mus_e_hadS9_);
1843     }
1844     if(mus_e_hadS9_branch == 0 ) {
1845     cout << "Branch mus_e_hadS9 does not exist." << endl;
1846     }
1847     mus_e_ho_branch = 0;
1848     if (tree->GetAlias("mus_e_ho") != 0) {
1849     mus_e_ho_branch = tree->GetBranch(tree->GetAlias("mus_e_ho"));
1850     mus_e_ho_branch->SetAddress(&mus_e_ho_);
1851     }
1852     if(mus_e_ho_branch == 0 ) {
1853     cout << "Branch mus_e_ho does not exist." << endl;
1854     }
1855     mus_e_hoS9_branch = 0;
1856     if (tree->GetAlias("mus_e_hoS9") != 0) {
1857     mus_e_hoS9_branch = tree->GetBranch(tree->GetAlias("mus_e_hoS9"));
1858     mus_e_hoS9_branch->SetAddress(&mus_e_hoS9_);
1859     }
1860     if(mus_e_hoS9_branch == 0 ) {
1861     cout << "Branch mus_e_hoS9 does not exist." << endl;
1862     }
1863     mus_etaErr_branch = 0;
1864     if (tree->GetAlias("mus_etaErr") != 0) {
1865     mus_etaErr_branch = tree->GetBranch(tree->GetAlias("mus_etaErr"));
1866     mus_etaErr_branch->SetAddress(&mus_etaErr_);
1867     }
1868     if(mus_etaErr_branch == 0 ) {
1869     cout << "Branch mus_etaErr does not exist." << endl;
1870     }
1871     mus_gfit_chi2_branch = 0;
1872     if (tree->GetAlias("mus_gfit_chi2") != 0) {
1873     mus_gfit_chi2_branch = tree->GetBranch(tree->GetAlias("mus_gfit_chi2"));
1874     mus_gfit_chi2_branch->SetAddress(&mus_gfit_chi2_);
1875     }
1876     if(mus_gfit_chi2_branch == 0 ) {
1877     cout << "Branch mus_gfit_chi2 does not exist." << endl;
1878     }
1879     mus_gfit_d0_branch = 0;
1880     if (tree->GetAlias("mus_gfit_d0") != 0) {
1881     mus_gfit_d0_branch = tree->GetBranch(tree->GetAlias("mus_gfit_d0"));
1882     mus_gfit_d0_branch->SetAddress(&mus_gfit_d0_);
1883     }
1884     if(mus_gfit_d0_branch == 0 ) {
1885     cout << "Branch mus_gfit_d0 does not exist." << endl;
1886     }
1887     mus_gfit_d0Err_branch = 0;
1888     if (tree->GetAlias("mus_gfit_d0Err") != 0) {
1889     mus_gfit_d0Err_branch = tree->GetBranch(tree->GetAlias("mus_gfit_d0Err"));
1890     mus_gfit_d0Err_branch->SetAddress(&mus_gfit_d0Err_);
1891     }
1892     if(mus_gfit_d0Err_branch == 0 ) {
1893     cout << "Branch mus_gfit_d0Err does not exist." << endl;
1894     }
1895     mus_gfit_d0corr_branch = 0;
1896     if (tree->GetAlias("mus_gfit_d0corr") != 0) {
1897     mus_gfit_d0corr_branch = tree->GetBranch(tree->GetAlias("mus_gfit_d0corr"));
1898     mus_gfit_d0corr_branch->SetAddress(&mus_gfit_d0corr_);
1899     }
1900     if(mus_gfit_d0corr_branch == 0 ) {
1901     cout << "Branch mus_gfit_d0corr does not exist." << endl;
1902     }
1903     mus_gfit_ndof_branch = 0;
1904     if (tree->GetAlias("mus_gfit_ndof") != 0) {
1905     mus_gfit_ndof_branch = tree->GetBranch(tree->GetAlias("mus_gfit_ndof"));
1906     mus_gfit_ndof_branch->SetAddress(&mus_gfit_ndof_);
1907     }
1908     if(mus_gfit_ndof_branch == 0 ) {
1909     cout << "Branch mus_gfit_ndof does not exist." << endl;
1910     }
1911     mus_gfit_qoverp_branch = 0;
1912     if (tree->GetAlias("mus_gfit_qoverp") != 0) {
1913     mus_gfit_qoverp_branch = tree->GetBranch(tree->GetAlias("mus_gfit_qoverp"));
1914     mus_gfit_qoverp_branch->SetAddress(&mus_gfit_qoverp_);
1915     }
1916     if(mus_gfit_qoverp_branch == 0 ) {
1917     cout << "Branch mus_gfit_qoverp does not exist." << endl;
1918     }
1919     mus_gfit_qoverpError_branch = 0;
1920     if (tree->GetAlias("mus_gfit_qoverpError") != 0) {
1921     mus_gfit_qoverpError_branch = tree->GetBranch(tree->GetAlias("mus_gfit_qoverpError"));
1922     mus_gfit_qoverpError_branch->SetAddress(&mus_gfit_qoverpError_);
1923     }
1924     if(mus_gfit_qoverpError_branch == 0 ) {
1925     cout << "Branch mus_gfit_qoverpError does not exist." << endl;
1926     }
1927     mus_gfit_z0_branch = 0;
1928     if (tree->GetAlias("mus_gfit_z0") != 0) {
1929     mus_gfit_z0_branch = tree->GetBranch(tree->GetAlias("mus_gfit_z0"));
1930     mus_gfit_z0_branch->SetAddress(&mus_gfit_z0_);
1931     }
1932     if(mus_gfit_z0_branch == 0 ) {
1933     cout << "Branch mus_gfit_z0 does not exist." << endl;
1934     }
1935     mus_gfit_z0Err_branch = 0;
1936     if (tree->GetAlias("mus_gfit_z0Err") != 0) {
1937     mus_gfit_z0Err_branch = tree->GetBranch(tree->GetAlias("mus_gfit_z0Err"));
1938     mus_gfit_z0Err_branch->SetAddress(&mus_gfit_z0Err_);
1939     }
1940     if(mus_gfit_z0Err_branch == 0 ) {
1941     cout << "Branch mus_gfit_z0Err does not exist." << endl;
1942     }
1943     mus_gfit_z0corr_branch = 0;
1944     if (tree->GetAlias("mus_gfit_z0corr") != 0) {
1945     mus_gfit_z0corr_branch = tree->GetBranch(tree->GetAlias("mus_gfit_z0corr"));
1946     mus_gfit_z0corr_branch->SetAddress(&mus_gfit_z0corr_);
1947     }
1948     if(mus_gfit_z0corr_branch == 0 ) {
1949     cout << "Branch mus_gfit_z0corr does not exist." << endl;
1950     }
1951     mus_iso03_emEt_branch = 0;
1952     if (tree->GetAlias("mus_iso03_emEt") != 0) {
1953     mus_iso03_emEt_branch = tree->GetBranch(tree->GetAlias("mus_iso03_emEt"));
1954     mus_iso03_emEt_branch->SetAddress(&mus_iso03_emEt_);
1955     }
1956     if(mus_iso03_emEt_branch == 0 ) {
1957     cout << "Branch mus_iso03_emEt does not exist." << endl;
1958     }
1959     mus_iso03_hadEt_branch = 0;
1960     if (tree->GetAlias("mus_iso03_hadEt") != 0) {
1961     mus_iso03_hadEt_branch = tree->GetBranch(tree->GetAlias("mus_iso03_hadEt"));
1962     mus_iso03_hadEt_branch->SetAddress(&mus_iso03_hadEt_);
1963     }
1964     if(mus_iso03_hadEt_branch == 0 ) {
1965     cout << "Branch mus_iso03_hadEt does not exist." << endl;
1966     }
1967     mus_iso03_hoEt_branch = 0;
1968     if (tree->GetAlias("mus_iso03_hoEt") != 0) {
1969     mus_iso03_hoEt_branch = tree->GetBranch(tree->GetAlias("mus_iso03_hoEt"));
1970     mus_iso03_hoEt_branch->SetAddress(&mus_iso03_hoEt_);
1971     }
1972     if(mus_iso03_hoEt_branch == 0 ) {
1973     cout << "Branch mus_iso03_hoEt does not exist." << endl;
1974     }
1975     mus_iso03_sumPt_branch = 0;
1976     if (tree->GetAlias("mus_iso03_sumPt") != 0) {
1977     mus_iso03_sumPt_branch = tree->GetBranch(tree->GetAlias("mus_iso03_sumPt"));
1978     mus_iso03_sumPt_branch->SetAddress(&mus_iso03_sumPt_);
1979     }
1980     if(mus_iso03_sumPt_branch == 0 ) {
1981     cout << "Branch mus_iso03_sumPt does not exist." << endl;
1982     }
1983     mus_iso05_emEt_branch = 0;
1984     if (tree->GetAlias("mus_iso05_emEt") != 0) {
1985     mus_iso05_emEt_branch = tree->GetBranch(tree->GetAlias("mus_iso05_emEt"));
1986     mus_iso05_emEt_branch->SetAddress(&mus_iso05_emEt_);
1987     }
1988     if(mus_iso05_emEt_branch == 0 ) {
1989     cout << "Branch mus_iso05_emEt does not exist." << endl;
1990     }
1991     mus_iso05_hadEt_branch = 0;
1992     if (tree->GetAlias("mus_iso05_hadEt") != 0) {
1993     mus_iso05_hadEt_branch = tree->GetBranch(tree->GetAlias("mus_iso05_hadEt"));
1994     mus_iso05_hadEt_branch->SetAddress(&mus_iso05_hadEt_);
1995     }
1996     if(mus_iso05_hadEt_branch == 0 ) {
1997     cout << "Branch mus_iso05_hadEt does not exist." << endl;
1998     }
1999     mus_iso05_hoEt_branch = 0;
2000     if (tree->GetAlias("mus_iso05_hoEt") != 0) {
2001     mus_iso05_hoEt_branch = tree->GetBranch(tree->GetAlias("mus_iso05_hoEt"));
2002     mus_iso05_hoEt_branch->SetAddress(&mus_iso05_hoEt_);
2003     }
2004     if(mus_iso05_hoEt_branch == 0 ) {
2005     cout << "Branch mus_iso05_hoEt does not exist." << endl;
2006     }
2007     mus_iso05_sumPt_branch = 0;
2008     if (tree->GetAlias("mus_iso05_sumPt") != 0) {
2009     mus_iso05_sumPt_branch = tree->GetBranch(tree->GetAlias("mus_iso05_sumPt"));
2010     mus_iso05_sumPt_branch->SetAddress(&mus_iso05_sumPt_);
2011     }
2012     if(mus_iso05_sumPt_branch == 0 ) {
2013     cout << "Branch mus_iso05_sumPt does not exist." << endl;
2014     }
2015     mus_iso_ecalvetoDep_branch = 0;
2016     if (tree->GetAlias("mus_iso_ecalvetoDep") != 0) {
2017     mus_iso_ecalvetoDep_branch = tree->GetBranch(tree->GetAlias("mus_iso_ecalvetoDep"));
2018     mus_iso_ecalvetoDep_branch->SetAddress(&mus_iso_ecalvetoDep_);
2019     }
2020     if(mus_iso_ecalvetoDep_branch == 0 ) {
2021     cout << "Branch mus_iso_ecalvetoDep does not exist." << endl;
2022     }
2023     mus_iso_hcalvetoDep_branch = 0;
2024     if (tree->GetAlias("mus_iso_hcalvetoDep") != 0) {
2025     mus_iso_hcalvetoDep_branch = tree->GetBranch(tree->GetAlias("mus_iso_hcalvetoDep"));
2026     mus_iso_hcalvetoDep_branch->SetAddress(&mus_iso_hcalvetoDep_);
2027     }
2028     if(mus_iso_hcalvetoDep_branch == 0 ) {
2029     cout << "Branch mus_iso_hcalvetoDep does not exist." << endl;
2030     }
2031     mus_iso_hovetoDep_branch = 0;
2032     if (tree->GetAlias("mus_iso_hovetoDep") != 0) {
2033     mus_iso_hovetoDep_branch = tree->GetBranch(tree->GetAlias("mus_iso_hovetoDep"));
2034     mus_iso_hovetoDep_branch->SetAddress(&mus_iso_hovetoDep_);
2035     }
2036     if(mus_iso_hovetoDep_branch == 0 ) {
2037     cout << "Branch mus_iso_hovetoDep does not exist." << endl;
2038     }
2039     mus_iso_trckvetoDep_branch = 0;
2040     if (tree->GetAlias("mus_iso_trckvetoDep") != 0) {
2041     mus_iso_trckvetoDep_branch = tree->GetBranch(tree->GetAlias("mus_iso_trckvetoDep"));
2042     mus_iso_trckvetoDep_branch->SetAddress(&mus_iso_trckvetoDep_);
2043     }
2044     if(mus_iso_trckvetoDep_branch == 0 ) {
2045     cout << "Branch mus_iso_trckvetoDep does not exist." << endl;
2046     }
2047     mus_ndof_branch = 0;
2048     if (tree->GetAlias("mus_ndof") != 0) {
2049     mus_ndof_branch = tree->GetBranch(tree->GetAlias("mus_ndof"));
2050     mus_ndof_branch->SetAddress(&mus_ndof_);
2051     }
2052     if(mus_ndof_branch == 0 ) {
2053     cout << "Branch mus_ndof does not exist." << endl;
2054     }
2055     mus_phiErr_branch = 0;
2056     if (tree->GetAlias("mus_phiErr") != 0) {
2057     mus_phiErr_branch = tree->GetBranch(tree->GetAlias("mus_phiErr"));
2058     mus_phiErr_branch->SetAddress(&mus_phiErr_);
2059     }
2060     if(mus_phiErr_branch == 0 ) {
2061     cout << "Branch mus_phiErr does not exist." << endl;
2062     }
2063     mus_ptErr_branch = 0;
2064     if (tree->GetAlias("mus_ptErr") != 0) {
2065     mus_ptErr_branch = tree->GetBranch(tree->GetAlias("mus_ptErr"));
2066     mus_ptErr_branch->SetAddress(&mus_ptErr_);
2067     }
2068     if(mus_ptErr_branch == 0 ) {
2069     cout << "Branch mus_ptErr does not exist." << endl;
2070     }
2071     mus_qoverp_branch = 0;
2072     if (tree->GetAlias("mus_qoverp") != 0) {
2073     mus_qoverp_branch = tree->GetBranch(tree->GetAlias("mus_qoverp"));
2074     mus_qoverp_branch->SetAddress(&mus_qoverp_);
2075     }
2076     if(mus_qoverp_branch == 0 ) {
2077     cout << "Branch mus_qoverp does not exist." << endl;
2078     }
2079     mus_qoverpError_branch = 0;
2080     if (tree->GetAlias("mus_qoverpError") != 0) {
2081     mus_qoverpError_branch = tree->GetBranch(tree->GetAlias("mus_qoverpError"));
2082     mus_qoverpError_branch->SetAddress(&mus_qoverpError_);
2083     }
2084     if(mus_qoverpError_branch == 0 ) {
2085     cout << "Branch mus_qoverpError does not exist." << endl;
2086     }
2087     mus_timeAtIpInOut_branch = 0;
2088     if (tree->GetAlias("mus_timeAtIpInOut") != 0) {
2089     mus_timeAtIpInOut_branch = tree->GetBranch(tree->GetAlias("mus_timeAtIpInOut"));
2090     mus_timeAtIpInOut_branch->SetAddress(&mus_timeAtIpInOut_);
2091     }
2092     if(mus_timeAtIpInOut_branch == 0 ) {
2093     cout << "Branch mus_timeAtIpInOut does not exist." << endl;
2094     }
2095     mus_timeAtIpInOutErr_branch = 0;
2096     if (tree->GetAlias("mus_timeAtIpInOutErr") != 0) {
2097     mus_timeAtIpInOutErr_branch = tree->GetBranch(tree->GetAlias("mus_timeAtIpInOutErr"));
2098     mus_timeAtIpInOutErr_branch->SetAddress(&mus_timeAtIpInOutErr_);
2099     }
2100     if(mus_timeAtIpInOutErr_branch == 0 ) {
2101     cout << "Branch mus_timeAtIpInOutErr does not exist." << endl;
2102     }
2103     mus_timeAtIpOutIn_branch = 0;
2104     if (tree->GetAlias("mus_timeAtIpOutIn") != 0) {
2105     mus_timeAtIpOutIn_branch = tree->GetBranch(tree->GetAlias("mus_timeAtIpOutIn"));
2106     mus_timeAtIpOutIn_branch->SetAddress(&mus_timeAtIpOutIn_);
2107     }
2108     if(mus_timeAtIpOutIn_branch == 0 ) {
2109     cout << "Branch mus_timeAtIpOutIn does not exist." << endl;
2110     }
2111     mus_timeAtIpOutInErr_branch = 0;
2112     if (tree->GetAlias("mus_timeAtIpOutInErr") != 0) {
2113     mus_timeAtIpOutInErr_branch = tree->GetBranch(tree->GetAlias("mus_timeAtIpOutInErr"));
2114     mus_timeAtIpOutInErr_branch->SetAddress(&mus_timeAtIpOutInErr_);
2115     }
2116     if(mus_timeAtIpOutInErr_branch == 0 ) {
2117     cout << "Branch mus_timeAtIpOutInErr does not exist." << endl;
2118     }
2119     mus_vertexphi_branch = 0;
2120     if (tree->GetAlias("mus_vertexphi") != 0) {
2121     mus_vertexphi_branch = tree->GetBranch(tree->GetAlias("mus_vertexphi"));
2122     mus_vertexphi_branch->SetAddress(&mus_vertexphi_);
2123     }
2124     if(mus_vertexphi_branch == 0 ) {
2125     cout << "Branch mus_vertexphi does not exist." << endl;
2126     }
2127     mus_z0_branch = 0;
2128     if (tree->GetAlias("mus_z0") != 0) {
2129     mus_z0_branch = tree->GetBranch(tree->GetAlias("mus_z0"));
2130     mus_z0_branch->SetAddress(&mus_z0_);
2131     }
2132     if(mus_z0_branch == 0 ) {
2133     cout << "Branch mus_z0 does not exist." << endl;
2134     }
2135     mus_z0Err_branch = 0;
2136     if (tree->GetAlias("mus_z0Err") != 0) {
2137     mus_z0Err_branch = tree->GetBranch(tree->GetAlias("mus_z0Err"));
2138     mus_z0Err_branch->SetAddress(&mus_z0Err_);
2139     }
2140     if(mus_z0Err_branch == 0 ) {
2141     cout << "Branch mus_z0Err does not exist." << endl;
2142     }
2143     mus_z0corr_branch = 0;
2144     if (tree->GetAlias("mus_z0corr") != 0) {
2145     mus_z0corr_branch = tree->GetBranch(tree->GetAlias("mus_z0corr"));
2146     mus_z0corr_branch->SetAddress(&mus_z0corr_);
2147     }
2148     if(mus_z0corr_branch == 0 ) {
2149     cout << "Branch mus_z0corr does not exist." << endl;
2150     }
2151     scs_clustersSize_branch = 0;
2152     if (tree->GetAlias("scs_clustersSize") != 0) {
2153     scs_clustersSize_branch = tree->GetBranch(tree->GetAlias("scs_clustersSize"));
2154     scs_clustersSize_branch->SetAddress(&scs_clustersSize_);
2155     }
2156     if(scs_clustersSize_branch == 0 ) {
2157     cout << "Branch scs_clustersSize does not exist." << endl;
2158     }
2159     scs_crystalsSize_branch = 0;
2160     if (tree->GetAlias("scs_crystalsSize") != 0) {
2161     scs_crystalsSize_branch = tree->GetBranch(tree->GetAlias("scs_crystalsSize"));
2162     scs_crystalsSize_branch->SetAddress(&scs_crystalsSize_);
2163     }
2164     if(scs_crystalsSize_branch == 0 ) {
2165     cout << "Branch scs_crystalsSize does not exist." << endl;
2166     }
2167     scs_e1x3_branch = 0;
2168     if (tree->GetAlias("scs_e1x3") != 0) {
2169     scs_e1x3_branch = tree->GetBranch(tree->GetAlias("scs_e1x3"));
2170     scs_e1x3_branch->SetAddress(&scs_e1x3_);
2171     }
2172     if(scs_e1x3_branch == 0 ) {
2173     cout << "Branch scs_e1x3 does not exist." << endl;
2174     }
2175     scs_e1x5_branch = 0;
2176     if (tree->GetAlias("scs_e1x5") != 0) {
2177     scs_e1x5_branch = tree->GetBranch(tree->GetAlias("scs_e1x5"));
2178     scs_e1x5_branch->SetAddress(&scs_e1x5_);
2179     }
2180     if(scs_e1x5_branch == 0 ) {
2181     cout << "Branch scs_e1x5 does not exist." << endl;
2182     }
2183     scs_e2x2_branch = 0;
2184     if (tree->GetAlias("scs_e2x2") != 0) {
2185     scs_e2x2_branch = tree->GetBranch(tree->GetAlias("scs_e2x2"));
2186     scs_e2x2_branch->SetAddress(&scs_e2x2_);
2187     }
2188     if(scs_e2x2_branch == 0 ) {
2189     cout << "Branch scs_e2x2 does not exist." << endl;
2190     }
2191     scs_e2x5Max_branch = 0;
2192     if (tree->GetAlias("scs_e2x5Max") != 0) {
2193     scs_e2x5Max_branch = tree->GetBranch(tree->GetAlias("scs_e2x5Max"));
2194     scs_e2x5Max_branch->SetAddress(&scs_e2x5Max_);
2195     }
2196     if(scs_e2x5Max_branch == 0 ) {
2197     cout << "Branch scs_e2x5Max does not exist." << endl;
2198     }
2199     scs_e3x1_branch = 0;
2200     if (tree->GetAlias("scs_e3x1") != 0) {
2201     scs_e3x1_branch = tree->GetBranch(tree->GetAlias("scs_e3x1"));
2202     scs_e3x1_branch->SetAddress(&scs_e3x1_);
2203     }
2204     if(scs_e3x1_branch == 0 ) {
2205     cout << "Branch scs_e3x1 does not exist." << endl;
2206     }
2207     scs_e3x2_branch = 0;
2208     if (tree->GetAlias("scs_e3x2") != 0) {
2209     scs_e3x2_branch = tree->GetBranch(tree->GetAlias("scs_e3x2"));
2210     scs_e3x2_branch->SetAddress(&scs_e3x2_);
2211     }
2212     if(scs_e3x2_branch == 0 ) {
2213     cout << "Branch scs_e3x2 does not exist." << endl;
2214     }
2215     scs_e3x3_branch = 0;
2216     if (tree->GetAlias("scs_e3x3") != 0) {
2217     scs_e3x3_branch = tree->GetBranch(tree->GetAlias("scs_e3x3"));
2218     scs_e3x3_branch->SetAddress(&scs_e3x3_);
2219     }
2220     if(scs_e3x3_branch == 0 ) {
2221     cout << "Branch scs_e3x3 does not exist." << endl;
2222     }
2223     scs_e4x4_branch = 0;
2224     if (tree->GetAlias("scs_e4x4") != 0) {
2225     scs_e4x4_branch = tree->GetBranch(tree->GetAlias("scs_e4x4"));
2226     scs_e4x4_branch->SetAddress(&scs_e4x4_);
2227     }
2228     if(scs_e4x4_branch == 0 ) {
2229     cout << "Branch scs_e4x4 does not exist." << endl;
2230     }
2231     scs_e5x5_branch = 0;
2232     if (tree->GetAlias("scs_e5x5") != 0) {
2233     scs_e5x5_branch = tree->GetBranch(tree->GetAlias("scs_e5x5"));
2234     scs_e5x5_branch->SetAddress(&scs_e5x5_);
2235     }
2236     if(scs_e5x5_branch == 0 ) {
2237     cout << "Branch scs_e5x5 does not exist." << endl;
2238     }
2239     scs_energy_branch = 0;
2240     if (tree->GetAlias("scs_energy") != 0) {
2241     scs_energy_branch = tree->GetBranch(tree->GetAlias("scs_energy"));
2242     scs_energy_branch->SetAddress(&scs_energy_);
2243     }
2244     if(scs_energy_branch == 0 ) {
2245     cout << "Branch scs_energy does not exist." << endl;
2246     }
2247     scs_eta_branch = 0;
2248     if (tree->GetAlias("scs_eta") != 0) {
2249     scs_eta_branch = tree->GetBranch(tree->GetAlias("scs_eta"));
2250     scs_eta_branch->SetAddress(&scs_eta_);
2251     }
2252     if(scs_eta_branch == 0 ) {
2253     cout << "Branch scs_eta does not exist." << endl;
2254     }
2255     scs_hoe_branch = 0;
2256     if (tree->GetAlias("scs_hoe") != 0) {
2257     scs_hoe_branch = tree->GetBranch(tree->GetAlias("scs_hoe"));
2258     scs_hoe_branch->SetAddress(&scs_hoe_);
2259     }
2260     if(scs_hoe_branch == 0 ) {
2261     cout << "Branch scs_hoe does not exist." << endl;
2262     }
2263     scs_phi_branch = 0;
2264     if (tree->GetAlias("scs_phi") != 0) {
2265     scs_phi_branch = tree->GetBranch(tree->GetAlias("scs_phi"));
2266     scs_phi_branch->SetAddress(&scs_phi_);
2267     }
2268     if(scs_phi_branch == 0 ) {
2269     cout << "Branch scs_phi does not exist." << endl;
2270     }
2271     scs_preshowerEnergy_branch = 0;
2272     if (tree->GetAlias("scs_preshowerEnergy") != 0) {
2273     scs_preshowerEnergy_branch = tree->GetBranch(tree->GetAlias("scs_preshowerEnergy"));
2274     scs_preshowerEnergy_branch->SetAddress(&scs_preshowerEnergy_);
2275     }
2276     if(scs_preshowerEnergy_branch == 0 ) {
2277     cout << "Branch scs_preshowerEnergy does not exist." << endl;
2278     }
2279     scs_rawEnergy_branch = 0;
2280     if (tree->GetAlias("scs_rawEnergy") != 0) {
2281     scs_rawEnergy_branch = tree->GetBranch(tree->GetAlias("scs_rawEnergy"));
2282     scs_rawEnergy_branch->SetAddress(&scs_rawEnergy_);
2283     }
2284     if(scs_rawEnergy_branch == 0 ) {
2285     cout << "Branch scs_rawEnergy does not exist." << endl;
2286     }
2287     scs_sigmaEtaEta_branch = 0;
2288     if (tree->GetAlias("scs_sigmaEtaEta") != 0) {
2289     scs_sigmaEtaEta_branch = tree->GetBranch(tree->GetAlias("scs_sigmaEtaEta"));
2290     scs_sigmaEtaEta_branch->SetAddress(&scs_sigmaEtaEta_);
2291     }
2292     if(scs_sigmaEtaEta_branch == 0 ) {
2293     cout << "Branch scs_sigmaEtaEta does not exist." << endl;
2294     }
2295     scs_sigmaEtaPhi_branch = 0;
2296     if (tree->GetAlias("scs_sigmaEtaPhi") != 0) {
2297     scs_sigmaEtaPhi_branch = tree->GetBranch(tree->GetAlias("scs_sigmaEtaPhi"));
2298     scs_sigmaEtaPhi_branch->SetAddress(&scs_sigmaEtaPhi_);
2299     }
2300     if(scs_sigmaEtaPhi_branch == 0 ) {
2301     cout << "Branch scs_sigmaEtaPhi does not exist." << endl;
2302     }
2303     scs_sigmaIEtaIEta_branch = 0;
2304     if (tree->GetAlias("scs_sigmaIEtaIEta") != 0) {
2305     scs_sigmaIEtaIEta_branch = tree->GetBranch(tree->GetAlias("scs_sigmaIEtaIEta"));
2306     scs_sigmaIEtaIEta_branch->SetAddress(&scs_sigmaIEtaIEta_);
2307     }
2308     if(scs_sigmaIEtaIEta_branch == 0 ) {
2309     cout << "Branch scs_sigmaIEtaIEta does not exist." << endl;
2310     }
2311     scs_sigmaIEtaIPhi_branch = 0;
2312     if (tree->GetAlias("scs_sigmaIEtaIPhi") != 0) {
2313     scs_sigmaIEtaIPhi_branch = tree->GetBranch(tree->GetAlias("scs_sigmaIEtaIPhi"));
2314     scs_sigmaIEtaIPhi_branch->SetAddress(&scs_sigmaIEtaIPhi_);
2315     }
2316     if(scs_sigmaIEtaIPhi_branch == 0 ) {
2317     cout << "Branch scs_sigmaIEtaIPhi does not exist." << endl;
2318     }
2319     scs_sigmaIPhiIPhi_branch = 0;
2320     if (tree->GetAlias("scs_sigmaIPhiIPhi") != 0) {
2321     scs_sigmaIPhiIPhi_branch = tree->GetBranch(tree->GetAlias("scs_sigmaIPhiIPhi"));
2322     scs_sigmaIPhiIPhi_branch->SetAddress(&scs_sigmaIPhiIPhi_);
2323     }
2324     if(scs_sigmaIPhiIPhi_branch == 0 ) {
2325     cout << "Branch scs_sigmaIPhiIPhi does not exist." << endl;
2326     }
2327     scs_sigmaPhiPhi_branch = 0;
2328     if (tree->GetAlias("scs_sigmaPhiPhi") != 0) {
2329     scs_sigmaPhiPhi_branch = tree->GetBranch(tree->GetAlias("scs_sigmaPhiPhi"));
2330     scs_sigmaPhiPhi_branch->SetAddress(&scs_sigmaPhiPhi_);
2331     }
2332     if(scs_sigmaPhiPhi_branch == 0 ) {
2333     cout << "Branch scs_sigmaPhiPhi does not exist." << endl;
2334     }
2335     trks_chi2_branch = 0;
2336     if (tree->GetAlias("trks_chi2") != 0) {
2337     trks_chi2_branch = tree->GetBranch(tree->GetAlias("trks_chi2"));
2338     trks_chi2_branch->SetAddress(&trks_chi2_);
2339     }
2340     if(trks_chi2_branch == 0 ) {
2341     cout << "Branch trks_chi2 does not exist." << endl;
2342     }
2343     trks_d0_branch = 0;
2344     if (tree->GetAlias("trks_d0") != 0) {
2345     trks_d0_branch = tree->GetBranch(tree->GetAlias("trks_d0"));
2346     trks_d0_branch->SetAddress(&trks_d0_);
2347     }
2348     if(trks_d0_branch == 0 ) {
2349     cout << "Branch trks_d0 does not exist." << endl;
2350     }
2351     trks_d0Err_branch = 0;
2352     if (tree->GetAlias("trks_d0Err") != 0) {
2353     trks_d0Err_branch = tree->GetBranch(tree->GetAlias("trks_d0Err"));
2354     trks_d0Err_branch->SetAddress(&trks_d0Err_);
2355     }
2356     if(trks_d0Err_branch == 0 ) {
2357     cout << "Branch trks_d0Err does not exist." << endl;
2358     }
2359     trks_d0corr_branch = 0;
2360     if (tree->GetAlias("trks_d0corr") != 0) {
2361     trks_d0corr_branch = tree->GetBranch(tree->GetAlias("trks_d0corr"));
2362     trks_d0corr_branch->SetAddress(&trks_d0corr_);
2363     }
2364     if(trks_d0corr_branch == 0 ) {
2365     cout << "Branch trks_d0corr does not exist." << endl;
2366     }
2367     trks_d0corrPhi_branch = 0;
2368     if (tree->GetAlias("trks_d0corrPhi") != 0) {
2369     trks_d0corrPhi_branch = tree->GetBranch(tree->GetAlias("trks_d0corrPhi"));
2370     trks_d0corrPhi_branch->SetAddress(&trks_d0corrPhi_);
2371     }
2372     if(trks_d0corrPhi_branch == 0 ) {
2373     cout << "Branch trks_d0corrPhi does not exist." << endl;
2374     }
2375     trks_etaErr_branch = 0;
2376     if (tree->GetAlias("trks_etaErr") != 0) {
2377     trks_etaErr_branch = tree->GetBranch(tree->GetAlias("trks_etaErr"));
2378     trks_etaErr_branch->SetAddress(&trks_etaErr_);
2379     }
2380     if(trks_etaErr_branch == 0 ) {
2381     cout << "Branch trks_etaErr does not exist." << endl;
2382     }
2383     trks_ndof_branch = 0;
2384     if (tree->GetAlias("trks_ndof") != 0) {
2385     trks_ndof_branch = tree->GetBranch(tree->GetAlias("trks_ndof"));
2386     trks_ndof_branch->SetAddress(&trks_ndof_);
2387     }
2388     if(trks_ndof_branch == 0 ) {
2389     cout << "Branch trks_ndof does not exist." << endl;
2390     }
2391     trks_phiErr_branch = 0;
2392     if (tree->GetAlias("trks_phiErr") != 0) {
2393     trks_phiErr_branch = tree->GetBranch(tree->GetAlias("trks_phiErr"));
2394     trks_phiErr_branch->SetAddress(&trks_phiErr_);
2395     }
2396     if(trks_phiErr_branch == 0 ) {
2397     cout << "Branch trks_phiErr does not exist." << endl;
2398     }
2399     trks_ptErr_branch = 0;
2400     if (tree->GetAlias("trks_ptErr") != 0) {
2401     trks_ptErr_branch = tree->GetBranch(tree->GetAlias("trks_ptErr"));
2402     trks_ptErr_branch->SetAddress(&trks_ptErr_);
2403     }
2404     if(trks_ptErr_branch == 0 ) {
2405     cout << "Branch trks_ptErr does not exist." << endl;
2406     }
2407     trks_tkIso_branch = 0;
2408     if (tree->GetAlias("trks_tkIso") != 0) {
2409     trks_tkIso_branch = tree->GetBranch(tree->GetAlias("trks_tkIso"));
2410     trks_tkIso_branch->SetAddress(&trks_tkIso_);
2411     }
2412     if(trks_tkIso_branch == 0 ) {
2413     cout << "Branch trks_tkIso does not exist." << endl;
2414     }
2415     trks_vertexphi_branch = 0;
2416     if (tree->GetAlias("trks_vertexphi") != 0) {
2417     trks_vertexphi_branch = tree->GetBranch(tree->GetAlias("trks_vertexphi"));
2418     trks_vertexphi_branch->SetAddress(&trks_vertexphi_);
2419     }
2420     if(trks_vertexphi_branch == 0 ) {
2421     cout << "Branch trks_vertexphi does not exist." << endl;
2422     }
2423     trks_z0_branch = 0;
2424     if (tree->GetAlias("trks_z0") != 0) {
2425     trks_z0_branch = tree->GetBranch(tree->GetAlias("trks_z0"));
2426     trks_z0_branch->SetAddress(&trks_z0_);
2427     }
2428     if(trks_z0_branch == 0 ) {
2429     cout << "Branch trks_z0 does not exist." << endl;
2430     }
2431     trks_z0Err_branch = 0;
2432     if (tree->GetAlias("trks_z0Err") != 0) {
2433     trks_z0Err_branch = tree->GetBranch(tree->GetAlias("trks_z0Err"));
2434     trks_z0Err_branch->SetAddress(&trks_z0Err_);
2435     }
2436     if(trks_z0Err_branch == 0 ) {
2437     cout << "Branch trks_z0Err does not exist." << endl;
2438     }
2439     trks_z0corr_branch = 0;
2440     if (tree->GetAlias("trks_z0corr") != 0) {
2441     trks_z0corr_branch = tree->GetBranch(tree->GetAlias("trks_z0corr"));
2442     trks_z0corr_branch->SetAddress(&trks_z0corr_);
2443     }
2444     if(trks_z0corr_branch == 0 ) {
2445     cout << "Branch trks_z0corr does not exist." << endl;
2446     }
2447     trks_elsdr_branch = 0;
2448     if (tree->GetAlias("trks_elsdr") != 0) {
2449     trks_elsdr_branch = tree->GetBranch(tree->GetAlias("trks_elsdr"));
2450     trks_elsdr_branch->SetAddress(&trks_elsdr_);
2451     }
2452     if(trks_elsdr_branch == 0 ) {
2453     cout << "Branch trks_elsdr does not exist." << endl;
2454     }
2455     trks_elsshFrac_branch = 0;
2456     if (tree->GetAlias("trks_elsshFrac") != 0) {
2457     trks_elsshFrac_branch = tree->GetBranch(tree->GetAlias("trks_elsshFrac"));
2458     trks_elsshFrac_branch->SetAddress(&trks_elsshFrac_);
2459     }
2460     if(trks_elsshFrac_branch == 0 ) {
2461     cout << "Branch trks_elsshFrac does not exist." << endl;
2462     }
2463     vtxs_chi2_branch = 0;
2464     if (tree->GetAlias("vtxs_chi2") != 0) {
2465     vtxs_chi2_branch = tree->GetBranch(tree->GetAlias("vtxs_chi2"));
2466     vtxs_chi2_branch->SetAddress(&vtxs_chi2_);
2467     }
2468     if(vtxs_chi2_branch == 0 ) {
2469     cout << "Branch vtxs_chi2 does not exist." << endl;
2470     }
2471     vtxs_ndof_branch = 0;
2472     if (tree->GetAlias("vtxs_ndof") != 0) {
2473     vtxs_ndof_branch = tree->GetBranch(tree->GetAlias("vtxs_ndof"));
2474     vtxs_ndof_branch->SetAddress(&vtxs_ndof_);
2475     }
2476     if(vtxs_ndof_branch == 0 ) {
2477     cout << "Branch vtxs_ndof does not exist." << endl;
2478     }
2479     vtxs_xError_branch = 0;
2480     if (tree->GetAlias("vtxs_xError") != 0) {
2481     vtxs_xError_branch = tree->GetBranch(tree->GetAlias("vtxs_xError"));
2482     vtxs_xError_branch->SetAddress(&vtxs_xError_);
2483     }
2484     if(vtxs_xError_branch == 0 ) {
2485     cout << "Branch vtxs_xError does not exist." << endl;
2486     }
2487     vtxs_yError_branch = 0;
2488     if (tree->GetAlias("vtxs_yError") != 0) {
2489     vtxs_yError_branch = tree->GetBranch(tree->GetAlias("vtxs_yError"));
2490     vtxs_yError_branch->SetAddress(&vtxs_yError_);
2491     }
2492     if(vtxs_yError_branch == 0 ) {
2493     cout << "Branch vtxs_yError does not exist." << endl;
2494     }
2495     vtxs_zError_branch = 0;
2496     if (tree->GetAlias("vtxs_zError") != 0) {
2497     vtxs_zError_branch = tree->GetBranch(tree->GetAlias("vtxs_zError"));
2498     vtxs_zError_branch->SetAddress(&vtxs_zError_);
2499     }
2500     if(vtxs_zError_branch == 0 ) {
2501     cout << "Branch vtxs_zError does not exist." << endl;
2502     }
2503     trks_residualX_branch = 0;
2504     if (tree->GetAlias("trks_residualX") != 0) {
2505     trks_residualX_branch = tree->GetBranch(tree->GetAlias("trks_residualX"));
2506     trks_residualX_branch->SetAddress(&trks_residualX_);
2507     }
2508     if(trks_residualX_branch == 0 ) {
2509     cout << "Branch trks_residualX does not exist." << endl;
2510     }
2511     trks_residualY_branch = 0;
2512     if (tree->GetAlias("trks_residualY") != 0) {
2513     trks_residualY_branch = tree->GetBranch(tree->GetAlias("trks_residualY"));
2514     trks_residualY_branch->SetAddress(&trks_residualY_);
2515     }
2516     if(trks_residualY_branch == 0 ) {
2517     cout << "Branch trks_residualY does not exist." << endl;
2518     }
2519     vtxs_covMatrix_branch = 0;
2520     if (tree->GetAlias("vtxs_covMatrix") != 0) {
2521     vtxs_covMatrix_branch = tree->GetBranch(tree->GetAlias("vtxs_covMatrix"));
2522     vtxs_covMatrix_branch->SetAddress(&vtxs_covMatrix_);
2523     }
2524     if(vtxs_covMatrix_branch == 0 ) {
2525     cout << "Branch vtxs_covMatrix does not exist." << endl;
2526     }
2527     evt_bsType_branch = 0;
2528     if (tree->GetAlias("evt_bsType") != 0) {
2529     evt_bsType_branch = tree->GetBranch(tree->GetAlias("evt_bsType"));
2530     evt_bsType_branch->SetAddress(&evt_bsType_);
2531     }
2532     if(evt_bsType_branch == 0 ) {
2533     cout << "Branch evt_bsType does not exist." << endl;
2534     }
2535     els_category_branch = 0;
2536     if (tree->GetAlias("els_category") != 0) {
2537     els_category_branch = tree->GetBranch(tree->GetAlias("els_category"));
2538     els_category_branch->SetAddress(&els_category_);
2539     }
2540     if(els_category_branch == 0 ) {
2541     cout << "Branch els_category does not exist." << endl;
2542     }
2543     els_charge_branch = 0;
2544     if (tree->GetAlias("els_charge") != 0) {
2545     els_charge_branch = tree->GetBranch(tree->GetAlias("els_charge"));
2546     els_charge_branch->SetAddress(&els_charge_);
2547     }
2548     if(els_charge_branch == 0 ) {
2549     cout << "Branch els_charge does not exist." << endl;
2550     }
2551     els_class_branch = 0;
2552     if (tree->GetAlias("els_class") != 0) {
2553     els_class_branch = tree->GetBranch(tree->GetAlias("els_class"));
2554     els_class_branch->SetAddress(&els_class_);
2555     }
2556     if(els_class_branch == 0 ) {
2557     cout << "Branch els_class does not exist." << endl;
2558     }
2559     els_fiduciality_branch = 0;
2560     if (tree->GetAlias("els_fiduciality") != 0) {
2561     els_fiduciality_branch = tree->GetBranch(tree->GetAlias("els_fiduciality"));
2562     els_fiduciality_branch->SetAddress(&els_fiduciality_);
2563     }
2564     if(els_fiduciality_branch == 0 ) {
2565     cout << "Branch els_fiduciality does not exist." << endl;
2566     }
2567     els_layer1_det_branch = 0;
2568     if (tree->GetAlias("els_layer1_det") != 0) {
2569     els_layer1_det_branch = tree->GetBranch(tree->GetAlias("els_layer1_det"));
2570     els_layer1_det_branch->SetAddress(&els_layer1_det_);
2571     }
2572     if(els_layer1_det_branch == 0 ) {
2573     cout << "Branch els_layer1_det does not exist." << endl;
2574     }
2575     els_layer1_layer_branch = 0;
2576     if (tree->GetAlias("els_layer1_layer") != 0) {
2577     els_layer1_layer_branch = tree->GetBranch(tree->GetAlias("els_layer1_layer"));
2578     els_layer1_layer_branch->SetAddress(&els_layer1_layer_);
2579     }
2580     if(els_layer1_layer_branch == 0 ) {
2581     cout << "Branch els_layer1_layer does not exist." << endl;
2582     }
2583     els_layer1_sizerphi_branch = 0;
2584     if (tree->GetAlias("els_layer1_sizerphi") != 0) {
2585     els_layer1_sizerphi_branch = tree->GetBranch(tree->GetAlias("els_layer1_sizerphi"));
2586     els_layer1_sizerphi_branch->SetAddress(&els_layer1_sizerphi_);
2587     }
2588     if(els_layer1_sizerphi_branch == 0 ) {
2589     cout << "Branch els_layer1_sizerphi does not exist." << endl;
2590     }
2591     els_layer1_sizerz_branch = 0;
2592     if (tree->GetAlias("els_layer1_sizerz") != 0) {
2593     els_layer1_sizerz_branch = tree->GetBranch(tree->GetAlias("els_layer1_sizerz"));
2594     els_layer1_sizerz_branch->SetAddress(&els_layer1_sizerz_);
2595     }
2596     if(els_layer1_sizerz_branch == 0 ) {
2597     cout << "Branch els_layer1_sizerz does not exist." << endl;
2598     }
2599     els_lostHits_branch = 0;
2600     if (tree->GetAlias("els_lostHits") != 0) {
2601     els_lostHits_branch = tree->GetBranch(tree->GetAlias("els_lostHits"));
2602     els_lostHits_branch->SetAddress(&els_lostHits_);
2603     }
2604     if(els_lostHits_branch == 0 ) {
2605     cout << "Branch els_lostHits does not exist." << endl;
2606     }
2607     els_lost_pixelhits_branch = 0;
2608     if (tree->GetAlias("els_lost_pixelhits") != 0) {
2609     els_lost_pixelhits_branch = tree->GetBranch(tree->GetAlias("els_lost_pixelhits"));
2610     els_lost_pixelhits_branch->SetAddress(&els_lost_pixelhits_);
2611     }
2612     if(els_lost_pixelhits_branch == 0 ) {
2613     cout << "Branch els_lost_pixelhits does not exist." << endl;
2614     }
2615     els_nSeed_branch = 0;
2616     if (tree->GetAlias("els_nSeed") != 0) {
2617     els_nSeed_branch = tree->GetBranch(tree->GetAlias("els_nSeed"));
2618     els_nSeed_branch->SetAddress(&els_nSeed_);
2619     }
2620     if(els_nSeed_branch == 0 ) {
2621     cout << "Branch els_nSeed does not exist." << endl;
2622     }
2623     els_sccharge_branch = 0;
2624     if (tree->GetAlias("els_sccharge") != 0) {
2625     els_sccharge_branch = tree->GetBranch(tree->GetAlias("els_sccharge"));
2626     els_sccharge_branch->SetAddress(&els_sccharge_);
2627     }
2628     if(els_sccharge_branch == 0 ) {
2629     cout << "Branch els_sccharge does not exist." << endl;
2630     }
2631     els_trkidx_branch = 0;
2632     if (tree->GetAlias("els_trkidx") != 0) {
2633     els_trkidx_branch = tree->GetBranch(tree->GetAlias("els_trkidx"));
2634     els_trkidx_branch->SetAddress(&els_trkidx_);
2635     }
2636     if(els_trkidx_branch == 0 ) {
2637     cout << "Branch els_trkidx does not exist." << endl;
2638     }
2639     els_type_branch = 0;
2640     if (tree->GetAlias("els_type") != 0) {
2641     els_type_branch = tree->GetBranch(tree->GetAlias("els_type"));
2642     els_type_branch->SetAddress(&els_type_);
2643     }
2644     if(els_type_branch == 0 ) {
2645     cout << "Branch els_type does not exist." << endl;
2646     }
2647     els_validHits_branch = 0;
2648     if (tree->GetAlias("els_validHits") != 0) {
2649     els_validHits_branch = tree->GetBranch(tree->GetAlias("els_validHits"));
2650     els_validHits_branch->SetAddress(&els_validHits_);
2651     }
2652     if(els_validHits_branch == 0 ) {
2653     cout << "Branch els_validHits does not exist." << endl;
2654     }
2655     els_valid_pixelhits_branch = 0;
2656     if (tree->GetAlias("els_valid_pixelhits") != 0) {
2657     els_valid_pixelhits_branch = tree->GetBranch(tree->GetAlias("els_valid_pixelhits"));
2658     els_valid_pixelhits_branch->SetAddress(&els_valid_pixelhits_);
2659     }
2660     if(els_valid_pixelhits_branch == 0 ) {
2661     cout << "Branch els_valid_pixelhits does not exist." << endl;
2662     }
2663     mus_charge_branch = 0;
2664     if (tree->GetAlias("mus_charge") != 0) {
2665     mus_charge_branch = tree->GetBranch(tree->GetAlias("mus_charge"));
2666     mus_charge_branch->SetAddress(&mus_charge_);
2667     }
2668     if(mus_charge_branch == 0 ) {
2669     cout << "Branch mus_charge does not exist." << endl;
2670     }
2671     mus_gfit_validHits_branch = 0;
2672     if (tree->GetAlias("mus_gfit_validHits") != 0) {
2673     mus_gfit_validHits_branch = tree->GetBranch(tree->GetAlias("mus_gfit_validHits"));
2674     mus_gfit_validHits_branch->SetAddress(&mus_gfit_validHits_);
2675     }
2676     if(mus_gfit_validHits_branch == 0 ) {
2677     cout << "Branch mus_gfit_validHits does not exist." << endl;
2678     }
2679     mus_gfit_validSTAHits_branch = 0;
2680     if (tree->GetAlias("mus_gfit_validSTAHits") != 0) {
2681     mus_gfit_validSTAHits_branch = tree->GetBranch(tree->GetAlias("mus_gfit_validSTAHits"));
2682     mus_gfit_validSTAHits_branch->SetAddress(&mus_gfit_validSTAHits_);
2683     }
2684     if(mus_gfit_validSTAHits_branch == 0 ) {
2685     cout << "Branch mus_gfit_validSTAHits does not exist." << endl;
2686     }
2687     mus_gfit_validSiHits_branch = 0;
2688     if (tree->GetAlias("mus_gfit_validSiHits") != 0) {
2689     mus_gfit_validSiHits_branch = tree->GetBranch(tree->GetAlias("mus_gfit_validSiHits"));
2690     mus_gfit_validSiHits_branch->SetAddress(&mus_gfit_validSiHits_);
2691     }
2692     if(mus_gfit_validSiHits_branch == 0 ) {
2693     cout << "Branch mus_gfit_validSiHits does not exist." << endl;
2694     }
2695     mus_goodmask_branch = 0;
2696     if (tree->GetAlias("mus_goodmask") != 0) {
2697     mus_goodmask_branch = tree->GetBranch(tree->GetAlias("mus_goodmask"));
2698     mus_goodmask_branch->SetAddress(&mus_goodmask_);
2699     }
2700     if(mus_goodmask_branch == 0 ) {
2701     cout << "Branch mus_goodmask does not exist." << endl;
2702     }
2703     mus_iso03_ntrk_branch = 0;
2704     if (tree->GetAlias("mus_iso03_ntrk") != 0) {
2705     mus_iso03_ntrk_branch = tree->GetBranch(tree->GetAlias("mus_iso03_ntrk"));
2706     mus_iso03_ntrk_branch->SetAddress(&mus_iso03_ntrk_);
2707     }
2708     if(mus_iso03_ntrk_branch == 0 ) {
2709     cout << "Branch mus_iso03_ntrk does not exist." << endl;
2710     }
2711     mus_iso05_ntrk_branch = 0;
2712     if (tree->GetAlias("mus_iso05_ntrk") != 0) {
2713     mus_iso05_ntrk_branch = tree->GetBranch(tree->GetAlias("mus_iso05_ntrk"));
2714     mus_iso05_ntrk_branch->SetAddress(&mus_iso05_ntrk_);
2715     }
2716     if(mus_iso05_ntrk_branch == 0 ) {
2717     cout << "Branch mus_iso05_ntrk does not exist." << endl;
2718     }
2719     mus_lostHits_branch = 0;
2720     if (tree->GetAlias("mus_lostHits") != 0) {
2721     mus_lostHits_branch = tree->GetBranch(tree->GetAlias("mus_lostHits"));
2722     mus_lostHits_branch->SetAddress(&mus_lostHits_);
2723     }
2724     if(mus_lostHits_branch == 0 ) {
2725     cout << "Branch mus_lostHits does not exist." << endl;
2726     }
2727     mus_nmatches_branch = 0;
2728     if (tree->GetAlias("mus_nmatches") != 0) {
2729     mus_nmatches_branch = tree->GetBranch(tree->GetAlias("mus_nmatches"));
2730     mus_nmatches_branch->SetAddress(&mus_nmatches_);
2731     }
2732     if(mus_nmatches_branch == 0 ) {
2733     cout << "Branch mus_nmatches does not exist." << endl;
2734     }
2735     mus_pid_TM2DCompatibilityLoose_branch = 0;
2736     if (tree->GetAlias("mus_pid_TM2DCompatibilityLoose") != 0) {
2737     mus_pid_TM2DCompatibilityLoose_branch = tree->GetBranch(tree->GetAlias("mus_pid_TM2DCompatibilityLoose"));
2738     mus_pid_TM2DCompatibilityLoose_branch->SetAddress(&mus_pid_TM2DCompatibilityLoose_);
2739     }
2740     if(mus_pid_TM2DCompatibilityLoose_branch == 0 ) {
2741     cout << "Branch mus_pid_TM2DCompatibilityLoose does not exist." << endl;
2742     }
2743     mus_pid_TM2DCompatibilityTight_branch = 0;
2744     if (tree->GetAlias("mus_pid_TM2DCompatibilityTight") != 0) {
2745     mus_pid_TM2DCompatibilityTight_branch = tree->GetBranch(tree->GetAlias("mus_pid_TM2DCompatibilityTight"));
2746     mus_pid_TM2DCompatibilityTight_branch->SetAddress(&mus_pid_TM2DCompatibilityTight_);
2747     }
2748     if(mus_pid_TM2DCompatibilityTight_branch == 0 ) {
2749     cout << "Branch mus_pid_TM2DCompatibilityTight does not exist." << endl;
2750     }
2751     mus_pid_TMLastStationLoose_branch = 0;
2752     if (tree->GetAlias("mus_pid_TMLastStationLoose") != 0) {
2753     mus_pid_TMLastStationLoose_branch = tree->GetBranch(tree->GetAlias("mus_pid_TMLastStationLoose"));
2754     mus_pid_TMLastStationLoose_branch->SetAddress(&mus_pid_TMLastStationLoose_);
2755     }
2756     if(mus_pid_TMLastStationLoose_branch == 0 ) {
2757     cout << "Branch mus_pid_TMLastStationLoose does not exist." << endl;
2758     }
2759     mus_pid_TMLastStationTight_branch = 0;
2760     if (tree->GetAlias("mus_pid_TMLastStationTight") != 0) {
2761     mus_pid_TMLastStationTight_branch = tree->GetBranch(tree->GetAlias("mus_pid_TMLastStationTight"));
2762     mus_pid_TMLastStationTight_branch->SetAddress(&mus_pid_TMLastStationTight_);
2763     }
2764     if(mus_pid_TMLastStationTight_branch == 0 ) {
2765     cout << "Branch mus_pid_TMLastStationTight does not exist." << endl;
2766     }
2767     mus_timeDirection_branch = 0;
2768     if (tree->GetAlias("mus_timeDirection") != 0) {
2769     mus_timeDirection_branch = tree->GetBranch(tree->GetAlias("mus_timeDirection"));
2770     mus_timeDirection_branch->SetAddress(&mus_timeDirection_);
2771     }
2772     if(mus_timeDirection_branch == 0 ) {
2773     cout << "Branch mus_timeDirection does not exist." << endl;
2774     }
2775     mus_timeNumStationsUsed_branch = 0;
2776     if (tree->GetAlias("mus_timeNumStationsUsed") != 0) {
2777     mus_timeNumStationsUsed_branch = tree->GetBranch(tree->GetAlias("mus_timeNumStationsUsed"));
2778     mus_timeNumStationsUsed_branch->SetAddress(&mus_timeNumStationsUsed_);
2779     }
2780     if(mus_timeNumStationsUsed_branch == 0 ) {
2781     cout << "Branch mus_timeNumStationsUsed does not exist." << endl;
2782     }
2783     mus_trk_charge_branch = 0;
2784     if (tree->GetAlias("mus_trk_charge") != 0) {
2785     mus_trk_charge_branch = tree->GetBranch(tree->GetAlias("mus_trk_charge"));
2786     mus_trk_charge_branch->SetAddress(&mus_trk_charge_);
2787     }
2788     if(mus_trk_charge_branch == 0 ) {
2789     cout << "Branch mus_trk_charge does not exist." << endl;
2790     }
2791     mus_trkidx_branch = 0;
2792     if (tree->GetAlias("mus_trkidx") != 0) {
2793     mus_trkidx_branch = tree->GetBranch(tree->GetAlias("mus_trkidx"));
2794     mus_trkidx_branch->SetAddress(&mus_trkidx_);
2795     }
2796     if(mus_trkidx_branch == 0 ) {
2797     cout << "Branch mus_trkidx does not exist." << endl;
2798     }
2799     mus_type_branch = 0;
2800     if (tree->GetAlias("mus_type") != 0) {
2801     mus_type_branch = tree->GetBranch(tree->GetAlias("mus_type"));
2802     mus_type_branch->SetAddress(&mus_type_);
2803     }
2804     if(mus_type_branch == 0 ) {
2805     cout << "Branch mus_type does not exist." << endl;
2806     }
2807     mus_validHits_branch = 0;
2808     if (tree->GetAlias("mus_validHits") != 0) {
2809     mus_validHits_branch = tree->GetBranch(tree->GetAlias("mus_validHits"));
2810     mus_validHits_branch->SetAddress(&mus_validHits_);
2811     }
2812     if(mus_validHits_branch == 0 ) {
2813     cout << "Branch mus_validHits does not exist." << endl;
2814     }
2815     scs_elsidx_branch = 0;
2816     if (tree->GetAlias("scs_elsidx") != 0) {
2817     scs_elsidx_branch = tree->GetBranch(tree->GetAlias("scs_elsidx"));
2818     scs_elsidx_branch->SetAddress(&scs_elsidx_);
2819     }
2820     if(scs_elsidx_branch == 0 ) {
2821     cout << "Branch scs_elsidx does not exist." << endl;
2822     }
2823     trks_algo_branch = 0;
2824     if (tree->GetAlias("trks_algo") != 0) {
2825     trks_algo_branch = tree->GetBranch(tree->GetAlias("trks_algo"));
2826     trks_algo_branch->SetAddress(&trks_algo_);
2827     }
2828     if(trks_algo_branch == 0 ) {
2829     cout << "Branch trks_algo does not exist." << endl;
2830     }
2831     trks_charge_branch = 0;
2832     if (tree->GetAlias("trks_charge") != 0) {
2833     trks_charge_branch = tree->GetBranch(tree->GetAlias("trks_charge"));
2834     trks_charge_branch->SetAddress(&trks_charge_);
2835     }
2836     if(trks_charge_branch == 0 ) {
2837     cout << "Branch trks_charge does not exist." << endl;
2838     }
2839     trks_lostHits_branch = 0;
2840     if (tree->GetAlias("trks_lostHits") != 0) {
2841     trks_lostHits_branch = tree->GetBranch(tree->GetAlias("trks_lostHits"));
2842     trks_lostHits_branch->SetAddress(&trks_lostHits_);
2843     }
2844     if(trks_lostHits_branch == 0 ) {
2845     cout << "Branch trks_lostHits does not exist." << endl;
2846     }
2847     trks_qualityMask_branch = 0;
2848     if (tree->GetAlias("trks_qualityMask") != 0) {
2849     trks_qualityMask_branch = tree->GetBranch(tree->GetAlias("trks_qualityMask"));
2850     trks_qualityMask_branch->SetAddress(&trks_qualityMask_);
2851     }
2852     if(trks_qualityMask_branch == 0 ) {
2853     cout << "Branch trks_qualityMask does not exist." << endl;
2854     }
2855     trks_validHits_branch = 0;
2856     if (tree->GetAlias("trks_validHits") != 0) {
2857     trks_validHits_branch = tree->GetBranch(tree->GetAlias("trks_validHits"));
2858     trks_validHits_branch->SetAddress(&trks_validHits_);
2859     }
2860     if(trks_validHits_branch == 0 ) {
2861     cout << "Branch trks_validHits does not exist." << endl;
2862     }
2863     trks_elsidx_branch = 0;
2864     if (tree->GetAlias("trks_elsidx") != 0) {
2865     trks_elsidx_branch = tree->GetBranch(tree->GetAlias("trks_elsidx"));
2866     trks_elsidx_branch->SetAddress(&trks_elsidx_);
2867     }
2868     if(trks_elsidx_branch == 0 ) {
2869     cout << "Branch trks_elsidx does not exist." << endl;
2870     }
2871     trk_musidx_branch = 0;
2872     if (tree->GetAlias("trk_musidx") != 0) {
2873     trk_musidx_branch = tree->GetBranch(tree->GetAlias("trk_musidx"));
2874     trk_musidx_branch->SetAddress(&trk_musidx_);
2875     }
2876     if(trk_musidx_branch == 0 ) {
2877     cout << "Branch trk_musidx does not exist." << endl;
2878     }
2879     vtxs_isFake_branch = 0;
2880     if (tree->GetAlias("vtxs_isFake") != 0) {
2881     vtxs_isFake_branch = tree->GetBranch(tree->GetAlias("vtxs_isFake"));
2882     vtxs_isFake_branch->SetAddress(&vtxs_isFake_);
2883     }
2884     if(vtxs_isFake_branch == 0 ) {
2885     cout << "Branch vtxs_isFake does not exist." << endl;
2886     }
2887     vtxs_isValid_branch = 0;
2888     if (tree->GetAlias("vtxs_isValid") != 0) {
2889     vtxs_isValid_branch = tree->GetBranch(tree->GetAlias("vtxs_isValid"));
2890     vtxs_isValid_branch->SetAddress(&vtxs_isValid_);
2891     }
2892     if(vtxs_isValid_branch == 0 ) {
2893     cout << "Branch vtxs_isValid does not exist." << endl;
2894     }
2895     vtxs_tracksSize_branch = 0;
2896     if (tree->GetAlias("vtxs_tracksSize") != 0) {
2897     vtxs_tracksSize_branch = tree->GetBranch(tree->GetAlias("vtxs_tracksSize"));
2898     vtxs_tracksSize_branch->SetAddress(&vtxs_tracksSize_);
2899     }
2900     if(vtxs_tracksSize_branch == 0 ) {
2901     cout << "Branch vtxs_tracksSize does not exist." << endl;
2902     }
2903     trks_hit_substructure_branch = 0;
2904     if (tree->GetAlias("trks_hit_substructure") != 0) {
2905     trks_hit_substructure_branch = tree->GetBranch(tree->GetAlias("trks_hit_substructure"));
2906     trks_hit_substructure_branch->SetAddress(&trks_hit_substructure_);
2907     }
2908     if(trks_hit_substructure_branch == 0 ) {
2909     cout << "Branch trks_hit_substructure does not exist." << endl;
2910     }
2911     trks_hit_type_branch = 0;
2912     if (tree->GetAlias("trks_hit_type") != 0) {
2913     trks_hit_type_branch = tree->GetBranch(tree->GetAlias("trks_hit_type"));
2914     trks_hit_type_branch->SetAddress(&trks_hit_type_);
2915     }
2916     if(trks_hit_type_branch == 0 ) {
2917     cout << "Branch trks_hit_type does not exist." << endl;
2918     }
2919     evt_ntwrs_branch = 0;
2920     if (tree->GetAlias("evt_ntwrs") != 0) {
2921     evt_ntwrs_branch = tree->GetBranch(tree->GetAlias("evt_ntwrs"));
2922     evt_ntwrs_branch->SetAddress(&evt_ntwrs_);
2923     }
2924     if(evt_ntwrs_branch == 0 ) {
2925     cout << "Branch evt_ntwrs does not exist." << endl;
2926     }
2927     evt_nels_branch = 0;
2928     if (tree->GetAlias("evt_nels") != 0) {
2929     evt_nels_branch = tree->GetBranch(tree->GetAlias("evt_nels"));
2930     evt_nels_branch->SetAddress(&evt_nels_);
2931     }
2932     if(evt_nels_branch == 0 ) {
2933     cout << "Branch evt_nels does not exist." << endl;
2934     }
2935     evt_event_branch = 0;
2936     if (tree->GetAlias("evt_event") != 0) {
2937     evt_event_branch = tree->GetBranch(tree->GetAlias("evt_event"));
2938     evt_event_branch->SetAddress(&evt_event_);
2939     }
2940     if(evt_event_branch == 0 ) {
2941     cout << "Branch evt_event does not exist." << endl;
2942     }
2943     evt_lumiBlock_branch = 0;
2944     if (tree->GetAlias("evt_lumiBlock") != 0) {
2945     evt_lumiBlock_branch = tree->GetBranch(tree->GetAlias("evt_lumiBlock"));
2946     evt_lumiBlock_branch->SetAddress(&evt_lumiBlock_);
2947     }
2948     if(evt_lumiBlock_branch == 0 ) {
2949     cout << "Branch evt_lumiBlock does not exist." << endl;
2950     }
2951     evt_run_branch = 0;
2952     if (tree->GetAlias("evt_run") != 0) {
2953     evt_run_branch = tree->GetBranch(tree->GetAlias("evt_run"));
2954     evt_run_branch->SetAddress(&evt_run_);
2955     }
2956     if(evt_run_branch == 0 ) {
2957     cout << "Branch evt_run does not exist." << endl;
2958     }
2959     evt_nscs_branch = 0;
2960     if (tree->GetAlias("evt_nscs") != 0) {
2961     evt_nscs_branch = tree->GetBranch(tree->GetAlias("evt_nscs"));
2962     evt_nscs_branch->SetAddress(&evt_nscs_);
2963     }
2964     if(evt_nscs_branch == 0 ) {
2965     cout << "Branch evt_nscs does not exist." << endl;
2966     }
2967     evt_nvtxs_branch = 0;
2968     if (tree->GetAlias("evt_nvtxs") != 0) {
2969     evt_nvtxs_branch = tree->GetBranch(tree->GetAlias("evt_nvtxs"));
2970     evt_nvtxs_branch->SetAddress(&evt_nvtxs_);
2971     }
2972     if(evt_nvtxs_branch == 0 ) {
2973     cout << "Branch evt_nvtxs does not exist." << endl;
2974     }
2975     twrs_numBadEcalCells_branch = 0;
2976     if (tree->GetAlias("twrs_numBadEcalCells") != 0) {
2977     twrs_numBadEcalCells_branch = tree->GetBranch(tree->GetAlias("twrs_numBadEcalCells"));
2978     twrs_numBadEcalCells_branch->SetAddress(&twrs_numBadEcalCells_);
2979     }
2980     if(twrs_numBadEcalCells_branch == 0 ) {
2981     cout << "Branch twrs_numBadEcalCells does not exist." << endl;
2982     }
2983     twrs_numBadHcalCells_branch = 0;
2984     if (tree->GetAlias("twrs_numBadHcalCells") != 0) {
2985     twrs_numBadHcalCells_branch = tree->GetBranch(tree->GetAlias("twrs_numBadHcalCells"));
2986     twrs_numBadHcalCells_branch->SetAddress(&twrs_numBadHcalCells_);
2987     }
2988     if(twrs_numBadHcalCells_branch == 0 ) {
2989     cout << "Branch twrs_numBadHcalCells does not exist." << endl;
2990     }
2991     twrs_numProblematicEcalCells_branch = 0;
2992     if (tree->GetAlias("twrs_numProblematicEcalCells") != 0) {
2993     twrs_numProblematicEcalCells_branch = tree->GetBranch(tree->GetAlias("twrs_numProblematicEcalCells"));
2994     twrs_numProblematicEcalCells_branch->SetAddress(&twrs_numProblematicEcalCells_);
2995     }
2996     if(twrs_numProblematicEcalCells_branch == 0 ) {
2997     cout << "Branch twrs_numProblematicEcalCells does not exist." << endl;
2998     }
2999     twrs_numProblematicHcalCells_branch = 0;
3000     if (tree->GetAlias("twrs_numProblematicHcalCells") != 0) {
3001     twrs_numProblematicHcalCells_branch = tree->GetBranch(tree->GetAlias("twrs_numProblematicHcalCells"));
3002     twrs_numProblematicHcalCells_branch->SetAddress(&twrs_numProblematicHcalCells_);
3003     }
3004     if(twrs_numProblematicHcalCells_branch == 0 ) {
3005     cout << "Branch twrs_numProblematicHcalCells does not exist." << endl;
3006     }
3007     twrs_numRecoveredEcalCells_branch = 0;
3008     if (tree->GetAlias("twrs_numRecoveredEcalCells") != 0) {
3009     twrs_numRecoveredEcalCells_branch = tree->GetBranch(tree->GetAlias("twrs_numRecoveredEcalCells"));
3010     twrs_numRecoveredEcalCells_branch->SetAddress(&twrs_numRecoveredEcalCells_);
3011     }
3012     if(twrs_numRecoveredEcalCells_branch == 0 ) {
3013     cout << "Branch twrs_numRecoveredEcalCells does not exist." << endl;
3014     }
3015     twrs_numRecoveredHcalCells_branch = 0;
3016     if (tree->GetAlias("twrs_numRecoveredHcalCells") != 0) {
3017     twrs_numRecoveredHcalCells_branch = tree->GetBranch(tree->GetAlias("twrs_numRecoveredHcalCells"));
3018     twrs_numRecoveredHcalCells_branch->SetAddress(&twrs_numRecoveredHcalCells_);
3019     }
3020     if(twrs_numRecoveredHcalCells_branch == 0 ) {
3021     cout << "Branch twrs_numRecoveredHcalCells does not exist." << endl;
3022     }
3023     evt_scale1fb_branch = 0;
3024     if (tree->GetAlias("evt_scale1fb") != 0) {
3025     evt_scale1fb_branch = tree->GetBranch(tree->GetAlias("evt_scale1fb"));
3026     evt_scale1fb_branch->SetAddress(&evt_scale1fb_);
3027     }
3028     if(evt_scale1fb_branch == 0 ) {
3029     cout << "Branch evt_scale1fb does not exist." << endl;
3030     }
3031     evt_xsec_excl_branch = 0;
3032     if (tree->GetAlias("evt_xsec_excl") != 0) {
3033     evt_xsec_excl_branch = tree->GetBranch(tree->GetAlias("evt_xsec_excl"));
3034     evt_xsec_excl_branch->SetAddress(&evt_xsec_excl_);
3035     }
3036     if(evt_xsec_excl_branch == 0 ) {
3037     cout << "Branch evt_xsec_excl does not exist." << endl;
3038     }
3039     evt_xsec_incl_branch = 0;
3040     if (tree->GetAlias("evt_xsec_incl") != 0) {
3041     evt_xsec_incl_branch = tree->GetBranch(tree->GetAlias("evt_xsec_incl"));
3042     evt_xsec_incl_branch->SetAddress(&evt_xsec_incl_);
3043     }
3044     if(evt_xsec_incl_branch == 0 ) {
3045     cout << "Branch evt_xsec_incl does not exist." << endl;
3046     }
3047     evt_kfactor_branch = 0;
3048     if (tree->GetAlias("evt_kfactor") != 0) {
3049     evt_kfactor_branch = tree->GetBranch(tree->GetAlias("evt_kfactor"));
3050     evt_kfactor_branch->SetAddress(&evt_kfactor_);
3051     }
3052     if(evt_kfactor_branch == 0 ) {
3053     cout << "Branch evt_kfactor does not exist." << endl;
3054     }
3055     evt_nEvts_branch = 0;
3056     if (tree->GetAlias("evt_nEvts") != 0) {
3057     evt_nEvts_branch = tree->GetBranch(tree->GetAlias("evt_nEvts"));
3058     evt_nEvts_branch->SetAddress(&evt_nEvts_);
3059     }
3060     if(evt_nEvts_branch == 0 ) {
3061     cout << "Branch evt_nEvts does not exist." << endl;
3062     }
3063     evt_filt_eff_branch = 0;
3064     if (tree->GetAlias("evt_filt_eff") != 0) {
3065     evt_filt_eff_branch = tree->GetBranch(tree->GetAlias("evt_filt_eff"));
3066     evt_filt_eff_branch->SetAddress(&evt_filt_eff_);
3067     }
3068     if(evt_filt_eff_branch == 0 ) {
3069     cout << "Branch evt_filt_eff does not exist." << endl;
3070     }
3071     tree->SetMakeClass(0);
3072     }
3073     void GetEntry(unsigned int idx)
3074     // this only marks branches as not loaded, saving a lot of time
3075     {
3076     index = idx;
3077     evt_CMS2tag_isLoaded = false;
3078     evt_dataset_isLoaded = false;
3079     els_inner_positionx_isLoaded = false;
3080     els_inner_positiony_isLoaded = false;
3081     els_inner_positionz_isLoaded = false;
3082     evt_bs_Xwidth_isLoaded = false;
3083     evt_bs_XwidthErr_isLoaded = false;
3084     evt_bs_Ywidth_isLoaded = false;
3085     evt_bs_YwidthErr_isLoaded = false;
3086     evt_bs_dxdz_isLoaded = false;
3087     evt_bs_dxdzErr_isLoaded = false;
3088     evt_bs_dydz_isLoaded = false;
3089     evt_bs_dydzErr_isLoaded = false;
3090     evt_bs_sigmaZ_isLoaded = false;
3091     evt_bs_sigmaZErr_isLoaded = false;
3092     evt_bs_xErr_isLoaded = false;
3093     evt_bs_yErr_isLoaded = false;
3094     evt_bs_zErr_isLoaded = false;
3095     evt_bField_isLoaded = false;
3096     evt_bsp4_isLoaded = false;
3097     els_p4_isLoaded = false;
3098     els_p4In_isLoaded = false;
3099     els_p4Out_isLoaded = false;
3100     els_trk_p4_isLoaded = false;
3101     els_vertex_p4_isLoaded = false;
3102     mus_fitdefault_p4_isLoaded = false;
3103     mus_fitfirsthit_p4_isLoaded = false;
3104     mus_fitpicky_p4_isLoaded = false;
3105     mus_fittev_p4_isLoaded = false;
3106     mus_gfit_outerPos_p4_isLoaded = false;
3107     mus_gfit_p4_isLoaded = false;
3108     mus_gfit_vertex_p4_isLoaded = false;
3109     mus_p4_isLoaded = false;
3110     mus_trk_p4_isLoaded = false;
3111     mus_vertex_p4_isLoaded = false;
3112     scs_p4_isLoaded = false;
3113     scs_pos_p4_isLoaded = false;
3114     scs_vtx_p4_isLoaded = false;
3115     trks_outer_p4_isLoaded = false;
3116     trks_trk_p4_isLoaded = false;
3117     trks_vertex_p4_isLoaded = false;
3118     vtxs_position_isLoaded = false;
3119     evt_covMatrix_isLoaded = false;
3120     twrs_ecalTime_isLoaded = false;
3121     twrs_emEnergy_isLoaded = false;
3122     twrs_emEt_isLoaded = false;
3123     twrs_emEtcorr_isLoaded = false;
3124     twrs_eta_isLoaded = false;
3125     twrs_etcorr_isLoaded = false;
3126     twrs_hadEnergy_isLoaded = false;
3127     twrs_hadEt_isLoaded = false;
3128     twrs_hadEtcorr_isLoaded = false;
3129     twrs_hcalTime_isLoaded = false;
3130     twrs_outerEnergy_isLoaded = false;
3131     twrs_outerEt_isLoaded = false;
3132     twrs_outerEtcorr_isLoaded = false;
3133     twrs_pcorr_isLoaded = false;
3134     twrs_phi_isLoaded = false;
3135     els_ecalJuraIso_isLoaded = false;
3136     els_ecalJuraTowerIso_isLoaded = false;
3137     els_hcalConeIso_isLoaded = false;
3138     els_chi2_isLoaded = false;
3139     els_d0_isLoaded = false;
3140     els_d0Err_isLoaded = false;
3141     els_d0corr_isLoaded = false;
3142     els_dEtaIn_isLoaded = false;
3143     els_dEtaOut_isLoaded = false;
3144     els_dPhiIn_isLoaded = false;
3145     els_dPhiInPhiOut_isLoaded = false;
3146     els_dPhiOut_isLoaded = false;
3147     els_e1x5_isLoaded = false;
3148     els_e2x5Max_isLoaded = false;
3149     els_e3x3_isLoaded = false;
3150     els_e5x5_isLoaded = false;
3151     els_eMax_isLoaded = false;
3152     els_eOverPIn_isLoaded = false;
3153     els_eSC_isLoaded = false;
3154     els_eSCPresh_isLoaded = false;
3155     els_eSCRaw_isLoaded = false;
3156     els_eSeed_isLoaded = false;
3157     els_eSeedOverPIn_isLoaded = false;
3158     els_eSeedOverPOut_isLoaded = false;
3159     els_ecalEnergy_isLoaded = false;
3160     els_ecalEnergyError_isLoaded = false;
3161     els_ecalIso_isLoaded = false;
3162     els_ecalIso04_isLoaded = false;
3163     els_egamma_looseId_isLoaded = false;
3164     els_egamma_robustHighEnergy_isLoaded = false;
3165     els_egamma_robustLooseId_isLoaded = false;
3166     els_egamma_robustTightId_isLoaded = false;
3167     els_egamma_tightId_isLoaded = false;
3168     els_electronMomentumError_isLoaded = false;
3169     els_etaErr_isLoaded = false;
3170     els_etaSC_isLoaded = false;
3171     els_fBrem_isLoaded = false;
3172     els_hOverE_isLoaded = false;
3173     els_hcalIso_isLoaded = false;
3174     els_hcalIso04_isLoaded = false;
3175     els_layer1_charge_isLoaded = false;
3176     els_ndof_isLoaded = false;
3177     els_phiErr_isLoaded = false;
3178     els_phiSC_isLoaded = false;
3179     els_ptErr_isLoaded = false;
3180     els_sigmaEtaEta_isLoaded = false;
3181     els_sigmaIEtaIEta_isLoaded = false;
3182     els_sigmaIPhiIPhi_isLoaded = false;
3183     els_sigmaPhiPhi_isLoaded = false;
3184     els_tkIso_isLoaded = false;
3185     els_tkIso04_isLoaded = false;
3186     els_trackMomentumError_isLoaded = false;
3187     els_trkdr_isLoaded = false;
3188     els_trkshFrac_isLoaded = false;
3189     els_z0_isLoaded = false;
3190     els_z0Err_isLoaded = false;
3191     els_z0corr_isLoaded = false;
3192     mus_caloCompatibility_isLoaded = false;
3193     mus_chi2_isLoaded = false;
3194     mus_d0_isLoaded = false;
3195     mus_d0Err_isLoaded = false;
3196     mus_d0corr_isLoaded = false;
3197     mus_e_em_isLoaded = false;
3198     mus_e_emS9_isLoaded = false;
3199     mus_e_had_isLoaded = false;
3200     mus_e_hadS9_isLoaded = false;
3201     mus_e_ho_isLoaded = false;
3202     mus_e_hoS9_isLoaded = false;
3203     mus_etaErr_isLoaded = false;
3204     mus_gfit_chi2_isLoaded = false;
3205     mus_gfit_d0_isLoaded = false;
3206     mus_gfit_d0Err_isLoaded = false;
3207     mus_gfit_d0corr_isLoaded = false;
3208     mus_gfit_ndof_isLoaded = false;
3209     mus_gfit_qoverp_isLoaded = false;
3210     mus_gfit_qoverpError_isLoaded = false;
3211     mus_gfit_z0_isLoaded = false;
3212     mus_gfit_z0Err_isLoaded = false;
3213     mus_gfit_z0corr_isLoaded = false;
3214     mus_iso03_emEt_isLoaded = false;
3215     mus_iso03_hadEt_isLoaded = false;
3216     mus_iso03_hoEt_isLoaded = false;
3217     mus_iso03_sumPt_isLoaded = false;
3218     mus_iso05_emEt_isLoaded = false;
3219     mus_iso05_hadEt_isLoaded = false;
3220     mus_iso05_hoEt_isLoaded = false;
3221     mus_iso05_sumPt_isLoaded = false;
3222     mus_iso_ecalvetoDep_isLoaded = false;
3223     mus_iso_hcalvetoDep_isLoaded = false;
3224     mus_iso_hovetoDep_isLoaded = false;
3225     mus_iso_trckvetoDep_isLoaded = false;
3226     mus_ndof_isLoaded = false;
3227     mus_phiErr_isLoaded = false;
3228     mus_ptErr_isLoaded = false;
3229     mus_qoverp_isLoaded = false;
3230     mus_qoverpError_isLoaded = false;
3231     mus_timeAtIpInOut_isLoaded = false;
3232     mus_timeAtIpInOutErr_isLoaded = false;
3233     mus_timeAtIpOutIn_isLoaded = false;
3234     mus_timeAtIpOutInErr_isLoaded = false;
3235     mus_vertexphi_isLoaded = false;
3236     mus_z0_isLoaded = false;
3237     mus_z0Err_isLoaded = false;
3238     mus_z0corr_isLoaded = false;
3239     scs_clustersSize_isLoaded = false;
3240     scs_crystalsSize_isLoaded = false;
3241     scs_e1x3_isLoaded = false;
3242     scs_e1x5_isLoaded = false;
3243     scs_e2x2_isLoaded = false;
3244     scs_e2x5Max_isLoaded = false;
3245     scs_e3x1_isLoaded = false;
3246     scs_e3x2_isLoaded = false;
3247     scs_e3x3_isLoaded = false;
3248     scs_e4x4_isLoaded = false;
3249     scs_e5x5_isLoaded = false;
3250     scs_energy_isLoaded = false;
3251     scs_eta_isLoaded = false;
3252     scs_hoe_isLoaded = false;
3253     scs_phi_isLoaded = false;
3254     scs_preshowerEnergy_isLoaded = false;
3255     scs_rawEnergy_isLoaded = false;
3256     scs_sigmaEtaEta_isLoaded = false;
3257     scs_sigmaEtaPhi_isLoaded = false;
3258     scs_sigmaIEtaIEta_isLoaded = false;
3259     scs_sigmaIEtaIPhi_isLoaded = false;
3260     scs_sigmaIPhiIPhi_isLoaded = false;
3261     scs_sigmaPhiPhi_isLoaded = false;
3262     trks_chi2_isLoaded = false;
3263     trks_d0_isLoaded = false;
3264     trks_d0Err_isLoaded = false;
3265     trks_d0corr_isLoaded = false;
3266     trks_d0corrPhi_isLoaded = false;
3267     trks_etaErr_isLoaded = false;
3268     trks_ndof_isLoaded = false;
3269     trks_phiErr_isLoaded = false;
3270     trks_ptErr_isLoaded = false;
3271     trks_tkIso_isLoaded = false;
3272     trks_vertexphi_isLoaded = false;
3273     trks_z0_isLoaded = false;
3274     trks_z0Err_isLoaded = false;
3275     trks_z0corr_isLoaded = false;
3276     trks_elsdr_isLoaded = false;
3277     trks_elsshFrac_isLoaded = false;
3278     vtxs_chi2_isLoaded = false;
3279     vtxs_ndof_isLoaded = false;
3280     vtxs_xError_isLoaded = false;
3281     vtxs_yError_isLoaded = false;
3282     vtxs_zError_isLoaded = false;
3283     trks_residualX_isLoaded = false;
3284     trks_residualY_isLoaded = false;
3285     vtxs_covMatrix_isLoaded = false;
3286     evt_bsType_isLoaded = false;
3287     els_category_isLoaded = false;
3288     els_charge_isLoaded = false;
3289     els_class_isLoaded = false;
3290     els_fiduciality_isLoaded = false;
3291     els_layer1_det_isLoaded = false;
3292     els_layer1_layer_isLoaded = false;
3293     els_layer1_sizerphi_isLoaded = false;
3294     els_layer1_sizerz_isLoaded = false;
3295     els_lostHits_isLoaded = false;
3296     els_lost_pixelhits_isLoaded = false;
3297     els_nSeed_isLoaded = false;
3298     els_sccharge_isLoaded = false;
3299     els_trkidx_isLoaded = false;
3300     els_type_isLoaded = false;
3301     els_validHits_isLoaded = false;
3302     els_valid_pixelhits_isLoaded = false;
3303     mus_charge_isLoaded = false;
3304     mus_gfit_validHits_isLoaded = false;
3305     mus_gfit_validSTAHits_isLoaded = false;
3306     mus_gfit_validSiHits_isLoaded = false;
3307     mus_goodmask_isLoaded = false;
3308     mus_iso03_ntrk_isLoaded = false;
3309     mus_iso05_ntrk_isLoaded = false;
3310     mus_lostHits_isLoaded = false;
3311     mus_nmatches_isLoaded = false;
3312     mus_pid_TM2DCompatibilityLoose_isLoaded = false;
3313     mus_pid_TM2DCompatibilityTight_isLoaded = false;
3314     mus_pid_TMLastStationLoose_isLoaded = false;
3315     mus_pid_TMLastStationTight_isLoaded = false;
3316     mus_timeDirection_isLoaded = false;
3317     mus_timeNumStationsUsed_isLoaded = false;
3318     mus_trk_charge_isLoaded = false;
3319     mus_trkidx_isLoaded = false;
3320     mus_type_isLoaded = false;
3321     mus_validHits_isLoaded = false;
3322     scs_elsidx_isLoaded = false;
3323     trks_algo_isLoaded = false;
3324     trks_charge_isLoaded = false;
3325     trks_lostHits_isLoaded = false;
3326     trks_qualityMask_isLoaded = false;
3327     trks_validHits_isLoaded = false;
3328     trks_elsidx_isLoaded = false;
3329     trk_musidx_isLoaded = false;
3330     vtxs_isFake_isLoaded = false;
3331     vtxs_isValid_isLoaded = false;
3332     vtxs_tracksSize_isLoaded = false;
3333     trks_hit_substructure_isLoaded = false;
3334     trks_hit_type_isLoaded = false;
3335     evt_ntwrs_isLoaded = false;
3336     evt_nels_isLoaded = false;
3337     evt_event_isLoaded = false;
3338     evt_lumiBlock_isLoaded = false;
3339     evt_run_isLoaded = false;
3340     evt_nscs_isLoaded = false;
3341     evt_nvtxs_isLoaded = false;
3342     twrs_numBadEcalCells_isLoaded = false;
3343     twrs_numBadHcalCells_isLoaded = false;
3344     twrs_numProblematicEcalCells_isLoaded = false;
3345     twrs_numProblematicHcalCells_isLoaded = false;
3346     twrs_numRecoveredEcalCells_isLoaded = false;
3347     twrs_numRecoveredHcalCells_isLoaded = false;
3348     evt_scale1fb_isLoaded = false;
3349     evt_xsec_excl_isLoaded = false;
3350     evt_xsec_incl_isLoaded = false;
3351     evt_kfactor_isLoaded = false;
3352     evt_nEvts_isLoaded = false;
3353     evt_filt_eff_isLoaded = false;
3354     }
3355    
3356     void LoadAllBranches()
3357     // load all branches
3358     {
3359     if (evt_CMS2tag_branch != 0) evt_CMS2tag();
3360     if (evt_dataset_branch != 0) evt_dataset();
3361     if (els_inner_positionx_branch != 0) els_inner_positionx();
3362     if (els_inner_positiony_branch != 0) els_inner_positiony();
3363     if (els_inner_positionz_branch != 0) els_inner_positionz();
3364     if (evt_bs_Xwidth_branch != 0) evt_bs_Xwidth();
3365     if (evt_bs_XwidthErr_branch != 0) evt_bs_XwidthErr();
3366     if (evt_bs_Ywidth_branch != 0) evt_bs_Ywidth();
3367     if (evt_bs_YwidthErr_branch != 0) evt_bs_YwidthErr();
3368     if (evt_bs_dxdz_branch != 0) evt_bs_dxdz();
3369     if (evt_bs_dxdzErr_branch != 0) evt_bs_dxdzErr();
3370     if (evt_bs_dydz_branch != 0) evt_bs_dydz();
3371     if (evt_bs_dydzErr_branch != 0) evt_bs_dydzErr();
3372     if (evt_bs_sigmaZ_branch != 0) evt_bs_sigmaZ();
3373     if (evt_bs_sigmaZErr_branch != 0) evt_bs_sigmaZErr();
3374     if (evt_bs_xErr_branch != 0) evt_bs_xErr();
3375     if (evt_bs_yErr_branch != 0) evt_bs_yErr();
3376     if (evt_bs_zErr_branch != 0) evt_bs_zErr();
3377     if (evt_bField_branch != 0) evt_bField();
3378     if (evt_bsp4_branch != 0) evt_bsp4();
3379     if (els_p4_branch != 0) els_p4();
3380     if (els_p4In_branch != 0) els_p4In();
3381     if (els_p4Out_branch != 0) els_p4Out();
3382     if (els_trk_p4_branch != 0) els_trk_p4();
3383     if (els_vertex_p4_branch != 0) els_vertex_p4();
3384     if (mus_fitdefault_p4_branch != 0) mus_fitdefault_p4();
3385     if (mus_fitfirsthit_p4_branch != 0) mus_fitfirsthit_p4();
3386     if (mus_fitpicky_p4_branch != 0) mus_fitpicky_p4();
3387     if (mus_fittev_p4_branch != 0) mus_fittev_p4();
3388     if (mus_gfit_outerPos_p4_branch != 0) mus_gfit_outerPos_p4();
3389     if (mus_gfit_p4_branch != 0) mus_gfit_p4();
3390     if (mus_gfit_vertex_p4_branch != 0) mus_gfit_vertex_p4();
3391     if (mus_p4_branch != 0) mus_p4();
3392     if (mus_trk_p4_branch != 0) mus_trk_p4();
3393     if (mus_vertex_p4_branch != 0) mus_vertex_p4();
3394     if (scs_p4_branch != 0) scs_p4();
3395     if (scs_pos_p4_branch != 0) scs_pos_p4();
3396     if (scs_vtx_p4_branch != 0) scs_vtx_p4();
3397     if (trks_outer_p4_branch != 0) trks_outer_p4();
3398     if (trks_trk_p4_branch != 0) trks_trk_p4();
3399     if (trks_vertex_p4_branch != 0) trks_vertex_p4();
3400     if (vtxs_position_branch != 0) vtxs_position();
3401     if (evt_covMatrix_branch != 0) evt_covMatrix();
3402     if (twrs_ecalTime_branch != 0) twrs_ecalTime();
3403     if (twrs_emEnergy_branch != 0) twrs_emEnergy();
3404     if (twrs_emEt_branch != 0) twrs_emEt();
3405     if (twrs_emEtcorr_branch != 0) twrs_emEtcorr();
3406     if (twrs_eta_branch != 0) twrs_eta();
3407     if (twrs_etcorr_branch != 0) twrs_etcorr();
3408     if (twrs_hadEnergy_branch != 0) twrs_hadEnergy();
3409     if (twrs_hadEt_branch != 0) twrs_hadEt();
3410     if (twrs_hadEtcorr_branch != 0) twrs_hadEtcorr();
3411     if (twrs_hcalTime_branch != 0) twrs_hcalTime();
3412     if (twrs_outerEnergy_branch != 0) twrs_outerEnergy();
3413     if (twrs_outerEt_branch != 0) twrs_outerEt();
3414     if (twrs_outerEtcorr_branch != 0) twrs_outerEtcorr();
3415     if (twrs_pcorr_branch != 0) twrs_pcorr();
3416     if (twrs_phi_branch != 0) twrs_phi();
3417     if (els_ecalJuraIso_branch != 0) els_ecalJuraIso();
3418     if (els_ecalJuraTowerIso_branch != 0) els_ecalJuraTowerIso();
3419     if (els_hcalConeIso_branch != 0) els_hcalConeIso();
3420     if (els_chi2_branch != 0) els_chi2();
3421     if (els_d0_branch != 0) els_d0();
3422     if (els_d0Err_branch != 0) els_d0Err();
3423     if (els_d0corr_branch != 0) els_d0corr();
3424     if (els_dEtaIn_branch != 0) els_dEtaIn();
3425     if (els_dEtaOut_branch != 0) els_dEtaOut();
3426     if (els_dPhiIn_branch != 0) els_dPhiIn();
3427     if (els_dPhiInPhiOut_branch != 0) els_dPhiInPhiOut();
3428     if (els_dPhiOut_branch != 0) els_dPhiOut();
3429     if (els_e1x5_branch != 0) els_e1x5();
3430     if (els_e2x5Max_branch != 0) els_e2x5Max();
3431     if (els_e3x3_branch != 0) els_e3x3();
3432     if (els_e5x5_branch != 0) els_e5x5();
3433     if (els_eMax_branch != 0) els_eMax();
3434     if (els_eOverPIn_branch != 0) els_eOverPIn();
3435     if (els_eSC_branch != 0) els_eSC();
3436     if (els_eSCPresh_branch != 0) els_eSCPresh();
3437     if (els_eSCRaw_branch != 0) els_eSCRaw();
3438     if (els_eSeed_branch != 0) els_eSeed();
3439     if (els_eSeedOverPIn_branch != 0) els_eSeedOverPIn();
3440     if (els_eSeedOverPOut_branch != 0) els_eSeedOverPOut();
3441     if (els_ecalEnergy_branch != 0) els_ecalEnergy();
3442     if (els_ecalEnergyError_branch != 0) els_ecalEnergyError();
3443     if (els_ecalIso_branch != 0) els_ecalIso();
3444     if (els_ecalIso04_branch != 0) els_ecalIso04();
3445     if (els_egamma_looseId_branch != 0) els_egamma_looseId();
3446     if (els_egamma_robustHighEnergy_branch != 0) els_egamma_robustHighEnergy();
3447     if (els_egamma_robustLooseId_branch != 0) els_egamma_robustLooseId();
3448     if (els_egamma_robustTightId_branch != 0) els_egamma_robustTightId();
3449     if (els_egamma_tightId_branch != 0) els_egamma_tightId();
3450     if (els_electronMomentumError_branch != 0) els_electronMomentumError();
3451     if (els_etaErr_branch != 0) els_etaErr();
3452     if (els_etaSC_branch != 0) els_etaSC();
3453     if (els_fBrem_branch != 0) els_fBrem();
3454     if (els_hOverE_branch != 0) els_hOverE();
3455     if (els_hcalIso_branch != 0) els_hcalIso();
3456     if (els_hcalIso04_branch != 0) els_hcalIso04();
3457     if (els_layer1_charge_branch != 0) els_layer1_charge();
3458     if (els_ndof_branch != 0) els_ndof();
3459     if (els_phiErr_branch != 0) els_phiErr();
3460     if (els_phiSC_branch != 0) els_phiSC();
3461     if (els_ptErr_branch != 0) els_ptErr();
3462     if (els_sigmaEtaEta_branch != 0) els_sigmaEtaEta();
3463     if (els_sigmaIEtaIEta_branch != 0) els_sigmaIEtaIEta();
3464     if (els_sigmaIPhiIPhi_branch != 0) els_sigmaIPhiIPhi();
3465     if (els_sigmaPhiPhi_branch != 0) els_sigmaPhiPhi();
3466     if (els_tkIso_branch != 0) els_tkIso();
3467     if (els_tkIso04_branch != 0) els_tkIso04();
3468     if (els_trackMomentumError_branch != 0) els_trackMomentumError();
3469     if (els_trkdr_branch != 0) els_trkdr();
3470     if (els_trkshFrac_branch != 0) els_trkshFrac();
3471     if (els_z0_branch != 0) els_z0();
3472     if (els_z0Err_branch != 0) els_z0Err();
3473     if (els_z0corr_branch != 0) els_z0corr();
3474     if (mus_caloCompatibility_branch != 0) mus_caloCompatibility();
3475     if (mus_chi2_branch != 0) mus_chi2();
3476     if (mus_d0_branch != 0) mus_d0();
3477     if (mus_d0Err_branch != 0) mus_d0Err();
3478     if (mus_d0corr_branch != 0) mus_d0corr();
3479     if (mus_e_em_branch != 0) mus_e_em();
3480     if (mus_e_emS9_branch != 0) mus_e_emS9();
3481     if (mus_e_had_branch != 0) mus_e_had();
3482     if (mus_e_hadS9_branch != 0) mus_e_hadS9();
3483     if (mus_e_ho_branch != 0) mus_e_ho();
3484     if (mus_e_hoS9_branch != 0) mus_e_hoS9();
3485     if (mus_etaErr_branch != 0) mus_etaErr();
3486     if (mus_gfit_chi2_branch != 0) mus_gfit_chi2();
3487     if (mus_gfit_d0_branch != 0) mus_gfit_d0();
3488     if (mus_gfit_d0Err_branch != 0) mus_gfit_d0Err();
3489     if (mus_gfit_d0corr_branch != 0) mus_gfit_d0corr();
3490     if (mus_gfit_ndof_branch != 0) mus_gfit_ndof();
3491     if (mus_gfit_qoverp_branch != 0) mus_gfit_qoverp();
3492     if (mus_gfit_qoverpError_branch != 0) mus_gfit_qoverpError();
3493     if (mus_gfit_z0_branch != 0) mus_gfit_z0();
3494     if (mus_gfit_z0Err_branch != 0) mus_gfit_z0Err();
3495     if (mus_gfit_z0corr_branch != 0) mus_gfit_z0corr();
3496     if (mus_iso03_emEt_branch != 0) mus_iso03_emEt();
3497     if (mus_iso03_hadEt_branch != 0) mus_iso03_hadEt();
3498     if (mus_iso03_hoEt_branch != 0) mus_iso03_hoEt();
3499     if (mus_iso03_sumPt_branch != 0) mus_iso03_sumPt();
3500     if (mus_iso05_emEt_branch != 0) mus_iso05_emEt();
3501     if (mus_iso05_hadEt_branch != 0) mus_iso05_hadEt();
3502     if (mus_iso05_hoEt_branch != 0) mus_iso05_hoEt();
3503     if (mus_iso05_sumPt_branch != 0) mus_iso05_sumPt();
3504     if (mus_iso_ecalvetoDep_branch != 0) mus_iso_ecalvetoDep();
3505     if (mus_iso_hcalvetoDep_branch != 0) mus_iso_hcalvetoDep();
3506     if (mus_iso_hovetoDep_branch != 0) mus_iso_hovetoDep();
3507     if (mus_iso_trckvetoDep_branch != 0) mus_iso_trckvetoDep();
3508     if (mus_ndof_branch != 0) mus_ndof();
3509     if (mus_phiErr_branch != 0) mus_phiErr();
3510     if (mus_ptErr_branch != 0) mus_ptErr();
3511     if (mus_qoverp_branch != 0) mus_qoverp();
3512     if (mus_qoverpError_branch != 0) mus_qoverpError();
3513     if (mus_timeAtIpInOut_branch != 0) mus_timeAtIpInOut();
3514     if (mus_timeAtIpInOutErr_branch != 0) mus_timeAtIpInOutErr();
3515     if (mus_timeAtIpOutIn_branch != 0) mus_timeAtIpOutIn();
3516     if (mus_timeAtIpOutInErr_branch != 0) mus_timeAtIpOutInErr();
3517     if (mus_vertexphi_branch != 0) mus_vertexphi();
3518     if (mus_z0_branch != 0) mus_z0();
3519     if (mus_z0Err_branch != 0) mus_z0Err();
3520     if (mus_z0corr_branch != 0) mus_z0corr();
3521     if (scs_clustersSize_branch != 0) scs_clustersSize();
3522     if (scs_crystalsSize_branch != 0) scs_crystalsSize();
3523     if (scs_e1x3_branch != 0) scs_e1x3();
3524     if (scs_e1x5_branch != 0) scs_e1x5();
3525     if (scs_e2x2_branch != 0) scs_e2x2();
3526     if (scs_e2x5Max_branch != 0) scs_e2x5Max();
3527     if (scs_e3x1_branch != 0) scs_e3x1();
3528     if (scs_e3x2_branch != 0) scs_e3x2();
3529     if (scs_e3x3_branch != 0) scs_e3x3();
3530     if (scs_e4x4_branch != 0) scs_e4x4();
3531     if (scs_e5x5_branch != 0) scs_e5x5();
3532     if (scs_energy_branch != 0) scs_energy();
3533     if (scs_eta_branch != 0) scs_eta();
3534     if (scs_hoe_branch != 0) scs_hoe();
3535     if (scs_phi_branch != 0) scs_phi();
3536     if (scs_preshowerEnergy_branch != 0) scs_preshowerEnergy();
3537     if (scs_rawEnergy_branch != 0) scs_rawEnergy();
3538     if (scs_sigmaEtaEta_branch != 0) scs_sigmaEtaEta();
3539     if (scs_sigmaEtaPhi_branch != 0) scs_sigmaEtaPhi();
3540     if (scs_sigmaIEtaIEta_branch != 0) scs_sigmaIEtaIEta();
3541     if (scs_sigmaIEtaIPhi_branch != 0) scs_sigmaIEtaIPhi();
3542     if (scs_sigmaIPhiIPhi_branch != 0) scs_sigmaIPhiIPhi();
3543     if (scs_sigmaPhiPhi_branch != 0) scs_sigmaPhiPhi();
3544     if (trks_chi2_branch != 0) trks_chi2();
3545     if (trks_d0_branch != 0) trks_d0();
3546     if (trks_d0Err_branch != 0) trks_d0Err();
3547     if (trks_d0corr_branch != 0) trks_d0corr();
3548     if (trks_d0corrPhi_branch != 0) trks_d0corrPhi();
3549     if (trks_etaErr_branch != 0) trks_etaErr();
3550     if (trks_ndof_branch != 0) trks_ndof();
3551     if (trks_phiErr_branch != 0) trks_phiErr();
3552     if (trks_ptErr_branch != 0) trks_ptErr();
3553     if (trks_tkIso_branch != 0) trks_tkIso();
3554     if (trks_vertexphi_branch != 0) trks_vertexphi();
3555     if (trks_z0_branch != 0) trks_z0();
3556     if (trks_z0Err_branch != 0) trks_z0Err();
3557     if (trks_z0corr_branch != 0) trks_z0corr();
3558     if (trks_elsdr_branch != 0) trks_elsdr();
3559     if (trks_elsshFrac_branch != 0) trks_elsshFrac();
3560     if (vtxs_chi2_branch != 0) vtxs_chi2();
3561     if (vtxs_ndof_branch != 0) vtxs_ndof();
3562     if (vtxs_xError_branch != 0) vtxs_xError();
3563     if (vtxs_yError_branch != 0) vtxs_yError();
3564     if (vtxs_zError_branch != 0) vtxs_zError();
3565     if (trks_residualX_branch != 0) trks_residualX();
3566     if (trks_residualY_branch != 0) trks_residualY();
3567     if (vtxs_covMatrix_branch != 0) vtxs_covMatrix();
3568     if (evt_bsType_branch != 0) evt_bsType();
3569     if (els_category_branch != 0) els_category();
3570     if (els_charge_branch != 0) els_charge();
3571     if (els_class_branch != 0) els_class();
3572     if (els_fiduciality_branch != 0) els_fiduciality();
3573     if (els_layer1_det_branch != 0) els_layer1_det();
3574     if (els_layer1_layer_branch != 0) els_layer1_layer();
3575     if (els_layer1_sizerphi_branch != 0) els_layer1_sizerphi();
3576     if (els_layer1_sizerz_branch != 0) els_layer1_sizerz();
3577     if (els_lostHits_branch != 0) els_lostHits();
3578     if (els_lost_pixelhits_branch != 0) els_lost_pixelhits();
3579     if (els_nSeed_branch != 0) els_nSeed();
3580     if (els_sccharge_branch != 0) els_sccharge();
3581     if (els_trkidx_branch != 0) els_trkidx();
3582     if (els_type_branch != 0) els_type();
3583     if (els_validHits_branch != 0) els_validHits();
3584     if (els_valid_pixelhits_branch != 0) els_valid_pixelhits();
3585     if (mus_charge_branch != 0) mus_charge();
3586     if (mus_gfit_validHits_branch != 0) mus_gfit_validHits();
3587     if (mus_gfit_validSTAHits_branch != 0) mus_gfit_validSTAHits();
3588     if (mus_gfit_validSiHits_branch != 0) mus_gfit_validSiHits();
3589     if (mus_goodmask_branch != 0) mus_goodmask();
3590     if (mus_iso03_ntrk_branch != 0) mus_iso03_ntrk();
3591     if (mus_iso05_ntrk_branch != 0) mus_iso05_ntrk();
3592     if (mus_lostHits_branch != 0) mus_lostHits();
3593     if (mus_nmatches_branch != 0) mus_nmatches();
3594     if (mus_pid_TM2DCompatibilityLoose_branch != 0) mus_pid_TM2DCompatibilityLoose();
3595     if (mus_pid_TM2DCompatibilityTight_branch != 0) mus_pid_TM2DCompatibilityTight();
3596     if (mus_pid_TMLastStationLoose_branch != 0) mus_pid_TMLastStationLoose();
3597     if (mus_pid_TMLastStationTight_branch != 0) mus_pid_TMLastStationTight();
3598     if (mus_timeDirection_branch != 0) mus_timeDirection();
3599     if (mus_timeNumStationsUsed_branch != 0) mus_timeNumStationsUsed();
3600     if (mus_trk_charge_branch != 0) mus_trk_charge();
3601     if (mus_trkidx_branch != 0) mus_trkidx();
3602     if (mus_type_branch != 0) mus_type();
3603     if (mus_validHits_branch != 0) mus_validHits();
3604     if (scs_elsidx_branch != 0) scs_elsidx();
3605     if (trks_algo_branch != 0) trks_algo();
3606     if (trks_charge_branch != 0) trks_charge();
3607     if (trks_lostHits_branch != 0) trks_lostHits();
3608     if (trks_qualityMask_branch != 0) trks_qualityMask();
3609     if (trks_validHits_branch != 0) trks_validHits();
3610     if (trks_elsidx_branch != 0) trks_elsidx();
3611     if (trk_musidx_branch != 0) trk_musidx();
3612     if (vtxs_isFake_branch != 0) vtxs_isFake();
3613     if (vtxs_isValid_branch != 0) vtxs_isValid();
3614     if (vtxs_tracksSize_branch != 0) vtxs_tracksSize();
3615     if (trks_hit_substructure_branch != 0) trks_hit_substructure();
3616     if (trks_hit_type_branch != 0) trks_hit_type();
3617     if (evt_ntwrs_branch != 0) evt_ntwrs();
3618     if (evt_nels_branch != 0) evt_nels();
3619     if (evt_event_branch != 0) evt_event();
3620     if (evt_lumiBlock_branch != 0) evt_lumiBlock();
3621     if (evt_run_branch != 0) evt_run();
3622     if (evt_nscs_branch != 0) evt_nscs();
3623     if (evt_nvtxs_branch != 0) evt_nvtxs();
3624     if (twrs_numBadEcalCells_branch != 0) twrs_numBadEcalCells();
3625     if (twrs_numBadHcalCells_branch != 0) twrs_numBadHcalCells();
3626     if (twrs_numProblematicEcalCells_branch != 0) twrs_numProblematicEcalCells();
3627     if (twrs_numProblematicHcalCells_branch != 0) twrs_numProblematicHcalCells();
3628     if (twrs_numRecoveredEcalCells_branch != 0) twrs_numRecoveredEcalCells();
3629     if (twrs_numRecoveredHcalCells_branch != 0) twrs_numRecoveredHcalCells();
3630     if (evt_scale1fb_branch != 0) evt_scale1fb();
3631     if (evt_xsec_excl_branch != 0) evt_xsec_excl();
3632     if (evt_xsec_incl_branch != 0) evt_xsec_incl();
3633     if (evt_kfactor_branch != 0) evt_kfactor();
3634     if (evt_nEvts_branch != 0) evt_nEvts();
3635     if (evt_filt_eff_branch != 0) evt_filt_eff();
3636     }
3637    
3638     TString &evt_CMS2tag()
3639     {
3640     if (not evt_CMS2tag_isLoaded) {
3641     if (evt_CMS2tag_branch != 0) {
3642     evt_CMS2tag_branch->GetEntry(index);
3643     #ifdef PARANOIA
3644     #endif // #ifdef PARANOIA
3645     } else {
3646     printf("branch evt_CMS2tag_branch does not exist!\n");
3647     exit(1);
3648     }
3649     evt_CMS2tag_isLoaded = true;
3650     }
3651     return evt_CMS2tag_;
3652     }
3653     TString &evt_dataset()
3654     {
3655     if (not evt_dataset_isLoaded) {
3656     if (evt_dataset_branch != 0) {
3657     evt_dataset_branch->GetEntry(index);
3658     #ifdef PARANOIA
3659     #endif // #ifdef PARANOIA
3660     } else {
3661     printf("branch evt_dataset_branch does not exist!\n");
3662     exit(1);
3663     }
3664     evt_dataset_isLoaded = true;
3665     }
3666     return evt_dataset_;
3667     }
3668     vector<double> &els_inner_positionx()
3669     {
3670     if (not els_inner_positionx_isLoaded) {
3671     if (els_inner_positionx_branch != 0) {
3672     els_inner_positionx_branch->GetEntry(index);
3673     #ifdef PARANOIA
3674     #endif // #ifdef PARANOIA
3675     } else {
3676     printf("branch els_inner_positionx_branch does not exist!\n");
3677     exit(1);
3678     }
3679     els_inner_positionx_isLoaded = true;
3680     }
3681     return els_inner_positionx_;
3682     }
3683     vector<double> &els_inner_positiony()
3684     {
3685     if (not els_inner_positiony_isLoaded) {
3686     if (els_inner_positiony_branch != 0) {
3687     els_inner_positiony_branch->GetEntry(index);
3688     #ifdef PARANOIA
3689     #endif // #ifdef PARANOIA
3690     } else {
3691     printf("branch els_inner_positiony_branch does not exist!\n");
3692     exit(1);
3693     }
3694     els_inner_positiony_isLoaded = true;
3695     }
3696     return els_inner_positiony_;
3697     }
3698     vector<double> &els_inner_positionz()
3699     {
3700     if (not els_inner_positionz_isLoaded) {
3701     if (els_inner_positionz_branch != 0) {
3702     els_inner_positionz_branch->GetEntry(index);
3703     #ifdef PARANOIA
3704     #endif // #ifdef PARANOIA
3705     } else {
3706     printf("branch els_inner_positionz_branch does not exist!\n");
3707     exit(1);
3708     }
3709     els_inner_positionz_isLoaded = true;
3710     }
3711     return els_inner_positionz_;
3712     }
3713     float &evt_bs_Xwidth()
3714     {
3715     if (not evt_bs_Xwidth_isLoaded) {
3716     if (evt_bs_Xwidth_branch != 0) {
3717     evt_bs_Xwidth_branch->GetEntry(index);
3718     #ifdef PARANOIA
3719     if (not isfinite(evt_bs_Xwidth_)) {
3720     printf("branch evt_bs_Xwidth_branch contains a bad float: %f\n", evt_bs_Xwidth_);
3721     exit(1);
3722     }
3723     #endif // #ifdef PARANOIA
3724     } else {
3725     printf("branch evt_bs_Xwidth_branch does not exist!\n");
3726     exit(1);
3727     }
3728     evt_bs_Xwidth_isLoaded = true;
3729     }
3730     return evt_bs_Xwidth_;
3731     }
3732     float &evt_bs_XwidthErr()
3733     {
3734     if (not evt_bs_XwidthErr_isLoaded) {
3735     if (evt_bs_XwidthErr_branch != 0) {
3736     evt_bs_XwidthErr_branch->GetEntry(index);
3737     #ifdef PARANOIA
3738     if (not isfinite(evt_bs_XwidthErr_)) {
3739     printf("branch evt_bs_XwidthErr_branch contains a bad float: %f\n", evt_bs_XwidthErr_);
3740     exit(1);
3741     }
3742     #endif // #ifdef PARANOIA
3743     } else {
3744     printf("branch evt_bs_XwidthErr_branch does not exist!\n");
3745     exit(1);
3746     }
3747     evt_bs_XwidthErr_isLoaded = true;
3748     }
3749     return evt_bs_XwidthErr_;
3750     }
3751     float &evt_bs_Ywidth()
3752     {
3753     if (not evt_bs_Ywidth_isLoaded) {
3754     if (evt_bs_Ywidth_branch != 0) {
3755     evt_bs_Ywidth_branch->GetEntry(index);
3756     #ifdef PARANOIA
3757     if (not isfinite(evt_bs_Ywidth_)) {
3758     printf("branch evt_bs_Ywidth_branch contains a bad float: %f\n", evt_bs_Ywidth_);
3759     exit(1);
3760     }
3761     #endif // #ifdef PARANOIA
3762     } else {
3763     printf("branch evt_bs_Ywidth_branch does not exist!\n");
3764     exit(1);
3765     }
3766     evt_bs_Ywidth_isLoaded = true;
3767     }
3768     return evt_bs_Ywidth_;
3769     }
3770     float &evt_bs_YwidthErr()
3771     {
3772     if (not evt_bs_YwidthErr_isLoaded) {
3773     if (evt_bs_YwidthErr_branch != 0) {
3774     evt_bs_YwidthErr_branch->GetEntry(index);
3775     #ifdef PARANOIA
3776     if (not isfinite(evt_bs_YwidthErr_)) {
3777     printf("branch evt_bs_YwidthErr_branch contains a bad float: %f\n", evt_bs_YwidthErr_);
3778     exit(1);
3779     }
3780     #endif // #ifdef PARANOIA
3781     } else {
3782     printf("branch evt_bs_YwidthErr_branch does not exist!\n");
3783     exit(1);
3784     }
3785     evt_bs_YwidthErr_isLoaded = true;
3786     }
3787     return evt_bs_YwidthErr_;
3788     }
3789     float &evt_bs_dxdz()
3790     {
3791     if (not evt_bs_dxdz_isLoaded) {
3792     if (evt_bs_dxdz_branch != 0) {
3793     evt_bs_dxdz_branch->GetEntry(index);
3794     #ifdef PARANOIA
3795     if (not isfinite(evt_bs_dxdz_)) {
3796     printf("branch evt_bs_dxdz_branch contains a bad float: %f\n", evt_bs_dxdz_);
3797     exit(1);
3798     }
3799     #endif // #ifdef PARANOIA
3800     } else {
3801     printf("branch evt_bs_dxdz_branch does not exist!\n");
3802     exit(1);
3803     }
3804     evt_bs_dxdz_isLoaded = true;
3805     }
3806     return evt_bs_dxdz_;
3807     }
3808     float &evt_bs_dxdzErr()
3809     {
3810     if (not evt_bs_dxdzErr_isLoaded) {
3811     if (evt_bs_dxdzErr_branch != 0) {
3812     evt_bs_dxdzErr_branch->GetEntry(index);
3813     #ifdef PARANOIA
3814     if (not isfinite(evt_bs_dxdzErr_)) {
3815     printf("branch evt_bs_dxdzErr_branch contains a bad float: %f\n", evt_bs_dxdzErr_);
3816     exit(1);
3817     }
3818     #endif // #ifdef PARANOIA
3819     } else {
3820     printf("branch evt_bs_dxdzErr_branch does not exist!\n");
3821     exit(1);
3822     }
3823     evt_bs_dxdzErr_isLoaded = true;
3824     }
3825     return evt_bs_dxdzErr_;
3826     }
3827     float &evt_bs_dydz()
3828     {
3829     if (not evt_bs_dydz_isLoaded) {
3830     if (evt_bs_dydz_branch != 0) {
3831     evt_bs_dydz_branch->GetEntry(index);
3832     #ifdef PARANOIA
3833     if (not isfinite(evt_bs_dydz_)) {
3834     printf("branch evt_bs_dydz_branch contains a bad float: %f\n", evt_bs_dydz_);
3835     exit(1);
3836     }
3837     #endif // #ifdef PARANOIA
3838     } else {
3839     printf("branch evt_bs_dydz_branch does not exist!\n");
3840     exit(1);
3841     }
3842     evt_bs_dydz_isLoaded = true;
3843     }
3844     return evt_bs_dydz_;
3845     }
3846     float &evt_bs_dydzErr()
3847     {
3848     if (not evt_bs_dydzErr_isLoaded) {
3849     if (evt_bs_dydzErr_branch != 0) {
3850     evt_bs_dydzErr_branch->GetEntry(index);
3851     #ifdef PARANOIA
3852     if (not isfinite(evt_bs_dydzErr_)) {
3853     printf("branch evt_bs_dydzErr_branch contains a bad float: %f\n", evt_bs_dydzErr_);
3854     exit(1);
3855     }
3856     #endif // #ifdef PARANOIA
3857     } else {
3858     printf("branch evt_bs_dydzErr_branch does not exist!\n");
3859     exit(1);
3860     }
3861     evt_bs_dydzErr_isLoaded = true;
3862     }
3863     return evt_bs_dydzErr_;
3864     }
3865     float &evt_bs_sigmaZ()
3866     {
3867     if (not evt_bs_sigmaZ_isLoaded) {
3868     if (evt_bs_sigmaZ_branch != 0) {
3869     evt_bs_sigmaZ_branch->GetEntry(index);
3870     #ifdef PARANOIA
3871     if (not isfinite(evt_bs_sigmaZ_)) {
3872     printf("branch evt_bs_sigmaZ_branch contains a bad float: %f\n", evt_bs_sigmaZ_);
3873     exit(1);
3874     }
3875     #endif // #ifdef PARANOIA
3876     } else {
3877     printf("branch evt_bs_sigmaZ_branch does not exist!\n");
3878     exit(1);
3879     }
3880     evt_bs_sigmaZ_isLoaded = true;
3881     }
3882     return evt_bs_sigmaZ_;
3883     }
3884     float &evt_bs_sigmaZErr()
3885     {
3886     if (not evt_bs_sigmaZErr_isLoaded) {
3887     if (evt_bs_sigmaZErr_branch != 0) {
3888     evt_bs_sigmaZErr_branch->GetEntry(index);
3889     #ifdef PARANOIA
3890     if (not isfinite(evt_bs_sigmaZErr_)) {
3891     printf("branch evt_bs_sigmaZErr_branch contains a bad float: %f\n", evt_bs_sigmaZErr_);
3892     exit(1);
3893     }
3894     #endif // #ifdef PARANOIA
3895     } else {
3896     printf("branch evt_bs_sigmaZErr_branch does not exist!\n");
3897     exit(1);
3898     }
3899     evt_bs_sigmaZErr_isLoaded = true;
3900     }
3901     return evt_bs_sigmaZErr_;
3902     }
3903     float &evt_bs_xErr()
3904     {
3905     if (not evt_bs_xErr_isLoaded) {
3906     if (evt_bs_xErr_branch != 0) {
3907     evt_bs_xErr_branch->GetEntry(index);
3908     #ifdef PARANOIA
3909     if (not isfinite(evt_bs_xErr_)) {
3910     printf("branch evt_bs_xErr_branch contains a bad float: %f\n", evt_bs_xErr_);
3911     exit(1);
3912     }
3913     #endif // #ifdef PARANOIA
3914     } else {
3915     printf("branch evt_bs_xErr_branch does not exist!\n");
3916     exit(1);
3917     }
3918     evt_bs_xErr_isLoaded = true;
3919     }
3920     return evt_bs_xErr_;
3921     }
3922     float &evt_bs_yErr()
3923     {
3924     if (not evt_bs_yErr_isLoaded) {
3925     if (evt_bs_yErr_branch != 0) {
3926     evt_bs_yErr_branch->GetEntry(index);
3927     #ifdef PARANOIA
3928     if (not isfinite(evt_bs_yErr_)) {
3929     printf("branch evt_bs_yErr_branch contains a bad float: %f\n", evt_bs_yErr_);
3930     exit(1);
3931     }
3932     #endif // #ifdef PARANOIA
3933     } else {
3934     printf("branch evt_bs_yErr_branch does not exist!\n");
3935     exit(1);
3936     }
3937     evt_bs_yErr_isLoaded = true;
3938     }
3939     return evt_bs_yErr_;
3940     }
3941     float &evt_bs_zErr()
3942     {
3943     if (not evt_bs_zErr_isLoaded) {
3944     if (evt_bs_zErr_branch != 0) {
3945     evt_bs_zErr_branch->GetEntry(index);
3946     #ifdef PARANOIA
3947     if (not isfinite(evt_bs_zErr_)) {
3948     printf("branch evt_bs_zErr_branch contains a bad float: %f\n", evt_bs_zErr_);
3949     exit(1);
3950     }
3951     #endif // #ifdef PARANOIA
3952     } else {
3953     printf("branch evt_bs_zErr_branch does not exist!\n");
3954     exit(1);
3955     }
3956     evt_bs_zErr_isLoaded = true;
3957     }
3958     return evt_bs_zErr_;
3959     }
3960     float &evt_bField()
3961     {
3962     if (not evt_bField_isLoaded) {
3963     if (evt_bField_branch != 0) {
3964     evt_bField_branch->GetEntry(index);
3965     #ifdef PARANOIA
3966     if (not isfinite(evt_bField_)) {
3967     printf("branch evt_bField_branch contains a bad float: %f\n", evt_bField_);
3968     exit(1);
3969     }
3970     #endif // #ifdef PARANOIA
3971     } else {
3972     printf("branch evt_bField_branch does not exist!\n");
3973     exit(1);
3974     }
3975     evt_bField_isLoaded = true;
3976     }
3977     return evt_bField_;
3978     }
3979     ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > &evt_bsp4()
3980     {
3981     if (not evt_bsp4_isLoaded) {
3982     if (evt_bsp4_branch != 0) {
3983     evt_bsp4_branch->GetEntry(index);
3984     #ifdef PARANOIA
3985     int e;
3986     frexp(evt_bsp4_.pt(), &e);
3987     if (not isfinite(evt_bsp4_.pt()) || e > 30) {
3988     printf("branch evt_bsp4_branch contains a bad float: %f\n", evt_bsp4_.pt());
3989     exit(1);
3990     }
3991     #endif // #ifdef PARANOIA
3992     } else {
3993     printf("branch evt_bsp4_branch does not exist!\n");
3994     exit(1);
3995     }
3996     evt_bsp4_isLoaded = true;
3997     }
3998     return evt_bsp4_;
3999     }
4000     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &els_p4()
4001     {
4002     if (not els_p4_isLoaded) {
4003     if (els_p4_branch != 0) {
4004     els_p4_branch->GetEntry(index);
4005     #ifdef PARANOIA
4006     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = els_p4_.begin(); i != els_p4_.end(); ++i) {
4007     int e;
4008     frexp(i->pt(), &e);
4009     if (not isfinite(i->pt()) || e > 30) {
4010     printf("branch els_p4_branch contains a bad float: %f\n", i->pt());
4011     exit(1);
4012     }
4013     }
4014     #endif // #ifdef PARANOIA
4015     } else {
4016     printf("branch els_p4_branch does not exist!\n");
4017     exit(1);
4018     }
4019     els_p4_isLoaded = true;
4020     }
4021     return els_p4_;
4022     }
4023     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &els_p4In()
4024     {
4025     if (not els_p4In_isLoaded) {
4026     if (els_p4In_branch != 0) {
4027     els_p4In_branch->GetEntry(index);
4028     #ifdef PARANOIA
4029     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = els_p4In_.begin(); i != els_p4In_.end(); ++i) {
4030     int e;
4031     frexp(i->pt(), &e);
4032     if (not isfinite(i->pt()) || e > 30) {
4033     printf("branch els_p4In_branch contains a bad float: %f\n", i->pt());
4034     exit(1);
4035     }
4036     }
4037     #endif // #ifdef PARANOIA
4038     } else {
4039     printf("branch els_p4In_branch does not exist!\n");
4040     exit(1);
4041     }
4042     els_p4In_isLoaded = true;
4043     }
4044     return els_p4In_;
4045     }
4046     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &els_p4Out()
4047     {
4048     if (not els_p4Out_isLoaded) {
4049     if (els_p4Out_branch != 0) {
4050     els_p4Out_branch->GetEntry(index);
4051     #ifdef PARANOIA
4052     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = els_p4Out_.begin(); i != els_p4Out_.end(); ++i) {
4053     int e;
4054     frexp(i->pt(), &e);
4055     if (not isfinite(i->pt()) || e > 30) {
4056     printf("branch els_p4Out_branch contains a bad float: %f\n", i->pt());
4057     exit(1);
4058     }
4059     }
4060     #endif // #ifdef PARANOIA
4061     } else {
4062     printf("branch els_p4Out_branch does not exist!\n");
4063     exit(1);
4064     }
4065     els_p4Out_isLoaded = true;
4066     }
4067     return els_p4Out_;
4068     }
4069     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &els_trk_p4()
4070     {
4071     if (not els_trk_p4_isLoaded) {
4072     if (els_trk_p4_branch != 0) {
4073     els_trk_p4_branch->GetEntry(index);
4074     #ifdef PARANOIA
4075     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = els_trk_p4_.begin(); i != els_trk_p4_.end(); ++i) {
4076     int e;
4077     frexp(i->pt(), &e);
4078     if (not isfinite(i->pt()) || e > 30) {
4079     printf("branch els_trk_p4_branch contains a bad float: %f\n", i->pt());
4080     exit(1);
4081     }
4082     }
4083     #endif // #ifdef PARANOIA
4084     } else {
4085     printf("branch els_trk_p4_branch does not exist!\n");
4086     exit(1);
4087     }
4088     els_trk_p4_isLoaded = true;
4089     }
4090     return els_trk_p4_;
4091     }
4092     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &els_vertex_p4()
4093     {
4094     if (not els_vertex_p4_isLoaded) {
4095     if (els_vertex_p4_branch != 0) {
4096     els_vertex_p4_branch->GetEntry(index);
4097     #ifdef PARANOIA
4098     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = els_vertex_p4_.begin(); i != els_vertex_p4_.end(); ++i) {
4099     int e;
4100     frexp(i->pt(), &e);
4101     if (not isfinite(i->pt()) || e > 30) {
4102     printf("branch els_vertex_p4_branch contains a bad float: %f\n", i->pt());
4103     exit(1);
4104     }
4105     }
4106     #endif // #ifdef PARANOIA
4107     } else {
4108     printf("branch els_vertex_p4_branch does not exist!\n");
4109     exit(1);
4110     }
4111     els_vertex_p4_isLoaded = true;
4112     }
4113     return els_vertex_p4_;
4114     }
4115     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &mus_fitdefault_p4()
4116     {
4117     if (not mus_fitdefault_p4_isLoaded) {
4118     if (mus_fitdefault_p4_branch != 0) {
4119     mus_fitdefault_p4_branch->GetEntry(index);
4120     #ifdef PARANOIA
4121     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = mus_fitdefault_p4_.begin(); i != mus_fitdefault_p4_.end(); ++i) {
4122     int e;
4123     frexp(i->pt(), &e);
4124     if (not isfinite(i->pt()) || e > 30) {
4125     printf("branch mus_fitdefault_p4_branch contains a bad float: %f\n", i->pt());
4126     exit(1);
4127     }
4128     }
4129     #endif // #ifdef PARANOIA
4130     } else {
4131     printf("branch mus_fitdefault_p4_branch does not exist!\n");
4132     exit(1);
4133     }
4134     mus_fitdefault_p4_isLoaded = true;
4135     }
4136     return mus_fitdefault_p4_;
4137     }
4138     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &mus_fitfirsthit_p4()
4139     {
4140     if (not mus_fitfirsthit_p4_isLoaded) {
4141     if (mus_fitfirsthit_p4_branch != 0) {
4142     mus_fitfirsthit_p4_branch->GetEntry(index);
4143     #ifdef PARANOIA
4144     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = mus_fitfirsthit_p4_.begin(); i != mus_fitfirsthit_p4_.end(); ++i) {
4145     int e;
4146     frexp(i->pt(), &e);
4147     if (not isfinite(i->pt()) || e > 30) {
4148     printf("branch mus_fitfirsthit_p4_branch contains a bad float: %f\n", i->pt());
4149     exit(1);
4150     }
4151     }
4152     #endif // #ifdef PARANOIA
4153     } else {
4154     printf("branch mus_fitfirsthit_p4_branch does not exist!\n");
4155     exit(1);
4156     }
4157     mus_fitfirsthit_p4_isLoaded = true;
4158     }
4159     return mus_fitfirsthit_p4_;
4160     }
4161     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &mus_fitpicky_p4()
4162     {
4163     if (not mus_fitpicky_p4_isLoaded) {
4164     if (mus_fitpicky_p4_branch != 0) {
4165     mus_fitpicky_p4_branch->GetEntry(index);
4166     #ifdef PARANOIA
4167     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = mus_fitpicky_p4_.begin(); i != mus_fitpicky_p4_.end(); ++i) {
4168     int e;
4169     frexp(i->pt(), &e);
4170     if (not isfinite(i->pt()) || e > 30) {
4171     printf("branch mus_fitpicky_p4_branch contains a bad float: %f\n", i->pt());
4172     exit(1);
4173     }
4174     }
4175     #endif // #ifdef PARANOIA
4176     } else {
4177     printf("branch mus_fitpicky_p4_branch does not exist!\n");
4178     exit(1);
4179     }
4180     mus_fitpicky_p4_isLoaded = true;
4181     }
4182     return mus_fitpicky_p4_;
4183     }
4184     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &mus_fittev_p4()
4185     {
4186     if (not mus_fittev_p4_isLoaded) {
4187     if (mus_fittev_p4_branch != 0) {
4188     mus_fittev_p4_branch->GetEntry(index);
4189     #ifdef PARANOIA
4190     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = mus_fittev_p4_.begin(); i != mus_fittev_p4_.end(); ++i) {
4191     int e;
4192     frexp(i->pt(), &e);
4193     if (not isfinite(i->pt()) || e > 30) {
4194     printf("branch mus_fittev_p4_branch contains a bad float: %f\n", i->pt());
4195     exit(1);
4196     }
4197     }
4198     #endif // #ifdef PARANOIA
4199     } else {
4200     printf("branch mus_fittev_p4_branch does not exist!\n");
4201     exit(1);
4202     }
4203     mus_fittev_p4_isLoaded = true;
4204     }
4205     return mus_fittev_p4_;
4206     }
4207     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &mus_gfit_outerPos_p4()
4208     {
4209     if (not mus_gfit_outerPos_p4_isLoaded) {
4210     if (mus_gfit_outerPos_p4_branch != 0) {
4211     mus_gfit_outerPos_p4_branch->GetEntry(index);
4212     #ifdef PARANOIA
4213     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = mus_gfit_outerPos_p4_.begin(); i != mus_gfit_outerPos_p4_.end(); ++i) {
4214     int e;
4215     frexp(i->pt(), &e);
4216     if (not isfinite(i->pt()) || e > 30) {
4217     printf("branch mus_gfit_outerPos_p4_branch contains a bad float: %f\n", i->pt());
4218     exit(1);
4219     }
4220     }
4221     #endif // #ifdef PARANOIA
4222     } else {
4223     printf("branch mus_gfit_outerPos_p4_branch does not exist!\n");
4224     exit(1);
4225     }
4226     mus_gfit_outerPos_p4_isLoaded = true;
4227     }
4228     return mus_gfit_outerPos_p4_;
4229     }
4230     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &mus_gfit_p4()
4231     {
4232     if (not mus_gfit_p4_isLoaded) {
4233     if (mus_gfit_p4_branch != 0) {
4234     mus_gfit_p4_branch->GetEntry(index);
4235     #ifdef PARANOIA
4236     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = mus_gfit_p4_.begin(); i != mus_gfit_p4_.end(); ++i) {
4237     int e;
4238     frexp(i->pt(), &e);
4239     if (not isfinite(i->pt()) || e > 30) {
4240     printf("branch mus_gfit_p4_branch contains a bad float: %f\n", i->pt());
4241     exit(1);
4242     }
4243     }
4244     #endif // #ifdef PARANOIA
4245     } else {
4246     printf("branch mus_gfit_p4_branch does not exist!\n");
4247     exit(1);
4248     }
4249     mus_gfit_p4_isLoaded = true;
4250     }
4251     return mus_gfit_p4_;
4252     }
4253     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &mus_gfit_vertex_p4()
4254     {
4255     if (not mus_gfit_vertex_p4_isLoaded) {
4256     if (mus_gfit_vertex_p4_branch != 0) {
4257     mus_gfit_vertex_p4_branch->GetEntry(index);
4258     #ifdef PARANOIA
4259     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = mus_gfit_vertex_p4_.begin(); i != mus_gfit_vertex_p4_.end(); ++i) {
4260     int e;
4261     frexp(i->pt(), &e);
4262     if (not isfinite(i->pt()) || e > 30) {
4263     printf("branch mus_gfit_vertex_p4_branch contains a bad float: %f\n", i->pt());
4264     exit(1);
4265     }
4266     }
4267     #endif // #ifdef PARANOIA
4268     } else {
4269     printf("branch mus_gfit_vertex_p4_branch does not exist!\n");
4270     exit(1);
4271     }
4272     mus_gfit_vertex_p4_isLoaded = true;
4273     }
4274     return mus_gfit_vertex_p4_;
4275     }
4276     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &mus_p4()
4277     {
4278     if (not mus_p4_isLoaded) {
4279     if (mus_p4_branch != 0) {
4280     mus_p4_branch->GetEntry(index);
4281     #ifdef PARANOIA
4282     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = mus_p4_.begin(); i != mus_p4_.end(); ++i) {
4283     int e;
4284     frexp(i->pt(), &e);
4285     if (not isfinite(i->pt()) || e > 30) {
4286     printf("branch mus_p4_branch contains a bad float: %f\n", i->pt());
4287     exit(1);
4288     }
4289     }
4290     #endif // #ifdef PARANOIA
4291     } else {
4292     printf("branch mus_p4_branch does not exist!\n");
4293     exit(1);
4294     }
4295     mus_p4_isLoaded = true;
4296     }
4297     return mus_p4_;
4298     }
4299     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &mus_trk_p4()
4300     {
4301     if (not mus_trk_p4_isLoaded) {
4302     if (mus_trk_p4_branch != 0) {
4303     mus_trk_p4_branch->GetEntry(index);
4304     #ifdef PARANOIA
4305     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = mus_trk_p4_.begin(); i != mus_trk_p4_.end(); ++i) {
4306     int e;
4307     frexp(i->pt(), &e);
4308     if (not isfinite(i->pt()) || e > 30) {
4309     printf("branch mus_trk_p4_branch contains a bad float: %f\n", i->pt());
4310     exit(1);
4311     }
4312     }
4313     #endif // #ifdef PARANOIA
4314     } else {
4315     printf("branch mus_trk_p4_branch does not exist!\n");
4316     exit(1);
4317     }
4318     mus_trk_p4_isLoaded = true;
4319     }
4320     return mus_trk_p4_;
4321     }
4322     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &mus_vertex_p4()
4323     {
4324     if (not mus_vertex_p4_isLoaded) {
4325     if (mus_vertex_p4_branch != 0) {
4326     mus_vertex_p4_branch->GetEntry(index);
4327     #ifdef PARANOIA
4328     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = mus_vertex_p4_.begin(); i != mus_vertex_p4_.end(); ++i) {
4329     int e;
4330     frexp(i->pt(), &e);
4331     if (not isfinite(i->pt()) || e > 30) {
4332     printf("branch mus_vertex_p4_branch contains a bad float: %f\n", i->pt());
4333     exit(1);
4334     }
4335     }
4336     #endif // #ifdef PARANOIA
4337     } else {
4338     printf("branch mus_vertex_p4_branch does not exist!\n");
4339     exit(1);
4340     }
4341     mus_vertex_p4_isLoaded = true;
4342     }
4343     return mus_vertex_p4_;
4344     }
4345     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &scs_p4()
4346     {
4347     if (not scs_p4_isLoaded) {
4348     if (scs_p4_branch != 0) {
4349     scs_p4_branch->GetEntry(index);
4350     #ifdef PARANOIA
4351     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = scs_p4_.begin(); i != scs_p4_.end(); ++i) {
4352     int e;
4353     frexp(i->pt(), &e);
4354     if (not isfinite(i->pt()) || e > 30) {
4355     printf("branch scs_p4_branch contains a bad float: %f\n", i->pt());
4356     exit(1);
4357     }
4358     }
4359     #endif // #ifdef PARANOIA
4360     } else {
4361     printf("branch scs_p4_branch does not exist!\n");
4362     exit(1);
4363     }
4364     scs_p4_isLoaded = true;
4365     }
4366     return scs_p4_;
4367     }
4368     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &scs_pos_p4()
4369     {
4370     if (not scs_pos_p4_isLoaded) {
4371     if (scs_pos_p4_branch != 0) {
4372     scs_pos_p4_branch->GetEntry(index);
4373     #ifdef PARANOIA
4374     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = scs_pos_p4_.begin(); i != scs_pos_p4_.end(); ++i) {
4375     int e;
4376     frexp(i->pt(), &e);
4377     if (not isfinite(i->pt()) || e > 30) {
4378     printf("branch scs_pos_p4_branch contains a bad float: %f\n", i->pt());
4379     exit(1);
4380     }
4381     }
4382     #endif // #ifdef PARANOIA
4383     } else {
4384     printf("branch scs_pos_p4_branch does not exist!\n");
4385     exit(1);
4386     }
4387     scs_pos_p4_isLoaded = true;
4388     }
4389     return scs_pos_p4_;
4390     }
4391     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &scs_vtx_p4()
4392     {
4393     if (not scs_vtx_p4_isLoaded) {
4394     if (scs_vtx_p4_branch != 0) {
4395     scs_vtx_p4_branch->GetEntry(index);
4396     #ifdef PARANOIA
4397     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = scs_vtx_p4_.begin(); i != scs_vtx_p4_.end(); ++i) {
4398     int e;
4399     frexp(i->pt(), &e);
4400     if (not isfinite(i->pt()) || e > 30) {
4401     printf("branch scs_vtx_p4_branch contains a bad float: %f\n", i->pt());
4402     exit(1);
4403     }
4404     }
4405     #endif // #ifdef PARANOIA
4406     } else {
4407     printf("branch scs_vtx_p4_branch does not exist!\n");
4408     exit(1);
4409     }
4410     scs_vtx_p4_isLoaded = true;
4411     }
4412     return scs_vtx_p4_;
4413     }
4414     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &trks_outer_p4()
4415     {
4416     if (not trks_outer_p4_isLoaded) {
4417     if (trks_outer_p4_branch != 0) {
4418     trks_outer_p4_branch->GetEntry(index);
4419     #ifdef PARANOIA
4420     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = trks_outer_p4_.begin(); i != trks_outer_p4_.end(); ++i) {
4421     int e;
4422     frexp(i->pt(), &e);
4423     if (not isfinite(i->pt()) || e > 30) {
4424     printf("branch trks_outer_p4_branch contains a bad float: %f\n", i->pt());
4425     exit(1);
4426     }
4427     }
4428     #endif // #ifdef PARANOIA
4429     } else {
4430     printf("branch trks_outer_p4_branch does not exist!\n");
4431     exit(1);
4432     }
4433     trks_outer_p4_isLoaded = true;
4434     }
4435     return trks_outer_p4_;
4436     }
4437     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &trks_trk_p4()
4438     {
4439     if (not trks_trk_p4_isLoaded) {
4440     if (trks_trk_p4_branch != 0) {
4441     trks_trk_p4_branch->GetEntry(index);
4442     #ifdef PARANOIA
4443     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = trks_trk_p4_.begin(); i != trks_trk_p4_.end(); ++i) {
4444     int e;
4445     frexp(i->pt(), &e);
4446     if (not isfinite(i->pt()) || e > 30) {
4447     printf("branch trks_trk_p4_branch contains a bad float: %f\n", i->pt());
4448     exit(1);
4449     }
4450     }
4451     #endif // #ifdef PARANOIA
4452     } else {
4453     printf("branch trks_trk_p4_branch does not exist!\n");
4454     exit(1);
4455     }
4456     trks_trk_p4_isLoaded = true;
4457     }
4458     return trks_trk_p4_;
4459     }
4460     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &trks_vertex_p4()
4461     {
4462     if (not trks_vertex_p4_isLoaded) {
4463     if (trks_vertex_p4_branch != 0) {
4464     trks_vertex_p4_branch->GetEntry(index);
4465     #ifdef PARANOIA
4466     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = trks_vertex_p4_.begin(); i != trks_vertex_p4_.end(); ++i) {
4467     int e;
4468     frexp(i->pt(), &e);
4469     if (not isfinite(i->pt()) || e > 30) {
4470     printf("branch trks_vertex_p4_branch contains a bad float: %f\n", i->pt());
4471     exit(1);
4472     }
4473     }
4474     #endif // #ifdef PARANOIA
4475     } else {
4476     printf("branch trks_vertex_p4_branch does not exist!\n");
4477     exit(1);
4478     }
4479     trks_vertex_p4_isLoaded = true;
4480     }
4481     return trks_vertex_p4_;
4482     }
4483     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &vtxs_position()
4484     {
4485     if (not vtxs_position_isLoaded) {
4486     if (vtxs_position_branch != 0) {
4487     vtxs_position_branch->GetEntry(index);
4488     #ifdef PARANOIA
4489     for (vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > >::const_iterator i = vtxs_position_.begin(); i != vtxs_position_.end(); ++i) {
4490     int e;
4491     frexp(i->pt(), &e);
4492     if (not isfinite(i->pt()) || e > 30) {
4493     printf("branch vtxs_position_branch contains a bad float: %f\n", i->pt());
4494     exit(1);
4495     }
4496     }
4497     #endif // #ifdef PARANOIA
4498     } else {
4499     printf("branch vtxs_position_branch does not exist!\n");
4500     exit(1);
4501     }
4502     vtxs_position_isLoaded = true;
4503     }
4504     return vtxs_position_;
4505     }
4506     vector<float> &evt_covMatrix()
4507     {
4508     if (not evt_covMatrix_isLoaded) {
4509     if (evt_covMatrix_branch != 0) {
4510     evt_covMatrix_branch->GetEntry(index);
4511     #ifdef PARANOIA
4512     for (vector<float>::const_iterator i = evt_covMatrix_.begin(); i != evt_covMatrix_.end(); ++i) {
4513     if (not isfinite(*i)) {
4514     printf("branch evt_covMatrix_branch contains a bad float: %f\n", *i);
4515     exit(1);
4516     }
4517     }
4518     #endif // #ifdef PARANOIA
4519     } else {
4520     printf("branch evt_covMatrix_branch does not exist!\n");
4521     exit(1);
4522     }
4523     evt_covMatrix_isLoaded = true;
4524     }
4525     return evt_covMatrix_;
4526     }
4527     vector<float> &twrs_ecalTime()
4528     {
4529     if (not twrs_ecalTime_isLoaded) {
4530     if (twrs_ecalTime_branch != 0) {
4531     twrs_ecalTime_branch->GetEntry(index);
4532     #ifdef PARANOIA
4533     for (vector<float>::const_iterator i = twrs_ecalTime_.begin(); i != twrs_ecalTime_.end(); ++i) {
4534     if (not isfinite(*i)) {
4535     printf("branch twrs_ecalTime_branch contains a bad float: %f\n", *i);
4536     exit(1);
4537     }
4538     }
4539     #endif // #ifdef PARANOIA
4540     } else {
4541     printf("branch twrs_ecalTime_branch does not exist!\n");
4542     exit(1);
4543     }
4544     twrs_ecalTime_isLoaded = true;
4545     }
4546     return twrs_ecalTime_;
4547     }
4548     vector<float> &twrs_emEnergy()
4549     {
4550     if (not twrs_emEnergy_isLoaded) {
4551     if (twrs_emEnergy_branch != 0) {
4552     twrs_emEnergy_branch->GetEntry(index);
4553     #ifdef PARANOIA
4554     for (vector<float>::const_iterator i = twrs_emEnergy_.begin(); i != twrs_emEnergy_.end(); ++i) {
4555     if (not isfinite(*i)) {
4556     printf("branch twrs_emEnergy_branch contains a bad float: %f\n", *i);
4557     exit(1);
4558     }
4559     }
4560     #endif // #ifdef PARANOIA
4561     } else {
4562     printf("branch twrs_emEnergy_branch does not exist!\n");
4563     exit(1);
4564     }
4565     twrs_emEnergy_isLoaded = true;
4566     }
4567     return twrs_emEnergy_;
4568     }
4569     vector<float> &twrs_emEt()
4570     {
4571     if (not twrs_emEt_isLoaded) {
4572     if (twrs_emEt_branch != 0) {
4573     twrs_emEt_branch->GetEntry(index);
4574     #ifdef PARANOIA
4575     for (vector<float>::const_iterator i = twrs_emEt_.begin(); i != twrs_emEt_.end(); ++i) {
4576     if (not isfinite(*i)) {
4577     printf("branch twrs_emEt_branch contains a bad float: %f\n", *i);
4578     exit(1);
4579     }
4580     }
4581     #endif // #ifdef PARANOIA
4582     } else {
4583     printf("branch twrs_emEt_branch does not exist!\n");
4584     exit(1);
4585     }
4586     twrs_emEt_isLoaded = true;
4587     }
4588     return twrs_emEt_;
4589     }
4590     vector<float> &twrs_emEtcorr()
4591     {
4592     if (not twrs_emEtcorr_isLoaded) {
4593     if (twrs_emEtcorr_branch != 0) {
4594     twrs_emEtcorr_branch->GetEntry(index);
4595     #ifdef PARANOIA
4596     for (vector<float>::const_iterator i = twrs_emEtcorr_.begin(); i != twrs_emEtcorr_.end(); ++i) {
4597     if (not isfinite(*i)) {
4598     printf("branch twrs_emEtcorr_branch contains a bad float: %f\n", *i);
4599     exit(1);
4600     }
4601     }
4602     #endif // #ifdef PARANOIA
4603     } else {
4604     printf("branch twrs_emEtcorr_branch does not exist!\n");
4605     exit(1);
4606     }
4607     twrs_emEtcorr_isLoaded = true;
4608     }
4609     return twrs_emEtcorr_;
4610     }
4611     vector<float> &twrs_eta()
4612     {
4613     if (not twrs_eta_isLoaded) {
4614     if (twrs_eta_branch != 0) {
4615     twrs_eta_branch->GetEntry(index);
4616     #ifdef PARANOIA
4617     for (vector<float>::const_iterator i = twrs_eta_.begin(); i != twrs_eta_.end(); ++i) {
4618     if (not isfinite(*i)) {
4619     printf("branch twrs_eta_branch contains a bad float: %f\n", *i);
4620     exit(1);
4621     }
4622     }
4623     #endif // #ifdef PARANOIA
4624     } else {
4625     printf("branch twrs_eta_branch does not exist!\n");
4626     exit(1);
4627     }
4628     twrs_eta_isLoaded = true;
4629     }
4630     return twrs_eta_;
4631     }
4632     vector<float> &twrs_etcorr()
4633     {
4634     if (not twrs_etcorr_isLoaded) {
4635     if (twrs_etcorr_branch != 0) {
4636     twrs_etcorr_branch->GetEntry(index);
4637     #ifdef PARANOIA
4638     for (vector<float>::const_iterator i = twrs_etcorr_.begin(); i != twrs_etcorr_.end(); ++i) {
4639     if (not isfinite(*i)) {
4640     printf("branch twrs_etcorr_branch contains a bad float: %f\n", *i);
4641     exit(1);
4642     }
4643     }
4644     #endif // #ifdef PARANOIA
4645     } else {
4646     printf("branch twrs_etcorr_branch does not exist!\n");
4647     exit(1);
4648     }
4649     twrs_etcorr_isLoaded = true;
4650     }
4651     return twrs_etcorr_;
4652     }
4653     vector<float> &twrs_hadEnergy()
4654     {
4655     if (not twrs_hadEnergy_isLoaded) {
4656     if (twrs_hadEnergy_branch != 0) {
4657     twrs_hadEnergy_branch->GetEntry(index);
4658     #ifdef PARANOIA
4659     for (vector<float>::const_iterator i = twrs_hadEnergy_.begin(); i != twrs_hadEnergy_.end(); ++i) {
4660     if (not isfinite(*i)) {
4661     printf("branch twrs_hadEnergy_branch contains a bad float: %f\n", *i);
4662     exit(1);
4663     }
4664     }
4665     #endif // #ifdef PARANOIA
4666     } else {
4667     printf("branch twrs_hadEnergy_branch does not exist!\n");
4668     exit(1);
4669     }
4670     twrs_hadEnergy_isLoaded = true;
4671     }
4672     return twrs_hadEnergy_;
4673     }
4674     vector<float> &twrs_hadEt()
4675     {
4676     if (not twrs_hadEt_isLoaded) {
4677     if (twrs_hadEt_branch != 0) {
4678     twrs_hadEt_branch->GetEntry(index);
4679     #ifdef PARANOIA
4680     for (vector<float>::const_iterator i = twrs_hadEt_.begin(); i != twrs_hadEt_.end(); ++i) {
4681     if (not isfinite(*i)) {
4682     printf("branch twrs_hadEt_branch contains a bad float: %f\n", *i);
4683     exit(1);
4684     }
4685     }
4686     #endif // #ifdef PARANOIA
4687     } else {
4688     printf("branch twrs_hadEt_branch does not exist!\n");
4689     exit(1);
4690     }
4691     twrs_hadEt_isLoaded = true;
4692     }
4693     return twrs_hadEt_;
4694     }
4695     vector<float> &twrs_hadEtcorr()
4696     {
4697     if (not twrs_hadEtcorr_isLoaded) {
4698     if (twrs_hadEtcorr_branch != 0) {
4699     twrs_hadEtcorr_branch->GetEntry(index);
4700     #ifdef PARANOIA
4701     for (vector<float>::const_iterator i = twrs_hadEtcorr_.begin(); i != twrs_hadEtcorr_.end(); ++i) {
4702     if (not isfinite(*i)) {
4703     printf("branch twrs_hadEtcorr_branch contains a bad float: %f\n", *i);
4704     exit(1);
4705     }
4706     }
4707     #endif // #ifdef PARANOIA
4708     } else {
4709     printf("branch twrs_hadEtcorr_branch does not exist!\n");
4710     exit(1);
4711     }
4712     twrs_hadEtcorr_isLoaded = true;
4713     }
4714     return twrs_hadEtcorr_;
4715     }
4716     vector<float> &twrs_hcalTime()
4717     {
4718     if (not twrs_hcalTime_isLoaded) {
4719     if (twrs_hcalTime_branch != 0) {
4720     twrs_hcalTime_branch->GetEntry(index);
4721     #ifdef PARANOIA
4722     for (vector<float>::const_iterator i = twrs_hcalTime_.begin(); i != twrs_hcalTime_.end(); ++i) {
4723     if (not isfinite(*i)) {
4724     printf("branch twrs_hcalTime_branch contains a bad float: %f\n", *i);
4725     exit(1);
4726     }
4727     }
4728     #endif // #ifdef PARANOIA
4729     } else {
4730     printf("branch twrs_hcalTime_branch does not exist!\n");
4731     exit(1);
4732     }
4733     twrs_hcalTime_isLoaded = true;
4734     }
4735     return twrs_hcalTime_;
4736     }
4737     vector<float> &twrs_outerEnergy()
4738     {
4739     if (not twrs_outerEnergy_isLoaded) {
4740     if (twrs_outerEnergy_branch != 0) {
4741     twrs_outerEnergy_branch->GetEntry(index);
4742     #ifdef PARANOIA
4743     for (vector<float>::const_iterator i = twrs_outerEnergy_.begin(); i != twrs_outerEnergy_.end(); ++i) {
4744     if (not isfinite(*i)) {
4745     printf("branch twrs_outerEnergy_branch contains a bad float: %f\n", *i);
4746     exit(1);
4747     }
4748     }
4749     #endif // #ifdef PARANOIA
4750     } else {
4751     printf("branch twrs_outerEnergy_branch does not exist!\n");
4752     exit(1);
4753     }
4754     twrs_outerEnergy_isLoaded = true;
4755     }
4756     return twrs_outerEnergy_;
4757     }
4758     vector<float> &twrs_outerEt()
4759     {
4760     if (not twrs_outerEt_isLoaded) {
4761     if (twrs_outerEt_branch != 0) {
4762     twrs_outerEt_branch->GetEntry(index);
4763     #ifdef PARANOIA
4764     for (vector<float>::const_iterator i = twrs_outerEt_.begin(); i != twrs_outerEt_.end(); ++i) {
4765     if (not isfinite(*i)) {
4766     printf("branch twrs_outerEt_branch contains a bad float: %f\n", *i);
4767     exit(1);
4768     }
4769     }
4770     #endif // #ifdef PARANOIA
4771     } else {
4772     printf("branch twrs_outerEt_branch does not exist!\n");
4773     exit(1);
4774     }
4775     twrs_outerEt_isLoaded = true;
4776     }
4777     return twrs_outerEt_;
4778     }
4779     vector<float> &twrs_outerEtcorr()
4780     {
4781     if (not twrs_outerEtcorr_isLoaded) {
4782     if (twrs_outerEtcorr_branch != 0) {
4783     twrs_outerEtcorr_branch->GetEntry(index);
4784     #ifdef PARANOIA
4785     for (vector<float>::const_iterator i = twrs_outerEtcorr_.begin(); i != twrs_outerEtcorr_.end(); ++i) {
4786     if (not isfinite(*i)) {
4787     printf("branch twrs_outerEtcorr_branch contains a bad float: %f\n", *i);
4788     exit(1);
4789     }
4790     }
4791     #endif // #ifdef PARANOIA
4792     } else {
4793     printf("branch twrs_outerEtcorr_branch does not exist!\n");
4794     exit(1);
4795     }
4796     twrs_outerEtcorr_isLoaded = true;
4797     }
4798     return twrs_outerEtcorr_;
4799     }
4800     vector<float> &twrs_pcorr()
4801     {
4802     if (not twrs_pcorr_isLoaded) {
4803     if (twrs_pcorr_branch != 0) {
4804     twrs_pcorr_branch->GetEntry(index);
4805     #ifdef PARANOIA
4806     for (vector<float>::const_iterator i = twrs_pcorr_.begin(); i != twrs_pcorr_.end(); ++i) {
4807     if (not isfinite(*i)) {
4808     printf("branch twrs_pcorr_branch contains a bad float: %f\n", *i);
4809     exit(1);
4810     }
4811     }
4812     #endif // #ifdef PARANOIA
4813     } else {
4814     printf("branch twrs_pcorr_branch does not exist!\n");
4815     exit(1);
4816     }
4817     twrs_pcorr_isLoaded = true;
4818     }
4819     return twrs_pcorr_;
4820     }
4821     vector<float> &twrs_phi()
4822     {
4823     if (not twrs_phi_isLoaded) {
4824     if (twrs_phi_branch != 0) {
4825     twrs_phi_branch->GetEntry(index);
4826     #ifdef PARANOIA
4827     for (vector<float>::const_iterator i = twrs_phi_.begin(); i != twrs_phi_.end(); ++i) {
4828     if (not isfinite(*i)) {
4829     printf("branch twrs_phi_branch contains a bad float: %f\n", *i);
4830     exit(1);
4831     }
4832     }
4833     #endif // #ifdef PARANOIA
4834     } else {
4835     printf("branch twrs_phi_branch does not exist!\n");
4836     exit(1);
4837     }
4838     twrs_phi_isLoaded = true;
4839     }
4840     return twrs_phi_;
4841     }
4842     vector<float> &els_ecalJuraIso()
4843     {
4844     if (not els_ecalJuraIso_isLoaded) {
4845     if (els_ecalJuraIso_branch != 0) {
4846     els_ecalJuraIso_branch->GetEntry(index);
4847     #ifdef PARANOIA
4848     for (vector<float>::const_iterator i = els_ecalJuraIso_.begin(); i != els_ecalJuraIso_.end(); ++i) {
4849     if (not isfinite(*i)) {
4850     printf("branch els_ecalJuraIso_branch contains a bad float: %f\n", *i);
4851     exit(1);
4852     }
4853     }
4854     #endif // #ifdef PARANOIA
4855     } else {
4856     printf("branch els_ecalJuraIso_branch does not exist!\n");
4857     exit(1);
4858     }
4859     els_ecalJuraIso_isLoaded = true;
4860     }
4861     return els_ecalJuraIso_;
4862     }
4863     vector<float> &els_ecalJuraTowerIso()
4864     {
4865     if (not els_ecalJuraTowerIso_isLoaded) {
4866     if (els_ecalJuraTowerIso_branch != 0) {
4867     els_ecalJuraTowerIso_branch->GetEntry(index);
4868     #ifdef PARANOIA
4869     for (vector<float>::const_iterator i = els_ecalJuraTowerIso_.begin(); i != els_ecalJuraTowerIso_.end(); ++i) {
4870     if (not isfinite(*i)) {
4871     printf("branch els_ecalJuraTowerIso_branch contains a bad float: %f\n", *i);
4872     exit(1);
4873     }
4874     }
4875     #endif // #ifdef PARANOIA
4876     } else {
4877     printf("branch els_ecalJuraTowerIso_branch does not exist!\n");
4878     exit(1);
4879     }
4880     els_ecalJuraTowerIso_isLoaded = true;
4881     }
4882     return els_ecalJuraTowerIso_;
4883     }
4884     vector<float> &els_hcalConeIso()
4885     {
4886     if (not els_hcalConeIso_isLoaded) {
4887     if (els_hcalConeIso_branch != 0) {
4888     els_hcalConeIso_branch->GetEntry(index);
4889     #ifdef PARANOIA
4890     for (vector<float>::const_iterator i = els_hcalConeIso_.begin(); i != els_hcalConeIso_.end(); ++i) {
4891     if (not isfinite(*i)) {
4892     printf("branch els_hcalConeIso_branch contains a bad float: %f\n", *i);
4893     exit(1);
4894     }
4895     }
4896     #endif // #ifdef PARANOIA
4897     } else {
4898     printf("branch els_hcalConeIso_branch does not exist!\n");
4899     exit(1);
4900     }
4901     els_hcalConeIso_isLoaded = true;
4902     }
4903     return els_hcalConeIso_;
4904     }
4905     vector<float> &els_chi2()
4906     {
4907     if (not els_chi2_isLoaded) {
4908     if (els_chi2_branch != 0) {
4909     els_chi2_branch->GetEntry(index);
4910     #ifdef PARANOIA
4911     for (vector<float>::const_iterator i = els_chi2_.begin(); i != els_chi2_.end(); ++i) {
4912     if (not isfinite(*i)) {
4913     printf("branch els_chi2_branch contains a bad float: %f\n", *i);
4914     exit(1);
4915     }
4916     }
4917     #endif // #ifdef PARANOIA
4918     } else {
4919     printf("branch els_chi2_branch does not exist!\n");
4920     exit(1);
4921     }
4922     els_chi2_isLoaded = true;
4923     }
4924     return els_chi2_;
4925     }
4926     vector<float> &els_d0()
4927     {
4928     if (not els_d0_isLoaded) {
4929     if (els_d0_branch != 0) {
4930     els_d0_branch->GetEntry(index);
4931     #ifdef PARANOIA
4932     for (vector<float>::const_iterator i = els_d0_.begin(); i != els_d0_.end(); ++i) {
4933     if (not isfinite(*i)) {
4934     printf("branch els_d0_branch contains a bad float: %f\n", *i);
4935     exit(1);
4936     }
4937     }
4938     #endif // #ifdef PARANOIA
4939     } else {
4940     printf("branch els_d0_branch does not exist!\n");
4941     exit(1);
4942     }
4943     els_d0_isLoaded = true;
4944     }
4945     return els_d0_;
4946     }
4947     vector<float> &els_d0Err()
4948     {
4949     if (not els_d0Err_isLoaded) {
4950     if (els_d0Err_branch != 0) {
4951     els_d0Err_branch->GetEntry(index);
4952     #ifdef PARANOIA
4953     for (vector<float>::const_iterator i = els_d0Err_.begin(); i != els_d0Err_.end(); ++i) {
4954     if (not isfinite(*i)) {
4955     printf("branch els_d0Err_branch contains a bad float: %f\n", *i);
4956     exit(1);
4957     }
4958     }
4959     #endif // #ifdef PARANOIA
4960     } else {
4961     printf("branch els_d0Err_branch does not exist!\n");
4962     exit(1);
4963     }
4964     els_d0Err_isLoaded = true;
4965     }
4966     return els_d0Err_;
4967     }
4968     vector<float> &els_d0corr()
4969     {
4970     if (not els_d0corr_isLoaded) {
4971     if (els_d0corr_branch != 0) {
4972     els_d0corr_branch->GetEntry(index);
4973     #ifdef PARANOIA
4974     for (vector<float>::const_iterator i = els_d0corr_.begin(); i != els_d0corr_.end(); ++i) {
4975     if (not isfinite(*i)) {
4976     printf("branch els_d0corr_branch contains a bad float: %f\n", *i);
4977     exit(1);
4978     }
4979     }
4980     #endif // #ifdef PARANOIA
4981     } else {
4982     printf("branch els_d0corr_branch does not exist!\n");
4983     exit(1);
4984     }
4985     els_d0corr_isLoaded = true;
4986     }
4987     return els_d0corr_;
4988     }
4989     vector<float> &els_dEtaIn()
4990     {
4991     if (not els_dEtaIn_isLoaded) {
4992     if (els_dEtaIn_branch != 0) {
4993     els_dEtaIn_branch->GetEntry(index);
4994     #ifdef PARANOIA
4995     for (vector<float>::const_iterator i = els_dEtaIn_.begin(); i != els_dEtaIn_.end(); ++i) {
4996     if (not isfinite(*i)) {
4997     printf("branch els_dEtaIn_branch contains a bad float: %f\n", *i);
4998     exit(1);
4999     }
5000     }
5001     #endif // #ifdef PARANOIA
5002     } else {
5003     printf("branch els_dEtaIn_branch does not exist!\n");
5004     exit(1);
5005     }
5006     els_dEtaIn_isLoaded = true;
5007     }
5008     return els_dEtaIn_;
5009     }
5010     vector<float> &els_dEtaOut()
5011     {
5012     if (not els_dEtaOut_isLoaded) {
5013     if (els_dEtaOut_branch != 0) {
5014     els_dEtaOut_branch->GetEntry(index);
5015     #ifdef PARANOIA
5016     for (vector<float>::const_iterator i = els_dEtaOut_.begin(); i != els_dEtaOut_.end(); ++i) {
5017     if (not isfinite(*i)) {
5018     printf("branch els_dEtaOut_branch contains a bad float: %f\n", *i);
5019     exit(1);
5020     }
5021     }
5022     #endif // #ifdef PARANOIA
5023     } else {
5024     printf("branch els_dEtaOut_branch does not exist!\n");
5025     exit(1);
5026     }
5027     els_dEtaOut_isLoaded = true;
5028     }
5029     return els_dEtaOut_;
5030     }
5031     vector<float> &els_dPhiIn()
5032     {
5033     if (not els_dPhiIn_isLoaded) {
5034     if (els_dPhiIn_branch != 0) {
5035     els_dPhiIn_branch->GetEntry(index);
5036     #ifdef PARANOIA
5037     for (vector<float>::const_iterator i = els_dPhiIn_.begin(); i != els_dPhiIn_.end(); ++i) {
5038     if (not isfinite(*i)) {
5039     printf("branch els_dPhiIn_branch contains a bad float: %f\n", *i);
5040     exit(1);
5041     }
5042     }
5043     #endif // #ifdef PARANOIA
5044     } else {
5045     printf("branch els_dPhiIn_branch does not exist!\n");
5046     exit(1);
5047     }
5048     els_dPhiIn_isLoaded = true;
5049     }
5050     return els_dPhiIn_;
5051     }
5052     vector<float> &els_dPhiInPhiOut()
5053     {
5054     if (not els_dPhiInPhiOut_isLoaded) {
5055     if (els_dPhiInPhiOut_branch != 0) {
5056     els_dPhiInPhiOut_branch->GetEntry(index);
5057     #ifdef PARANOIA
5058     for (vector<float>::const_iterator i = els_dPhiInPhiOut_.begin(); i != els_dPhiInPhiOut_.end(); ++i) {
5059     if (not isfinite(*i)) {
5060     printf("branch els_dPhiInPhiOut_branch contains a bad float: %f\n", *i);
5061     exit(1);
5062     }
5063     }
5064     #endif // #ifdef PARANOIA
5065     } else {
5066     printf("branch els_dPhiInPhiOut_branch does not exist!\n");
5067     exit(1);
5068     }
5069     els_dPhiInPhiOut_isLoaded = true;
5070     }
5071     return els_dPhiInPhiOut_;
5072     }
5073     vector<float> &els_dPhiOut()
5074     {
5075     if (not els_dPhiOut_isLoaded) {
5076     if (els_dPhiOut_branch != 0) {
5077     els_dPhiOut_branch->GetEntry(index);
5078     #ifdef PARANOIA
5079     for (vector<float>::const_iterator i = els_dPhiOut_.begin(); i != els_dPhiOut_.end(); ++i) {
5080     if (not isfinite(*i)) {
5081     printf("branch els_dPhiOut_branch contains a bad float: %f\n", *i);
5082     exit(1);
5083     }
5084     }
5085     #endif // #ifdef PARANOIA
5086     } else {
5087     printf("branch els_dPhiOut_branch does not exist!\n");
5088     exit(1);
5089     }
5090     els_dPhiOut_isLoaded = true;
5091     }
5092     return els_dPhiOut_;
5093     }
5094     vector<float> &els_e1x5()
5095     {
5096     if (not els_e1x5_isLoaded) {
5097     if (els_e1x5_branch != 0) {
5098     els_e1x5_branch->GetEntry(index);
5099     #ifdef PARANOIA
5100     for (vector<float>::const_iterator i = els_e1x5_.begin(); i != els_e1x5_.end(); ++i) {
5101     if (not isfinite(*i)) {
5102     printf("branch els_e1x5_branch contains a bad float: %f\n", *i);
5103     exit(1);
5104     }
5105     }
5106     #endif // #ifdef PARANOIA
5107     } else {
5108     printf("branch els_e1x5_branch does not exist!\n");
5109     exit(1);
5110     }
5111     els_e1x5_isLoaded = true;
5112     }
5113     return els_e1x5_;
5114     }
5115     vector<float> &els_e2x5Max()
5116     {
5117     if (not els_e2x5Max_isLoaded) {
5118     if (els_e2x5Max_branch != 0) {
5119     els_e2x5Max_branch->GetEntry(index);
5120     #ifdef PARANOIA
5121     for (vector<float>::const_iterator i = els_e2x5Max_.begin(); i != els_e2x5Max_.end(); ++i) {
5122     if (not isfinite(*i)) {
5123     printf("branch els_e2x5Max_branch contains a bad float: %f\n", *i);
5124     exit(1);
5125     }
5126     }
5127     #endif // #ifdef PARANOIA
5128     } else {
5129     printf("branch els_e2x5Max_branch does not exist!\n");
5130     exit(1);
5131     }
5132     els_e2x5Max_isLoaded = true;
5133     }
5134     return els_e2x5Max_;
5135     }
5136     vector<float> &els_e3x3()
5137     {
5138     if (not els_e3x3_isLoaded) {
5139     if (els_e3x3_branch != 0) {
5140     els_e3x3_branch->GetEntry(index);
5141     #ifdef PARANOIA
5142     for (vector<float>::const_iterator i = els_e3x3_.begin(); i != els_e3x3_.end(); ++i) {
5143     if (not isfinite(*i)) {
5144     printf("branch els_e3x3_branch contains a bad float: %f\n", *i);
5145     exit(1);
5146     }
5147     }
5148     #endif // #ifdef PARANOIA
5149     } else {
5150     printf("branch els_e3x3_branch does not exist!\n");
5151     exit(1);
5152     }
5153     els_e3x3_isLoaded = true;
5154     }
5155     return els_e3x3_;
5156     }
5157     vector<float> &els_e5x5()
5158     {
5159     if (not els_e5x5_isLoaded) {
5160     if (els_e5x5_branch != 0) {
5161     els_e5x5_branch->GetEntry(index);
5162     #ifdef PARANOIA
5163     for (vector<float>::const_iterator i = els_e5x5_.begin(); i != els_e5x5_.end(); ++i) {
5164     if (not isfinite(*i)) {
5165     printf("branch els_e5x5_branch contains a bad float: %f\n", *i);
5166     exit(1);
5167     }
5168     }
5169     #endif // #ifdef PARANOIA
5170     } else {
5171     printf("branch els_e5x5_branch does not exist!\n");
5172     exit(1);
5173     }
5174     els_e5x5_isLoaded = true;
5175     }
5176     return els_e5x5_;
5177     }
5178     vector<float> &els_eMax()
5179     {
5180     if (not els_eMax_isLoaded) {
5181     if (els_eMax_branch != 0) {
5182     els_eMax_branch->GetEntry(index);
5183     #ifdef PARANOIA
5184     for (vector<float>::const_iterator i = els_eMax_.begin(); i != els_eMax_.end(); ++i) {
5185     if (not isfinite(*i)) {
5186     printf("branch els_eMax_branch contains a bad float: %f\n", *i);
5187     exit(1);
5188     }
5189     }
5190     #endif // #ifdef PARANOIA
5191     } else {
5192     printf("branch els_eMax_branch does not exist!\n");
5193     exit(1);
5194     }
5195     els_eMax_isLoaded = true;
5196     }
5197     return els_eMax_;
5198     }
5199     vector<float> &els_eOverPIn()
5200     {
5201     if (not els_eOverPIn_isLoaded) {
5202     if (els_eOverPIn_branch != 0) {
5203     els_eOverPIn_branch->GetEntry(index);
5204     #ifdef PARANOIA
5205     for (vector<float>::const_iterator i = els_eOverPIn_.begin(); i != els_eOverPIn_.end(); ++i) {
5206     if (not isfinite(*i)) {
5207     printf("branch els_eOverPIn_branch contains a bad float: %f\n", *i);
5208     exit(1);
5209     }
5210     }
5211     #endif // #ifdef PARANOIA
5212     } else {
5213     printf("branch els_eOverPIn_branch does not exist!\n");
5214     exit(1);
5215     }
5216     els_eOverPIn_isLoaded = true;
5217     }
5218     return els_eOverPIn_;
5219     }
5220     vector<float> &els_eSC()
5221     {
5222     if (not els_eSC_isLoaded) {
5223     if (els_eSC_branch != 0) {
5224     els_eSC_branch->GetEntry(index);
5225     #ifdef PARANOIA
5226     for (vector<float>::const_iterator i = els_eSC_.begin(); i != els_eSC_.end(); ++i) {
5227     if (not isfinite(*i)) {
5228     printf("branch els_eSC_branch contains a bad float: %f\n", *i);
5229     exit(1);
5230     }
5231     }
5232     #endif // #ifdef PARANOIA
5233     } else {
5234     printf("branch els_eSC_branch does not exist!\n");
5235     exit(1);
5236     }
5237     els_eSC_isLoaded = true;
5238     }
5239     return els_eSC_;
5240     }
5241     vector<float> &els_eSCPresh()
5242     {
5243     if (not els_eSCPresh_isLoaded) {
5244     if (els_eSCPresh_branch != 0) {
5245     els_eSCPresh_branch->GetEntry(index);
5246     #ifdef PARANOIA
5247     for (vector<float>::const_iterator i = els_eSCPresh_.begin(); i != els_eSCPresh_.end(); ++i) {
5248     if (not isfinite(*i)) {
5249     printf("branch els_eSCPresh_branch contains a bad float: %f\n", *i);
5250     exit(1);
5251     }
5252     }
5253     #endif // #ifdef PARANOIA
5254     } else {
5255     printf("branch els_eSCPresh_branch does not exist!\n");
5256     exit(1);
5257     }
5258     els_eSCPresh_isLoaded = true;
5259     }
5260     return els_eSCPresh_;
5261     }
5262     vector<float> &els_eSCRaw()
5263     {
5264     if (not els_eSCRaw_isLoaded) {
5265     if (els_eSCRaw_branch != 0) {
5266     els_eSCRaw_branch->GetEntry(index);
5267     #ifdef PARANOIA
5268     for (vector<float>::const_iterator i = els_eSCRaw_.begin(); i != els_eSCRaw_.end(); ++i) {
5269     if (not isfinite(*i)) {
5270     printf("branch els_eSCRaw_branch contains a bad float: %f\n", *i);
5271     exit(1);
5272     }
5273     }
5274     #endif // #ifdef PARANOIA
5275     } else {
5276     printf("branch els_eSCRaw_branch does not exist!\n");
5277     exit(1);
5278     }
5279     els_eSCRaw_isLoaded = true;
5280     }
5281     return els_eSCRaw_;
5282     }
5283     vector<float> &els_eSeed()
5284     {
5285     if (not els_eSeed_isLoaded) {
5286     if (els_eSeed_branch != 0) {
5287     els_eSeed_branch->GetEntry(index);
5288     #ifdef PARANOIA
5289     for (vector<float>::const_iterator i = els_eSeed_.begin(); i != els_eSeed_.end(); ++i) {
5290     if (not isfinite(*i)) {
5291     printf("branch els_eSeed_branch contains a bad float: %f\n", *i);
5292     exit(1);
5293     }
5294     }
5295     #endif // #ifdef PARANOIA
5296     } else {
5297     printf("branch els_eSeed_branch does not exist!\n");
5298     exit(1);
5299     }
5300     els_eSeed_isLoaded = true;
5301     }
5302     return els_eSeed_;
5303     }
5304     vector<float> &els_eSeedOverPIn()
5305     {
5306     if (not els_eSeedOverPIn_isLoaded) {
5307     if (els_eSeedOverPIn_branch != 0) {
5308     els_eSeedOverPIn_branch->GetEntry(index);
5309     #ifdef PARANOIA
5310     for (vector<float>::const_iterator i = els_eSeedOverPIn_.begin(); i != els_eSeedOverPIn_.end(); ++i) {
5311     if (not isfinite(*i)) {
5312     printf("branch els_eSeedOverPIn_branch contains a bad float: %f\n", *i);
5313     exit(1);
5314     }
5315     }
5316     #endif // #ifdef PARANOIA
5317     } else {
5318     printf("branch els_eSeedOverPIn_branch does not exist!\n");
5319     exit(1);
5320     }
5321     els_eSeedOverPIn_isLoaded = true;
5322     }
5323     return els_eSeedOverPIn_;
5324     }
5325     vector<float> &els_eSeedOverPOut()
5326     {
5327     if (not els_eSeedOverPOut_isLoaded) {
5328     if (els_eSeedOverPOut_branch != 0) {
5329     els_eSeedOverPOut_branch->GetEntry(index);
5330     #ifdef PARANOIA
5331     for (vector<float>::const_iterator i = els_eSeedOverPOut_.begin(); i != els_eSeedOverPOut_.end(); ++i) {
5332     if (not isfinite(*i)) {
5333     printf("branch els_eSeedOverPOut_branch contains a bad float: %f\n", *i);
5334     exit(1);
5335     }
5336     }
5337     #endif // #ifdef PARANOIA
5338     } else {
5339     printf("branch els_eSeedOverPOut_branch does not exist!\n");
5340     exit(1);
5341     }
5342     els_eSeedOverPOut_isLoaded = true;
5343     }
5344     return els_eSeedOverPOut_;
5345     }
5346     vector<float> &els_ecalEnergy()
5347     {
5348     if (not els_ecalEnergy_isLoaded) {
5349     if (els_ecalEnergy_branch != 0) {
5350     els_ecalEnergy_branch->GetEntry(index);
5351     #ifdef PARANOIA
5352     for (vector<float>::const_iterator i = els_ecalEnergy_.begin(); i != els_ecalEnergy_.end(); ++i) {
5353     if (not isfinite(*i)) {
5354     printf("branch els_ecalEnergy_branch contains a bad float: %f\n", *i);
5355     exit(1);
5356     }
5357     }
5358     #endif // #ifdef PARANOIA
5359     } else {
5360     printf("branch els_ecalEnergy_branch does not exist!\n");
5361     exit(1);
5362     }
5363     els_ecalEnergy_isLoaded = true;
5364     }
5365     return els_ecalEnergy_;
5366     }
5367     vector<float> &els_ecalEnergyError()
5368     {
5369     if (not els_ecalEnergyError_isLoaded) {
5370     if (els_ecalEnergyError_branch != 0) {
5371     els_ecalEnergyError_branch->GetEntry(index);
5372     #ifdef PARANOIA
5373     for (vector<float>::const_iterator i = els_ecalEnergyError_.begin(); i != els_ecalEnergyError_.end(); ++i) {
5374     if (not isfinite(*i)) {
5375     printf("branch els_ecalEnergyError_branch contains a bad float: %f\n", *i);
5376     exit(1);
5377     }
5378     }
5379     #endif // #ifdef PARANOIA
5380     } else {
5381     printf("branch els_ecalEnergyError_branch does not exist!\n");
5382     exit(1);
5383     }
5384     els_ecalEnergyError_isLoaded = true;
5385     }
5386     return els_ecalEnergyError_;
5387     }
5388     vector<float> &els_ecalIso()
5389     {
5390     if (not els_ecalIso_isLoaded) {
5391     if (els_ecalIso_branch != 0) {
5392     els_ecalIso_branch->GetEntry(index);
5393     #ifdef PARANOIA
5394     for (vector<float>::const_iterator i = els_ecalIso_.begin(); i != els_ecalIso_.end(); ++i) {
5395     if (not isfinite(*i)) {
5396     printf("branch els_ecalIso_branch contains a bad float: %f\n", *i);
5397     exit(1);
5398     }
5399     }
5400     #endif // #ifdef PARANOIA
5401     } else {
5402     printf("branch els_ecalIso_branch does not exist!\n");
5403     exit(1);
5404     }
5405     els_ecalIso_isLoaded = true;
5406     }
5407     return els_ecalIso_;
5408     }
5409     vector<float> &els_ecalIso04()
5410     {
5411     if (not els_ecalIso04_isLoaded) {
5412     if (els_ecalIso04_branch != 0) {
5413     els_ecalIso04_branch->GetEntry(index);
5414     #ifdef PARANOIA
5415     for (vector<float>::const_iterator i = els_ecalIso04_.begin(); i != els_ecalIso04_.end(); ++i) {
5416     if (not isfinite(*i)) {
5417     printf("branch els_ecalIso04_branch contains a bad float: %f\n", *i);
5418     exit(1);
5419     }
5420     }
5421     #endif // #ifdef PARANOIA
5422     } else {
5423     printf("branch els_ecalIso04_branch does not exist!\n");
5424     exit(1);
5425     }
5426     els_ecalIso04_isLoaded = true;
5427     }
5428     return els_ecalIso04_;
5429     }
5430     vector<float> &els_egamma_looseId()
5431     {
5432     if (not els_egamma_looseId_isLoaded) {
5433     if (els_egamma_looseId_branch != 0) {
5434     els_egamma_looseId_branch->GetEntry(index);
5435     #ifdef PARANOIA
5436     for (vector<float>::const_iterator i = els_egamma_looseId_.begin(); i != els_egamma_looseId_.end(); ++i) {
5437     if (not isfinite(*i)) {
5438     printf("branch els_egamma_looseId_branch contains a bad float: %f\n", *i);
5439     exit(1);
5440     }
5441     }
5442     #endif // #ifdef PARANOIA
5443     } else {
5444     printf("branch els_egamma_looseId_branch does not exist!\n");
5445     exit(1);
5446     }
5447     els_egamma_looseId_isLoaded = true;
5448     }
5449     return els_egamma_looseId_;
5450     }
5451     vector<float> &els_egamma_robustHighEnergy()
5452     {
5453     if (not els_egamma_robustHighEnergy_isLoaded) {
5454     if (els_egamma_robustHighEnergy_branch != 0) {
5455     els_egamma_robustHighEnergy_branch->GetEntry(index);
5456     #ifdef PARANOIA
5457     for (vector<float>::const_iterator i = els_egamma_robustHighEnergy_.begin(); i != els_egamma_robustHighEnergy_.end(); ++i) {
5458     if (not isfinite(*i)) {
5459     printf("branch els_egamma_robustHighEnergy_branch contains a bad float: %f\n", *i);
5460     exit(1);
5461     }
5462     }
5463     #endif // #ifdef PARANOIA
5464     } else {
5465     printf("branch els_egamma_robustHighEnergy_branch does not exist!\n");
5466     exit(1);
5467     }
5468     els_egamma_robustHighEnergy_isLoaded = true;
5469     }
5470     return els_egamma_robustHighEnergy_;
5471     }
5472     vector<float> &els_egamma_robustLooseId()
5473     {
5474     if (not els_egamma_robustLooseId_isLoaded) {
5475     if (els_egamma_robustLooseId_branch != 0) {
5476     els_egamma_robustLooseId_branch->GetEntry(index);
5477     #ifdef PARANOIA
5478     for (vector<float>::const_iterator i = els_egamma_robustLooseId_.begin(); i != els_egamma_robustLooseId_.end(); ++i) {
5479     if (not isfinite(*i)) {
5480     printf("branch els_egamma_robustLooseId_branch contains a bad float: %f\n", *i);
5481     exit(1);
5482     }
5483     }
5484     #endif // #ifdef PARANOIA
5485     } else {
5486     printf("branch els_egamma_robustLooseId_branch does not exist!\n");
5487     exit(1);
5488     }
5489     els_egamma_robustLooseId_isLoaded = true;
5490     }
5491     return els_egamma_robustLooseId_;
5492     }
5493     vector<float> &els_egamma_robustTightId()
5494     {
5495     if (not els_egamma_robustTightId_isLoaded) {
5496     if (els_egamma_robustTightId_branch != 0) {
5497     els_egamma_robustTightId_branch->GetEntry(index);
5498     #ifdef PARANOIA
5499     for (vector<float>::const_iterator i = els_egamma_robustTightId_.begin(); i != els_egamma_robustTightId_.end(); ++i) {
5500     if (not isfinite(*i)) {
5501     printf("branch els_egamma_robustTightId_branch contains a bad float: %f\n", *i);
5502     exit(1);
5503     }
5504     }
5505     #endif // #ifdef PARANOIA
5506     } else {
5507     printf("branch els_egamma_robustTightId_branch does not exist!\n");
5508     exit(1);
5509     }
5510     els_egamma_robustTightId_isLoaded = true;
5511     }
5512     return els_egamma_robustTightId_;
5513     }
5514     vector<float> &els_egamma_tightId()
5515     {
5516     if (not els_egamma_tightId_isLoaded) {
5517     if (els_egamma_tightId_branch != 0) {
5518     els_egamma_tightId_branch->GetEntry(index);
5519     #ifdef PARANOIA
5520     for (vector<float>::const_iterator i = els_egamma_tightId_.begin(); i != els_egamma_tightId_.end(); ++i) {
5521     if (not isfinite(*i)) {
5522     printf("branch els_egamma_tightId_branch contains a bad float: %f\n", *i);
5523     exit(1);
5524     }
5525     }
5526     #endif // #ifdef PARANOIA
5527     } else {
5528     printf("branch els_egamma_tightId_branch does not exist!\n");
5529     exit(1);
5530     }
5531     els_egamma_tightId_isLoaded = true;
5532     }
5533     return els_egamma_tightId_;
5534     }
5535     vector<float> &els_electronMomentumError()
5536     {
5537     if (not els_electronMomentumError_isLoaded) {
5538     if (els_electronMomentumError_branch != 0) {
5539     els_electronMomentumError_branch->GetEntry(index);
5540     #ifdef PARANOIA
5541     for (vector<float>::const_iterator i = els_electronMomentumError_.begin(); i != els_electronMomentumError_.end(); ++i) {
5542     if (not isfinite(*i)) {
5543     printf("branch els_electronMomentumError_branch contains a bad float: %f\n", *i);
5544     exit(1);
5545     }
5546     }
5547     #endif // #ifdef PARANOIA
5548     } else {
5549     printf("branch els_electronMomentumError_branch does not exist!\n");
5550     exit(1);
5551     }
5552     els_electronMomentumError_isLoaded = true;
5553     }
5554     return els_electronMomentumError_;
5555     }
5556     vector<float> &els_etaErr()
5557     {
5558     if (not els_etaErr_isLoaded) {
5559     if (els_etaErr_branch != 0) {
5560     els_etaErr_branch->GetEntry(index);
5561     #ifdef PARANOIA
5562     for (vector<float>::const_iterator i = els_etaErr_.begin(); i != els_etaErr_.end(); ++i) {
5563     if (not isfinite(*i)) {
5564     printf("branch els_etaErr_branch contains a bad float: %f\n", *i);
5565     exit(1);
5566     }
5567     }
5568     #endif // #ifdef PARANOIA
5569     } else {
5570     printf("branch els_etaErr_branch does not exist!\n");
5571     exit(1);
5572     }
5573     els_etaErr_isLoaded = true;
5574     }
5575     return els_etaErr_;
5576     }
5577     vector<float> &els_etaSC()
5578     {
5579     if (not els_etaSC_isLoaded) {
5580     if (els_etaSC_branch != 0) {
5581     els_etaSC_branch->GetEntry(index);
5582     #ifdef PARANOIA
5583     for (vector<float>::const_iterator i = els_etaSC_.begin(); i != els_etaSC_.end(); ++i) {
5584     if (not isfinite(*i)) {
5585     printf("branch els_etaSC_branch contains a bad float: %f\n", *i);
5586     exit(1);
5587     }
5588     }
5589     #endif // #ifdef PARANOIA
5590     } else {
5591     printf("branch els_etaSC_branch does not exist!\n");
5592     exit(1);
5593     }
5594     els_etaSC_isLoaded = true;
5595     }
5596     return els_etaSC_;
5597     }
5598     vector<float> &els_fBrem()
5599     {
5600     if (not els_fBrem_isLoaded) {
5601     if (els_fBrem_branch != 0) {
5602     els_fBrem_branch->GetEntry(index);
5603     #ifdef PARANOIA
5604     for (vector<float>::const_iterator i = els_fBrem_.begin(); i != els_fBrem_.end(); ++i) {
5605     if (not isfinite(*i)) {
5606     printf("branch els_fBrem_branch contains a bad float: %f\n", *i);
5607     exit(1);
5608     }
5609     }
5610     #endif // #ifdef PARANOIA
5611     } else {
5612     printf("branch els_fBrem_branch does not exist!\n");
5613     exit(1);
5614     }
5615     els_fBrem_isLoaded = true;
5616     }
5617     return els_fBrem_;
5618     }
5619     vector<float> &els_hOverE()
5620     {
5621     if (not els_hOverE_isLoaded) {
5622     if (els_hOverE_branch != 0) {
5623     els_hOverE_branch->GetEntry(index);
5624     #ifdef PARANOIA
5625     for (vector<float>::const_iterator i = els_hOverE_.begin(); i != els_hOverE_.end(); ++i) {
5626     if (not isfinite(*i)) {
5627     printf("branch els_hOverE_branch contains a bad float: %f\n", *i);
5628     exit(1);
5629     }
5630     }
5631     #endif // #ifdef PARANOIA
5632     } else {
5633     printf("branch els_hOverE_branch does not exist!\n");
5634     exit(1);
5635     }
5636     els_hOverE_isLoaded = true;
5637     }
5638     return els_hOverE_;
5639     }
5640     vector<float> &els_hcalIso()
5641     {
5642     if (not els_hcalIso_isLoaded) {
5643     if (els_hcalIso_branch != 0) {
5644     els_hcalIso_branch->GetEntry(index);
5645     #ifdef PARANOIA
5646     for (vector<float>::const_iterator i = els_hcalIso_.begin(); i != els_hcalIso_.end(); ++i) {
5647     if (not isfinite(*i)) {
5648     printf("branch els_hcalIso_branch contains a bad float: %f\n", *i);
5649     exit(1);
5650     }
5651     }
5652     #endif // #ifdef PARANOIA
5653     } else {
5654     printf("branch els_hcalIso_branch does not exist!\n");
5655     exit(1);
5656     }
5657     els_hcalIso_isLoaded = true;
5658     }
5659     return els_hcalIso_;
5660     }
5661     vector<float> &els_hcalIso04()
5662     {
5663     if (not els_hcalIso04_isLoaded) {
5664     if (els_hcalIso04_branch != 0) {
5665     els_hcalIso04_branch->GetEntry(index);
5666     #ifdef PARANOIA
5667     for (vector<float>::const_iterator i = els_hcalIso04_.begin(); i != els_hcalIso04_.end(); ++i) {
5668     if (not isfinite(*i)) {
5669     printf("branch els_hcalIso04_branch contains a bad float: %f\n", *i);
5670     exit(1);
5671     }
5672     }
5673     #endif // #ifdef PARANOIA
5674     } else {
5675     printf("branch els_hcalIso04_branch does not exist!\n");
5676     exit(1);
5677     }
5678     els_hcalIso04_isLoaded = true;
5679     }
5680     return els_hcalIso04_;
5681     }
5682     vector<float> &els_layer1_charge()
5683     {
5684     if (not els_layer1_charge_isLoaded) {
5685     if (els_layer1_charge_branch != 0) {
5686     els_layer1_charge_branch->GetEntry(index);
5687     #ifdef PARANOIA
5688     for (vector<float>::const_iterator i = els_layer1_charge_.begin(); i != els_layer1_charge_.end(); ++i) {
5689     if (not isfinite(*i)) {
5690     printf("branch els_layer1_charge_branch contains a bad float: %f\n", *i);
5691     exit(1);
5692     }
5693     }
5694     #endif // #ifdef PARANOIA
5695     } else {
5696     printf("branch els_layer1_charge_branch does not exist!\n");
5697     exit(1);
5698     }
5699     els_layer1_charge_isLoaded = true;
5700     }
5701     return els_layer1_charge_;
5702     }
5703     vector<float> &els_ndof()
5704     {
5705     if (not els_ndof_isLoaded) {
5706     if (els_ndof_branch != 0) {
5707     els_ndof_branch->GetEntry(index);
5708     #ifdef PARANOIA
5709     for (vector<float>::const_iterator i = els_ndof_.begin(); i != els_ndof_.end(); ++i) {
5710     if (not isfinite(*i)) {
5711     printf("branch els_ndof_branch contains a bad float: %f\n", *i);
5712     exit(1);
5713     }
5714     }
5715     #endif // #ifdef PARANOIA
5716     } else {
5717     printf("branch els_ndof_branch does not exist!\n");
5718     exit(1);
5719     }
5720     els_ndof_isLoaded = true;
5721     }
5722     return els_ndof_;
5723     }
5724     vector<float> &els_phiErr()
5725     {
5726     if (not els_phiErr_isLoaded) {
5727     if (els_phiErr_branch != 0) {
5728     els_phiErr_branch->GetEntry(index);
5729     #ifdef PARANOIA
5730     for (vector<float>::const_iterator i = els_phiErr_.begin(); i != els_phiErr_.end(); ++i) {
5731     if (not isfinite(*i)) {
5732     printf("branch els_phiErr_branch contains a bad float: %f\n", *i);
5733     exit(1);
5734     }
5735     }
5736     #endif // #ifdef PARANOIA
5737     } else {
5738     printf("branch els_phiErr_branch does not exist!\n");
5739     exit(1);
5740     }
5741     els_phiErr_isLoaded = true;
5742     }
5743     return els_phiErr_;
5744     }
5745     vector<float> &els_phiSC()
5746     {
5747     if (not els_phiSC_isLoaded) {
5748     if (els_phiSC_branch != 0) {
5749     els_phiSC_branch->GetEntry(index);
5750     #ifdef PARANOIA
5751     for (vector<float>::const_iterator i = els_phiSC_.begin(); i != els_phiSC_.end(); ++i) {
5752     if (not isfinite(*i)) {
5753     printf("branch els_phiSC_branch contains a bad float: %f\n", *i);
5754     exit(1);
5755     }
5756     }
5757     #endif // #ifdef PARANOIA
5758     } else {
5759     printf("branch els_phiSC_branch does not exist!\n");
5760     exit(1);
5761     }
5762     els_phiSC_isLoaded = true;
5763     }
5764     return els_phiSC_;
5765     }
5766     vector<float> &els_ptErr()
5767     {
5768     if (not els_ptErr_isLoaded) {
5769     if (els_ptErr_branch != 0) {
5770     els_ptErr_branch->GetEntry(index);
5771     #ifdef PARANOIA
5772     for (vector<float>::const_iterator i = els_ptErr_.begin(); i != els_ptErr_.end(); ++i) {
5773     if (not isfinite(*i)) {
5774     printf("branch els_ptErr_branch contains a bad float: %f\n", *i);
5775     exit(1);
5776     }
5777     }
5778     #endif // #ifdef PARANOIA
5779     } else {
5780     printf("branch els_ptErr_branch does not exist!\n");
5781     exit(1);
5782     }
5783     els_ptErr_isLoaded = true;
5784     }
5785     return els_ptErr_;
5786     }
5787     vector<float> &els_sigmaEtaEta()
5788     {
5789     if (not els_sigmaEtaEta_isLoaded) {
5790     if (els_sigmaEtaEta_branch != 0) {
5791     els_sigmaEtaEta_branch->GetEntry(index);
5792     #ifdef PARANOIA
5793     for (vector<float>::const_iterator i = els_sigmaEtaEta_.begin(); i != els_sigmaEtaEta_.end(); ++i) {
5794     if (not isfinite(*i)) {
5795     printf("branch els_sigmaEtaEta_branch contains a bad float: %f\n", *i);
5796     exit(1);
5797     }
5798     }
5799     #endif // #ifdef PARANOIA
5800     } else {
5801     printf("branch els_sigmaEtaEta_branch does not exist!\n");
5802     exit(1);
5803     }
5804     els_sigmaEtaEta_isLoaded = true;
5805     }
5806     return els_sigmaEtaEta_;
5807     }
5808     vector<float> &els_sigmaIEtaIEta()
5809     {
5810     if (not els_sigmaIEtaIEta_isLoaded) {
5811     if (els_sigmaIEtaIEta_branch != 0) {
5812     els_sigmaIEtaIEta_branch->GetEntry(index);
5813     #ifdef PARANOIA
5814     for (vector<float>::const_iterator i = els_sigmaIEtaIEta_.begin(); i != els_sigmaIEtaIEta_.end(); ++i) {
5815     if (not isfinite(*i)) {
5816     printf("branch els_sigmaIEtaIEta_branch contains a bad float: %f\n", *i);
5817     exit(1);
5818     }
5819     }
5820     #endif // #ifdef PARANOIA
5821     } else {
5822     printf("branch els_sigmaIEtaIEta_branch does not exist!\n");
5823     exit(1);
5824     }
5825     els_sigmaIEtaIEta_isLoaded = true;
5826     }
5827     return els_sigmaIEtaIEta_;
5828     }
5829     vector<float> &els_sigmaIPhiIPhi()
5830     {
5831     if (not els_sigmaIPhiIPhi_isLoaded) {
5832     if (els_sigmaIPhiIPhi_branch != 0) {
5833     els_sigmaIPhiIPhi_branch->GetEntry(index);
5834     #ifdef PARANOIA
5835     for (vector<float>::const_iterator i = els_sigmaIPhiIPhi_.begin(); i != els_sigmaIPhiIPhi_.end(); ++i) {
5836     if (not isfinite(*i)) {
5837     printf("branch els_sigmaIPhiIPhi_branch contains a bad float: %f\n", *i);
5838     exit(1);
5839     }
5840     }
5841     #endif // #ifdef PARANOIA
5842     } else {
5843     printf("branch els_sigmaIPhiIPhi_branch does not exist!\n");
5844     exit(1);
5845     }
5846     els_sigmaIPhiIPhi_isLoaded = true;
5847     }
5848     return els_sigmaIPhiIPhi_;
5849     }
5850     vector<float> &els_sigmaPhiPhi()
5851     {
5852     if (not els_sigmaPhiPhi_isLoaded) {
5853     if (els_sigmaPhiPhi_branch != 0) {
5854     els_sigmaPhiPhi_branch->GetEntry(index);
5855     #ifdef PARANOIA
5856     for (vector<float>::const_iterator i = els_sigmaPhiPhi_.begin(); i != els_sigmaPhiPhi_.end(); ++i) {
5857     if (not isfinite(*i)) {
5858     printf("branch els_sigmaPhiPhi_branch contains a bad float: %f\n", *i);
5859     exit(1);
5860     }
5861     }
5862     #endif // #ifdef PARANOIA
5863     } else {
5864     printf("branch els_sigmaPhiPhi_branch does not exist!\n");
5865     exit(1);
5866     }
5867     els_sigmaPhiPhi_isLoaded = true;
5868     }
5869     return els_sigmaPhiPhi_;
5870     }
5871     vector<float> &els_tkIso()
5872     {
5873     if (not els_tkIso_isLoaded) {
5874     if (els_tkIso_branch != 0) {
5875     els_tkIso_branch->GetEntry(index);
5876     #ifdef PARANOIA
5877     for (vector<float>::const_iterator i = els_tkIso_.begin(); i != els_tkIso_.end(); ++i) {
5878     if (not isfinite(*i)) {
5879     printf("branch els_tkIso_branch contains a bad float: %f\n", *i);
5880     exit(1);
5881     }
5882     }
5883     #endif // #ifdef PARANOIA
5884     } else {
5885     printf("branch els_tkIso_branch does not exist!\n");
5886     exit(1);
5887     }
5888     els_tkIso_isLoaded = true;
5889     }
5890     return els_tkIso_;
5891     }
5892     vector<float> &els_tkIso04()
5893     {
5894     if (not els_tkIso04_isLoaded) {
5895     if (els_tkIso04_branch != 0) {
5896     els_tkIso04_branch->GetEntry(index);
5897     #ifdef PARANOIA
5898     for (vector<float>::const_iterator i = els_tkIso04_.begin(); i != els_tkIso04_.end(); ++i) {
5899     if (not isfinite(*i)) {
5900     printf("branch els_tkIso04_branch contains a bad float: %f\n", *i);
5901     exit(1);
5902     }
5903     }
5904     #endif // #ifdef PARANOIA
5905     } else {
5906     printf("branch els_tkIso04_branch does not exist!\n");
5907     exit(1);
5908     }
5909     els_tkIso04_isLoaded = true;
5910     }
5911     return els_tkIso04_;
5912     }
5913     vector<float> &els_trackMomentumError()
5914     {
5915     if (not els_trackMomentumError_isLoaded) {
5916     if (els_trackMomentumError_branch != 0) {
5917     els_trackMomentumError_branch->GetEntry(index);
5918     #ifdef PARANOIA
5919     for (vector<float>::const_iterator i = els_trackMomentumError_.begin(); i != els_trackMomentumError_.end(); ++i) {
5920     if (not isfinite(*i)) {
5921     printf("branch els_trackMomentumError_branch contains a bad float: %f\n", *i);
5922     exit(1);
5923     }
5924     }
5925     #endif // #ifdef PARANOIA
5926     } else {
5927     printf("branch els_trackMomentumError_branch does not exist!\n");
5928     exit(1);
5929     }
5930     els_trackMomentumError_isLoaded = true;
5931     }
5932     return els_trackMomentumError_;
5933     }
5934     vector<float> &els_trkdr()
5935     {
5936     if (not els_trkdr_isLoaded) {
5937     if (els_trkdr_branch != 0) {
5938     els_trkdr_branch->GetEntry(index);
5939     #ifdef PARANOIA
5940     for (vector<float>::const_iterator i = els_trkdr_.begin(); i != els_trkdr_.end(); ++i) {
5941     if (not isfinite(*i)) {
5942     printf("branch els_trkdr_branch contains a bad float: %f\n", *i);
5943     exit(1);
5944     }
5945     }
5946     #endif // #ifdef PARANOIA
5947     } else {
5948     printf("branch els_trkdr_branch does not exist!\n");
5949     exit(1);
5950     }
5951     els_trkdr_isLoaded = true;
5952     }
5953     return els_trkdr_;
5954     }
5955     vector<float> &els_trkshFrac()
5956     {
5957     if (not els_trkshFrac_isLoaded) {
5958     if (els_trkshFrac_branch != 0) {
5959     els_trkshFrac_branch->GetEntry(index);
5960     #ifdef PARANOIA
5961     for (vector<float>::const_iterator i = els_trkshFrac_.begin(); i != els_trkshFrac_.end(); ++i) {
5962     if (not isfinite(*i)) {
5963     printf("branch els_trkshFrac_branch contains a bad float: %f\n", *i);
5964     exit(1);
5965     }
5966     }
5967     #endif // #ifdef PARANOIA
5968     } else {
5969     printf("branch els_trkshFrac_branch does not exist!\n");
5970     exit(1);
5971     }
5972     els_trkshFrac_isLoaded = true;
5973     }
5974     return els_trkshFrac_;
5975     }
5976     vector<float> &els_z0()
5977     {
5978     if (not els_z0_isLoaded) {
5979     if (els_z0_branch != 0) {
5980     els_z0_branch->GetEntry(index);
5981     #ifdef PARANOIA
5982     for (vector<float>::const_iterator i = els_z0_.begin(); i != els_z0_.end(); ++i) {
5983     if (not isfinite(*i)) {
5984     printf("branch els_z0_branch contains a bad float: %f\n", *i);
5985     exit(1);
5986     }
5987     }
5988     #endif // #ifdef PARANOIA
5989     } else {
5990     printf("branch els_z0_branch does not exist!\n");
5991     exit(1);
5992     }
5993     els_z0_isLoaded = true;
5994     }
5995     return els_z0_;
5996     }
5997     vector<float> &els_z0Err()
5998     {
5999     if (not els_z0Err_isLoaded) {
6000     if (els_z0Err_branch != 0) {
6001     els_z0Err_branch->GetEntry(index);
6002     #ifdef PARANOIA
6003     for (vector<float>::const_iterator i = els_z0Err_.begin(); i != els_z0Err_.end(); ++i) {
6004     if (not isfinite(*i)) {
6005     printf("branch els_z0Err_branch contains a bad float: %f\n", *i);
6006     exit(1);
6007     }
6008     }
6009     #endif // #ifdef PARANOIA
6010     } else {
6011     printf("branch els_z0Err_branch does not exist!\n");
6012     exit(1);
6013     }
6014     els_z0Err_isLoaded = true;
6015     }
6016     return els_z0Err_;
6017     }
6018     vector<float> &els_z0corr()
6019     {
6020     if (not els_z0corr_isLoaded) {
6021     if (els_z0corr_branch != 0) {
6022     els_z0corr_branch->GetEntry(index);
6023     #ifdef PARANOIA
6024     for (vector<float>::const_iterator i = els_z0corr_.begin(); i != els_z0corr_.end(); ++i) {
6025     if (not isfinite(*i)) {
6026     printf("branch els_z0corr_branch contains a bad float: %f\n", *i);
6027     exit(1);
6028     }
6029     }
6030     #endif // #ifdef PARANOIA
6031     } else {
6032     printf("branch els_z0corr_branch does not exist!\n");
6033     exit(1);
6034     }
6035     els_z0corr_isLoaded = true;
6036     }
6037     return els_z0corr_;
6038     }
6039     vector<float> &mus_caloCompatibility()
6040     {
6041     if (not mus_caloCompatibility_isLoaded) {
6042     if (mus_caloCompatibility_branch != 0) {
6043     mus_caloCompatibility_branch->GetEntry(index);
6044     #ifdef PARANOIA
6045     for (vector<float>::const_iterator i = mus_caloCompatibility_.begin(); i != mus_caloCompatibility_.end(); ++i) {
6046     if (not isfinite(*i)) {
6047     printf("branch mus_caloCompatibility_branch contains a bad float: %f\n", *i);
6048     exit(1);
6049     }
6050     }
6051     #endif // #ifdef PARANOIA
6052     } else {
6053     printf("branch mus_caloCompatibility_branch does not exist!\n");
6054     exit(1);
6055     }
6056     mus_caloCompatibility_isLoaded = true;
6057     }
6058     return mus_caloCompatibility_;
6059     }
6060     vector<float> &mus_chi2()
6061     {
6062     if (not mus_chi2_isLoaded) {
6063     if (mus_chi2_branch != 0) {
6064     mus_chi2_branch->GetEntry(index);
6065     #ifdef PARANOIA
6066     for (vector<float>::const_iterator i = mus_chi2_.begin(); i != mus_chi2_.end(); ++i) {
6067     if (not isfinite(*i)) {
6068     printf("branch mus_chi2_branch contains a bad float: %f\n", *i);
6069     exit(1);
6070     }
6071     }
6072     #endif // #ifdef PARANOIA
6073     } else {
6074     printf("branch mus_chi2_branch does not exist!\n");
6075     exit(1);
6076     }
6077     mus_chi2_isLoaded = true;
6078     }
6079     return mus_chi2_;
6080     }
6081     vector<float> &mus_d0()
6082     {
6083     if (not mus_d0_isLoaded) {
6084     if (mus_d0_branch != 0) {
6085     mus_d0_branch->GetEntry(index);
6086     #ifdef PARANOIA
6087     for (vector<float>::const_iterator i = mus_d0_.begin(); i != mus_d0_.end(); ++i) {
6088     if (not isfinite(*i)) {
6089     printf("branch mus_d0_branch contains a bad float: %f\n", *i);
6090     exit(1);
6091     }
6092     }
6093     #endif // #ifdef PARANOIA
6094     } else {
6095     printf("branch mus_d0_branch does not exist!\n");
6096     exit(1);
6097     }
6098     mus_d0_isLoaded = true;
6099     }
6100     return mus_d0_;
6101     }
6102     vector<float> &mus_d0Err()
6103     {
6104     if (not mus_d0Err_isLoaded) {
6105     if (mus_d0Err_branch != 0) {
6106     mus_d0Err_branch->GetEntry(index);
6107     #ifdef PARANOIA
6108     for (vector<float>::const_iterator i = mus_d0Err_.begin(); i != mus_d0Err_.end(); ++i) {
6109     if (not isfinite(*i)) {
6110     printf("branch mus_d0Err_branch contains a bad float: %f\n", *i);
6111     exit(1);
6112     }
6113     }
6114     #endif // #ifdef PARANOIA
6115     } else {
6116     printf("branch mus_d0Err_branch does not exist!\n");
6117     exit(1);
6118     }
6119     mus_d0Err_isLoaded = true;
6120     }
6121     return mus_d0Err_;
6122     }
6123     vector<float> &mus_d0corr()
6124     {
6125     if (not mus_d0corr_isLoaded) {
6126     if (mus_d0corr_branch != 0) {
6127     mus_d0corr_branch->GetEntry(index);
6128     #ifdef PARANOIA
6129     for (vector<float>::const_iterator i = mus_d0corr_.begin(); i != mus_d0corr_.end(); ++i) {
6130     if (not isfinite(*i)) {
6131     printf("branch mus_d0corr_branch contains a bad float: %f\n", *i);
6132     exit(1);
6133     }
6134     }
6135     #endif // #ifdef PARANOIA
6136     } else {
6137     printf("branch mus_d0corr_branch does not exist!\n");
6138     exit(1);
6139     }
6140     mus_d0corr_isLoaded = true;
6141     }
6142     return mus_d0corr_;
6143     }
6144     vector<float> &mus_e_em()
6145     {
6146     if (not mus_e_em_isLoaded) {
6147     if (mus_e_em_branch != 0) {
6148     mus_e_em_branch->GetEntry(index);
6149     #ifdef PARANOIA
6150     for (vector<float>::const_iterator i = mus_e_em_.begin(); i != mus_e_em_.end(); ++i) {
6151     if (not isfinite(*i)) {
6152     printf("branch mus_e_em_branch contains a bad float: %f\n", *i);
6153     exit(1);
6154     }
6155     }
6156     #endif // #ifdef PARANOIA
6157     } else {
6158     printf("branch mus_e_em_branch does not exist!\n");
6159     exit(1);
6160     }
6161     mus_e_em_isLoaded = true;
6162     }
6163     return mus_e_em_;
6164     }
6165     vector<float> &mus_e_emS9()
6166     {
6167     if (not mus_e_emS9_isLoaded) {
6168     if (mus_e_emS9_branch != 0) {
6169     mus_e_emS9_branch->GetEntry(index);
6170     #ifdef PARANOIA
6171     for (vector<float>::const_iterator i = mus_e_emS9_.begin(); i != mus_e_emS9_.end(); ++i) {
6172     if (not isfinite(*i)) {
6173     printf("branch mus_e_emS9_branch contains a bad float: %f\n", *i);
6174     exit(1);
6175     }
6176     }
6177     #endif // #ifdef PARANOIA
6178     } else {
6179     printf("branch mus_e_emS9_branch does not exist!\n");
6180     exit(1);
6181     }
6182     mus_e_emS9_isLoaded = true;
6183     }
6184     return mus_e_emS9_;
6185     }
6186     vector<float> &mus_e_had()
6187     {
6188     if (not mus_e_had_isLoaded) {
6189     if (mus_e_had_branch != 0) {
6190     mus_e_had_branch->GetEntry(index);
6191     #ifdef PARANOIA
6192     for (vector<float>::const_iterator i = mus_e_had_.begin(); i != mus_e_had_.end(); ++i) {
6193     if (not isfinite(*i)) {
6194     printf("branch mus_e_had_branch contains a bad float: %f\n", *i);
6195     exit(1);
6196     }
6197     }
6198     #endif // #ifdef PARANOIA
6199     } else {
6200     printf("branch mus_e_had_branch does not exist!\n");
6201     exit(1);
6202     }
6203     mus_e_had_isLoaded = true;
6204     }
6205     return mus_e_had_;
6206     }
6207     vector<float> &mus_e_hadS9()
6208     {
6209     if (not mus_e_hadS9_isLoaded) {
6210     if (mus_e_hadS9_branch != 0) {
6211     mus_e_hadS9_branch->GetEntry(index);
6212     #ifdef PARANOIA
6213     for (vector<float>::const_iterator i = mus_e_hadS9_.begin(); i != mus_e_hadS9_.end(); ++i) {
6214     if (not isfinite(*i)) {
6215     printf("branch mus_e_hadS9_branch contains a bad float: %f\n", *i);
6216     exit(1);
6217     }
6218     }
6219     #endif // #ifdef PARANOIA
6220     } else {
6221     printf("branch mus_e_hadS9_branch does not exist!\n");
6222     exit(1);
6223     }
6224     mus_e_hadS9_isLoaded = true;
6225     }
6226     return mus_e_hadS9_;
6227     }
6228     vector<float> &mus_e_ho()
6229     {
6230     if (not mus_e_ho_isLoaded) {
6231     if (mus_e_ho_branch != 0) {
6232     mus_e_ho_branch->GetEntry(index);
6233     #ifdef PARANOIA
6234     for (vector<float>::const_iterator i = mus_e_ho_.begin(); i != mus_e_ho_.end(); ++i) {
6235     if (not isfinite(*i)) {
6236     printf("branch mus_e_ho_branch contains a bad float: %f\n", *i);
6237     exit(1);
6238     }
6239     }
6240     #endif // #ifdef PARANOIA
6241     } else {
6242     printf("branch mus_e_ho_branch does not exist!\n");
6243     exit(1);
6244     }
6245     mus_e_ho_isLoaded = true;
6246     }
6247     return mus_e_ho_;
6248     }
6249     vector<float> &mus_e_hoS9()
6250     {
6251     if (not mus_e_hoS9_isLoaded) {
6252     if (mus_e_hoS9_branch != 0) {
6253     mus_e_hoS9_branch->GetEntry(index);
6254     #ifdef PARANOIA
6255     for (vector<float>::const_iterator i = mus_e_hoS9_.begin(); i != mus_e_hoS9_.end(); ++i) {
6256     if (not isfinite(*i)) {
6257     printf("branch mus_e_hoS9_branch contains a bad float: %f\n", *i);
6258     exit(1);
6259     }
6260     }
6261     #endif // #ifdef PARANOIA
6262     } else {
6263     printf("branch mus_e_hoS9_branch does not exist!\n");
6264     exit(1);
6265     }
6266     mus_e_hoS9_isLoaded = true;
6267     }
6268     return mus_e_hoS9_;
6269     }
6270     vector<float> &mus_etaErr()
6271     {
6272     if (not mus_etaErr_isLoaded) {
6273     if (mus_etaErr_branch != 0) {
6274     mus_etaErr_branch->GetEntry(index);
6275     #ifdef PARANOIA
6276     for (vector<float>::const_iterator i = mus_etaErr_.begin(); i != mus_etaErr_.end(); ++i) {
6277     if (not isfinite(*i)) {
6278     printf("branch mus_etaErr_branch contains a bad float: %f\n", *i);
6279     exit(1);
6280     }
6281     }
6282     #endif // #ifdef PARANOIA
6283     } else {
6284     printf("branch mus_etaErr_branch does not exist!\n");
6285     exit(1);
6286     }
6287     mus_etaErr_isLoaded = true;
6288     }
6289     return mus_etaErr_;
6290     }
6291     vector<float> &mus_gfit_chi2()
6292     {
6293     if (not mus_gfit_chi2_isLoaded) {
6294     if (mus_gfit_chi2_branch != 0) {
6295     mus_gfit_chi2_branch->GetEntry(index);
6296     #ifdef PARANOIA
6297     for (vector<float>::const_iterator i = mus_gfit_chi2_.begin(); i != mus_gfit_chi2_.end(); ++i) {
6298     if (not isfinite(*i)) {
6299     printf("branch mus_gfit_chi2_branch contains a bad float: %f\n", *i);
6300     exit(1);
6301     }
6302     }
6303     #endif // #ifdef PARANOIA
6304     } else {
6305     printf("branch mus_gfit_chi2_branch does not exist!\n");
6306     exit(1);
6307     }
6308     mus_gfit_chi2_isLoaded = true;
6309     }
6310     return mus_gfit_chi2_;
6311     }
6312     vector<float> &mus_gfit_d0()
6313     {
6314     if (not mus_gfit_d0_isLoaded) {
6315     if (mus_gfit_d0_branch != 0) {
6316     mus_gfit_d0_branch->GetEntry(index);
6317     #ifdef PARANOIA
6318     for (vector<float>::const_iterator i = mus_gfit_d0_.begin(); i != mus_gfit_d0_.end(); ++i) {
6319     if (not isfinite(*i)) {
6320     printf("branch mus_gfit_d0_branch contains a bad float: %f\n", *i);
6321     exit(1);
6322     }
6323     }
6324     #endif // #ifdef PARANOIA
6325     } else {
6326     printf("branch mus_gfit_d0_branch does not exist!\n");
6327     exit(1);
6328     }
6329     mus_gfit_d0_isLoaded = true;
6330     }
6331     return mus_gfit_d0_;
6332     }
6333     vector<float> &mus_gfit_d0Err()
6334     {
6335     if (not mus_gfit_d0Err_isLoaded) {
6336     if (mus_gfit_d0Err_branch != 0) {
6337     mus_gfit_d0Err_branch->GetEntry(index);
6338     #ifdef PARANOIA
6339     for (vector<float>::const_iterator i = mus_gfit_d0Err_.begin(); i != mus_gfit_d0Err_.end(); ++i) {
6340     if (not isfinite(*i)) {
6341     printf("branch mus_gfit_d0Err_branch contains a bad float: %f\n", *i);
6342     exit(1);
6343     }
6344     }
6345     #endif // #ifdef PARANOIA
6346     } else {
6347     printf("branch mus_gfit_d0Err_branch does not exist!\n");
6348     exit(1);
6349     }
6350     mus_gfit_d0Err_isLoaded = true;
6351     }
6352     return mus_gfit_d0Err_;
6353     }
6354     vector<float> &mus_gfit_d0corr()
6355     {
6356     if (not mus_gfit_d0corr_isLoaded) {
6357     if (mus_gfit_d0corr_branch != 0) {
6358     mus_gfit_d0corr_branch->GetEntry(index);
6359     #ifdef PARANOIA
6360     for (vector<float>::const_iterator i = mus_gfit_d0corr_.begin(); i != mus_gfit_d0corr_.end(); ++i) {
6361     if (not isfinite(*i)) {
6362     printf("branch mus_gfit_d0corr_branch contains a bad float: %f\n", *i);
6363     exit(1);
6364     }
6365     }
6366     #endif // #ifdef PARANOIA
6367     } else {
6368     printf("branch mus_gfit_d0corr_branch does not exist!\n");
6369     exit(1);
6370     }
6371     mus_gfit_d0corr_isLoaded = true;
6372     }
6373     return mus_gfit_d0corr_;
6374     }
6375     vector<float> &mus_gfit_ndof()
6376     {
6377     if (not mus_gfit_ndof_isLoaded) {
6378     if (mus_gfit_ndof_branch != 0) {
6379     mus_gfit_ndof_branch->GetEntry(index);
6380     #ifdef PARANOIA
6381     for (vector<float>::const_iterator i = mus_gfit_ndof_.begin(); i != mus_gfit_ndof_.end(); ++i) {
6382     if (not isfinite(*i)) {
6383     printf("branch mus_gfit_ndof_branch contains a bad float: %f\n", *i);
6384     exit(1);
6385     }
6386     }
6387     #endif // #ifdef PARANOIA
6388     } else {
6389     printf("branch mus_gfit_ndof_branch does not exist!\n");
6390     exit(1);
6391     }
6392     mus_gfit_ndof_isLoaded = true;
6393     }
6394     return mus_gfit_ndof_;
6395     }
6396     vector<float> &mus_gfit_qoverp()
6397     {
6398     if (not mus_gfit_qoverp_isLoaded) {
6399     if (mus_gfit_qoverp_branch != 0) {
6400     mus_gfit_qoverp_branch->GetEntry(index);
6401     #ifdef PARANOIA
6402     for (vector<float>::const_iterator i = mus_gfit_qoverp_.begin(); i != mus_gfit_qoverp_.end(); ++i) {
6403     if (not isfinite(*i)) {
6404     printf("branch mus_gfit_qoverp_branch contains a bad float: %f\n", *i);
6405     exit(1);
6406     }
6407     }
6408     #endif // #ifdef PARANOIA
6409     } else {
6410     printf("branch mus_gfit_qoverp_branch does not exist!\n");
6411     exit(1);
6412     }
6413     mus_gfit_qoverp_isLoaded = true;
6414     }
6415     return mus_gfit_qoverp_;
6416     }
6417     vector<float> &mus_gfit_qoverpError()
6418     {
6419     if (not mus_gfit_qoverpError_isLoaded) {
6420     if (mus_gfit_qoverpError_branch != 0) {
6421     mus_gfit_qoverpError_branch->GetEntry(index);
6422     #ifdef PARANOIA
6423     for (vector<float>::const_iterator i = mus_gfit_qoverpError_.begin(); i != mus_gfit_qoverpError_.end(); ++i) {
6424     if (not isfinite(*i)) {
6425     printf("branch mus_gfit_qoverpError_branch contains a bad float: %f\n", *i);
6426     exit(1);
6427     }
6428     }
6429     #endif // #ifdef PARANOIA
6430     } else {
6431     printf("branch mus_gfit_qoverpError_branch does not exist!\n");
6432     exit(1);
6433     }
6434     mus_gfit_qoverpError_isLoaded = true;
6435     }
6436     return mus_gfit_qoverpError_;
6437     }
6438     vector<float> &mus_gfit_z0()
6439     {
6440     if (not mus_gfit_z0_isLoaded) {
6441     if (mus_gfit_z0_branch != 0) {
6442     mus_gfit_z0_branch->GetEntry(index);
6443     #ifdef PARANOIA
6444     for (vector<float>::const_iterator i = mus_gfit_z0_.begin(); i != mus_gfit_z0_.end(); ++i) {
6445     if (not isfinite(*i)) {
6446     printf("branch mus_gfit_z0_branch contains a bad float: %f\n", *i);
6447     exit(1);
6448     }
6449     }
6450     #endif // #ifdef PARANOIA
6451     } else {
6452     printf("branch mus_gfit_z0_branch does not exist!\n");
6453     exit(1);
6454     }
6455     mus_gfit_z0_isLoaded = true;
6456     }
6457     return mus_gfit_z0_;
6458     }
6459     vector<float> &mus_gfit_z0Err()
6460     {
6461     if (not mus_gfit_z0Err_isLoaded) {
6462     if (mus_gfit_z0Err_branch != 0) {
6463     mus_gfit_z0Err_branch->GetEntry(index);
6464     #ifdef PARANOIA
6465     for (vector<float>::const_iterator i = mus_gfit_z0Err_.begin(); i != mus_gfit_z0Err_.end(); ++i) {
6466     if (not isfinite(*i)) {
6467     printf("branch mus_gfit_z0Err_branch contains a bad float: %f\n", *i);
6468     exit(1);
6469     }
6470     }
6471     #endif // #ifdef PARANOIA
6472     } else {
6473     printf("branch mus_gfit_z0Err_branch does not exist!\n");
6474     exit(1);
6475     }
6476     mus_gfit_z0Err_isLoaded = true;
6477     }
6478     return mus_gfit_z0Err_;
6479     }
6480     vector<float> &mus_gfit_z0corr()
6481     {
6482     if (not mus_gfit_z0corr_isLoaded) {
6483     if (mus_gfit_z0corr_branch != 0) {
6484     mus_gfit_z0corr_branch->GetEntry(index);
6485     #ifdef PARANOIA
6486     for (vector<float>::const_iterator i = mus_gfit_z0corr_.begin(); i != mus_gfit_z0corr_.end(); ++i) {
6487     if (not isfinite(*i)) {
6488     printf("branch mus_gfit_z0corr_branch contains a bad float: %f\n", *i);
6489     exit(1);
6490     }
6491     }
6492     #endif // #ifdef PARANOIA
6493     } else {
6494     printf("branch mus_gfit_z0corr_branch does not exist!\n");
6495     exit(1);
6496     }
6497     mus_gfit_z0corr_isLoaded = true;
6498     }
6499     return mus_gfit_z0corr_;
6500     }
6501     vector<float> &mus_iso03_emEt()
6502     {
6503     if (not mus_iso03_emEt_isLoaded) {
6504     if (mus_iso03_emEt_branch != 0) {
6505     mus_iso03_emEt_branch->GetEntry(index);
6506     #ifdef PARANOIA
6507     for (vector<float>::const_iterator i = mus_iso03_emEt_.begin(); i != mus_iso03_emEt_.end(); ++i) {
6508     if (not isfinite(*i)) {
6509     printf("branch mus_iso03_emEt_branch contains a bad float: %f\n", *i);
6510     exit(1);
6511     }
6512     }
6513     #endif // #ifdef PARANOIA
6514     } else {
6515     printf("branch mus_iso03_emEt_branch does not exist!\n");
6516     exit(1);
6517     }
6518     mus_iso03_emEt_isLoaded = true;
6519     }
6520     return mus_iso03_emEt_;
6521     }
6522     vector<float> &mus_iso03_hadEt()
6523     {
6524     if (not mus_iso03_hadEt_isLoaded) {
6525     if (mus_iso03_hadEt_branch != 0) {
6526     mus_iso03_hadEt_branch->GetEntry(index);
6527     #ifdef PARANOIA
6528     for (vector<float>::const_iterator i = mus_iso03_hadEt_.begin(); i != mus_iso03_hadEt_.end(); ++i) {
6529     if (not isfinite(*i)) {
6530     printf("branch mus_iso03_hadEt_branch contains a bad float: %f\n", *i);
6531     exit(1);
6532     }
6533     }
6534     #endif // #ifdef PARANOIA
6535     } else {
6536     printf("branch mus_iso03_hadEt_branch does not exist!\n");
6537     exit(1);
6538     }
6539     mus_iso03_hadEt_isLoaded = true;
6540     }
6541     return mus_iso03_hadEt_;
6542     }
6543     vector<float> &mus_iso03_hoEt()
6544     {
6545     if (not mus_iso03_hoEt_isLoaded) {
6546     if (mus_iso03_hoEt_branch != 0) {
6547     mus_iso03_hoEt_branch->GetEntry(index);
6548     #ifdef PARANOIA
6549     for (vector<float>::const_iterator i = mus_iso03_hoEt_.begin(); i != mus_iso03_hoEt_.end(); ++i) {
6550     if (not isfinite(*i)) {
6551     printf("branch mus_iso03_hoEt_branch contains a bad float: %f\n", *i);
6552     exit(1);
6553     }
6554     }
6555     #endif // #ifdef PARANOIA
6556     } else {
6557     printf("branch mus_iso03_hoEt_branch does not exist!\n");
6558     exit(1);
6559     }
6560     mus_iso03_hoEt_isLoaded = true;
6561     }
6562     return mus_iso03_hoEt_;
6563     }
6564     vector<float> &mus_iso03_sumPt()
6565     {
6566     if (not mus_iso03_sumPt_isLoaded) {
6567     if (mus_iso03_sumPt_branch != 0) {
6568     mus_iso03_sumPt_branch->GetEntry(index);
6569     #ifdef PARANOIA
6570     for (vector<float>::const_iterator i = mus_iso03_sumPt_.begin(); i != mus_iso03_sumPt_.end(); ++i) {
6571     if (not isfinite(*i)) {
6572     printf("branch mus_iso03_sumPt_branch contains a bad float: %f\n", *i);
6573     exit(1);
6574     }
6575     }
6576     #endif // #ifdef PARANOIA
6577     } else {
6578     printf("branch mus_iso03_sumPt_branch does not exist!\n");
6579     exit(1);
6580     }
6581     mus_iso03_sumPt_isLoaded = true;
6582     }
6583     return mus_iso03_sumPt_;
6584     }
6585     vector<float> &mus_iso05_emEt()
6586     {
6587     if (not mus_iso05_emEt_isLoaded) {
6588     if (mus_iso05_emEt_branch != 0) {
6589     mus_iso05_emEt_branch->GetEntry(index);
6590     #ifdef PARANOIA
6591     for (vector<float>::const_iterator i = mus_iso05_emEt_.begin(); i != mus_iso05_emEt_.end(); ++i) {
6592     if (not isfinite(*i)) {
6593     printf("branch mus_iso05_emEt_branch contains a bad float: %f\n", *i);
6594     exit(1);
6595     }
6596     }
6597     #endif // #ifdef PARANOIA
6598     } else {
6599     printf("branch mus_iso05_emEt_branch does not exist!\n");
6600     exit(1);
6601     }
6602     mus_iso05_emEt_isLoaded = true;
6603     }
6604     return mus_iso05_emEt_;
6605     }
6606     vector<float> &mus_iso05_hadEt()
6607     {
6608     if (not mus_iso05_hadEt_isLoaded) {
6609     if (mus_iso05_hadEt_branch != 0) {
6610     mus_iso05_hadEt_branch->GetEntry(index);
6611     #ifdef PARANOIA
6612     for (vector<float>::const_iterator i = mus_iso05_hadEt_.begin(); i != mus_iso05_hadEt_.end(); ++i) {
6613     if (not isfinite(*i)) {
6614     printf("branch mus_iso05_hadEt_branch contains a bad float: %f\n", *i);
6615     exit(1);
6616     }
6617     }
6618     #endif // #ifdef PARANOIA
6619     } else {
6620     printf("branch mus_iso05_hadEt_branch does not exist!\n");
6621     exit(1);
6622     }
6623     mus_iso05_hadEt_isLoaded = true;
6624     }
6625     return mus_iso05_hadEt_;
6626     }
6627     vector<float> &mus_iso05_hoEt()
6628     {
6629     if (not mus_iso05_hoEt_isLoaded) {
6630     if (mus_iso05_hoEt_branch != 0) {
6631     mus_iso05_hoEt_branch->GetEntry(index);
6632     #ifdef PARANOIA
6633     for (vector<float>::const_iterator i = mus_iso05_hoEt_.begin(); i != mus_iso05_hoEt_.end(); ++i) {
6634     if (not isfinite(*i)) {
6635     printf("branch mus_iso05_hoEt_branch contains a bad float: %f\n", *i);
6636     exit(1);
6637     }
6638     }
6639     #endif // #ifdef PARANOIA
6640     } else {
6641     printf("branch mus_iso05_hoEt_branch does not exist!\n");
6642     exit(1);
6643     }
6644     mus_iso05_hoEt_isLoaded = true;
6645     }
6646     return mus_iso05_hoEt_;
6647     }
6648     vector<float> &mus_iso05_sumPt()
6649     {
6650     if (not mus_iso05_sumPt_isLoaded) {
6651     if (mus_iso05_sumPt_branch != 0) {
6652     mus_iso05_sumPt_branch->GetEntry(index);
6653     #ifdef PARANOIA
6654     for (vector<float>::const_iterator i = mus_iso05_sumPt_.begin(); i != mus_iso05_sumPt_.end(); ++i) {
6655     if (not isfinite(*i)) {
6656     printf("branch mus_iso05_sumPt_branch contains a bad float: %f\n", *i);
6657     exit(1);
6658     }
6659     }
6660     #endif // #ifdef PARANOIA
6661     } else {
6662     printf("branch mus_iso05_sumPt_branch does not exist!\n");
6663     exit(1);
6664     }
6665     mus_iso05_sumPt_isLoaded = true;
6666     }
6667     return mus_iso05_sumPt_;
6668     }
6669     vector<float> &mus_iso_ecalvetoDep()
6670     {
6671     if (not mus_iso_ecalvetoDep_isLoaded) {
6672     if (mus_iso_ecalvetoDep_branch != 0) {
6673     mus_iso_ecalvetoDep_branch->GetEntry(index);
6674     #ifdef PARANOIA
6675     for (vector<float>::const_iterator i = mus_iso_ecalvetoDep_.begin(); i != mus_iso_ecalvetoDep_.end(); ++i) {
6676     if (not isfinite(*i)) {
6677     printf("branch mus_iso_ecalvetoDep_branch contains a bad float: %f\n", *i);
6678     exit(1);
6679     }
6680     }
6681     #endif // #ifdef PARANOIA
6682     } else {
6683     printf("branch mus_iso_ecalvetoDep_branch does not exist!\n");
6684     exit(1);
6685     }
6686     mus_iso_ecalvetoDep_isLoaded = true;
6687     }
6688     return mus_iso_ecalvetoDep_;
6689     }
6690     vector<float> &mus_iso_hcalvetoDep()
6691     {
6692     if (not mus_iso_hcalvetoDep_isLoaded) {
6693     if (mus_iso_hcalvetoDep_branch != 0) {
6694     mus_iso_hcalvetoDep_branch->GetEntry(index);
6695     #ifdef PARANOIA
6696     for (vector<float>::const_iterator i = mus_iso_hcalvetoDep_.begin(); i != mus_iso_hcalvetoDep_.end(); ++i) {
6697     if (not isfinite(*i)) {
6698     printf("branch mus_iso_hcalvetoDep_branch contains a bad float: %f\n", *i);
6699     exit(1);
6700     }
6701     }
6702     #endif // #ifdef PARANOIA
6703     } else {
6704     printf("branch mus_iso_hcalvetoDep_branch does not exist!\n");
6705     exit(1);
6706     }
6707     mus_iso_hcalvetoDep_isLoaded = true;
6708     }
6709     return mus_iso_hcalvetoDep_;
6710     }
6711     vector<float> &mus_iso_hovetoDep()
6712     {
6713     if (not mus_iso_hovetoDep_isLoaded) {
6714     if (mus_iso_hovetoDep_branch != 0) {
6715     mus_iso_hovetoDep_branch->GetEntry(index);
6716     #ifdef PARANOIA
6717     for (vector<float>::const_iterator i = mus_iso_hovetoDep_.begin(); i != mus_iso_hovetoDep_.end(); ++i) {
6718     if (not isfinite(*i)) {
6719     printf("branch mus_iso_hovetoDep_branch contains a bad float: %f\n", *i);
6720     exit(1);
6721     }
6722     }
6723     #endif // #ifdef PARANOIA
6724     } else {
6725     printf("branch mus_iso_hovetoDep_branch does not exist!\n");
6726     exit(1);
6727     }
6728     mus_iso_hovetoDep_isLoaded = true;
6729     }
6730     return mus_iso_hovetoDep_;
6731     }
6732     vector<float> &mus_iso_trckvetoDep()
6733     {
6734     if (not mus_iso_trckvetoDep_isLoaded) {
6735     if (mus_iso_trckvetoDep_branch != 0) {
6736     mus_iso_trckvetoDep_branch->GetEntry(index);
6737     #ifdef PARANOIA
6738     for (vector<float>::const_iterator i = mus_iso_trckvetoDep_.begin(); i != mus_iso_trckvetoDep_.end(); ++i) {
6739     if (not isfinite(*i)) {
6740     printf("branch mus_iso_trckvetoDep_branch contains a bad float: %f\n", *i);
6741     exit(1);
6742     }
6743     }
6744     #endif // #ifdef PARANOIA
6745     } else {
6746     printf("branch mus_iso_trckvetoDep_branch does not exist!\n");
6747     exit(1);
6748     }
6749     mus_iso_trckvetoDep_isLoaded = true;
6750     }
6751     return mus_iso_trckvetoDep_;
6752     }
6753     vector<float> &mus_ndof()
6754     {
6755     if (not mus_ndof_isLoaded) {
6756     if (mus_ndof_branch != 0) {
6757     mus_ndof_branch->GetEntry(index);
6758     #ifdef PARANOIA
6759     for (vector<float>::const_iterator i = mus_ndof_.begin(); i != mus_ndof_.end(); ++i) {
6760     if (not isfinite(*i)) {
6761     printf("branch mus_ndof_branch contains a bad float: %f\n", *i);
6762     exit(1);
6763     }
6764     }
6765     #endif // #ifdef PARANOIA
6766     } else {
6767     printf("branch mus_ndof_branch does not exist!\n");
6768     exit(1);
6769     }
6770     mus_ndof_isLoaded = true;
6771     }
6772     return mus_ndof_;
6773     }
6774     vector<float> &mus_phiErr()
6775     {
6776     if (not mus_phiErr_isLoaded) {
6777     if (mus_phiErr_branch != 0) {
6778     mus_phiErr_branch->GetEntry(index);
6779     #ifdef PARANOIA
6780     for (vector<float>::const_iterator i = mus_phiErr_.begin(); i != mus_phiErr_.end(); ++i) {
6781     if (not isfinite(*i)) {
6782     printf("branch mus_phiErr_branch contains a bad float: %f\n", *i);
6783     exit(1);
6784     }
6785     }
6786     #endif // #ifdef PARANOIA
6787     } else {
6788     printf("branch mus_phiErr_branch does not exist!\n");
6789     exit(1);
6790     }
6791     mus_phiErr_isLoaded = true;
6792     }
6793     return mus_phiErr_;
6794     }
6795     vector<float> &mus_ptErr()
6796     {
6797     if (not mus_ptErr_isLoaded) {
6798     if (mus_ptErr_branch != 0) {
6799     mus_ptErr_branch->GetEntry(index);
6800     #ifdef PARANOIA
6801     for (vector<float>::const_iterator i = mus_ptErr_.begin(); i != mus_ptErr_.end(); ++i) {
6802     if (not isfinite(*i)) {
6803     printf("branch mus_ptErr_branch contains a bad float: %f\n", *i);
6804     exit(1);
6805     }
6806     }
6807     #endif // #ifdef PARANOIA
6808     } else {
6809     printf("branch mus_ptErr_branch does not exist!\n");
6810     exit(1);
6811     }
6812     mus_ptErr_isLoaded = true;
6813     }
6814     return mus_ptErr_;
6815     }
6816     vector<float> &mus_qoverp()
6817     {
6818     if (not mus_qoverp_isLoaded) {
6819     if (mus_qoverp_branch != 0) {
6820     mus_qoverp_branch->GetEntry(index);
6821     #ifdef PARANOIA
6822     for (vector<float>::const_iterator i = mus_qoverp_.begin(); i != mus_qoverp_.end(); ++i) {
6823     if (not isfinite(*i)) {
6824     printf("branch mus_qoverp_branch contains a bad float: %f\n", *i);
6825     exit(1);
6826     }
6827     }
6828     #endif // #ifdef PARANOIA
6829     } else {
6830     printf("branch mus_qoverp_branch does not exist!\n");
6831     exit(1);
6832     }
6833     mus_qoverp_isLoaded = true;
6834     }
6835     return mus_qoverp_;
6836     }
6837     vector<float> &mus_qoverpError()
6838     {
6839     if (not mus_qoverpError_isLoaded) {
6840     if (mus_qoverpError_branch != 0) {
6841     mus_qoverpError_branch->GetEntry(index);
6842     #ifdef PARANOIA
6843     for (vector<float>::const_iterator i = mus_qoverpError_.begin(); i != mus_qoverpError_.end(); ++i) {
6844     if (not isfinite(*i)) {
6845     printf("branch mus_qoverpError_branch contains a bad float: %f\n", *i);
6846     exit(1);
6847     }
6848     }
6849     #endif // #ifdef PARANOIA
6850     } else {
6851     printf("branch mus_qoverpError_branch does not exist!\n");
6852     exit(1);
6853     }
6854     mus_qoverpError_isLoaded = true;
6855     }
6856     return mus_qoverpError_;
6857     }
6858     vector<float> &mus_timeAtIpInOut()
6859     {
6860     if (not mus_timeAtIpInOut_isLoaded) {
6861     if (mus_timeAtIpInOut_branch != 0) {
6862     mus_timeAtIpInOut_branch->GetEntry(index);
6863     #ifdef PARANOIA
6864     for (vector<float>::const_iterator i = mus_timeAtIpInOut_.begin(); i != mus_timeAtIpInOut_.end(); ++i) {
6865     if (not isfinite(*i)) {
6866     printf("branch mus_timeAtIpInOut_branch contains a bad float: %f\n", *i);
6867     exit(1);
6868     }
6869     }
6870     #endif // #ifdef PARANOIA
6871     } else {
6872     printf("branch mus_timeAtIpInOut_branch does not exist!\n");
6873     exit(1);
6874     }
6875     mus_timeAtIpInOut_isLoaded = true;
6876     }
6877     return mus_timeAtIpInOut_;
6878     }
6879     vector<float> &mus_timeAtIpInOutErr()
6880     {
6881     if (not mus_timeAtIpInOutErr_isLoaded) {
6882     if (mus_timeAtIpInOutErr_branch != 0) {
6883     mus_timeAtIpInOutErr_branch->GetEntry(index);
6884     #ifdef PARANOIA
6885     for (vector<float>::const_iterator i = mus_timeAtIpInOutErr_.begin(); i != mus_timeAtIpInOutErr_.end(); ++i) {
6886     if (not isfinite(*i)) {
6887     printf("branch mus_timeAtIpInOutErr_branch contains a bad float: %f\n", *i);
6888     exit(1);
6889     }
6890     }
6891     #endif // #ifdef PARANOIA
6892     } else {
6893     printf("branch mus_timeAtIpInOutErr_branch does not exist!\n");
6894     exit(1);
6895     }
6896     mus_timeAtIpInOutErr_isLoaded = true;
6897     }
6898     return mus_timeAtIpInOutErr_;
6899     }
6900     vector<float> &mus_timeAtIpOutIn()
6901     {
6902     if (not mus_timeAtIpOutIn_isLoaded) {
6903     if (mus_timeAtIpOutIn_branch != 0) {
6904     mus_timeAtIpOutIn_branch->GetEntry(index);
6905     #ifdef PARANOIA
6906     for (vector<float>::const_iterator i = mus_timeAtIpOutIn_.begin(); i != mus_timeAtIpOutIn_.end(); ++i) {
6907     if (not isfinite(*i)) {
6908     printf("branch mus_timeAtIpOutIn_branch contains a bad float: %f\n", *i);
6909     exit(1);
6910     }
6911     }
6912     #endif // #ifdef PARANOIA
6913     } else {
6914     printf("branch mus_timeAtIpOutIn_branch does not exist!\n");
6915     exit(1);
6916     }
6917     mus_timeAtIpOutIn_isLoaded = true;
6918     }
6919     return mus_timeAtIpOutIn_;
6920     }
6921     vector<float> &mus_timeAtIpOutInErr()
6922     {
6923     if (not mus_timeAtIpOutInErr_isLoaded) {
6924     if (mus_timeAtIpOutInErr_branch != 0) {
6925     mus_timeAtIpOutInErr_branch->GetEntry(index);
6926     #ifdef PARANOIA
6927     for (vector<float>::const_iterator i = mus_timeAtIpOutInErr_.begin(); i != mus_timeAtIpOutInErr_.end(); ++i) {
6928     if (not isfinite(*i)) {
6929     printf("branch mus_timeAtIpOutInErr_branch contains a bad float: %f\n", *i);
6930     exit(1);
6931     }
6932     }
6933     #endif // #ifdef PARANOIA
6934     } else {
6935     printf("branch mus_timeAtIpOutInErr_branch does not exist!\n");
6936     exit(1);
6937     }
6938     mus_timeAtIpOutInErr_isLoaded = true;
6939     }
6940     return mus_timeAtIpOutInErr_;
6941     }
6942     vector<float> &mus_vertexphi()
6943     {
6944     if (not mus_vertexphi_isLoaded) {
6945     if (mus_vertexphi_branch != 0) {
6946     mus_vertexphi_branch->GetEntry(index);
6947     #ifdef PARANOIA
6948     for (vector<float>::const_iterator i = mus_vertexphi_.begin(); i != mus_vertexphi_.end(); ++i) {
6949     if (not isfinite(*i)) {
6950     printf("branch mus_vertexphi_branch contains a bad float: %f\n", *i);
6951     exit(1);
6952     }
6953     }
6954     #endif // #ifdef PARANOIA
6955     } else {
6956     printf("branch mus_vertexphi_branch does not exist!\n");
6957     exit(1);
6958     }
6959     mus_vertexphi_isLoaded = true;
6960     }
6961     return mus_vertexphi_;
6962     }
6963     vector<float> &mus_z0()
6964     {
6965     if (not mus_z0_isLoaded) {
6966     if (mus_z0_branch != 0) {
6967     mus_z0_branch->GetEntry(index);
6968     #ifdef PARANOIA
6969     for (vector<float>::const_iterator i = mus_z0_.begin(); i != mus_z0_.end(); ++i) {
6970     if (not isfinite(*i)) {
6971     printf("branch mus_z0_branch contains a bad float: %f\n", *i);
6972     exit(1);
6973     }
6974     }
6975     #endif // #ifdef PARANOIA
6976     } else {
6977     printf("branch mus_z0_branch does not exist!\n");
6978     exit(1);
6979     }
6980     mus_z0_isLoaded = true;
6981     }
6982     return mus_z0_;
6983     }
6984     vector<float> &mus_z0Err()
6985     {
6986     if (not mus_z0Err_isLoaded) {
6987     if (mus_z0Err_branch != 0) {
6988     mus_z0Err_branch->GetEntry(index);
6989     #ifdef PARANOIA
6990     for (vector<float>::const_iterator i = mus_z0Err_.begin(); i != mus_z0Err_.end(); ++i) {
6991     if (not isfinite(*i)) {
6992     printf("branch mus_z0Err_branch contains a bad float: %f\n", *i);
6993     exit(1);
6994     }
6995     }
6996     #endif // #ifdef PARANOIA
6997     } else {
6998     printf("branch mus_z0Err_branch does not exist!\n");
6999     exit(1);
7000     }
7001     mus_z0Err_isLoaded = true;
7002     }
7003     return mus_z0Err_;
7004     }
7005     vector<float> &mus_z0corr()
7006     {
7007     if (not mus_z0corr_isLoaded) {
7008     if (mus_z0corr_branch != 0) {
7009     mus_z0corr_branch->GetEntry(index);
7010     #ifdef PARANOIA
7011     for (vector<float>::const_iterator i = mus_z0corr_.begin(); i != mus_z0corr_.end(); ++i) {
7012     if (not isfinite(*i)) {
7013     printf("branch mus_z0corr_branch contains a bad float: %f\n", *i);
7014     exit(1);
7015     }
7016     }
7017     #endif // #ifdef PARANOIA
7018     } else {
7019     printf("branch mus_z0corr_branch does not exist!\n");
7020     exit(1);
7021     }
7022     mus_z0corr_isLoaded = true;
7023     }
7024     return mus_z0corr_;
7025     }
7026     vector<float> &scs_clustersSize()
7027     {
7028     if (not scs_clustersSize_isLoaded) {
7029     if (scs_clustersSize_branch != 0) {
7030     scs_clustersSize_branch->GetEntry(index);
7031     #ifdef PARANOIA
7032     for (vector<float>::const_iterator i = scs_clustersSize_.begin(); i != scs_clustersSize_.end(); ++i) {
7033     if (not isfinite(*i)) {
7034     printf("branch scs_clustersSize_branch contains a bad float: %f\n", *i);
7035     exit(1);
7036     }
7037     }
7038     #endif // #ifdef PARANOIA
7039     } else {
7040     printf("branch scs_clustersSize_branch does not exist!\n");
7041     exit(1);
7042     }
7043     scs_clustersSize_isLoaded = true;
7044     }
7045     return scs_clustersSize_;
7046     }
7047     vector<float> &scs_crystalsSize()
7048     {
7049     if (not scs_crystalsSize_isLoaded) {
7050     if (scs_crystalsSize_branch != 0) {
7051     scs_crystalsSize_branch->GetEntry(index);
7052     #ifdef PARANOIA
7053     for (vector<float>::const_iterator i = scs_crystalsSize_.begin(); i != scs_crystalsSize_.end(); ++i) {
7054     if (not isfinite(*i)) {
7055     printf("branch scs_crystalsSize_branch contains a bad float: %f\n", *i);
7056     exit(1);
7057     }
7058     }
7059     #endif // #ifdef PARANOIA
7060     } else {
7061     printf("branch scs_crystalsSize_branch does not exist!\n");
7062     exit(1);
7063     }
7064     scs_crystalsSize_isLoaded = true;
7065     }
7066     return scs_crystalsSize_;
7067     }
7068     vector<float> &scs_e1x3()
7069     {
7070     if (not scs_e1x3_isLoaded) {
7071     if (scs_e1x3_branch != 0) {
7072     scs_e1x3_branch->GetEntry(index);
7073     #ifdef PARANOIA
7074     for (vector<float>::const_iterator i = scs_e1x3_.begin(); i != scs_e1x3_.end(); ++i) {
7075     if (not isfinite(*i)) {
7076     printf("branch scs_e1x3_branch contains a bad float: %f\n", *i);
7077     exit(1);
7078     }
7079     }
7080     #endif // #ifdef PARANOIA
7081     } else {
7082     printf("branch scs_e1x3_branch does not exist!\n");
7083     exit(1);
7084     }
7085     scs_e1x3_isLoaded = true;
7086     }
7087     return scs_e1x3_;
7088     }
7089     vector<float> &scs_e1x5()
7090     {
7091     if (not scs_e1x5_isLoaded) {
7092     if (scs_e1x5_branch != 0) {
7093     scs_e1x5_branch->GetEntry(index);
7094     #ifdef PARANOIA
7095     for (vector<float>::const_iterator i = scs_e1x5_.begin(); i != scs_e1x5_.end(); ++i) {
7096     if (not isfinite(*i)) {
7097     printf("branch scs_e1x5_branch contains a bad float: %f\n", *i);
7098     exit(1);
7099     }
7100     }
7101     #endif // #ifdef PARANOIA
7102     } else {
7103     printf("branch scs_e1x5_branch does not exist!\n");
7104     exit(1);
7105     }
7106     scs_e1x5_isLoaded = true;
7107     }
7108     return scs_e1x5_;
7109     }
7110     vector<float> &scs_e2x2()
7111     {
7112     if (not scs_e2x2_isLoaded) {
7113     if (scs_e2x2_branch != 0) {
7114     scs_e2x2_branch->GetEntry(index);
7115     #ifdef PARANOIA
7116     for (vector<float>::const_iterator i = scs_e2x2_.begin(); i != scs_e2x2_.end(); ++i) {
7117     if (not isfinite(*i)) {
7118     printf("branch scs_e2x2_branch contains a bad float: %f\n", *i);
7119     exit(1);
7120     }
7121     }
7122     #endif // #ifdef PARANOIA
7123     } else {
7124     printf("branch scs_e2x2_branch does not exist!\n");
7125     exit(1);
7126     }
7127     scs_e2x2_isLoaded = true;
7128     }
7129     return scs_e2x2_;
7130     }
7131     vector<float> &scs_e2x5Max()
7132     {
7133     if (not scs_e2x5Max_isLoaded) {
7134     if (scs_e2x5Max_branch != 0) {
7135     scs_e2x5Max_branch->GetEntry(index);
7136     #ifdef PARANOIA
7137     for (vector<float>::const_iterator i = scs_e2x5Max_.begin(); i != scs_e2x5Max_.end(); ++i) {
7138     if (not isfinite(*i)) {
7139     printf("branch scs_e2x5Max_branch contains a bad float: %f\n", *i);
7140     exit(1);
7141     }
7142     }
7143     #endif // #ifdef PARANOIA
7144     } else {
7145     printf("branch scs_e2x5Max_branch does not exist!\n");
7146     exit(1);
7147     }
7148     scs_e2x5Max_isLoaded = true;
7149     }
7150     return scs_e2x5Max_;
7151     }
7152     vector<float> &scs_e3x1()
7153     {
7154     if (not scs_e3x1_isLoaded) {
7155     if (scs_e3x1_branch != 0) {
7156     scs_e3x1_branch->GetEntry(index);
7157     #ifdef PARANOIA
7158     for (vector<float>::const_iterator i = scs_e3x1_.begin(); i != scs_e3x1_.end(); ++i) {
7159     if (not isfinite(*i)) {
7160     printf("branch scs_e3x1_branch contains a bad float: %f\n", *i);
7161     exit(1);
7162     }
7163     }
7164     #endif // #ifdef PARANOIA
7165     } else {
7166     printf("branch scs_e3x1_branch does not exist!\n");
7167     exit(1);
7168     }
7169     scs_e3x1_isLoaded = true;
7170     }
7171     return scs_e3x1_;
7172     }
7173     vector<float> &scs_e3x2()
7174     {
7175     if (not scs_e3x2_isLoaded) {
7176     if (scs_e3x2_branch != 0) {
7177     scs_e3x2_branch->GetEntry(index);
7178     #ifdef PARANOIA
7179     for (vector<float>::const_iterator i = scs_e3x2_.begin(); i != scs_e3x2_.end(); ++i) {
7180     if (not isfinite(*i)) {
7181     printf("branch scs_e3x2_branch contains a bad float: %f\n", *i);
7182     exit(1);
7183     }
7184     }
7185     #endif // #ifdef PARANOIA
7186     } else {
7187     printf("branch scs_e3x2_branch does not exist!\n");
7188     exit(1);
7189     }
7190     scs_e3x2_isLoaded = true;
7191     }
7192     return scs_e3x2_;
7193     }
7194     vector<float> &scs_e3x3()
7195     {
7196     if (not scs_e3x3_isLoaded) {
7197     if (scs_e3x3_branch != 0) {
7198     scs_e3x3_branch->GetEntry(index);
7199     #ifdef PARANOIA
7200     for (vector<float>::const_iterator i = scs_e3x3_.begin(); i != scs_e3x3_.end(); ++i) {
7201     if (not isfinite(*i)) {
7202     printf("branch scs_e3x3_branch contains a bad float: %f\n", *i);
7203     exit(1);
7204     }
7205     }
7206     #endif // #ifdef PARANOIA
7207     } else {
7208     printf("branch scs_e3x3_branch does not exist!\n");
7209     exit(1);
7210     }
7211     scs_e3x3_isLoaded = true;
7212     }
7213     return scs_e3x3_;
7214     }
7215     vector<float> &scs_e4x4()
7216     {
7217     if (not scs_e4x4_isLoaded) {
7218     if (scs_e4x4_branch != 0) {
7219     scs_e4x4_branch->GetEntry(index);
7220     #ifdef PARANOIA
7221     for (vector<float>::const_iterator i = scs_e4x4_.begin(); i != scs_e4x4_.end(); ++i) {
7222     if (not isfinite(*i)) {
7223     printf("branch scs_e4x4_branch contains a bad float: %f\n", *i);
7224     exit(1);
7225     }
7226     }
7227     #endif // #ifdef PARANOIA
7228     } else {
7229     printf("branch scs_e4x4_branch does not exist!\n");
7230     exit(1);
7231     }
7232     scs_e4x4_isLoaded = true;
7233     }
7234     return scs_e4x4_;
7235     }
7236     vector<float> &scs_e5x5()
7237     {
7238     if (not scs_e5x5_isLoaded) {
7239     if (scs_e5x5_branch != 0) {
7240     scs_e5x5_branch->GetEntry(index);
7241     #ifdef PARANOIA
7242     for (vector<float>::const_iterator i = scs_e5x5_.begin(); i != scs_e5x5_.end(); ++i) {
7243     if (not isfinite(*i)) {
7244     printf("branch scs_e5x5_branch contains a bad float: %f\n", *i);
7245     exit(1);
7246     }
7247     }
7248     #endif // #ifdef PARANOIA
7249     } else {
7250     printf("branch scs_e5x5_branch does not exist!\n");
7251     exit(1);
7252     }
7253     scs_e5x5_isLoaded = true;
7254     }
7255     return scs_e5x5_;
7256     }
7257     vector<float> &scs_energy()
7258     {
7259     if (not scs_energy_isLoaded) {
7260     if (scs_energy_branch != 0) {
7261     scs_energy_branch->GetEntry(index);
7262     #ifdef PARANOIA
7263     for (vector<float>::const_iterator i = scs_energy_.begin(); i != scs_energy_.end(); ++i) {
7264     if (not isfinite(*i)) {
7265     printf("branch scs_energy_branch contains a bad float: %f\n", *i);
7266     exit(1);
7267     }
7268     }
7269     #endif // #ifdef PARANOIA
7270     } else {
7271     printf("branch scs_energy_branch does not exist!\n");
7272     exit(1);
7273     }
7274     scs_energy_isLoaded = true;
7275     }
7276     return scs_energy_;
7277     }
7278     vector<float> &scs_eta()
7279     {
7280     if (not scs_eta_isLoaded) {
7281     if (scs_eta_branch != 0) {
7282     scs_eta_branch->GetEntry(index);
7283     #ifdef PARANOIA
7284     for (vector<float>::const_iterator i = scs_eta_.begin(); i != scs_eta_.end(); ++i) {
7285     if (not isfinite(*i)) {
7286     printf("branch scs_eta_branch contains a bad float: %f\n", *i);
7287     exit(1);
7288     }
7289     }
7290     #endif // #ifdef PARANOIA
7291     } else {
7292     printf("branch scs_eta_branch does not exist!\n");
7293     exit(1);
7294     }
7295     scs_eta_isLoaded = true;
7296     }
7297     return scs_eta_;
7298     }
7299     vector<float> &scs_hoe()
7300     {
7301     if (not scs_hoe_isLoaded) {
7302     if (scs_hoe_branch != 0) {
7303     scs_hoe_branch->GetEntry(index);
7304     #ifdef PARANOIA
7305     for (vector<float>::const_iterator i = scs_hoe_.begin(); i != scs_hoe_.end(); ++i) {
7306     if (not isfinite(*i)) {
7307     printf("branch scs_hoe_branch contains a bad float: %f\n", *i);
7308     exit(1);
7309     }
7310     }
7311     #endif // #ifdef PARANOIA
7312     } else {
7313     printf("branch scs_hoe_branch does not exist!\n");
7314     exit(1);
7315     }
7316     scs_hoe_isLoaded = true;
7317     }
7318     return scs_hoe_;
7319     }
7320     vector<float> &scs_phi()
7321     {
7322     if (not scs_phi_isLoaded) {
7323     if (scs_phi_branch != 0) {
7324     scs_phi_branch->GetEntry(index);
7325     #ifdef PARANOIA
7326     for (vector<float>::const_iterator i = scs_phi_.begin(); i != scs_phi_.end(); ++i) {
7327     if (not isfinite(*i)) {
7328     printf("branch scs_phi_branch contains a bad float: %f\n", *i);
7329     exit(1);
7330     }
7331     }
7332     #endif // #ifdef PARANOIA
7333     } else {
7334     printf("branch scs_phi_branch does not exist!\n");
7335     exit(1);
7336     }
7337     scs_phi_isLoaded = true;
7338     }
7339     return scs_phi_;
7340     }
7341     vector<float> &scs_preshowerEnergy()
7342     {
7343     if (not scs_preshowerEnergy_isLoaded) {
7344     if (scs_preshowerEnergy_branch != 0) {
7345     scs_preshowerEnergy_branch->GetEntry(index);
7346     #ifdef PARANOIA
7347     for (vector<float>::const_iterator i = scs_preshowerEnergy_.begin(); i != scs_preshowerEnergy_.end(); ++i) {
7348     if (not isfinite(*i)) {
7349     printf("branch scs_preshowerEnergy_branch contains a bad float: %f\n", *i);
7350     exit(1);
7351     }
7352     }
7353     #endif // #ifdef PARANOIA
7354     } else {
7355     printf("branch scs_preshowerEnergy_branch does not exist!\n");
7356     exit(1);
7357     }
7358     scs_preshowerEnergy_isLoaded = true;
7359     }
7360     return scs_preshowerEnergy_;
7361     }
7362     vector<float> &scs_rawEnergy()
7363     {
7364     if (not scs_rawEnergy_isLoaded) {
7365     if (scs_rawEnergy_branch != 0) {
7366     scs_rawEnergy_branch->GetEntry(index);
7367     #ifdef PARANOIA
7368     for (vector<float>::const_iterator i = scs_rawEnergy_.begin(); i != scs_rawEnergy_.end(); ++i) {
7369     if (not isfinite(*i)) {
7370     printf("branch scs_rawEnergy_branch contains a bad float: %f\n", *i);
7371     exit(1);
7372     }
7373     }
7374     #endif // #ifdef PARANOIA
7375     } else {
7376     printf("branch scs_rawEnergy_branch does not exist!\n");
7377     exit(1);
7378     }
7379     scs_rawEnergy_isLoaded = true;
7380     }
7381     return scs_rawEnergy_;
7382     }
7383     vector<float> &scs_sigmaEtaEta()
7384     {
7385     if (not scs_sigmaEtaEta_isLoaded) {
7386     if (scs_sigmaEtaEta_branch != 0) {
7387     scs_sigmaEtaEta_branch->GetEntry(index);
7388     #ifdef PARANOIA
7389     for (vector<float>::const_iterator i = scs_sigmaEtaEta_.begin(); i != scs_sigmaEtaEta_.end(); ++i) {
7390     if (not isfinite(*i)) {
7391     printf("branch scs_sigmaEtaEta_branch contains a bad float: %f\n", *i);
7392     exit(1);
7393     }
7394     }
7395     #endif // #ifdef PARANOIA
7396     } else {
7397     printf("branch scs_sigmaEtaEta_branch does not exist!\n");
7398     exit(1);
7399     }
7400     scs_sigmaEtaEta_isLoaded = true;
7401     }
7402     return scs_sigmaEtaEta_;
7403     }
7404     vector<float> &scs_sigmaEtaPhi()
7405     {
7406     if (not scs_sigmaEtaPhi_isLoaded) {
7407     if (scs_sigmaEtaPhi_branch != 0) {
7408     scs_sigmaEtaPhi_branch->GetEntry(index);
7409     #ifdef PARANOIA
7410     for (vector<float>::const_iterator i = scs_sigmaEtaPhi_.begin(); i != scs_sigmaEtaPhi_.end(); ++i) {
7411     if (not isfinite(*i)) {
7412     printf("branch scs_sigmaEtaPhi_branch contains a bad float: %f\n", *i);
7413     exit(1);
7414     }
7415     }
7416     #endif // #ifdef PARANOIA
7417     } else {
7418     printf("branch scs_sigmaEtaPhi_branch does not exist!\n");
7419     exit(1);
7420     }
7421     scs_sigmaEtaPhi_isLoaded = true;
7422     }
7423     return scs_sigmaEtaPhi_;
7424     }
7425     vector<float> &scs_sigmaIEtaIEta()
7426     {
7427     if (not scs_sigmaIEtaIEta_isLoaded) {
7428     if (scs_sigmaIEtaIEta_branch != 0) {
7429     scs_sigmaIEtaIEta_branch->GetEntry(index);
7430     #ifdef PARANOIA
7431     for (vector<float>::const_iterator i = scs_sigmaIEtaIEta_.begin(); i != scs_sigmaIEtaIEta_.end(); ++i) {
7432     if (not isfinite(*i)) {
7433     printf("branch scs_sigmaIEtaIEta_branch contains a bad float: %f\n", *i);
7434     exit(1);
7435     }
7436     }
7437     #endif // #ifdef PARANOIA
7438     } else {
7439     printf("branch scs_sigmaIEtaIEta_branch does not exist!\n");
7440     exit(1);
7441     }
7442     scs_sigmaIEtaIEta_isLoaded = true;
7443     }
7444     return scs_sigmaIEtaIEta_;
7445     }
7446     vector<float> &scs_sigmaIEtaIPhi()
7447     {
7448     if (not scs_sigmaIEtaIPhi_isLoaded) {
7449     if (scs_sigmaIEtaIPhi_branch != 0) {
7450     scs_sigmaIEtaIPhi_branch->GetEntry(index);
7451     #ifdef PARANOIA
7452     for (vector<float>::const_iterator i = scs_sigmaIEtaIPhi_.begin(); i != scs_sigmaIEtaIPhi_.end(); ++i) {
7453     if (not isfinite(*i)) {
7454     printf("branch scs_sigmaIEtaIPhi_branch contains a bad float: %f\n", *i);
7455     exit(1);
7456     }
7457     }
7458     #endif // #ifdef PARANOIA
7459     } else {
7460     printf("branch scs_sigmaIEtaIPhi_branch does not exist!\n");
7461     exit(1);
7462     }
7463     scs_sigmaIEtaIPhi_isLoaded = true;
7464     }
7465     return scs_sigmaIEtaIPhi_;
7466     }
7467     vector<float> &scs_sigmaIPhiIPhi()
7468     {
7469     if (not scs_sigmaIPhiIPhi_isLoaded) {
7470     if (scs_sigmaIPhiIPhi_branch != 0) {
7471     scs_sigmaIPhiIPhi_branch->GetEntry(index);
7472     #ifdef PARANOIA
7473     for (vector<float>::const_iterator i = scs_sigmaIPhiIPhi_.begin(); i != scs_sigmaIPhiIPhi_.end(); ++i) {
7474     if (not isfinite(*i)) {
7475     printf("branch scs_sigmaIPhiIPhi_branch contains a bad float: %f\n", *i);
7476     exit(1);
7477     }
7478     }
7479     #endif // #ifdef PARANOIA
7480     } else {
7481     printf("branch scs_sigmaIPhiIPhi_branch does not exist!\n");
7482     exit(1);
7483     }
7484     scs_sigmaIPhiIPhi_isLoaded = true;
7485     }
7486     return scs_sigmaIPhiIPhi_;
7487     }
7488     vector<float> &scs_sigmaPhiPhi()
7489     {
7490     if (not scs_sigmaPhiPhi_isLoaded) {
7491     if (scs_sigmaPhiPhi_branch != 0) {
7492     scs_sigmaPhiPhi_branch->GetEntry(index);
7493     #ifdef PARANOIA
7494     for (vector<float>::const_iterator i = scs_sigmaPhiPhi_.begin(); i != scs_sigmaPhiPhi_.end(); ++i) {
7495     if (not isfinite(*i)) {
7496     printf("branch scs_sigmaPhiPhi_branch contains a bad float: %f\n", *i);
7497     exit(1);
7498     }
7499     }
7500     #endif // #ifdef PARANOIA
7501     } else {
7502     printf("branch scs_sigmaPhiPhi_branch does not exist!\n");
7503     exit(1);
7504     }
7505     scs_sigmaPhiPhi_isLoaded = true;
7506     }
7507     return scs_sigmaPhiPhi_;
7508     }
7509     vector<float> &trks_chi2()
7510     {
7511     if (not trks_chi2_isLoaded) {
7512     if (trks_chi2_branch != 0) {
7513     trks_chi2_branch->GetEntry(index);
7514     #ifdef PARANOIA
7515     for (vector<float>::const_iterator i = trks_chi2_.begin(); i != trks_chi2_.end(); ++i) {
7516     if (not isfinite(*i)) {
7517     printf("branch trks_chi2_branch contains a bad float: %f\n", *i);
7518     exit(1);
7519     }
7520     }
7521     #endif // #ifdef PARANOIA
7522     } else {
7523     printf("branch trks_chi2_branch does not exist!\n");
7524     exit(1);
7525     }
7526     trks_chi2_isLoaded = true;
7527     }
7528     return trks_chi2_;
7529     }
7530     vector<float> &trks_d0()
7531     {
7532     if (not trks_d0_isLoaded) {
7533     if (trks_d0_branch != 0) {
7534     trks_d0_branch->GetEntry(index);
7535     #ifdef PARANOIA
7536     for (vector<float>::const_iterator i = trks_d0_.begin(); i != trks_d0_.end(); ++i) {
7537     if (not isfinite(*i)) {
7538     printf("branch trks_d0_branch contains a bad float: %f\n", *i);
7539     exit(1);
7540     }
7541     }
7542     #endif // #ifdef PARANOIA
7543     } else {
7544     printf("branch trks_d0_branch does not exist!\n");
7545     exit(1);
7546     }
7547     trks_d0_isLoaded = true;
7548     }
7549     return trks_d0_;
7550     }
7551     vector<float> &trks_d0Err()
7552     {
7553     if (not trks_d0Err_isLoaded) {
7554     if (trks_d0Err_branch != 0) {
7555     trks_d0Err_branch->GetEntry(index);
7556     #ifdef PARANOIA
7557     for (vector<float>::const_iterator i = trks_d0Err_.begin(); i != trks_d0Err_.end(); ++i) {
7558     if (not isfinite(*i)) {
7559     printf("branch trks_d0Err_branch contains a bad float: %f\n", *i);
7560     exit(1);
7561     }
7562     }
7563     #endif // #ifdef PARANOIA
7564     } else {
7565     printf("branch trks_d0Err_branch does not exist!\n");
7566     exit(1);
7567     }
7568     trks_d0Err_isLoaded = true;
7569     }
7570     return trks_d0Err_;
7571     }
7572     vector<float> &trks_d0corr()
7573     {
7574     if (not trks_d0corr_isLoaded) {
7575     if (trks_d0corr_branch != 0) {
7576     trks_d0corr_branch->GetEntry(index);
7577     #ifdef PARANOIA
7578     for (vector<float>::const_iterator i = trks_d0corr_.begin(); i != trks_d0corr_.end(); ++i) {
7579     if (not isfinite(*i)) {
7580     printf("branch trks_d0corr_branch contains a bad float: %f\n", *i);
7581     exit(1);
7582     }
7583     }
7584     #endif // #ifdef PARANOIA
7585     } else {
7586     printf("branch trks_d0corr_branch does not exist!\n");
7587     exit(1);
7588     }
7589     trks_d0corr_isLoaded = true;
7590     }
7591     return trks_d0corr_;
7592     }
7593     vector<float> &trks_d0corrPhi()
7594     {
7595     if (not trks_d0corrPhi_isLoaded) {
7596     if (trks_d0corrPhi_branch != 0) {
7597     trks_d0corrPhi_branch->GetEntry(index);
7598     #ifdef PARANOIA
7599     for (vector<float>::const_iterator i = trks_d0corrPhi_.begin(); i != trks_d0corrPhi_.end(); ++i) {
7600     if (not isfinite(*i)) {
7601     printf("branch trks_d0corrPhi_branch contains a bad float: %f\n", *i);
7602     exit(1);
7603     }
7604     }
7605     #endif // #ifdef PARANOIA
7606     } else {
7607     printf("branch trks_d0corrPhi_branch does not exist!\n");
7608     exit(1);
7609     }
7610     trks_d0corrPhi_isLoaded = true;
7611     }
7612     return trks_d0corrPhi_;
7613     }
7614     vector<float> &trks_etaErr()
7615     {
7616     if (not trks_etaErr_isLoaded) {
7617     if (trks_etaErr_branch != 0) {
7618     trks_etaErr_branch->GetEntry(index);
7619     #ifdef PARANOIA
7620     for (vector<float>::const_iterator i = trks_etaErr_.begin(); i != trks_etaErr_.end(); ++i) {
7621     if (not isfinite(*i)) {
7622     printf("branch trks_etaErr_branch contains a bad float: %f\n", *i);
7623     exit(1);
7624     }
7625     }
7626     #endif // #ifdef PARANOIA
7627     } else {
7628     printf("branch trks_etaErr_branch does not exist!\n");
7629     exit(1);
7630     }
7631     trks_etaErr_isLoaded = true;
7632     }
7633     return trks_etaErr_;
7634     }
7635     vector<float> &trks_ndof()
7636     {
7637     if (not trks_ndof_isLoaded) {
7638     if (trks_ndof_branch != 0) {
7639     trks_ndof_branch->GetEntry(index);
7640     #ifdef PARANOIA
7641     for (vector<float>::const_iterator i = trks_ndof_.begin(); i != trks_ndof_.end(); ++i) {
7642     if (not isfinite(*i)) {
7643     printf("branch trks_ndof_branch contains a bad float: %f\n", *i);
7644     exit(1);
7645     }
7646     }
7647     #endif // #ifdef PARANOIA
7648     } else {
7649     printf("branch trks_ndof_branch does not exist!\n");
7650     exit(1);
7651     }
7652     trks_ndof_isLoaded = true;
7653     }
7654     return trks_ndof_;
7655     }
7656     vector<float> &trks_phiErr()
7657     {
7658     if (not trks_phiErr_isLoaded) {
7659     if (trks_phiErr_branch != 0) {
7660     trks_phiErr_branch->GetEntry(index);
7661     #ifdef PARANOIA
7662     for (vector<float>::const_iterator i = trks_phiErr_.begin(); i != trks_phiErr_.end(); ++i) {
7663     if (not isfinite(*i)) {
7664     printf("branch trks_phiErr_branch contains a bad float: %f\n", *i);
7665     exit(1);
7666     }
7667     }
7668     #endif // #ifdef PARANOIA
7669     } else {
7670     printf("branch trks_phiErr_branch does not exist!\n");
7671     exit(1);
7672     }
7673     trks_phiErr_isLoaded = true;
7674     }
7675     return trks_phiErr_;
7676     }
7677     vector<float> &trks_ptErr()
7678     {
7679     if (not trks_ptErr_isLoaded) {
7680     if (trks_ptErr_branch != 0) {
7681     trks_ptErr_branch->GetEntry(index);
7682     #ifdef PARANOIA
7683     for (vector<float>::const_iterator i = trks_ptErr_.begin(); i != trks_ptErr_.end(); ++i) {
7684     if (not isfinite(*i)) {
7685     printf("branch trks_ptErr_branch contains a bad float: %f\n", *i);
7686     exit(1);
7687     }
7688     }
7689     #endif // #ifdef PARANOIA
7690     } else {
7691     printf("branch trks_ptErr_branch does not exist!\n");
7692     exit(1);
7693     }
7694     trks_ptErr_isLoaded = true;
7695     }
7696     return trks_ptErr_;
7697     }
7698     vector<float> &trks_tkIso()
7699     {
7700     if (not trks_tkIso_isLoaded) {
7701     if (trks_tkIso_branch != 0) {
7702     trks_tkIso_branch->GetEntry(index);
7703     #ifdef PARANOIA
7704     for (vector<float>::const_iterator i = trks_tkIso_.begin(); i != trks_tkIso_.end(); ++i) {
7705     if (not isfinite(*i)) {
7706     printf("branch trks_tkIso_branch contains a bad float: %f\n", *i);
7707     exit(1);
7708     }
7709     }
7710     #endif // #ifdef PARANOIA
7711     } else {
7712     printf("branch trks_tkIso_branch does not exist!\n");
7713     exit(1);
7714     }
7715     trks_tkIso_isLoaded = true;
7716     }
7717     return trks_tkIso_;
7718     }
7719     vector<float> &trks_vertexphi()
7720     {
7721     if (not trks_vertexphi_isLoaded) {
7722     if (trks_vertexphi_branch != 0) {
7723     trks_vertexphi_branch->GetEntry(index);
7724     #ifdef PARANOIA
7725     for (vector<float>::const_iterator i = trks_vertexphi_.begin(); i != trks_vertexphi_.end(); ++i) {
7726     if (not isfinite(*i)) {
7727     printf("branch trks_vertexphi_branch contains a bad float: %f\n", *i);
7728     exit(1);
7729     }
7730     }
7731     #endif // #ifdef PARANOIA
7732     } else {
7733     printf("branch trks_vertexphi_branch does not exist!\n");
7734     exit(1);
7735     }
7736     trks_vertexphi_isLoaded = true;
7737     }
7738     return trks_vertexphi_;
7739     }
7740     vector<float> &trks_z0()
7741     {
7742     if (not trks_z0_isLoaded) {
7743     if (trks_z0_branch != 0) {
7744     trks_z0_branch->GetEntry(index);
7745     #ifdef PARANOIA
7746     for (vector<float>::const_iterator i = trks_z0_.begin(); i != trks_z0_.end(); ++i) {
7747     if (not isfinite(*i)) {
7748     printf("branch trks_z0_branch contains a bad float: %f\n", *i);
7749     exit(1);
7750     }
7751     }
7752     #endif // #ifdef PARANOIA
7753     } else {
7754     printf("branch trks_z0_branch does not exist!\n");
7755     exit(1);
7756     }
7757     trks_z0_isLoaded = true;
7758     }
7759     return trks_z0_;
7760     }
7761     vector<float> &trks_z0Err()
7762     {
7763     if (not trks_z0Err_isLoaded) {
7764     if (trks_z0Err_branch != 0) {
7765     trks_z0Err_branch->GetEntry(index);
7766     #ifdef PARANOIA
7767     for (vector<float>::const_iterator i = trks_z0Err_.begin(); i != trks_z0Err_.end(); ++i) {
7768     if (not isfinite(*i)) {
7769     printf("branch trks_z0Err_branch contains a bad float: %f\n", *i);
7770     exit(1);
7771     }
7772     }
7773     #endif // #ifdef PARANOIA
7774     } else {
7775     printf("branch trks_z0Err_branch does not exist!\n");
7776     exit(1);
7777     }
7778     trks_z0Err_isLoaded = true;
7779     }
7780     return trks_z0Err_;
7781     }
7782     vector<float> &trks_z0corr()
7783     {
7784     if (not trks_z0corr_isLoaded) {
7785     if (trks_z0corr_branch != 0) {
7786     trks_z0corr_branch->GetEntry(index);
7787     #ifdef PARANOIA
7788     for (vector<float>::const_iterator i = trks_z0corr_.begin(); i != trks_z0corr_.end(); ++i) {
7789     if (not isfinite(*i)) {
7790     printf("branch trks_z0corr_branch contains a bad float: %f\n", *i);
7791     exit(1);
7792     }
7793     }
7794     #endif // #ifdef PARANOIA
7795     } else {
7796     printf("branch trks_z0corr_branch does not exist!\n");
7797     exit(1);
7798     }
7799     trks_z0corr_isLoaded = true;
7800     }
7801     return trks_z0corr_;
7802     }
7803     vector<float> &trks_elsdr()
7804     {
7805     if (not trks_elsdr_isLoaded) {
7806     if (trks_elsdr_branch != 0) {
7807     trks_elsdr_branch->GetEntry(index);
7808     #ifdef PARANOIA
7809     for (vector<float>::const_iterator i = trks_elsdr_.begin(); i != trks_elsdr_.end(); ++i) {
7810     if (not isfinite(*i)) {
7811     printf("branch trks_elsdr_branch contains a bad float: %f\n", *i);
7812     exit(1);
7813     }
7814     }
7815     #endif // #ifdef PARANOIA
7816     } else {
7817     printf("branch trks_elsdr_branch does not exist!\n");
7818     exit(1);
7819     }
7820     trks_elsdr_isLoaded = true;
7821     }
7822     return trks_elsdr_;
7823     }
7824     vector<float> &trks_elsshFrac()
7825     {
7826     if (not trks_elsshFrac_isLoaded) {
7827     if (trks_elsshFrac_branch != 0) {
7828     trks_elsshFrac_branch->GetEntry(index);
7829     #ifdef PARANOIA
7830     for (vector<float>::const_iterator i = trks_elsshFrac_.begin(); i != trks_elsshFrac_.end(); ++i) {
7831     if (not isfinite(*i)) {
7832     printf("branch trks_elsshFrac_branch contains a bad float: %f\n", *i);
7833     exit(1);
7834     }
7835     }
7836     #endif // #ifdef PARANOIA
7837     } else {
7838     printf("branch trks_elsshFrac_branch does not exist!\n");
7839     exit(1);
7840     }
7841     trks_elsshFrac_isLoaded = true;
7842     }
7843     return trks_elsshFrac_;
7844     }
7845     vector<float> &vtxs_chi2()
7846     {
7847     if (not vtxs_chi2_isLoaded) {
7848     if (vtxs_chi2_branch != 0) {
7849     vtxs_chi2_branch->GetEntry(index);
7850     #ifdef PARANOIA
7851     for (vector<float>::const_iterator i = vtxs_chi2_.begin(); i != vtxs_chi2_.end(); ++i) {
7852     if (not isfinite(*i)) {
7853     printf("branch vtxs_chi2_branch contains a bad float: %f\n", *i);
7854     exit(1);
7855     }
7856     }
7857     #endif // #ifdef PARANOIA
7858     } else {
7859     printf("branch vtxs_chi2_branch does not exist!\n");
7860     exit(1);
7861     }
7862     vtxs_chi2_isLoaded = true;
7863     }
7864     return vtxs_chi2_;
7865     }
7866     vector<float> &vtxs_ndof()
7867     {
7868     if (not vtxs_ndof_isLoaded) {
7869     if (vtxs_ndof_branch != 0) {
7870     vtxs_ndof_branch->GetEntry(index);
7871     #ifdef PARANOIA
7872     for (vector<float>::const_iterator i = vtxs_ndof_.begin(); i != vtxs_ndof_.end(); ++i) {
7873     if (not isfinite(*i)) {
7874     printf("branch vtxs_ndof_branch contains a bad float: %f\n", *i);
7875     exit(1);
7876     }
7877     }
7878     #endif // #ifdef PARANOIA
7879     } else {
7880     printf("branch vtxs_ndof_branch does not exist!\n");
7881     exit(1);
7882     }
7883     vtxs_ndof_isLoaded = true;
7884     }
7885     return vtxs_ndof_;
7886     }
7887     vector<float> &vtxs_xError()
7888     {
7889     if (not vtxs_xError_isLoaded) {
7890     if (vtxs_xError_branch != 0) {
7891     vtxs_xError_branch->GetEntry(index);
7892     #ifdef PARANOIA
7893     for (vector<float>::const_iterator i = vtxs_xError_.begin(); i != vtxs_xError_.end(); ++i) {
7894     if (not isfinite(*i)) {
7895     printf("branch vtxs_xError_branch contains a bad float: %f\n", *i);
7896     exit(1);
7897     }
7898     }
7899     #endif // #ifdef PARANOIA
7900     } else {
7901     printf("branch vtxs_xError_branch does not exist!\n");
7902     exit(1);
7903     }
7904     vtxs_xError_isLoaded = true;
7905     }
7906     return vtxs_xError_;
7907     }
7908     vector<float> &vtxs_yError()
7909     {
7910     if (not vtxs_yError_isLoaded) {
7911     if (vtxs_yError_branch != 0) {
7912     vtxs_yError_branch->GetEntry(index);
7913     #ifdef PARANOIA
7914     for (vector<float>::const_iterator i = vtxs_yError_.begin(); i != vtxs_yError_.end(); ++i) {
7915     if (not isfinite(*i)) {
7916     printf("branch vtxs_yError_branch contains a bad float: %f\n", *i);
7917     exit(1);
7918     }
7919     }
7920     #endif // #ifdef PARANOIA
7921     } else {
7922     printf("branch vtxs_yError_branch does not exist!\n");
7923     exit(1);
7924     }
7925     vtxs_yError_isLoaded = true;
7926     }
7927     return vtxs_yError_;
7928     }
7929     vector<float> &vtxs_zError()
7930     {
7931     if (not vtxs_zError_isLoaded) {
7932     if (vtxs_zError_branch != 0) {
7933     vtxs_zError_branch->GetEntry(index);
7934     #ifdef PARANOIA
7935     for (vector<float>::const_iterator i = vtxs_zError_.begin(); i != vtxs_zError_.end(); ++i) {
7936     if (not isfinite(*i)) {
7937     printf("branch vtxs_zError_branch contains a bad float: %f\n", *i);
7938     exit(1);
7939     }
7940     }
7941     #endif // #ifdef PARANOIA
7942     } else {
7943     printf("branch vtxs_zError_branch does not exist!\n");
7944     exit(1);
7945     }
7946     vtxs_zError_isLoaded = true;
7947     }
7948     return vtxs_zError_;
7949     }
7950     vector<vector<float> > &trks_residualX()
7951     {
7952     if (not trks_residualX_isLoaded) {
7953     if (trks_residualX_branch != 0) {
7954     trks_residualX_branch->GetEntry(index);
7955     #ifdef PARANOIA
7956     for (vector<vector<float> >::const_iterator i = trks_residualX_.begin(); i != trks_residualX_.end(); ++i) {
7957     for (vector<float>::const_iterator j = i->begin(); j != i->end(); ++j) {
7958     if (not isfinite(*j)) {
7959     printf("branch trks_residualX_branch contains a bad float: %f\n", *j);
7960     exit(1);
7961     }
7962     }
7963     }
7964     #endif // #ifdef PARANOIA
7965     } else {
7966     printf("branch trks_residualX_branch does not exist!\n");
7967     exit(1);
7968     }
7969     trks_residualX_isLoaded = true;
7970     }
7971     return trks_residualX_;
7972     }
7973     vector<vector<float> > &trks_residualY()
7974     {
7975     if (not trks_residualY_isLoaded) {
7976     if (trks_residualY_branch != 0) {
7977     trks_residualY_branch->GetEntry(index);
7978     #ifdef PARANOIA
7979     for (vector<vector<float> >::const_iterator i = trks_residualY_.begin(); i != trks_residualY_.end(); ++i) {
7980     for (vector<float>::const_iterator j = i->begin(); j != i->end(); ++j) {
7981     if (not isfinite(*j)) {
7982     printf("branch trks_residualY_branch contains a bad float: %f\n", *j);
7983     exit(1);
7984     }
7985     }
7986     }
7987     #endif // #ifdef PARANOIA
7988     } else {
7989     printf("branch trks_residualY_branch does not exist!\n");
7990     exit(1);
7991     }
7992     trks_residualY_isLoaded = true;
7993     }
7994     return trks_residualY_;
7995     }
7996     vector<vector<float> > &vtxs_covMatrix()
7997     {
7998     if (not vtxs_covMatrix_isLoaded) {
7999     if (vtxs_covMatrix_branch != 0) {
8000     vtxs_covMatrix_branch->GetEntry(index);
8001     #ifdef PARANOIA
8002     for (vector<vector<float> >::const_iterator i = vtxs_covMatrix_.begin(); i != vtxs_covMatrix_.end(); ++i) {
8003     for (vector<float>::const_iterator j = i->begin(); j != i->end(); ++j) {
8004     if (not isfinite(*j)) {
8005     printf("branch vtxs_covMatrix_branch contains a bad float: %f\n", *j);
8006     exit(1);
8007     }
8008     }
8009     }
8010     #endif // #ifdef PARANOIA
8011     } else {
8012     printf("branch vtxs_covMatrix_branch does not exist!\n");
8013     exit(1);
8014     }
8015     vtxs_covMatrix_isLoaded = true;
8016     }
8017     return vtxs_covMatrix_;
8018     }
8019     int &evt_bsType()
8020     {
8021     if (not evt_bsType_isLoaded) {
8022     if (evt_bsType_branch != 0) {
8023     evt_bsType_branch->GetEntry(index);
8024     #ifdef PARANOIA
8025     #endif // #ifdef PARANOIA
8026     } else {
8027     printf("branch evt_bsType_branch does not exist!\n");
8028     exit(1);
8029     }
8030     evt_bsType_isLoaded = true;
8031     }
8032     return evt_bsType_;
8033     }
8034     vector<int> &els_category()
8035     {
8036     if (not els_category_isLoaded) {
8037     if (els_category_branch != 0) {
8038     els_category_branch->GetEntry(index);
8039     #ifdef PARANOIA
8040     #endif // #ifdef PARANOIA
8041     } else {
8042     printf("branch els_category_branch does not exist!\n");
8043     exit(1);
8044     }
8045     els_category_isLoaded = true;
8046     }
8047     return els_category_;
8048     }
8049     vector<int> &els_charge()
8050     {
8051     if (not els_charge_isLoaded) {
8052     if (els_charge_branch != 0) {
8053     els_charge_branch->GetEntry(index);
8054     #ifdef PARANOIA
8055     #endif // #ifdef PARANOIA
8056     } else {
8057     printf("branch els_charge_branch does not exist!\n");
8058     exit(1);
8059     }
8060     els_charge_isLoaded = true;
8061     }
8062     return els_charge_;
8063     }
8064     vector<int> &els_class()
8065     {
8066     if (not els_class_isLoaded) {
8067     if (els_class_branch != 0) {
8068     els_class_branch->GetEntry(index);
8069     #ifdef PARANOIA
8070     #endif // #ifdef PARANOIA
8071     } else {
8072     printf("branch els_class_branch does not exist!\n");
8073     exit(1);
8074     }
8075     els_class_isLoaded = true;
8076     }
8077     return els_class_;
8078     }
8079     vector<int> &els_fiduciality()
8080     {
8081     if (not els_fiduciality_isLoaded) {
8082     if (els_fiduciality_branch != 0) {
8083     els_fiduciality_branch->GetEntry(index);
8084     #ifdef PARANOIA
8085     #endif // #ifdef PARANOIA
8086     } else {
8087     printf("branch els_fiduciality_branch does not exist!\n");
8088     exit(1);
8089     }
8090     els_fiduciality_isLoaded = true;
8091     }
8092     return els_fiduciality_;
8093     }
8094     vector<int> &els_layer1_det()
8095     {
8096     if (not els_layer1_det_isLoaded) {
8097     if (els_layer1_det_branch != 0) {
8098     els_layer1_det_branch->GetEntry(index);
8099     #ifdef PARANOIA
8100     #endif // #ifdef PARANOIA
8101     } else {
8102     printf("branch els_layer1_det_branch does not exist!\n");
8103     exit(1);
8104     }
8105     els_layer1_det_isLoaded = true;
8106     }
8107     return els_layer1_det_;
8108     }
8109     vector<int> &els_layer1_layer()
8110     {
8111     if (not els_layer1_layer_isLoaded) {
8112     if (els_layer1_layer_branch != 0) {
8113     els_layer1_layer_branch->GetEntry(index);
8114     #ifdef PARANOIA
8115     #endif // #ifdef PARANOIA
8116     } else {
8117     printf("branch els_layer1_layer_branch does not exist!\n");
8118     exit(1);
8119     }
8120     els_layer1_layer_isLoaded = true;
8121     }
8122     return els_layer1_layer_;
8123     }
8124     vector<int> &els_layer1_sizerphi()
8125     {
8126     if (not els_layer1_sizerphi_isLoaded) {
8127     if (els_layer1_sizerphi_branch != 0) {
8128     els_layer1_sizerphi_branch->GetEntry(index);
8129     #ifdef PARANOIA
8130     #endif // #ifdef PARANOIA
8131     } else {
8132     printf("branch els_layer1_sizerphi_branch does not exist!\n");
8133     exit(1);
8134     }
8135     els_layer1_sizerphi_isLoaded = true;
8136     }
8137     return els_layer1_sizerphi_;
8138     }
8139     vector<int> &els_layer1_sizerz()
8140     {
8141     if (not els_layer1_sizerz_isLoaded) {
8142     if (els_layer1_sizerz_branch != 0) {
8143     els_layer1_sizerz_branch->GetEntry(index);
8144     #ifdef PARANOIA
8145     #endif // #ifdef PARANOIA
8146     } else {
8147     printf("branch els_layer1_sizerz_branch does not exist!\n");
8148     exit(1);
8149     }
8150     els_layer1_sizerz_isLoaded = true;
8151     }
8152     return els_layer1_sizerz_;
8153     }
8154     vector<int> &els_lostHits()
8155     {
8156     if (not els_lostHits_isLoaded) {
8157     if (els_lostHits_branch != 0) {
8158     els_lostHits_branch->GetEntry(index);
8159     #ifdef PARANOIA
8160     #endif // #ifdef PARANOIA
8161     } else {
8162     printf("branch els_lostHits_branch does not exist!\n");
8163     exit(1);
8164     }
8165     els_lostHits_isLoaded = true;
8166     }
8167     return els_lostHits_;
8168     }
8169     vector<int> &els_lost_pixelhits()
8170     {
8171     if (not els_lost_pixelhits_isLoaded) {
8172     if (els_lost_pixelhits_branch != 0) {
8173     els_lost_pixelhits_branch->GetEntry(index);
8174     #ifdef PARANOIA
8175     #endif // #ifdef PARANOIA
8176     } else {
8177     printf("branch els_lost_pixelhits_branch does not exist!\n");
8178     exit(1);
8179     }
8180     els_lost_pixelhits_isLoaded = true;
8181     }
8182     return els_lost_pixelhits_;
8183     }
8184     vector<int> &els_nSeed()
8185     {
8186     if (not els_nSeed_isLoaded) {
8187     if (els_nSeed_branch != 0) {
8188     els_nSeed_branch->GetEntry(index);
8189     #ifdef PARANOIA
8190     #endif // #ifdef PARANOIA
8191     } else {
8192     printf("branch els_nSeed_branch does not exist!\n");
8193     exit(1);
8194     }
8195     els_nSeed_isLoaded = true;
8196     }
8197     return els_nSeed_;
8198     }
8199     vector<int> &els_sccharge()
8200     {
8201     if (not els_sccharge_isLoaded) {
8202     if (els_sccharge_branch != 0) {
8203     els_sccharge_branch->GetEntry(index);
8204     #ifdef PARANOIA
8205     #endif // #ifdef PARANOIA
8206     } else {
8207     printf("branch els_sccharge_branch does not exist!\n");
8208     exit(1);
8209     }
8210     els_sccharge_isLoaded = true;
8211     }
8212     return els_sccharge_;
8213     }
8214     vector<int> &els_trkidx()
8215     {
8216     if (not els_trkidx_isLoaded) {
8217     if (els_trkidx_branch != 0) {
8218     els_trkidx_branch->GetEntry(index);
8219     #ifdef PARANOIA
8220     #endif // #ifdef PARANOIA
8221     } else {
8222     printf("branch els_trkidx_branch does not exist!\n");
8223     exit(1);
8224     }
8225     els_trkidx_isLoaded = true;
8226     }
8227     return els_trkidx_;
8228     }
8229     vector<int> &els_type()
8230     {
8231     if (not els_type_isLoaded) {
8232     if (els_type_branch != 0) {
8233     els_type_branch->GetEntry(index);
8234     #ifdef PARANOIA
8235     #endif // #ifdef PARANOIA
8236     } else {
8237     printf("branch els_type_branch does not exist!\n");
8238     exit(1);
8239     }
8240     els_type_isLoaded = true;
8241     }
8242     return els_type_;
8243     }
8244     vector<int> &els_validHits()
8245     {
8246     if (not els_validHits_isLoaded) {
8247     if (els_validHits_branch != 0) {
8248     els_validHits_branch->GetEntry(index);
8249     #ifdef PARANOIA
8250     #endif // #ifdef PARANOIA
8251     } else {
8252     printf("branch els_validHits_branch does not exist!\n");
8253     exit(1);
8254     }
8255     els_validHits_isLoaded = true;
8256     }
8257     return els_validHits_;
8258     }
8259     vector<int> &els_valid_pixelhits()
8260     {
8261     if (not els_valid_pixelhits_isLoaded) {
8262     if (els_valid_pixelhits_branch != 0) {
8263     els_valid_pixelhits_branch->GetEntry(index);
8264     #ifdef PARANOIA
8265     #endif // #ifdef PARANOIA
8266     } else {
8267     printf("branch els_valid_pixelhits_branch does not exist!\n");
8268     exit(1);
8269     }
8270     els_valid_pixelhits_isLoaded = true;
8271     }
8272     return els_valid_pixelhits_;
8273     }
8274     vector<int> &mus_charge()
8275     {
8276     if (not mus_charge_isLoaded) {
8277     if (mus_charge_branch != 0) {
8278     mus_charge_branch->GetEntry(index);
8279     #ifdef PARANOIA
8280     #endif // #ifdef PARANOIA
8281     } else {
8282     printf("branch mus_charge_branch does not exist!\n");
8283     exit(1);
8284     }
8285     mus_charge_isLoaded = true;
8286     }
8287     return mus_charge_;
8288     }
8289     vector<int> &mus_gfit_validHits()
8290     {
8291     if (not mus_gfit_validHits_isLoaded) {
8292     if (mus_gfit_validHits_branch != 0) {
8293     mus_gfit_validHits_branch->GetEntry(index);
8294     #ifdef PARANOIA
8295     #endif // #ifdef PARANOIA
8296     } else {
8297     printf("branch mus_gfit_validHits_branch does not exist!\n");
8298     exit(1);
8299     }
8300     mus_gfit_validHits_isLoaded = true;
8301     }
8302     return mus_gfit_validHits_;
8303     }
8304     vector<int> &mus_gfit_validSTAHits()
8305     {
8306     if (not mus_gfit_validSTAHits_isLoaded) {
8307     if (mus_gfit_validSTAHits_branch != 0) {
8308     mus_gfit_validSTAHits_branch->GetEntry(index);
8309     #ifdef PARANOIA
8310     #endif // #ifdef PARANOIA
8311     } else {
8312     printf("branch mus_gfit_validSTAHits_branch does not exist!\n");
8313     exit(1);
8314     }
8315     mus_gfit_validSTAHits_isLoaded = true;
8316     }
8317     return mus_gfit_validSTAHits_;
8318     }
8319     vector<int> &mus_gfit_validSiHits()
8320     {
8321     if (not mus_gfit_validSiHits_isLoaded) {
8322     if (mus_gfit_validSiHits_branch != 0) {
8323     mus_gfit_validSiHits_branch->GetEntry(index);
8324     #ifdef PARANOIA
8325     #endif // #ifdef PARANOIA
8326     } else {
8327     printf("branch mus_gfit_validSiHits_branch does not exist!\n");
8328     exit(1);
8329     }
8330     mus_gfit_validSiHits_isLoaded = true;
8331     }
8332     return mus_gfit_validSiHits_;
8333     }
8334     vector<int> &mus_goodmask()
8335     {
8336     if (not mus_goodmask_isLoaded) {
8337     if (mus_goodmask_branch != 0) {
8338     mus_goodmask_branch->GetEntry(index);
8339     #ifdef PARANOIA
8340     #endif // #ifdef PARANOIA
8341     } else {
8342     printf("branch mus_goodmask_branch does not exist!\n");
8343     exit(1);
8344     }
8345     mus_goodmask_isLoaded = true;
8346     }
8347     return mus_goodmask_;
8348     }
8349     vector<int> &mus_iso03_ntrk()
8350     {
8351     if (not mus_iso03_ntrk_isLoaded) {
8352     if (mus_iso03_ntrk_branch != 0) {
8353     mus_iso03_ntrk_branch->GetEntry(index);
8354     #ifdef PARANOIA
8355     #endif // #ifdef PARANOIA
8356     } else {
8357     printf("branch mus_iso03_ntrk_branch does not exist!\n");
8358     exit(1);
8359     }
8360     mus_iso03_ntrk_isLoaded = true;
8361     }
8362     return mus_iso03_ntrk_;
8363     }
8364     vector<int> &mus_iso05_ntrk()
8365     {
8366     if (not mus_iso05_ntrk_isLoaded) {
8367     if (mus_iso05_ntrk_branch != 0) {
8368     mus_iso05_ntrk_branch->GetEntry(index);
8369     #ifdef PARANOIA
8370     #endif // #ifdef PARANOIA
8371     } else {
8372     printf("branch mus_iso05_ntrk_branch does not exist!\n");
8373     exit(1);
8374     }
8375     mus_iso05_ntrk_isLoaded = true;
8376     }
8377     return mus_iso05_ntrk_;
8378     }
8379     vector<int> &mus_lostHits()
8380     {
8381     if (not mus_lostHits_isLoaded) {
8382     if (mus_lostHits_branch != 0) {
8383     mus_lostHits_branch->GetEntry(index);
8384     #ifdef PARANOIA
8385     #endif // #ifdef PARANOIA
8386     } else {
8387     printf("branch mus_lostHits_branch does not exist!\n");
8388     exit(1);
8389     }
8390     mus_lostHits_isLoaded = true;
8391     }
8392     return mus_lostHits_;
8393     }
8394     vector<int> &mus_nmatches()
8395     {
8396     if (not mus_nmatches_isLoaded) {
8397     if (mus_nmatches_branch != 0) {
8398     mus_nmatches_branch->GetEntry(index);
8399     #ifdef PARANOIA
8400     #endif // #ifdef PARANOIA
8401     } else {
8402     printf("branch mus_nmatches_branch does not exist!\n");
8403     exit(1);
8404     }
8405     mus_nmatches_isLoaded = true;
8406     }
8407     return mus_nmatches_;
8408     }
8409     vector<int> &mus_pid_TM2DCompatibilityLoose()
8410     {
8411     if (not mus_pid_TM2DCompatibilityLoose_isLoaded) {
8412     if (mus_pid_TM2DCompatibilityLoose_branch != 0) {
8413     mus_pid_TM2DCompatibilityLoose_branch->GetEntry(index);
8414     #ifdef PARANOIA
8415     #endif // #ifdef PARANOIA
8416     } else {
8417     printf("branch mus_pid_TM2DCompatibilityLoose_branch does not exist!\n");
8418     exit(1);
8419     }
8420     mus_pid_TM2DCompatibilityLoose_isLoaded = true;
8421     }
8422     return mus_pid_TM2DCompatibilityLoose_;
8423     }
8424     vector<int> &mus_pid_TM2DCompatibilityTight()
8425     {
8426     if (not mus_pid_TM2DCompatibilityTight_isLoaded) {
8427     if (mus_pid_TM2DCompatibilityTight_branch != 0) {
8428     mus_pid_TM2DCompatibilityTight_branch->GetEntry(index);
8429     #ifdef PARANOIA
8430     #endif // #ifdef PARANOIA
8431     } else {
8432     printf("branch mus_pid_TM2DCompatibilityTight_branch does not exist!\n");
8433     exit(1);
8434     }
8435     mus_pid_TM2DCompatibilityTight_isLoaded = true;
8436     }
8437     return mus_pid_TM2DCompatibilityTight_;
8438     }
8439     vector<int> &mus_pid_TMLastStationLoose()
8440     {
8441     if (not mus_pid_TMLastStationLoose_isLoaded) {
8442     if (mus_pid_TMLastStationLoose_branch != 0) {
8443     mus_pid_TMLastStationLoose_branch->GetEntry(index);
8444     #ifdef PARANOIA
8445     #endif // #ifdef PARANOIA
8446     } else {
8447     printf("branch mus_pid_TMLastStationLoose_branch does not exist!\n");
8448     exit(1);
8449     }
8450     mus_pid_TMLastStationLoose_isLoaded = true;
8451     }
8452     return mus_pid_TMLastStationLoose_;
8453     }
8454     vector<int> &mus_pid_TMLastStationTight()
8455     {
8456     if (not mus_pid_TMLastStationTight_isLoaded) {
8457     if (mus_pid_TMLastStationTight_branch != 0) {
8458     mus_pid_TMLastStationTight_branch->GetEntry(index);
8459     #ifdef PARANOIA
8460     #endif // #ifdef PARANOIA
8461     } else {
8462     printf("branch mus_pid_TMLastStationTight_branch does not exist!\n");
8463     exit(1);
8464     }
8465     mus_pid_TMLastStationTight_isLoaded = true;
8466     }
8467     return mus_pid_TMLastStationTight_;
8468     }
8469     vector<int> &mus_timeDirection()
8470     {
8471     if (not mus_timeDirection_isLoaded) {
8472     if (mus_timeDirection_branch != 0) {
8473     mus_timeDirection_branch->GetEntry(index);
8474     #ifdef PARANOIA
8475     #endif // #ifdef PARANOIA
8476     } else {
8477     printf("branch mus_timeDirection_branch does not exist!\n");
8478     exit(1);
8479     }
8480     mus_timeDirection_isLoaded = true;
8481     }
8482     return mus_timeDirection_;
8483     }
8484     vector<int> &mus_timeNumStationsUsed()
8485     {
8486     if (not mus_timeNumStationsUsed_isLoaded) {
8487     if (mus_timeNumStationsUsed_branch != 0) {
8488     mus_timeNumStationsUsed_branch->GetEntry(index);
8489     #ifdef PARANOIA
8490     #endif // #ifdef PARANOIA
8491     } else {
8492     printf("branch mus_timeNumStationsUsed_branch does not exist!\n");
8493     exit(1);
8494     }
8495     mus_timeNumStationsUsed_isLoaded = true;
8496     }
8497     return mus_timeNumStationsUsed_;
8498     }
8499     vector<int> &mus_trk_charge()
8500     {
8501     if (not mus_trk_charge_isLoaded) {
8502     if (mus_trk_charge_branch != 0) {
8503     mus_trk_charge_branch->GetEntry(index);
8504     #ifdef PARANOIA
8505     #endif // #ifdef PARANOIA
8506     } else {
8507     printf("branch mus_trk_charge_branch does not exist!\n");
8508     exit(1);
8509     }
8510     mus_trk_charge_isLoaded = true;
8511     }
8512     return mus_trk_charge_;
8513     }
8514     vector<int> &mus_trkidx()
8515     {
8516     if (not mus_trkidx_isLoaded) {
8517     if (mus_trkidx_branch != 0) {
8518     mus_trkidx_branch->GetEntry(index);
8519     #ifdef PARANOIA
8520     #endif // #ifdef PARANOIA
8521     } else {
8522     printf("branch mus_trkidx_branch does not exist!\n");
8523     exit(1);
8524     }
8525     mus_trkidx_isLoaded = true;
8526     }
8527     return mus_trkidx_;
8528     }
8529     vector<int> &mus_type()
8530     {
8531     if (not mus_type_isLoaded) {
8532     if (mus_type_branch != 0) {
8533     mus_type_branch->GetEntry(index);
8534     #ifdef PARANOIA
8535     #endif // #ifdef PARANOIA
8536     } else {
8537     printf("branch mus_type_branch does not exist!\n");
8538     exit(1);
8539     }
8540     mus_type_isLoaded = true;
8541     }
8542     return mus_type_;
8543     }
8544     vector<int> &mus_validHits()
8545     {
8546     if (not mus_validHits_isLoaded) {
8547     if (mus_validHits_branch != 0) {
8548     mus_validHits_branch->GetEntry(index);
8549     #ifdef PARANOIA
8550     #endif // #ifdef PARANOIA
8551     } else {
8552     printf("branch mus_validHits_branch does not exist!\n");
8553     exit(1);
8554     }
8555     mus_validHits_isLoaded = true;
8556     }
8557     return mus_validHits_;
8558     }
8559     vector<int> &scs_elsidx()
8560     {
8561     if (not scs_elsidx_isLoaded) {
8562     if (scs_elsidx_branch != 0) {
8563     scs_elsidx_branch->GetEntry(index);
8564     #ifdef PARANOIA
8565     #endif // #ifdef PARANOIA
8566     } else {
8567     printf("branch scs_elsidx_branch does not exist!\n");
8568     exit(1);
8569     }
8570     scs_elsidx_isLoaded = true;
8571     }
8572     return scs_elsidx_;
8573     }
8574     vector<int> &trks_algo()
8575     {
8576     if (not trks_algo_isLoaded) {
8577     if (trks_algo_branch != 0) {
8578     trks_algo_branch->GetEntry(index);
8579     #ifdef PARANOIA
8580     #endif // #ifdef PARANOIA
8581     } else {
8582     printf("branch trks_algo_branch does not exist!\n");
8583     exit(1);
8584     }
8585     trks_algo_isLoaded = true;
8586     }
8587     return trks_algo_;
8588     }
8589     vector<int> &trks_charge()
8590     {
8591     if (not trks_charge_isLoaded) {
8592     if (trks_charge_branch != 0) {
8593     trks_charge_branch->GetEntry(index);
8594     #ifdef PARANOIA
8595     #endif // #ifdef PARANOIA
8596     } else {
8597     printf("branch trks_charge_branch does not exist!\n");
8598     exit(1);
8599     }
8600     trks_charge_isLoaded = true;
8601     }
8602     return trks_charge_;
8603     }
8604     vector<int> &trks_lostHits()
8605     {
8606     if (not trks_lostHits_isLoaded) {
8607     if (trks_lostHits_branch != 0) {
8608     trks_lostHits_branch->GetEntry(index);
8609     #ifdef PARANOIA
8610     #endif // #ifdef PARANOIA
8611     } else {
8612     printf("branch trks_lostHits_branch does not exist!\n");
8613     exit(1);
8614     }
8615     trks_lostHits_isLoaded = true;
8616     }
8617     return trks_lostHits_;
8618     }
8619     vector<int> &trks_qualityMask()
8620     {
8621     if (not trks_qualityMask_isLoaded) {
8622     if (trks_qualityMask_branch != 0) {
8623     trks_qualityMask_branch->GetEntry(index);
8624     #ifdef PARANOIA
8625     #endif // #ifdef PARANOIA
8626     } else {
8627     printf("branch trks_qualityMask_branch does not exist!\n");
8628     exit(1);
8629     }
8630     trks_qualityMask_isLoaded = true;
8631     }
8632     return trks_qualityMask_;
8633     }
8634     vector<int> &trks_validHits()
8635     {
8636     if (not trks_validHits_isLoaded) {
8637     if (trks_validHits_branch != 0) {
8638     trks_validHits_branch->GetEntry(index);
8639     #ifdef PARANOIA
8640     #endif // #ifdef PARANOIA
8641     } else {
8642     printf("branch trks_validHits_branch does not exist!\n");
8643     exit(1);
8644     }
8645     trks_validHits_isLoaded = true;
8646     }
8647     return trks_validHits_;
8648     }
8649     vector<int> &trks_elsidx()
8650     {
8651     if (not trks_elsidx_isLoaded) {
8652     if (trks_elsidx_branch != 0) {
8653     trks_elsidx_branch->GetEntry(index);
8654     #ifdef PARANOIA
8655     #endif // #ifdef PARANOIA
8656     } else {
8657     printf("branch trks_elsidx_branch does not exist!\n");
8658     exit(1);
8659     }
8660     trks_elsidx_isLoaded = true;
8661     }
8662     return trks_elsidx_;
8663     }
8664     vector<int> &trk_musidx()
8665     {
8666     if (not trk_musidx_isLoaded) {
8667     if (trk_musidx_branch != 0) {
8668     trk_musidx_branch->GetEntry(index);
8669     #ifdef PARANOIA
8670     #endif // #ifdef PARANOIA
8671     } else {
8672     printf("branch trk_musidx_branch does not exist!\n");
8673     exit(1);
8674     }
8675     trk_musidx_isLoaded = true;
8676     }
8677     return trk_musidx_;
8678     }
8679     vector<int> &vtxs_isFake()
8680     {
8681     if (not vtxs_isFake_isLoaded) {
8682     if (vtxs_isFake_branch != 0) {
8683     vtxs_isFake_branch->GetEntry(index);
8684     #ifdef PARANOIA
8685     #endif // #ifdef PARANOIA
8686     } else {
8687     printf("branch vtxs_isFake_branch does not exist!\n");
8688     exit(1);
8689     }
8690     vtxs_isFake_isLoaded = true;
8691     }
8692     return vtxs_isFake_;
8693     }
8694     vector<int> &vtxs_isValid()
8695     {
8696     if (not vtxs_isValid_isLoaded) {
8697     if (vtxs_isValid_branch != 0) {
8698     vtxs_isValid_branch->GetEntry(index);
8699     #ifdef PARANOIA
8700     #endif // #ifdef PARANOIA
8701     } else {
8702     printf("branch vtxs_isValid_branch does not exist!\n");
8703     exit(1);
8704     }
8705     vtxs_isValid_isLoaded = true;
8706     }
8707     return vtxs_isValid_;
8708     }
8709     vector<int> &vtxs_tracksSize()
8710     {
8711     if (not vtxs_tracksSize_isLoaded) {
8712     if (vtxs_tracksSize_branch != 0) {
8713     vtxs_tracksSize_branch->GetEntry(index);
8714     #ifdef PARANOIA
8715     #endif // #ifdef PARANOIA
8716     } else {
8717     printf("branch vtxs_tracksSize_branch does not exist!\n");
8718     exit(1);
8719     }
8720     vtxs_tracksSize_isLoaded = true;
8721     }
8722     return vtxs_tracksSize_;
8723     }
8724     vector<vector<int> > &trks_hit_substructure()
8725     {
8726     if (not trks_hit_substructure_isLoaded) {
8727     if (trks_hit_substructure_branch != 0) {
8728     trks_hit_substructure_branch->GetEntry(index);
8729     #ifdef PARANOIA
8730     #endif // #ifdef PARANOIA
8731     } else {
8732     printf("branch trks_hit_substructure_branch does not exist!\n");
8733     exit(1);
8734     }
8735     trks_hit_substructure_isLoaded = true;
8736     }
8737     return trks_hit_substructure_;
8738     }
8739     vector<vector<int> > &trks_hit_type()
8740     {
8741     if (not trks_hit_type_isLoaded) {
8742     if (trks_hit_type_branch != 0) {
8743     trks_hit_type_branch->GetEntry(index);
8744     #ifdef PARANOIA
8745     #endif // #ifdef PARANOIA
8746     } else {
8747     printf("branch trks_hit_type_branch does not exist!\n");
8748     exit(1);
8749     }
8750     trks_hit_type_isLoaded = true;
8751     }
8752     return trks_hit_type_;
8753     }
8754     unsigned int &evt_ntwrs()
8755     {
8756     if (not evt_ntwrs_isLoaded) {
8757     if (evt_ntwrs_branch != 0) {
8758     evt_ntwrs_branch->GetEntry(index);
8759     #ifdef PARANOIA
8760     #endif // #ifdef PARANOIA
8761     } else {
8762     printf("branch evt_ntwrs_branch does not exist!\n");
8763     exit(1);
8764     }
8765     evt_ntwrs_isLoaded = true;
8766     }
8767     return evt_ntwrs_;
8768     }
8769     unsigned int &evt_nels()
8770     {
8771     if (not evt_nels_isLoaded) {
8772     if (evt_nels_branch != 0) {
8773     evt_nels_branch->GetEntry(index);
8774     #ifdef PARANOIA
8775     #endif // #ifdef PARANOIA
8776     } else {
8777     printf("branch evt_nels_branch does not exist!\n");
8778     exit(1);
8779     }
8780     evt_nels_isLoaded = true;
8781     }
8782     return evt_nels_;
8783     }
8784     unsigned int &evt_event()
8785     {
8786     if (not evt_event_isLoaded) {
8787     if (evt_event_branch != 0) {
8788     evt_event_branch->GetEntry(index);
8789     #ifdef PARANOIA
8790     #endif // #ifdef PARANOIA
8791     } else {
8792     printf("branch evt_event_branch does not exist!\n");
8793     exit(1);
8794     }
8795     evt_event_isLoaded = true;
8796     }
8797     return evt_event_;
8798     }
8799     unsigned int &evt_lumiBlock()
8800     {
8801     if (not evt_lumiBlock_isLoaded) {
8802     if (evt_lumiBlock_branch != 0) {
8803     evt_lumiBlock_branch->GetEntry(index);
8804     #ifdef PARANOIA
8805     #endif // #ifdef PARANOIA
8806     } else {
8807     printf("branch evt_lumiBlock_branch does not exist!\n");
8808     exit(1);
8809     }
8810     evt_lumiBlock_isLoaded = true;
8811     }
8812     return evt_lumiBlock_;
8813     }
8814     unsigned int &evt_run()
8815     {
8816     if (not evt_run_isLoaded) {
8817     if (evt_run_branch != 0) {
8818     evt_run_branch->GetEntry(index);
8819     #ifdef PARANOIA
8820     #endif // #ifdef PARANOIA
8821     } else {
8822     printf("branch evt_run_branch does not exist!\n");
8823     exit(1);
8824     }
8825     evt_run_isLoaded = true;
8826     }
8827     return evt_run_;
8828     }
8829     unsigned int &evt_nscs()
8830     {
8831     if (not evt_nscs_isLoaded) {
8832     if (evt_nscs_branch != 0) {
8833     evt_nscs_branch->GetEntry(index);
8834     #ifdef PARANOIA
8835     #endif // #ifdef PARANOIA
8836     } else {
8837     printf("branch evt_nscs_branch does not exist!\n");
8838     exit(1);
8839     }
8840     evt_nscs_isLoaded = true;
8841     }
8842     return evt_nscs_;
8843     }
8844     unsigned int &evt_nvtxs()
8845     {
8846     if (not evt_nvtxs_isLoaded) {
8847     if (evt_nvtxs_branch != 0) {
8848     evt_nvtxs_branch->GetEntry(index);
8849     #ifdef PARANOIA
8850     #endif // #ifdef PARANOIA
8851     } else {
8852     printf("branch evt_nvtxs_branch does not exist!\n");
8853     exit(1);
8854     }
8855     evt_nvtxs_isLoaded = true;
8856     }
8857     return evt_nvtxs_;
8858     }
8859     vector<unsigned int> &twrs_numBadEcalCells()
8860     {
8861     if (not twrs_numBadEcalCells_isLoaded) {
8862     if (twrs_numBadEcalCells_branch != 0) {
8863     twrs_numBadEcalCells_branch->GetEntry(index);
8864     #ifdef PARANOIA
8865     #endif // #ifdef PARANOIA
8866     } else {
8867     printf("branch twrs_numBadEcalCells_branch does not exist!\n");
8868     exit(1);
8869     }
8870     twrs_numBadEcalCells_isLoaded = true;
8871     }
8872     return twrs_numBadEcalCells_;
8873     }
8874     vector<unsigned int> &twrs_numBadHcalCells()
8875     {
8876     if (not twrs_numBadHcalCells_isLoaded) {
8877     if (twrs_numBadHcalCells_branch != 0) {
8878     twrs_numBadHcalCells_branch->GetEntry(index);
8879     #ifdef PARANOIA
8880     #endif // #ifdef PARANOIA
8881     } else {
8882     printf("branch twrs_numBadHcalCells_branch does not exist!\n");
8883     exit(1);
8884     }
8885     twrs_numBadHcalCells_isLoaded = true;
8886     }
8887     return twrs_numBadHcalCells_;
8888     }
8889     vector<unsigned int> &twrs_numProblematicEcalCells()
8890     {
8891     if (not twrs_numProblematicEcalCells_isLoaded) {
8892     if (twrs_numProblematicEcalCells_branch != 0) {
8893     twrs_numProblematicEcalCells_branch->GetEntry(index);
8894     #ifdef PARANOIA
8895     #endif // #ifdef PARANOIA
8896     } else {
8897     printf("branch twrs_numProblematicEcalCells_branch does not exist!\n");
8898     exit(1);
8899     }
8900     twrs_numProblematicEcalCells_isLoaded = true;
8901     }
8902     return twrs_numProblematicEcalCells_;
8903     }
8904     vector<unsigned int> &twrs_numProblematicHcalCells()
8905     {
8906     if (not twrs_numProblematicHcalCells_isLoaded) {
8907     if (twrs_numProblematicHcalCells_branch != 0) {
8908     twrs_numProblematicHcalCells_branch->GetEntry(index);
8909     #ifdef PARANOIA
8910     #endif // #ifdef PARANOIA
8911     } else {
8912     printf("branch twrs_numProblematicHcalCells_branch does not exist!\n");
8913     exit(1);
8914     }
8915     twrs_numProblematicHcalCells_isLoaded = true;
8916     }
8917     return twrs_numProblematicHcalCells_;
8918     }
8919     vector<unsigned int> &twrs_numRecoveredEcalCells()
8920     {
8921     if (not twrs_numRecoveredEcalCells_isLoaded) {
8922     if (twrs_numRecoveredEcalCells_branch != 0) {
8923     twrs_numRecoveredEcalCells_branch->GetEntry(index);
8924     #ifdef PARANOIA
8925     #endif // #ifdef PARANOIA
8926     } else {
8927     printf("branch twrs_numRecoveredEcalCells_branch does not exist!\n");
8928     exit(1);
8929     }
8930     twrs_numRecoveredEcalCells_isLoaded = true;
8931     }
8932     return twrs_numRecoveredEcalCells_;
8933     }
8934     vector<unsigned int> &twrs_numRecoveredHcalCells()
8935     {
8936     if (not twrs_numRecoveredHcalCells_isLoaded) {
8937     if (twrs_numRecoveredHcalCells_branch != 0) {
8938     twrs_numRecoveredHcalCells_branch->GetEntry(index);
8939     #ifdef PARANOIA
8940     #endif // #ifdef PARANOIA
8941     } else {
8942     printf("branch twrs_numRecoveredHcalCells_branch does not exist!\n");
8943     exit(1);
8944     }
8945     twrs_numRecoveredHcalCells_isLoaded = true;
8946     }
8947     return twrs_numRecoveredHcalCells_;
8948     }
8949     float &evt_scale1fb()
8950     {
8951     if (not evt_scale1fb_isLoaded) {
8952     if (evt_scale1fb_branch != 0) {
8953     evt_scale1fb_branch->GetEntry(index);
8954     #ifdef PARANOIA
8955     #endif // #ifdef PARANOIA
8956     } else {
8957     printf("branch evt_scale1fb_branch does not exist!\n");
8958     exit(1);
8959     }
8960     evt_scale1fb_isLoaded = true;
8961     }
8962     return evt_scale1fb_;
8963     }
8964     float &evt_xsec_excl()
8965     {
8966     if (not evt_xsec_excl_isLoaded) {
8967     if (evt_xsec_excl_branch != 0) {
8968     evt_xsec_excl_branch->GetEntry(index);
8969     #ifdef PARANOIA
8970     #endif // #ifdef PARANOIA
8971     } else {
8972     printf("branch evt_xsec_excl_branch does not exist!\n");
8973     exit(1);
8974     }
8975     evt_xsec_excl_isLoaded = true;
8976     }
8977     return evt_xsec_excl_;
8978     }
8979     float &evt_xsec_incl()
8980     {
8981     if (not evt_xsec_incl_isLoaded) {
8982     if (evt_xsec_incl_branch != 0) {
8983     evt_xsec_incl_branch->GetEntry(index);
8984     #ifdef PARANOIA
8985     #endif // #ifdef PARANOIA
8986     } else {
8987     printf("branch evt_xsec_incl_branch does not exist!\n");
8988     exit(1);
8989     }
8990     evt_xsec_incl_isLoaded = true;
8991     }
8992     return evt_xsec_incl_;
8993     }
8994     float &evt_kfactor()
8995     {
8996     if (not evt_kfactor_isLoaded) {
8997     if (evt_kfactor_branch != 0) {
8998     evt_kfactor_branch->GetEntry(index);
8999     #ifdef PARANOIA
9000     #endif // #ifdef PARANOIA
9001     } else {
9002     printf("branch evt_kfactor_branch does not exist!\n");
9003     exit(1);
9004     }
9005     evt_kfactor_isLoaded = true;
9006     }
9007     return evt_kfactor_;
9008     }
9009     int &evt_nEvts()
9010     {
9011     if (not evt_nEvts_isLoaded) {
9012     if (evt_nEvts_branch != 0) {
9013     evt_nEvts_branch->GetEntry(index);
9014     #ifdef PARANOIA
9015     #endif // #ifdef PARANOIA
9016     } else {
9017     printf("branch evt_nEvts_branch does not exist!\n");
9018     exit(1);
9019     }
9020     evt_nEvts_isLoaded = true;
9021     }
9022     return evt_nEvts_;
9023     }
9024     float &evt_filt_eff()
9025     {
9026     if (not evt_filt_eff_isLoaded) {
9027     if (evt_filt_eff_branch != 0) {
9028     evt_filt_eff_branch->GetEntry(index);
9029     #ifdef PARANOIA
9030     #endif // #ifdef PARANOIA
9031     } else {
9032     printf("branch evt_filt_eff_branch does not exist!\n");
9033     exit(1);
9034     }
9035     evt_filt_eff_isLoaded = true;
9036     }
9037     return evt_filt_eff_;
9038     }
9039     };
9040    
9041     #ifndef __CINT__
9042     extern CMS2 cms2;
9043     #endif
9044    
9045     namespace tas {
9046     TString &evt_CMS2tag() { return cms2.evt_CMS2tag(); }
9047     TString &evt_dataset() { return cms2.evt_dataset(); }
9048     vector<double> &els_inner_positionx() { return cms2.els_inner_positionx(); }
9049     vector<double> &els_inner_positiony() { return cms2.els_inner_positiony(); }
9050     vector<double> &els_inner_positionz() { return cms2.els_inner_positionz(); }
9051     float &evt_bs_Xwidth() { return cms2.evt_bs_Xwidth(); }
9052     float &evt_bs_XwidthErr() { return cms2.evt_bs_XwidthErr(); }
9053     float &evt_bs_Ywidth() { return cms2.evt_bs_Ywidth(); }
9054     float &evt_bs_YwidthErr() { return cms2.evt_bs_YwidthErr(); }
9055     float &evt_bs_dxdz() { return cms2.evt_bs_dxdz(); }
9056     float &evt_bs_dxdzErr() { return cms2.evt_bs_dxdzErr(); }
9057     float &evt_bs_dydz() { return cms2.evt_bs_dydz(); }
9058     float &evt_bs_dydzErr() { return cms2.evt_bs_dydzErr(); }
9059     float &evt_bs_sigmaZ() { return cms2.evt_bs_sigmaZ(); }
9060     float &evt_bs_sigmaZErr() { return cms2.evt_bs_sigmaZErr(); }
9061     float &evt_bs_xErr() { return cms2.evt_bs_xErr(); }
9062     float &evt_bs_yErr() { return cms2.evt_bs_yErr(); }
9063     float &evt_bs_zErr() { return cms2.evt_bs_zErr(); }
9064     float &evt_bField() { return cms2.evt_bField(); }
9065     ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > &evt_bsp4() { return cms2.evt_bsp4(); }
9066     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &els_p4() { return cms2.els_p4(); }
9067     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &els_p4In() { return cms2.els_p4In(); }
9068     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &els_p4Out() { return cms2.els_p4Out(); }
9069     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &els_trk_p4() { return cms2.els_trk_p4(); }
9070     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &els_vertex_p4() { return cms2.els_vertex_p4(); }
9071     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &mus_fitdefault_p4() { return cms2.mus_fitdefault_p4(); }
9072     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &mus_fitfirsthit_p4() { return cms2.mus_fitfirsthit_p4(); }
9073     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &mus_fitpicky_p4() { return cms2.mus_fitpicky_p4(); }
9074     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &mus_fittev_p4() { return cms2.mus_fittev_p4(); }
9075     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &mus_gfit_outerPos_p4() { return cms2.mus_gfit_outerPos_p4(); }
9076     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &mus_gfit_p4() { return cms2.mus_gfit_p4(); }
9077     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &mus_gfit_vertex_p4() { return cms2.mus_gfit_vertex_p4(); }
9078     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &mus_p4() { return cms2.mus_p4(); }
9079     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &mus_trk_p4() { return cms2.mus_trk_p4(); }
9080     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &mus_vertex_p4() { return cms2.mus_vertex_p4(); }
9081     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &scs_p4() { return cms2.scs_p4(); }
9082     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &scs_pos_p4() { return cms2.scs_pos_p4(); }
9083     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &scs_vtx_p4() { return cms2.scs_vtx_p4(); }
9084     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &trks_outer_p4() { return cms2.trks_outer_p4(); }
9085     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &trks_trk_p4() { return cms2.trks_trk_p4(); }
9086     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &trks_vertex_p4() { return cms2.trks_vertex_p4(); }
9087     vector<ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> > > &vtxs_position() { return cms2.vtxs_position(); }
9088     vector<float> &evt_covMatrix() { return cms2.evt_covMatrix(); }
9089     vector<float> &twrs_ecalTime() { return cms2.twrs_ecalTime(); }
9090     vector<float> &twrs_emEnergy() { return cms2.twrs_emEnergy(); }
9091     vector<float> &twrs_emEt() { return cms2.twrs_emEt(); }
9092     vector<float> &twrs_emEtcorr() { return cms2.twrs_emEtcorr(); }
9093     vector<float> &twrs_eta() { return cms2.twrs_eta(); }
9094     vector<float> &twrs_etcorr() { return cms2.twrs_etcorr(); }
9095     vector<float> &twrs_hadEnergy() { return cms2.twrs_hadEnergy(); }
9096     vector<float> &twrs_hadEt() { return cms2.twrs_hadEt(); }
9097     vector<float> &twrs_hadEtcorr() { return cms2.twrs_hadEtcorr(); }
9098     vector<float> &twrs_hcalTime() { return cms2.twrs_hcalTime(); }
9099     vector<float> &twrs_outerEnergy() { return cms2.twrs_outerEnergy(); }
9100     vector<float> &twrs_outerEt() { return cms2.twrs_outerEt(); }
9101     vector<float> &twrs_outerEtcorr() { return cms2.twrs_outerEtcorr(); }
9102     vector<float> &twrs_pcorr() { return cms2.twrs_pcorr(); }
9103     vector<float> &twrs_phi() { return cms2.twrs_phi(); }
9104     vector<float> &els_ecalJuraIso() { return cms2.els_ecalJuraIso(); }
9105     vector<float> &els_ecalJuraTowerIso() { return cms2.els_ecalJuraTowerIso(); }
9106     vector<float> &els_hcalConeIso() { return cms2.els_hcalConeIso(); }
9107     vector<float> &els_chi2() { return cms2.els_chi2(); }
9108     vector<float> &els_d0() { return cms2.els_d0(); }
9109     vector<float> &els_d0Err() { return cms2.els_d0Err(); }
9110     vector<float> &els_d0corr() { return cms2.els_d0corr(); }
9111     vector<float> &els_dEtaIn() { return cms2.els_dEtaIn(); }
9112     vector<float> &els_dEtaOut() { return cms2.els_dEtaOut(); }
9113     vector<float> &els_dPhiIn() { return cms2.els_dPhiIn(); }
9114     vector<float> &els_dPhiInPhiOut() { return cms2.els_dPhiInPhiOut(); }
9115     vector<float> &els_dPhiOut() { return cms2.els_dPhiOut(); }
9116     vector<float> &els_e1x5() { return cms2.els_e1x5(); }
9117     vector<float> &els_e2x5Max() { return cms2.els_e2x5Max(); }
9118     vector<float> &els_e3x3() { return cms2.els_e3x3(); }
9119     vector<float> &els_e5x5() { return cms2.els_e5x5(); }
9120     vector<float> &els_eMax() { return cms2.els_eMax(); }
9121     vector<float> &els_eOverPIn() { return cms2.els_eOverPIn(); }
9122     vector<float> &els_eSC() { return cms2.els_eSC(); }
9123     vector<float> &els_eSCPresh() { return cms2.els_eSCPresh(); }
9124     vector<float> &els_eSCRaw() { return cms2.els_eSCRaw(); }
9125     vector<float> &els_eSeed() { return cms2.els_eSeed(); }
9126     vector<float> &els_eSeedOverPIn() { return cms2.els_eSeedOverPIn(); }
9127     vector<float> &els_eSeedOverPOut() { return cms2.els_eSeedOverPOut(); }
9128     vector<float> &els_ecalEnergy() { return cms2.els_ecalEnergy(); }
9129     vector<float> &els_ecalEnergyError() { return cms2.els_ecalEnergyError(); }
9130     vector<float> &els_ecalIso() { return cms2.els_ecalIso(); }
9131     vector<float> &els_ecalIso04() { return cms2.els_ecalIso04(); }
9132     vector<float> &els_egamma_looseId() { return cms2.els_egamma_looseId(); }
9133     vector<float> &els_egamma_robustHighEnergy() { return cms2.els_egamma_robustHighEnergy(); }
9134     vector<float> &els_egamma_robustLooseId() { return cms2.els_egamma_robustLooseId(); }
9135     vector<float> &els_egamma_robustTightId() { return cms2.els_egamma_robustTightId(); }
9136     vector<float> &els_egamma_tightId() { return cms2.els_egamma_tightId(); }
9137     vector<float> &els_electronMomentumError() { return cms2.els_electronMomentumError(); }
9138     vector<float> &els_etaErr() { return cms2.els_etaErr(); }
9139     vector<float> &els_etaSC() { return cms2.els_etaSC(); }
9140     vector<float> &els_fBrem() { return cms2.els_fBrem(); }
9141     vector<float> &els_hOverE() { return cms2.els_hOverE(); }
9142     vector<float> &els_hcalIso() { return cms2.els_hcalIso(); }
9143     vector<float> &els_hcalIso04() { return cms2.els_hcalIso04(); }
9144     vector<float> &els_layer1_charge() { return cms2.els_layer1_charge(); }
9145     vector<float> &els_ndof() { return cms2.els_ndof(); }
9146     vector<float> &els_phiErr() { return cms2.els_phiErr(); }
9147     vector<float> &els_phiSC() { return cms2.els_phiSC(); }
9148     vector<float> &els_ptErr() { return cms2.els_ptErr(); }
9149     vector<float> &els_sigmaEtaEta() { return cms2.els_sigmaEtaEta(); }
9150     vector<float> &els_sigmaIEtaIEta() { return cms2.els_sigmaIEtaIEta(); }
9151     vector<float> &els_sigmaIPhiIPhi() { return cms2.els_sigmaIPhiIPhi(); }
9152     vector<float> &els_sigmaPhiPhi() { return cms2.els_sigmaPhiPhi(); }
9153     vector<float> &els_tkIso() { return cms2.els_tkIso(); }
9154     vector<float> &els_tkIso04() { return cms2.els_tkIso04(); }
9155     vector<float> &els_trackMomentumError() { return cms2.els_trackMomentumError(); }
9156     vector<float> &els_trkdr() { return cms2.els_trkdr(); }
9157     vector<float> &els_trkshFrac() { return cms2.els_trkshFrac(); }
9158     vector<float> &els_z0() { return cms2.els_z0(); }
9159     vector<float> &els_z0Err() { return cms2.els_z0Err(); }
9160     vector<float> &els_z0corr() { return cms2.els_z0corr(); }
9161     vector<float> &mus_caloCompatibility() { return cms2.mus_caloCompatibility(); }
9162     vector<float> &mus_chi2() { return cms2.mus_chi2(); }
9163     vector<float> &mus_d0() { return cms2.mus_d0(); }
9164     vector<float> &mus_d0Err() { return cms2.mus_d0Err(); }
9165     vector<float> &mus_d0corr() { return cms2.mus_d0corr(); }
9166     vector<float> &mus_e_em() { return cms2.mus_e_em(); }
9167     vector<float> &mus_e_emS9() { return cms2.mus_e_emS9(); }
9168     vector<float> &mus_e_had() { return cms2.mus_e_had(); }
9169     vector<float> &mus_e_hadS9() { return cms2.mus_e_hadS9(); }
9170     vector<float> &mus_e_ho() { return cms2.mus_e_ho(); }
9171     vector<float> &mus_e_hoS9() { return cms2.mus_e_hoS9(); }
9172     vector<float> &mus_etaErr() { return cms2.mus_etaErr(); }
9173     vector<float> &mus_gfit_chi2() { return cms2.mus_gfit_chi2(); }
9174     vector<float> &mus_gfit_d0() { return cms2.mus_gfit_d0(); }
9175     vector<float> &mus_gfit_d0Err() { return cms2.mus_gfit_d0Err(); }
9176     vector<float> &mus_gfit_d0corr() { return cms2.mus_gfit_d0corr(); }
9177     vector<float> &mus_gfit_ndof() { return cms2.mus_gfit_ndof(); }
9178     vector<float> &mus_gfit_qoverp() { return cms2.mus_gfit_qoverp(); }
9179     vector<float> &mus_gfit_qoverpError() { return cms2.mus_gfit_qoverpError(); }
9180     vector<float> &mus_gfit_z0() { return cms2.mus_gfit_z0(); }
9181     vector<float> &mus_gfit_z0Err() { return cms2.mus_gfit_z0Err(); }
9182     vector<float> &mus_gfit_z0corr() { return cms2.mus_gfit_z0corr(); }
9183     vector<float> &mus_iso03_emEt() { return cms2.mus_iso03_emEt(); }
9184     vector<float> &mus_iso03_hadEt() { return cms2.mus_iso03_hadEt(); }
9185     vector<float> &mus_iso03_hoEt() { return cms2.mus_iso03_hoEt(); }
9186     vector<float> &mus_iso03_sumPt() { return cms2.mus_iso03_sumPt(); }
9187     vector<float> &mus_iso05_emEt() { return cms2.mus_iso05_emEt(); }
9188     vector<float> &mus_iso05_hadEt() { return cms2.mus_iso05_hadEt(); }
9189     vector<float> &mus_iso05_hoEt() { return cms2.mus_iso05_hoEt(); }
9190     vector<float> &mus_iso05_sumPt() { return cms2.mus_iso05_sumPt(); }
9191     vector<float> &mus_iso_ecalvetoDep() { return cms2.mus_iso_ecalvetoDep(); }
9192     vector<float> &mus_iso_hcalvetoDep() { return cms2.mus_iso_hcalvetoDep(); }
9193     vector<float> &mus_iso_hovetoDep() { return cms2.mus_iso_hovetoDep(); }
9194     vector<float> &mus_iso_trckvetoDep() { return cms2.mus_iso_trckvetoDep(); }
9195     vector<float> &mus_ndof() { return cms2.mus_ndof(); }
9196     vector<float> &mus_phiErr() { return cms2.mus_phiErr(); }
9197     vector<float> &mus_ptErr() { return cms2.mus_ptErr(); }
9198     vector<float> &mus_qoverp() { return cms2.mus_qoverp(); }
9199     vector<float> &mus_qoverpError() { return cms2.mus_qoverpError(); }
9200     vector<float> &mus_timeAtIpInOut() { return cms2.mus_timeAtIpInOut(); }
9201     vector<float> &mus_timeAtIpInOutErr() { return cms2.mus_timeAtIpInOutErr(); }
9202     vector<float> &mus_timeAtIpOutIn() { return cms2.mus_timeAtIpOutIn(); }
9203     vector<float> &mus_timeAtIpOutInErr() { return cms2.mus_timeAtIpOutInErr(); }
9204     vector<float> &mus_vertexphi() { return cms2.mus_vertexphi(); }
9205     vector<float> &mus_z0() { return cms2.mus_z0(); }
9206     vector<float> &mus_z0Err() { return cms2.mus_z0Err(); }
9207     vector<float> &mus_z0corr() { return cms2.mus_z0corr(); }
9208     vector<float> &scs_clustersSize() { return cms2.scs_clustersSize(); }
9209     vector<float> &scs_crystalsSize() { return cms2.scs_crystalsSize(); }
9210     vector<float> &scs_e1x3() { return cms2.scs_e1x3(); }
9211     vector<float> &scs_e1x5() { return cms2.scs_e1x5(); }
9212     vector<float> &scs_e2x2() { return cms2.scs_e2x2(); }
9213     vector<float> &scs_e2x5Max() { return cms2.scs_e2x5Max(); }
9214     vector<float> &scs_e3x1() { return cms2.scs_e3x1(); }
9215     vector<float> &scs_e3x2() { return cms2.scs_e3x2(); }
9216     vector<float> &scs_e3x3() { return cms2.scs_e3x3(); }
9217     vector<float> &scs_e4x4() { return cms2.scs_e4x4(); }
9218     vector<float> &scs_e5x5() { return cms2.scs_e5x5(); }
9219     vector<float> &scs_energy() { return cms2.scs_energy(); }
9220     vector<float> &scs_eta() { return cms2.scs_eta(); }
9221     vector<float> &scs_hoe() { return cms2.scs_hoe(); }
9222     vector<float> &scs_phi() { return cms2.scs_phi(); }
9223     vector<float> &scs_preshowerEnergy() { return cms2.scs_preshowerEnergy(); }
9224     vector<float> &scs_rawEnergy() { return cms2.scs_rawEnergy(); }
9225     vector<float> &scs_sigmaEtaEta() { return cms2.scs_sigmaEtaEta(); }
9226     vector<float> &scs_sigmaEtaPhi() { return cms2.scs_sigmaEtaPhi(); }
9227     vector<float> &scs_sigmaIEtaIEta() { return cms2.scs_sigmaIEtaIEta(); }
9228     vector<float> &scs_sigmaIEtaIPhi() { return cms2.scs_sigmaIEtaIPhi(); }
9229     vector<float> &scs_sigmaIPhiIPhi() { return cms2.scs_sigmaIPhiIPhi(); }
9230     vector<float> &scs_sigmaPhiPhi() { return cms2.scs_sigmaPhiPhi(); }
9231     vector<float> &trks_chi2() { return cms2.trks_chi2(); }
9232     vector<float> &trks_d0() { return cms2.trks_d0(); }
9233     vector<float> &trks_d0Err() { return cms2.trks_d0Err(); }
9234     vector<float> &trks_d0corr() { return cms2.trks_d0corr(); }
9235     vector<float> &trks_d0corrPhi() { return cms2.trks_d0corrPhi(); }
9236     vector<float> &trks_etaErr() { return cms2.trks_etaErr(); }
9237     vector<float> &trks_ndof() { return cms2.trks_ndof(); }
9238     vector<float> &trks_phiErr() { return cms2.trks_phiErr(); }
9239     vector<float> &trks_ptErr() { return cms2.trks_ptErr(); }
9240     vector<float> &trks_tkIso() { return cms2.trks_tkIso(); }
9241     vector<float> &trks_vertexphi() { return cms2.trks_vertexphi(); }
9242     vector<float> &trks_z0() { return cms2.trks_z0(); }
9243     vector<float> &trks_z0Err() { return cms2.trks_z0Err(); }
9244     vector<float> &trks_z0corr() { return cms2.trks_z0corr(); }
9245     vector<float> &trks_elsdr() { return cms2.trks_elsdr(); }
9246     vector<float> &trks_elsshFrac() { return cms2.trks_elsshFrac(); }
9247     vector<float> &vtxs_chi2() { return cms2.vtxs_chi2(); }
9248     vector<float> &vtxs_ndof() { return cms2.vtxs_ndof(); }
9249     vector<float> &vtxs_xError() { return cms2.vtxs_xError(); }
9250     vector<float> &vtxs_yError() { return cms2.vtxs_yError(); }
9251     vector<float> &vtxs_zError() { return cms2.vtxs_zError(); }
9252     vector<vector<float> > &trks_residualX() { return cms2.trks_residualX(); }
9253     vector<vector<float> > &trks_residualY() { return cms2.trks_residualY(); }
9254     vector<vector<float> > &vtxs_covMatrix() { return cms2.vtxs_covMatrix(); }
9255     int &evt_bsType() { return cms2.evt_bsType(); }
9256     vector<int> &els_category() { return cms2.els_category(); }
9257     vector<int> &els_charge() { return cms2.els_charge(); }
9258     vector<int> &els_class() { return cms2.els_class(); }
9259     vector<int> &els_fiduciality() { return cms2.els_fiduciality(); }
9260     vector<int> &els_layer1_det() { return cms2.els_layer1_det(); }
9261     vector<int> &els_layer1_layer() { return cms2.els_layer1_layer(); }
9262     vector<int> &els_layer1_sizerphi() { return cms2.els_layer1_sizerphi(); }
9263     vector<int> &els_layer1_sizerz() { return cms2.els_layer1_sizerz(); }
9264     vector<int> &els_lostHits() { return cms2.els_lostHits(); }
9265     vector<int> &els_lost_pixelhits() { return cms2.els_lost_pixelhits(); }
9266     vector<int> &els_nSeed() { return cms2.els_nSeed(); }
9267     vector<int> &els_sccharge() { return cms2.els_sccharge(); }
9268     vector<int> &els_trkidx() { return cms2.els_trkidx(); }
9269     vector<int> &els_type() { return cms2.els_type(); }
9270     vector<int> &els_validHits() { return cms2.els_validHits(); }
9271     vector<int> &els_valid_pixelhits() { return cms2.els_valid_pixelhits(); }
9272     vector<int> &mus_charge() { return cms2.mus_charge(); }
9273     vector<int> &mus_gfit_validHits() { return cms2.mus_gfit_validHits(); }
9274     vector<int> &mus_gfit_validSTAHits() { return cms2.mus_gfit_validSTAHits(); }
9275     vector<int> &mus_gfit_validSiHits() { return cms2.mus_gfit_validSiHits(); }
9276     vector<int> &mus_goodmask() { return cms2.mus_goodmask(); }
9277     vector<int> &mus_iso03_ntrk() { return cms2.mus_iso03_ntrk(); }
9278     vector<int> &mus_iso05_ntrk() { return cms2.mus_iso05_ntrk(); }
9279     vector<int> &mus_lostHits() { return cms2.mus_lostHits(); }
9280     vector<int> &mus_nmatches() { return cms2.mus_nmatches(); }
9281     vector<int> &mus_pid_TM2DCompatibilityLoose() { return cms2.mus_pid_TM2DCompatibilityLoose(); }
9282     vector<int> &mus_pid_TM2DCompatibilityTight() { return cms2.mus_pid_TM2DCompatibilityTight(); }
9283     vector<int> &mus_pid_TMLastStationLoose() { return cms2.mus_pid_TMLastStationLoose(); }
9284     vector<int> &mus_pid_TMLastStationTight() { return cms2.mus_pid_TMLastStationTight(); }
9285     vector<int> &mus_timeDirection() { return cms2.mus_timeDirection(); }
9286     vector<int> &mus_timeNumStationsUsed() { return cms2.mus_timeNumStationsUsed(); }
9287     vector<int> &mus_trk_charge() { return cms2.mus_trk_charge(); }
9288     vector<int> &mus_trkidx() { return cms2.mus_trkidx(); }
9289     vector<int> &mus_type() { return cms2.mus_type(); }
9290     vector<int> &mus_validHits() { return cms2.mus_validHits(); }
9291     vector<int> &scs_elsidx() { return cms2.scs_elsidx(); }
9292     vector<int> &trks_algo() { return cms2.trks_algo(); }
9293     vector<int> &trks_charge() { return cms2.trks_charge(); }
9294     vector<int> &trks_lostHits() { return cms2.trks_lostHits(); }
9295     vector<int> &trks_qualityMask() { return cms2.trks_qualityMask(); }
9296     vector<int> &trks_validHits() { return cms2.trks_validHits(); }
9297     vector<int> &trks_elsidx() { return cms2.trks_elsidx(); }
9298     vector<int> &trk_musidx() { return cms2.trk_musidx(); }
9299     vector<int> &vtxs_isFake() { return cms2.vtxs_isFake(); }
9300     vector<int> &vtxs_isValid() { return cms2.vtxs_isValid(); }
9301     vector<int> &vtxs_tracksSize() { return cms2.vtxs_tracksSize(); }
9302     vector<vector<int> > &trks_hit_substructure() { return cms2.trks_hit_substructure(); }
9303     vector<vector<int> > &trks_hit_type() { return cms2.trks_hit_type(); }
9304     unsigned int &evt_ntwrs() { return cms2.evt_ntwrs(); }
9305     unsigned int &evt_nels() { return cms2.evt_nels(); }
9306     unsigned int &evt_event() { return cms2.evt_event(); }
9307     unsigned int &evt_lumiBlock() { return cms2.evt_lumiBlock(); }
9308     unsigned int &evt_run() { return cms2.evt_run(); }
9309     unsigned int &evt_nscs() { return cms2.evt_nscs(); }
9310     unsigned int &evt_nvtxs() { return cms2.evt_nvtxs(); }
9311     vector<unsigned int> &twrs_numBadEcalCells() { return cms2.twrs_numBadEcalCells(); }
9312     vector<unsigned int> &twrs_numBadHcalCells() { return cms2.twrs_numBadHcalCells(); }
9313     vector<unsigned int> &twrs_numProblematicEcalCells() { return cms2.twrs_numProblematicEcalCells(); }
9314     vector<unsigned int> &twrs_numProblematicHcalCells() { return cms2.twrs_numProblematicHcalCells(); }
9315     vector<unsigned int> &twrs_numRecoveredEcalCells() { return cms2.twrs_numRecoveredEcalCells(); }
9316     vector<unsigned int> &twrs_numRecoveredHcalCells() { return cms2.twrs_numRecoveredHcalCells(); }
9317     float &evt_scale1fb() { return cms2.evt_scale1fb(); }
9318     float &evt_xsec_excl() { return cms2.evt_xsec_excl(); }
9319     float &evt_xsec_incl() { return cms2.evt_xsec_incl(); }
9320     float &evt_kfactor() { return cms2.evt_kfactor(); }
9321     int &evt_nEvts() { return cms2.evt_nEvts(); }
9322     float &evt_filt_eff() { return cms2.evt_filt_eff(); }
9323     }
9324     #endif