ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/MitPhysics/Mods/src/PhotonIDMod.cc
Revision: 1.32
Committed: Tue Jul 24 11:41:21 2012 UTC (12 years, 9 months ago) by fabstoec
Content type: text/plain
Branch: MAIN
Changes since 1.31: +187 -44 lines
Log Message: 
outsourced Photon shower-shape scaling to PhotonTools

File Contents

# User Rev Content
1 fabstoec 1.30
2 fabstoec 1.32 // $Id: PhotonIDMod.cc,v 1.31 2012/05/27 17:02:19 bendavid Exp $
3 sixie 1.1
4 bendavid 1.24 #include "TDataMember.h"
5     #include "TTree.h"
6 fabstoec 1.32 #include "TRandom3.h"
7 sixie 1.1 #include "MitPhysics/Mods/interface/PhotonIDMod.h"
8 loizides 1.7 #include "MitAna/DataTree/interface/PhotonCol.h"
9 sixie 1.1 #include "MitPhysics/Init/interface/ModNames.h"
10 fabstoec 1.17 #include "MitPhysics/Utils/interface/IsolationTools.h"
11 bendavid 1.19 #include "MitPhysics/Utils/interface/PhotonTools.h"
12 sixie 1.1
13 fabstoec 1.26 #include <TSystem.h>
14    
15 sixie 1.1 using namespace mithep;
16    
17     ClassImp(mithep::PhotonIDMod)
18 fabstoec 1.32
19 sixie 1.1 //--------------------------------------------------------------------------------------------------
20     PhotonIDMod::PhotonIDMod(const char *name, const char *title) :
21     BaseMod(name,title),
22 fabstoec 1.17 fPhotonBranchName (Names::gkPhotonBrn),
23     fGoodPhotonsName (ModNames::gkGoodPhotonsName),
24     fTrackBranchName (Names::gkTrackBrn),
25     fBeamspotBranchName(Names::gkBeamSpotBrn),
26 fabstoec 1.18 fPileUpDenName (Names::gkPileupEnergyDensityBrn),
27 bendavid 1.19 fConversionName ("MergedConversions"),
28     fElectronName ("Electrons"),
29 bendavid 1.25 fGoodElectronName ("Electrons"),
30 fabstoec 1.22 fPVName (Names::gkPVBeamSpotBrn),
31 bendavid 1.24 // MC specific stuff...
32     fMCParticleName (Names::gkMCPartBrn),
33     fPileUpName (Names::gkPileupInfoBrn),
34 bendavid 1.31 fPFCandsName ("PFCandidates"),
35 fabstoec 1.32
36 fabstoec 1.22 fPhotonIDType ("Custom"),
37     fPhotonIsoType ("Custom"),
38     fPhotonPtMin (15.0),
39     fHadOverEmMax (0.02),
40     fApplySpikeRemoval (kFALSE),
41     fApplyPixelSeed (kTRUE),
42     fApplyElectronVeto (kFALSE),
43 bendavid 1.25 fInvertElectronVeto(kFALSE),
44 bendavid 1.19 fApplyElectronVetoConvRecovery(kFALSE),
45 fabstoec 1.22 fApplyConversionId (kFALSE),
46 bendavid 1.19 fApplyTriggerMatching(kFALSE),
47 fabstoec 1.22 fPhotonR9Min (0.5),
48     fPhIdType (kIdUndef),
49     fPhIsoType (kIsoUndef),
50     fFiduciality (kTRUE),
51     fEtaWidthEB (0.01),
52     fEtaWidthEE (0.028),
53     fAbsEtaMax (999.99),
54     fApplyR9Min (kFALSE),
55 fabstoec 1.32
56 fabstoec 1.22 fEffAreaEcalEE (0.089),
57     fEffAreaHcalEE (0.156),
58     fEffAreaTrackEE (0.261),
59 fabstoec 1.32
60 fabstoec 1.22 fEffAreaEcalEB (0.183),
61     fEffAreaHcalEB (0.062),
62     fEffAreaTrackEB (0.306),
63 fabstoec 1.32
64 fabstoec 1.17 fPhotons(0),
65     fTracks(0),
66     fBeamspots(0),
67 bendavid 1.19 fPileUpDen(0),
68     fConversions(0),
69 fabstoec 1.22 fElectrons(0),
70 bendavid 1.25 fGoodElectrons(0),
71 fabstoec 1.22 fPV(0),
72 bendavid 1.24 fMCParticles (0),
73     fPileUp (0),
74 bendavid 1.31 fPFCands (0),
75 fabstoec 1.32
76 fabstoec 1.26 // MVA ID Stuff
77 bendavid 1.27 fbdtCutBarrel (0.0744), //cuts give the same effiiciency (relative to preselection) with cic
78     fbdtCutEndcap (0.0959), //cuts give the same effiiciency (relative to preselection) with cic
79 bendavid 1.29 fVariableType (10), //please use 4 which is the correct type
80     fEndcapWeights (gSystem->Getenv("CMSSW_BASE")+TString("/src/MitPhysics/data/TMVAClassificationPhotonID_Endcap_PassPreSel_Variable_10_BDTnCuts2000_BDT.weights.xml")),
81     fBarrelWeights (gSystem->Getenv("CMSSW_BASE")+TString("/src/MitPhysics/data/TMVAClassificationPhotonID_Barrel_PassPreSel_Variable_10_BDTnCuts2000_BDT.weights.xml")),
82 fabstoec 1.32
83     // fDoMCR9Scaling (kFALSE),
84     // fMCR9ScaleEB (1.0),
85     // fMCR9ScaleEE (1.0),
86     // fDoMCSigIEtaIEtaScaling(kFALSE),
87     // fDoMCWidthScaling (kFALSE),
88    
89     fDoMCErrScaling (kFALSE),
90     fMCErrScaleEB (1.0),
91     fMCErrScaleEE (1.0),
92    
93 fabstoec 1.30 fPhotonsFromBranch(true),
94 bendavid 1.24 fPVFromBranch (true),
95 bendavid 1.25 fGoodElectronsFromBranch (kTRUE),
96 fabstoec 1.32 fIsData(false),
97    
98     // ------------------------------------------------
99     // added by fab: smearing/scaling options...
100     fDoDataEneCorr (false),
101     fDoMCSmear (false),
102    
103     fDoShowerShapeScaling (false),
104     // ------------------------------------------------
105     fDataEnCorr_EBlowEta_hR9central(0.),
106     fDataEnCorr_EBlowEta_hR9gap (0.),
107     fDataEnCorr_EBlowEta_lR9 (0.),
108     fDataEnCorr_EBhighEta_hR9 (0.),
109     fDataEnCorr_EBhighEta_lR9 (0.),
110     fDataEnCorr_EElowEta_hR9 (0.),
111     fDataEnCorr_EElowEta_lR9 (0.),
112     fDataEnCorr_EEhighEta_hR9 (0.),
113     fDataEnCorr_EEhighEta_lR9 (0.),
114     fRunStart (0),
115     fRunEnd (0),
116     fMCSmear_EBlowEta_hR9central (0.),
117     fMCSmear_EBlowEta_hR9gap (0.),
118     fMCSmear_EBlowEta_lR9 (0.),
119     fMCSmear_EBhighEta_hR9 (0.),
120     fMCSmear_EBhighEta_lR9 (0.),
121     fMCSmear_EElowEta_hR9 (0.),
122     fMCSmear_EElowEta_lR9 (0.),
123     fMCSmear_EEhighEta_hR9 (0.),
124     fMCSmear_EEhighEta_lR9 (0.),
125 fabstoec 1.17
126 fabstoec 1.32 fRng (new TRandom3())
127    
128 sixie 1.1 {
129     // Constructor.
130     }
131    
132     //--------------------------------------------------------------------------------------------------
133     void PhotonIDMod::Process()
134     {
135     // Process entries of the tree.
136    
137 fabstoec 1.17 LoadEventObject(fPhotonBranchName, fPhotons);
138 bendavid 1.19
139     const BaseVertex *bsp = NULL;
140     Double_t _tRho = -1.;
141 bendavid 1.31 Float_t rho2012 = -99;
142 bendavid 1.19 const TriggerObjectCol *trigObjs = 0;
143     if (fPhotons->GetEntries()>0) {
144     LoadEventObject(fTrackBranchName, fTracks);
145     LoadEventObject(fBeamspotBranchName, fBeamspots);
146 bendavid 1.24 LoadEventObject(fPileUpDenName, fPileUpDen);
147 bendavid 1.19 LoadEventObject(fConversionName, fConversions);
148     LoadEventObject(fElectronName, fElectrons);
149 fabstoec 1.26 LoadEventObject(fGoodElectronName, fGoodElectrons);
150 bendavid 1.24 LoadEventObject(fPVName, fPV);
151 bendavid 1.31 LoadEventObject(fPFCandsName, fPFCands);
152    
153 bendavid 1.19
154     if(fBeamspots->GetEntries() > 0)
155     bsp = fBeamspots->At(0);
156 fabstoec 1.17
157 bendavid 1.24 if(fPileUpDen->GetEntries() > 0)
158 fabstoec 1.23 _tRho = (Double_t) fPileUpDen->At(0)->RhoRandomLowEta();
159 fabstoec 1.26
160 bendavid 1.31 if (fPileUpDen->At(0)->RhoKt6PFJets()>0.) rho2012 = fPileUpDen->At(0)->RhoKt6PFJets();
161     else rho2012 = fPileUpDen->At(0)->Rho();
162 bendavid 1.19
163     //get trigger object collection if trigger matching is enabled
164     if (fApplyTriggerMatching) {
165     trigObjs = GetHLTObjects(fTrigObjectsName);
166     }
167    
168     }
169 fabstoec 1.17
170 fabstoec 1.32
171     // ------------------------------------------------------------
172     // Get Event header for Run info etc.
173     const EventHeader* evtHead = this->GetEventHeader();
174     unsigned int evtNum = evtHead->EvtNum();
175     UInt_t runNumber = evtHead->RunNum();
176     Float_t _runNum = (Float_t) runNumber;
177     Float_t _lumiSec = (Float_t) evtHead->LumiSec();
178    
179 sixie 1.1 PhotonOArr *GoodPhotons = new PhotonOArr;
180     GoodPhotons->SetName(fGoodPhotonsName);
181 fabstoec 1.30 GoodPhotons->SetOwner(kTRUE);
182 sixie 1.1
183     for (UInt_t i=0; i<fPhotons->GetEntries(); ++i) {
184 fabstoec 1.30 // need to cpoy the photon in order to be able to scale R9 etc.
185     Photon *ph = new Photon(*fPhotons->At(i));
186 sixie 1.1
187 bendavid 1.24
188     if (fFiduciality == kTRUE &&
189     (ph->SCluster()->AbsEta()>=2.5 || (ph->SCluster()->AbsEta()>=1.4442 && ph->SCluster()->AbsEta()<=1.566) ) )
190     continue;
191    
192 fabstoec 1.30 if (fInvertElectronVeto && PhotonTools::PassElectronVeto(ph,fGoodElectrons) && false) {
193 bendavid 1.25 continue;
194     }
195    
196 fabstoec 1.30 // -----------------------------------------------------------------------------------
197     // Do all the scaling ....
198     if (fDoMCErrScaling && !fIsData) {
199     if (ph->SCluster()->AbsEta()<1.5) PhotonTools::ScalePhotonError(ph,fMCErrScaleEB);
200     else PhotonTools::ScalePhotonError(ph,fMCErrScaleEE);
201     }
202    
203 fabstoec 1.32 if (fDoShowerShapeScaling && !fIsData) {
204     PhotonTools::ScalePhotonShowerShapes(ph,fSSType);
205 fabstoec 1.30 }
206    
207 fabstoec 1.32 // fab: replaced by shower-shape scaling above...
208     // if (fDoMCR9Scaling && !fIsData) {
209     // if (ph->SCluster()->AbsEta()<1.5) PhotonTools::ScalePhotonR9(ph,fMCR9ScaleEB);
210     // else PhotonTools::ScalePhotonR9(ph,fMCR9ScaleEE);
211     // }
212    
213     // if (fDoMCSigIEtaIEtaScaling && !fIsData) {
214     // if (ph->SCluster()->AbsEta()<1.5) ph->SetCoviEtaiEta(0.87*ph->CoviEtaiEta() + 0.0011);
215     // else ph->SetCoviEtaiEta(0.99*ph->CoviEtaiEta());
216     // }
217    
218     // if (fDoMCWidthScaling && !fIsData) {
219     // ph->SetEtaWidth(0.99*ph->EtaWidth());
220     // ph->SetPhiWidth(0.99*ph->PhiWidth());
221     // }
222    
223     PhotonTools::eScaleCats escalecat = PhotonTools::EScaleCat(ph);
224    
225     // now we dicide if we either scale (Data) or Smear (MC) the Photons
226     if (fIsData) {
227     if (fDoDataEneCorr) {
228     // starting with scale = 1.
229     double scaleFac = 1.;
230     // checking the run Rangees ...
231     Int_t runRange = FindRunRangeIdx(runNumber);
232     if(runRange > -1) {
233     scaleFac *= GetDataEnCorr(runRange, escalecat);
234     }
235     PhotonTools::ScalePhoton(ph, scaleFac);
236     }
237 fabstoec 1.30 }
238 fabstoec 1.32
239     if (fDoMCSmear) {
240     double width = GetMCSmearFac(escalecat);
241     if (!fIsData) {
242     // get the seed to do deterministic smearing...
243     UInt_t seedBase = (UInt_t) evtNum + (UInt_t) _runNum + (UInt_t) _lumiSec;
244     UInt_t seed = seedBase + (UInt_t) ph->E() +
245     (UInt_t) (TMath::Abs(10.*ph->SCluster()->Eta()));
246     // get the smearing for MC photons..
247     PhotonTools::SmearPhoton(ph, fRng, width, seed);
248     }
249     PhotonTools::SmearPhotonError(ph, width);
250 fabstoec 1.30 }
251    
252    
253 fabstoec 1.22 // ---------------------------------------------------------------------
254     // check if we use the CiC Selection. If yes, bypass all the below...
255     if(fPhIdType == kBaseLineCiC) {
256     if( PhotonTools::PassCiCSelection(ph, fPV->At(0), fTracks, fElectrons, fPV, _tRho, fPhotonPtMin, fApplyElectronVeto) )
257 fabstoec 1.30 GoodPhotons->AddOwned(ph);
258 fabstoec 1.22 continue; // go to next Photons
259     }
260 bendavid 1.31
261     if(fPhIdType == kBaseLineCiCPF) {
262     if( PhotonTools::PassSinglePhotonPreselPFISO(ph,fElectrons,fConversions,bsp,fTracks,fPV->At(0),rho2012,fPFCands,fApplyElectronVeto,fInvertElectronVeto) && PhotonTools::PassCiCPFIsoSelection(ph, fPV->At(0), fPFCands, fPV, rho2012, fPhotonPtMin) )
263     GoodPhotons->AddOwned(ph);
264     continue; // go to next Photons
265     }
266 fabstoec 1.22 // ---------------------------------------------------------------------
267    
268 bendavid 1.27 //loose photon preselection for subsequent mva
269     if(fPhIdType == kMITPhSelection ) {
270 fabstoec 1.30 if( ph->Pt()>fPhotonPtMin && PhotonTools::PassSinglePhotonPresel(ph,fElectrons,fConversions,bsp,fTracks,fPV->At(0),_tRho,fApplyElectronVeto,fInvertElectronVeto) ) {
271     GoodPhotons->AddOwned(ph);
272 bendavid 1.27 }
273     continue;
274     }
275    
276 bendavid 1.31 //loose photon preselection for subsequent mva
277     if(fPhIdType == kMITPFPhSelection ) {
278     if( ph->Pt()>fPhotonPtMin && PhotonTools::PassSinglePhotonPreselPFISO(ph,fElectrons,fConversions,bsp,fTracks,fPV->At(0),rho2012,fPFCands,fApplyElectronVeto,fInvertElectronVeto) ) {
279     GoodPhotons->AddOwned(ph);
280     }
281     continue;
282     }
283    
284 fabstoec 1.26 // add MingMings MVA ID on single Photon level
285     if(fPhIdType == kMITMVAId ) {
286 bendavid 1.28 if( ph->Pt()>fPhotonPtMin && PhotonTools::PassSinglePhotonPresel(ph,fElectrons,fConversions,bsp,fTracks,fPV->At(0),_tRho,fApplyElectronVeto) && fTool.PassMVASelection(ph, fPV->At(0) ,fTracks, fPV, _tRho ,fbdtCutBarrel,fbdtCutEndcap, fElectrons, fApplyElectronVeto) ) {
287 fabstoec 1.30 GoodPhotons->AddOwned(ph);
288 fabstoec 1.26 }
289     continue;
290     } // go to next Photon
291    
292 sixie 1.1 if (ph->Pt() <= fPhotonPtMin)
293 fabstoec 1.22 continue; // add good electron
294 sixie 1.13
295 bendavid 1.21 Bool_t isbarrel = ph->SCluster()->AbsEta()<1.5;
296 sixie 1.1
297 sixie 1.13 Bool_t passSpikeRemovalFilter = kTRUE;
298 fabstoec 1.32
299 sixie 1.15 if (ph->SCluster() && ph->SCluster()->Seed()) {
300     if(ph->SCluster()->Seed()->Energy() > 5.0 &&
301     ph->SCluster()->Seed()->EMax() / ph->SCluster()->Seed()->E3x3() > 0.95
302 fabstoec 1.32 ) {
303 sixie 1.15 passSpikeRemovalFilter = kFALSE;
304     }
305 sixie 1.13 }
306 fabstoec 1.32
307 sixie 1.13 // For Now Only use the EMax/E3x3 prescription.
308     //if(ph->SCluster()->Seed()->Energy() > 5.0 &&
309     // (1 - (ph->SCluster()->Seed()->E1x3() + ph->SCluster()->Seed()->E3x1() - 2*ph->SCluster()->Seed()->EMax())) > 0.95
310     // ) {
311     // passSpikeRemovalFilter = kFALSE;
312     //}
313 fabstoec 1.32
314 sixie 1.13 if (fApplySpikeRemoval && !passSpikeRemovalFilter) continue;
315    
316 ceballos 1.2 if (ph->HadOverEm() >= fHadOverEmMax)
317     continue;
318 ceballos 1.14
319 ceballos 1.2 if (fApplyPixelSeed == kTRUE &&
320     ph->HasPixelSeed() == kTRUE)
321     continue;
322 ceballos 1.14
323 bendavid 1.19 if (fApplyElectronVeto && !PhotonTools::PassElectronVeto(ph,fElectrons) ) continue;
324    
325     if (fApplyElectronVetoConvRecovery && !PhotonTools::PassElectronVetoConvRecovery(ph,fElectrons,fConversions,bsp) ) continue;
326    
327     if (fApplyConversionId && !PhotonTools::PassConversionId(ph,PhotonTools::MatchedConversion(ph,fConversions,bsp))) continue;
328    
329     if (fApplyTriggerMatching && !PhotonTools::PassTriggerMatching(ph,trigObjs)) continue;
330    
331 sixie 1.1 Bool_t idcut = kFALSE;
332     switch (fPhIdType) {
333     case kTight:
334     idcut = ph->IsTightPhoton();
335     break;
336     case kLoose:
337     idcut = ph->IsLoosePhoton();
338     break;
339     case kLooseEM:
340     idcut = ph->IsLooseEM();
341     break;
342     case kCustomId:
343 ceballos 1.5 idcut = kTRUE;
344 sixie 1.1 default:
345     break;
346     }
347    
348     if (!idcut)
349     continue;
350    
351     Bool_t isocut = kFALSE;
352     switch (fPhIsoType) {
353     case kNoIso:
354     isocut = kTRUE;
355     break;
356 ceballos 1.2 case kCombinedIso:
357 bendavid 1.12 {
358     Double_t totalIso = ph->HollowConeTrkIsoDr04()+
359     ph->EcalRecHitIsoDr04() +
360     ph->HcalTowerSumEtDr04();
361     if (totalIso/ph->Pt() < 0.25)
362     isocut = kTRUE;
363     }
364 ceballos 1.2 break;
365 sixie 1.1 case kCustomIso:
366 bendavid 1.16 {
367     if ( ph->HollowConeTrkIsoDr04() < (1.5 + 0.001*ph->Pt()) && ph->EcalRecHitIsoDr04()<(2.0+0.006*ph->Pt()) && ph->HcalTowerSumEtDr04()<(2.0+0.0025*ph->Pt()) )
368     isocut = kTRUE;
369     }
370 fabstoec 1.17 break;
371    
372     case kMITPUCorrected:
373     {
374     // compute the PU corrections only if Rho is available
375 fabstoec 1.32 // ... otherwise (_tRho = 0.0) it's the std isolation
376 fabstoec 1.17 isocut = kTRUE;
377 fabstoec 1.20 Double_t fEffAreaEcal = fEffAreaEcalEB;
378     Double_t fEffAreaHcal = fEffAreaHcalEB;
379     Double_t fEffAreaTrack = fEffAreaTrackEB;
380    
381 bendavid 1.21 if( !isbarrel ) {
382 fabstoec 1.20 fEffAreaEcal = fEffAreaEcalEE;
383     fEffAreaHcal = fEffAreaHcalEE;
384     fEffAreaTrack = fEffAreaTrackEE;
385     }
386 fabstoec 1.26
387 fabstoec 1.17 Double_t EcalCorrISO = ph->EcalRecHitIsoDr04();
388     if(_tRho > -0.5 ) EcalCorrISO -= _tRho * fEffAreaEcal;
389     if ( EcalCorrISO > (2.0+0.006*ph->Pt()) ) isocut = kFALSE;
390 fabstoec 1.26 if ( isocut || true ) {
391 fabstoec 1.17 Double_t HcalCorrISO = ph->HcalTowerSumEtDr04();
392     if(_tRho > -0.5 ) HcalCorrISO -= _tRho * fEffAreaHcal;
393     if ( HcalCorrISO > (2.0+0.0025*ph->Pt()) ) isocut = kFALSE;
394     }
395 fabstoec 1.26 if ( isocut || true ) {
396 fabstoec 1.17 Double_t TrackCorrISO = IsolationTools::TrackIsolationNoPV(ph, bsp, 0.4, 0.04, 0.0, 0.015, 0.1, TrackQuality::highPurity, fTracks);
397     if(_tRho > -0.5 )
398     TrackCorrISO -= _tRho * fEffAreaTrack;
399     if ( TrackCorrISO > (1.5 + 0.001*ph->Pt()) ) isocut = kFALSE;
400     }
401     break;
402     }
403     default:
404     break;
405 sixie 1.1 }
406 fabstoec 1.17
407 sixie 1.1 if (!isocut)
408     continue;
409 fabstoec 1.17
410 bendavid 1.16 if ( fApplyR9Min && ph->R9() <= fPhotonR9Min)
411 ceballos 1.5 continue;
412    
413 bendavid 1.21 if ((isbarrel && ph->CoviEtaiEta() >= fEtaWidthEB) ||
414     (!isbarrel && ph->CoviEtaiEta() >= fEtaWidthEE))
415 ceballos 1.10 continue;
416    
417 ceballos 1.11 if (ph->AbsEta() >= fAbsEtaMax)
418     continue;
419 bendavid 1.25
420 sixie 1.1 // add good electron
421 fabstoec 1.30 GoodPhotons->AddOwned(ph);
422 sixie 1.1 }
423    
424 loizides 1.4 // sort according to pt
425     GoodPhotons->Sort();
426    
427 sixie 1.1 // add to event for other modules to use
428     AddObjThisEvt(GoodPhotons);
429 bendavid 1.24
430 bendavid 1.25 return;
431 bendavid 1.24
432 sixie 1.1 }
433    
434     //--------------------------------------------------------------------------------------------------
435     void PhotonIDMod::SlaveBegin()
436     {
437     // Run startup code on the computer (slave) doing the actual analysis. Here,
438 loizides 1.3 // we just request the photon collection branch.
439 sixie 1.1
440 fabstoec 1.30 ReqEventObject(fPhotonBranchName, fPhotons, fPhotonsFromBranch);
441 fabstoec 1.22 ReqEventObject(fTrackBranchName, fTracks, kTRUE);
442     ReqEventObject(fBeamspotBranchName, fBeamspots, kTRUE);
443 bendavid 1.19 ReqEventObject(fConversionName, fConversions, kTRUE);
444 fabstoec 1.22 ReqEventObject(fElectronName, fElectrons, kTRUE);
445 bendavid 1.25 ReqEventObject(fGoodElectronName, fGoodElectrons, fGoodElectronsFromBranch);
446 bendavid 1.24 ReqEventObject(fPVName, fPV, fPVFromBranch);
447     ReqEventObject(fPileUpDenName, fPileUpDen, kTRUE);
448 bendavid 1.31 ReqEventObject(fPFCandsName, fPFCands, kTRUE);
449 fabstoec 1.30
450 bendavid 1.24 if (!fIsData) {
451     ReqBranch(fPileUpName, fPileUp);
452     ReqBranch(fMCParticleName, fMCParticles);
453     }
454    
455 sixie 1.1 if (fPhotonIDType.CompareTo("Tight") == 0)
456     fPhIdType = kTight;
457     else if (fPhotonIDType.CompareTo("Loose") == 0)
458     fPhIdType = kLoose;
459     else if (fPhotonIDType.CompareTo("LooseEM") == 0)
460     fPhIdType = kLooseEM;
461 fabstoec 1.22 else if (fPhotonIDType.CompareTo("Custom") == 0)
462 sixie 1.1 fPhIdType = kCustomId;
463 fabstoec 1.22 else if (fPhotonIDType.CompareTo("BaseLineCiC") == 0) {
464     fPhIdType = kBaseLineCiC;
465     fPhotonIsoType = "NoIso";
466 fabstoec 1.26 }
467 bendavid 1.31 else if (fPhotonIDType.CompareTo("BaseLineCiCPF") == 0) {
468     fPhIdType = kBaseLineCiCPF;
469     fPhotonIsoType = "NoIso";
470     }
471 fabstoec 1.26 else if (fPhotonIDType.CompareTo("MITMVAId") == 0) {
472     fPhIdType = kMITMVAId;
473     fPhotonIsoType = "NoIso";
474     fTool.InitializeMVA(fVariableType,fEndcapWeights,fBarrelWeights);
475 bendavid 1.27 }
476     else if (fPhotonIDType.CompareTo("MITSelection") == 0) {
477     fPhIdType = kMITPhSelection;
478     fPhotonIsoType = "NoIso";
479     }
480 bendavid 1.31 else if (fPhotonIDType.CompareTo("MITPFSelection") == 0) {
481     fPhIdType = kMITPFPhSelection;
482     fPhotonIsoType = "NoIso";
483     }
484 bendavid 1.27 else {
485 sixie 1.1 SendError(kAbortAnalysis, "SlaveBegin",
486 ceballos 1.2 "The specified photon identification %s is not defined.",
487 sixie 1.1 fPhotonIDType.Data());
488     return;
489     }
490    
491     if (fPhotonIsoType.CompareTo("NoIso") == 0 )
492     fPhIsoType = kNoIso;
493 ceballos 1.2 else if (fPhotonIsoType.CompareTo("CombinedIso") == 0 )
494     fPhIsoType = kCombinedIso;
495 fabstoec 1.17 else if (fPhotonIsoType.CompareTo("Custom") == 0 )
496 sixie 1.1 fPhIsoType = kCustomIso;
497 fabstoec 1.17 else if (fPhotonIsoType.CompareTo("MITPUCorrected") == 0 )
498     fPhIsoType = kMITPUCorrected;
499     else {
500 sixie 1.1 SendError(kAbortAnalysis, "SlaveBegin",
501 ceballos 1.2 "The specified photon isolation %s is not defined.",
502 sixie 1.1 fPhotonIsoType.Data());
503     return;
504     }
505 bendavid 1.25
506 fabstoec 1.32 if (fShowerShapeType.CompareTo("None") == 0)
507     fSSType = PhotonTools::kNoShowerShapeScaling;
508     else if (fShowerShapeType.CompareTo("2011ShowerShape") == 0)
509     fSSType = PhotonTools::k2011ShowerShape;
510     else if (fShowerShapeType.CompareTo("2012ShowerShape") == 0)
511     fSSType = PhotonTools::k2012ShowerShape;
512     else {
513     std::cerr<<"shower shape scale "<<fShowerShapeType<<" not implemented."<<std::endl;
514     return;
515     }
516 bendavid 1.24
517 sixie 1.1 }
518 fabstoec 1.32
519    
520     //---------------------------------------------------------------------------------------------------
521     Int_t PhotonIDMod::FindRunRangeIdx(UInt_t run)
522     {
523     // this routine looks for the idx of the run-range
524     Int_t runRange=-1;
525     for (UInt_t iRun = 0; iRun<fRunStart.size(); ++iRun) {
526     if (run >= fRunStart[iRun] && run <= fRunEnd[iRun]) {
527     runRange = (Int_t) iRun;
528     return runRange;
529     }
530     }
531     return runRange;
532     }
533    
534     //---------------------------------------------------------------------------------------------------
535     Double_t PhotonIDMod::GetDataEnCorr(Int_t runRange, PhotonTools::eScaleCats cat)
536     {
537     switch (cat) {
538     case PhotonTools::kEBhighEtaGold:
539     return fDataEnCorr_EBhighEta_hR9[runRange];
540     case PhotonTools::kEBhighEtaBad:
541     return fDataEnCorr_EBhighEta_lR9[runRange];
542     case PhotonTools::kEBlowEtaGoldCenter:
543     return fDataEnCorr_EBlowEta_hR9central[runRange];
544     case PhotonTools::kEBlowEtaGoldGap:
545     return fDataEnCorr_EBlowEta_hR9gap[runRange];
546     case PhotonTools::kEBlowEtaBad:
547     return fDataEnCorr_EBlowEta_lR9[runRange];
548     case PhotonTools::kEEhighEtaGold:
549     return fDataEnCorr_EEhighEta_hR9[runRange];
550     case PhotonTools::kEEhighEtaBad:
551     return fDataEnCorr_EEhighEta_lR9[runRange];
552     case PhotonTools::kEElowEtaGold:
553     return fDataEnCorr_EElowEta_hR9[runRange];
554     case PhotonTools::kEElowEtaBad:
555     return fDataEnCorr_EElowEta_lR9[runRange];
556     default:
557     return 1.;
558     }
559     }
560    
561     //---------------------------------------------------------------------------------------------------
562     Double_t PhotonIDMod::GetMCSmearFac(PhotonTools::eScaleCats cat)
563     {
564     switch (cat) {
565     case PhotonTools::kEBhighEtaGold:
566     return fMCSmear_EBhighEta_hR9;
567     case PhotonTools::kEBhighEtaBad:
568     return fMCSmear_EBhighEta_lR9;
569     case PhotonTools::kEBlowEtaGoldCenter:
570     return fMCSmear_EBlowEta_hR9central;
571     case PhotonTools::kEBlowEtaGoldGap:
572     return fMCSmear_EBlowEta_hR9gap;
573     case PhotonTools::kEBlowEtaBad:
574     return fMCSmear_EBlowEta_lR9;
575     case PhotonTools::kEEhighEtaGold:
576     return fMCSmear_EEhighEta_hR9;
577     case PhotonTools::kEEhighEtaBad:
578     return fMCSmear_EEhighEta_lR9;
579     case PhotonTools::kEElowEtaGold:
580     return fMCSmear_EElowEta_hR9;
581     case PhotonTools::kEElowEtaBad:
582     return fMCSmear_EElowEta_lR9;
583     default:
584     return 1.;
585     }
586     }