HbbAnalyzer/python/pfIsoDeltaBeta04_cff.py

### assembled and modified from CommonTools/ ParticleFlow/ python/ ParticleSelectors/ pfCandsForIsolation_cff.py
import FWCore.ParameterSet.Config as cms

from CommonTools.ParticleFlow.pfNoPileUp_cff  import *
from CommonTools.ParticleFlow.ParticleSelectors.pfSortByType_cff import *

#Create the PU candidates
pfPileUpCandidates = cms.EDProducer("TPPFCandidatesOnPFCandidates",
                                                                             enable =  cms.bool( True ),
                                                                             verbose = cms.untracked.bool( False ),
                                                                             name = cms.untracked.string("pileUpCandidates"),
                                                                             topCollection = cms.InputTag("pfNoPileUp"),
                                                                            ### bottomCollection = cms.InputTag("particleFlowTmp") ## ..Tmp in 44X
                                                                             bottomCollection = cms.InputTag("particleFlow"),
                                    
                                                                             )


 #Take the PU charged particles
pfPUChargedCandidates = cms.EDFilter("PdgIdPFCandidateSelector",
                                                                     src = cms.InputTag("pfPileUpCandidates"),
                                                                     pdgId = cms.vint32(211,-211,321,-321,999211,2212,-2212,11,-11,13,-13)
                                                                     )


#Create All Charged Particles
pfAllChargedCandidates = cms.EDFilter("PdgIdPFCandidateSelector",
       src = cms.InputTag("pfNoPileUp"),
       pdgId = cms.vint32(211,-211,321,-321,999211,2212,-2212,11,-11,13,-13)
       )


pfPileUpCandidatesSequence = cms.Sequence(pfPileUpCandidates+
                pfPUChargedCandidates+
                pfAllChargedCandidates)


pfCandsForIsolationSequence = cms.Sequence(
     pfNoPileUpSequence +
     pfSortByTypeSequence +
     pfPileUpCandidatesSequence
       )

##assembled and modified from /CMSSW/RecoMuon/MuonIsolation/python/muonPFIsolation_cff.py from V02-03-01 (44X) and adapting also for electrons

import FWCore.ParameterSet.Config as cms

from CommonTools.ParticleFlow.Isolation.tools_cfi import *
from PhysicsTools.PatAlgos.patSequences_cff import patMuons
from PhysicsTools.PatAlgos.patSequences_cff import patElectrons


##### MUONS ##################
#Now prepare the iso deposits
muPFIsoDepositCharged=isoDepositReplace('pfSelectedMuons','pfAllChargedHadrons')
muPFIsoDepositChargedAll=isoDepositReplace('pfSelectedMuons','pfAllChargedCandidates')
muPFIsoDepositNeutral=isoDepositReplace('pfSelectedMuons','pfAllNeutralHadrons')
muPFIsoDepositGamma=isoDepositReplace('pfSelectedMuons','pfAllPhotons')
muPFIsoDepositPU=isoDepositReplace('pfSelectedMuons','pfPUChargedCandidates')


#Now create isolation values for those isolation deposits 

muPFIsoValueCharged03 = cms.EDProducer("CandIsolatorFromDeposits",
    deposits = cms.VPSet(
            cms.PSet(
            src = cms.InputTag("muPFIsoDepositCharged"),
            deltaR = cms.double(0.3),
            weight = cms.string('1'),
            vetos = cms.vstring('0.0001','Threshold(0.0)'),
            skipDefaultVeto = cms.bool(True),
            mode = cms.string('sum')
            )
     )
)

muPFIsoValueChargedAll03 = cms.EDProducer("CandIsolatorFromDeposits",
    deposits = cms.VPSet(
            cms.PSet(
            src = cms.InputTag("muPFIsoDepositChargedAll"),
            deltaR = cms.double(0.3),
            weight = cms.string('1'),
            vetos = cms.vstring('0.0001','Threshold(0.0)'),
            skipDefaultVeto = cms.bool(True),
            mode = cms.string('sum')
     )
   )
)

muPFIsoValueGamma03 = cms.EDProducer("CandIsolatorFromDeposits",
    deposits = cms.VPSet(
            cms.PSet(
            src = cms.InputTag("muPFIsoDepositGamma"),
            deltaR = cms.double(0.3),
            weight = cms.string('1'),
            vetos = cms.vstring('0.01','Threshold(0.5)'),
            skipDefaultVeto = cms.bool(True),
            mode = cms.string('sum')
      )
   )
)

muPFIsoValueNeutral03 = cms.EDProducer("CandIsolatorFromDeposits",
    deposits = cms.VPSet(
            cms.PSet(
            src = cms.InputTag("muPFIsoDepositNeutral"),
            deltaR = cms.double(0.3),
            weight = cms.string('1'),
            vetos = cms.vstring('0.01','Threshold(0.5)'),
            skipDefaultVeto = cms.bool(True),
            mode = cms.string('sum')
    )
 )
)

muPFIsoValuePU03 = cms.EDProducer("CandIsolatorFromDeposits",
    deposits = cms.VPSet(
            cms.PSet(
            src = cms.InputTag("muPFIsoDepositPU"),
            deltaR = cms.double(0.3),
            weight = cms.string('1'),
            vetos = cms.vstring('0.01','Threshold(0.5)'),
            skipDefaultVeto = cms.bool(True),
            mode = cms.string('sum')
      )
   )
)


muPFIsoValueCharged04 = cms.EDProducer("CandIsolatorFromDeposits",
    deposits = cms.VPSet(
            cms.PSet(
            src = cms.InputTag("muPFIsoDepositCharged"),
            deltaR = cms.double(0.4),
            weight = cms.string('1'),
            vetos = cms.vstring('0.0001','Threshold(0.0)'),
            skipDefaultVeto = cms.bool(True),
            mode = cms.string('sum')
            )
     )
)


muPFIsoValueChargedAll04 = cms.EDProducer("CandIsolatorFromDeposits",
    deposits = cms.VPSet(
            cms.PSet(
            src = cms.InputTag("muPFIsoDepositChargedAll"),
            deltaR = cms.double(0.4),
            weight = cms.string('1'),
            vetos = cms.vstring('0.0001','Threshold(0.0)'),
            skipDefaultVeto = cms.bool(True),
            mode = cms.string('sum')
     )
   )
)

muPFIsoValueGamma04 = cms.EDProducer("CandIsolatorFromDeposits",
    deposits = cms.VPSet(
            cms.PSet(
            src = cms.InputTag("muPFIsoDepositGamma"),
            deltaR = cms.double(0.4),
            weight = cms.string('1'),
            vetos = cms.vstring('0.01','Threshold(0.5)'),
            skipDefaultVeto = cms.bool(True),
            mode = cms.string('sum')
      )
   )
)


muPFIsoValueNeutral04 = cms.EDProducer("CandIsolatorFromDeposits",
    deposits = cms.VPSet(
            cms.PSet(
            src = cms.InputTag("muPFIsoDepositNeutral"),
            deltaR = cms.double(0.4),
            weight = cms.string('1'),
            vetos = cms.vstring('0.01','Threshold(0.5)'),
            skipDefaultVeto = cms.bool(True),
            mode = cms.string('sum')
    )
 )

)
muPFIsoValuePU04 = cms.EDProducer("CandIsolatorFromDeposits",
    deposits = cms.VPSet(
            cms.PSet(
            src = cms.InputTag("muPFIsoDepositPU"),
            deltaR = cms.double(0.4),
            weight = cms.string('1'),
            vetos = cms.vstring('0.01','Threshold(0.5)'),
            skipDefaultVeto = cms.bool(True),
            mode = cms.string('sum')
      )
   )
)

patMuons.isoDeposits = cms.PSet(
       pfAllParticles    = cms.InputTag("muPFIsoDepositChargedAll"),
       pfChargedHadrons = cms.InputTag("muPFIsoDepositCharged"),
       pfNeutralHadrons = cms.InputTag("muPFIsoDepositNeutral"),
       pfPhotons        = cms.InputTag("muPFIsoDepositGamma")
)

patMuons.isolationValues = cms.PSet(
           pfAllParticles   = cms.InputTag("muPFIsoValueChargedAll04"),
           pfChargedHadrons = cms.InputTag("muPFIsoValueCharged04"),
           pfNeutralHadrons = cms.InputTag("muPFIsoValueNeutral04"),
           pfPhotons        = cms.InputTag("muPFIsoValueGamma04"),
           user = cms.VInputTag(
                        cms.InputTag("muPFIsoValueChargedAll03"),            
                        cms.InputTag("muPFIsoValueCharged03"),               
                        cms.InputTag("muPFIsoValueNeutral03"),               
                        cms.InputTag("muPFIsoValueGamma03"),                 
                        cms.InputTag("muPFIsoValuePU03"),
                        cms.InputTag("muPFIsoValuePU04"),
                        
          )
 )


muonPFIsolationSequence =  cms.Sequence(muPFIsoDepositCharged+
                                        muPFIsoDepositChargedAll+
                                        muPFIsoDepositGamma+
                                        muPFIsoDepositNeutral+
                                        muPFIsoDepositPU+
                                        ##############################
                                        muPFIsoValueCharged03+
                                        muPFIsoValueChargedAll03+
                                        muPFIsoValueGamma03+
                                        muPFIsoValueNeutral03+
                                        muPFIsoValuePU03+
                                        ############################## 
                                        muPFIsoValueCharged04+
                                        muPFIsoValueChargedAll04+
                                        muPFIsoValueGamma04+
                                        muPFIsoValueNeutral04+
                                        muPFIsoValuePU04 
                                       ## *     patMuons    
                                      

)                                         


########  ELECTRONS ###########
#Now prepare the iso deposits
elePFIsoDepositCharged=isoDepositReplace('pfSelectedElectrons','pfAllChargedHadrons')
elePFIsoDepositChargedAll=isoDepositReplace('pfSelectedElectrons','pfAllChargedCandidates')
elePFIsoDepositNeutral=isoDepositReplace('pfSelectedElectrons','pfAllNeutralHadrons')
elePFIsoDepositGamma=isoDepositReplace('pfSelectedElectrons','pfAllPhotons')
elePFIsoDepositPU=isoDepositReplace('pfSelectedElectrons','pfPUChargedCandidates')


#Now create isolation values for those isolation deposits 


elePFIsoValueCharged03 = cms.EDProducer("CandIsolatorFromDeposits",
    deposits = cms.VPSet(
            cms.PSet(
            src = cms.InputTag("elePFIsoDepositCharged"),
            deltaR = cms.double(0.3),
            weight = cms.string('1'),
            vetos = cms.vstring('0.0001','Threshold(0.0)'),
            skipDefaultVeto = cms.bool(True),
            mode = cms.string('sum')
            )
     )
)

elePFIsoValueChargedAll03 = cms.EDProducer("CandIsolatorFromDeposits",
    deposits = cms.VPSet(
            cms.PSet(
            src = cms.InputTag("elePFIsoDepositChargedAll"),
            deltaR = cms.double(0.3),
            weight = cms.string('1'),
            vetos = cms.vstring('0.0001','Threshold(0.0)'),
            skipDefaultVeto = cms.bool(True),
            mode = cms.string('sum')
     )
   )
)

elePFIsoValueGamma03 = cms.EDProducer("CandIsolatorFromDeposits",
    deposits = cms.VPSet(
            cms.PSet(
            src = cms.InputTag("elePFIsoDepositGamma"),
            deltaR = cms.double(0.3),
            weight = cms.string('1'),
            vetos = cms.vstring('0.01','Threshold(0.5)'),
            skipDefaultVeto = cms.bool(True),
            mode = cms.string('sum')
      )
   )
)

elePFIsoValueNeutral03 = cms.EDProducer("CandIsolatorFromDeposits",
    deposits = cms.VPSet(
            cms.PSet(
            src = cms.InputTag("elePFIsoDepositNeutral"),
            deltaR = cms.double(0.3),
            weight = cms.string('1'),
            vetos = cms.vstring('0.01','Threshold(0.5)'),
            skipDefaultVeto = cms.bool(True),
            mode = cms.string('sum')
    )
 )
)

elePFIsoValuePU03 = cms.EDProducer("CandIsolatorFromDeposits",
    deposits = cms.VPSet(
            cms.PSet(
            src = cms.InputTag("elePFIsoDepositPU"),
            deltaR = cms.double(0.3),
            weight = cms.string('1'),
            vetos = cms.vstring('0.01','Threshold(0.5)'),
            skipDefaultVeto = cms.bool(True),
            mode = cms.string('sum')
      )
   )
)


elePFIsoValueCharged04 = cms.EDProducer("CandIsolatorFromDeposits",
    deposits = cms.VPSet(
            cms.PSet(
            src = cms.InputTag("elePFIsoDepositCharged"),
            deltaR = cms.double(0.4),
            weight = cms.string('1'),
            vetos = cms.vstring('0.0001','Threshold(0.0)'),
            skipDefaultVeto = cms.bool(True),
            mode = cms.string('sum')
            )
     )
)


elePFIsoValueChargedAll04 = cms.EDProducer("CandIsolatorFromDeposits",
    deposits = cms.VPSet(
            cms.PSet(
            src = cms.InputTag("elePFIsoDepositChargedAll"),
            deltaR = cms.double(0.4),
            weight = cms.string('1'),
            vetos = cms.vstring('0.0001','Threshold(0.0)'),
            skipDefaultVeto = cms.bool(True),
            mode = cms.string('sum')
     )
   )
)

elePFIsoValueGamma04 = cms.EDProducer("CandIsolatorFromDeposits",
    deposits = cms.VPSet(
            cms.PSet(
            src = cms.InputTag("elePFIsoDepositGamma"),
            deltaR = cms.double(0.4),
            weight = cms.string('1'),
            vetos = cms.vstring('0.01','Threshold(0.5)'),
            skipDefaultVeto = cms.bool(True),
            mode = cms.string('sum')
      )
   )
)


elePFIsoValueNeutral04 = cms.EDProducer("CandIsolatorFromDeposits",
    deposits = cms.VPSet(
            cms.PSet(
            src = cms.InputTag("elePFIsoDepositNeutral"),
            deltaR = cms.double(0.4),
            weight = cms.string('1'),
            vetos = cms.vstring('0.01','Threshold(0.5)'),
            skipDefaultVeto = cms.bool(True),
            mode = cms.string('sum')
    )
 )

)
elePFIsoValuePU04 = cms.EDProducer("CandIsolatorFromDeposits",
    deposits = cms.VPSet(
            cms.PSet(
            src = cms.InputTag("elePFIsoDepositPU"),
            deltaR = cms.double(0.4),
            weight = cms.string('1'),
            vetos = cms.vstring('0.01','Threshold(0.5)'),
            skipDefaultVeto = cms.bool(True),
            mode = cms.string('sum')
      )
   )
)

patElectrons.isoDeposits = cms.PSet(
       pfAllParticles    = cms.InputTag("elePFIsoDepositChargedAll"),
       pfChargedHadrons = cms.InputTag("elePFIsoDepositCharged"),
       pfNeutralHadrons = cms.InputTag("elePFIsoDepositNeutral"),
       pfPhotons        = cms.InputTag("elePFIsoDepositGamma")
)

patElectrons.isolationValues = cms.PSet(
           pfAllParticles   = cms.InputTag("elePFIsoValueChargedAll04"),
           pfChargedHadrons = cms.InputTag("elePFIsoValueCharged04"),
           pfNeutralHadrons = cms.InputTag("elePFIsoValueNeutral04"),
           pfPhotons        = cms.InputTag("elePFIsoValueGamma04"),
           user = cms.VInputTag(
                        cms.InputTag("elePFIsoValueChargedAll03"),            
                        cms.InputTag("elePFIsoValueCharged03"),               
                        cms.InputTag("elePFIsoValueNeutral03"),               
                        cms.InputTag("elePFIsoValueGamma03"),                 
                        cms.InputTag("elePFIsoValuePU03"),
                        cms.InputTag("elePFIsoValuePU04"),
                        
          )
 )


electronPFIsolationSequence =  cms.Sequence(elePFIsoDepositCharged+
                                        elePFIsoDepositChargedAll+
                                        elePFIsoDepositGamma+
                                        elePFIsoDepositNeutral+
                                        elePFIsoDepositPU+
                                        ##############################
                                        elePFIsoValueCharged03+
                                        elePFIsoValueChargedAll03+
                                        elePFIsoValueGamma03+
                                        elePFIsoValueNeutral03+
                                        elePFIsoValuePU03+
                                        ############################## 
                                        elePFIsoValueCharged04+
                                        elePFIsoValueChargedAll04+
                                        elePFIsoValueGamma04+
                                        elePFIsoValueNeutral04+
                                        elePFIsoValuePU04 
                                       ## patElectrons
                                       

)                                         
Revision:	1.1
Committed:	Thu Sep 15 14:00:30 2011 UTC (13 years, 8 months ago) by degrutto
Content type:	text/x-python
Branch:	MAIN
CVS Tags:	EDMV42_Step2_V6, EDMV42_Step2_V5a, EDMV42_Step2_V5, tauCandV42, hbbsubstructDev_11, hbbsubstructDev_10, hbbsubstructDev_9, hbbsubstructDev_8, hbbsubstructDev_7, hbbsubstructDev_6, hbbsubstructDev_5, hbbsubstructDev_4, hbbsubstructDev_3, hbbsubstructDev_2, hbbsubstructDev_1, hbbsubstructDev, V21TauCand_0, TauCandidates_0, EDMV42_Step2_V4a, EDMV42_Step2_V4, EDMV42_Step2_V3, EDMV42_Step2_V2, EDMV42_Step2_V1, EdmV42, EdmV41alpha1, EdmV40alpha1, EdmV40alpha, V21emuCand, EdmV33Jun12v2_consistent, Step2ForV33_v2, Step2ForV33_v1, EdmV33Jun12v2, EdmV33Jun12v1, EdmV33Jun12v0, Step2ForV32_v2, Step2ForV32_v0, Step2ForV31_v0, EdmV32May24v0, EdmV31May21v1, EdmV31May17v0, May14thStep2, EdmV30Apr10, EdmV21Apr10v2, EdmV22May9, EdmV21Apr06, EdmV21Apr10, EdmV21Apr04, EdmV21Apr03, EdmV21Apr2, EdmV21Mar30, EdmV20Mar12, EdmV11Oct2011_fixMET, EdmV11Oct2011, EdmV10Oct2011, EdmV9Sept2011, Sept19th2011_2, Sept19th2011, Sept19th, VHNtupleV9_AR1, HEAD
Branch point for:	V42TauCandidate, hbbsubstructDevPostHCP, V21TauCand, TauCandidatesV21, V21emuCandidate
Log Message:	rho25 and pfChaPUIso added
#	User	Rev	Content
1	degrutto	1.1	### assembled and modified from CommonTools/ ParticleFlow/ python/ ParticleSelectors/ pfCandsForIsolation_cff.py
2			import FWCore.ParameterSet.Config as cms
3
4			from CommonTools.ParticleFlow.pfNoPileUp_cff import *
5			from CommonTools.ParticleFlow.ParticleSelectors.pfSortByType_cff import *
6
7			#Create the PU candidates
8			pfPileUpCandidates = cms.EDProducer("TPPFCandidatesOnPFCandidates",
9			enable = cms.bool( True ),
10			verbose = cms.untracked.bool( False ),
11			name = cms.untracked.string("pileUpCandidates"),
12			topCollection = cms.InputTag("pfNoPileUp"),
13			### bottomCollection = cms.InputTag("particleFlowTmp") ## ..Tmp in 44X
14			bottomCollection = cms.InputTag("particleFlow"),
15
16			)
17
18
19			#Take the PU charged particles
20			pfPUChargedCandidates = cms.EDFilter("PdgIdPFCandidateSelector",
21			src = cms.InputTag("pfPileUpCandidates"),
22			pdgId = cms.vint32(211,-211,321,-321,999211,2212,-2212,11,-11,13,-13)
23			)
24
25
26			#Create All Charged Particles
27			pfAllChargedCandidates = cms.EDFilter("PdgIdPFCandidateSelector",
28			src = cms.InputTag("pfNoPileUp"),
29			pdgId = cms.vint32(211,-211,321,-321,999211,2212,-2212,11,-11,13,-13)
30			)
31
32
33			pfPileUpCandidatesSequence = cms.Sequence(pfPileUpCandidates+
34			pfPUChargedCandidates+
35			pfAllChargedCandidates)
36
37
38
39			pfCandsForIsolationSequence = cms.Sequence(
40			pfNoPileUpSequence +
41			pfSortByTypeSequence +
42			pfPileUpCandidatesSequence
43			)
44
45			##assembled and modified from /CMSSW/RecoMuon/MuonIsolation/python/muonPFIsolation_cff.py from V02-03-01 (44X) and adapting also for electrons
46
47			import FWCore.ParameterSet.Config as cms
48
49			from CommonTools.ParticleFlow.Isolation.tools_cfi import *
50			from PhysicsTools.PatAlgos.patSequences_cff import patMuons
51			from PhysicsTools.PatAlgos.patSequences_cff import patElectrons
52
53
54			##### MUONS ##################
55			#Now prepare the iso deposits
56			muPFIsoDepositCharged=isoDepositReplace('pfSelectedMuons','pfAllChargedHadrons')
57			muPFIsoDepositChargedAll=isoDepositReplace('pfSelectedMuons','pfAllChargedCandidates')
58			muPFIsoDepositNeutral=isoDepositReplace('pfSelectedMuons','pfAllNeutralHadrons')
59			muPFIsoDepositGamma=isoDepositReplace('pfSelectedMuons','pfAllPhotons')
60			muPFIsoDepositPU=isoDepositReplace('pfSelectedMuons','pfPUChargedCandidates')
61
62
63
64			#Now create isolation values for those isolation deposits
65
66			muPFIsoValueCharged03 = cms.EDProducer("CandIsolatorFromDeposits",
67			deposits = cms.VPSet(
68			cms.PSet(
69			src = cms.InputTag("muPFIsoDepositCharged"),
70			deltaR = cms.double(0.3),
71			weight = cms.string('1'),
72			vetos = cms.vstring('0.0001','Threshold(0.0)'),
73			skipDefaultVeto = cms.bool(True),
74			mode = cms.string('sum')
75			)
76			)
77			)
78
79			muPFIsoValueChargedAll03 = cms.EDProducer("CandIsolatorFromDeposits",
80			deposits = cms.VPSet(
81			cms.PSet(
82			src = cms.InputTag("muPFIsoDepositChargedAll"),
83			deltaR = cms.double(0.3),
84			weight = cms.string('1'),
85			vetos = cms.vstring('0.0001','Threshold(0.0)'),
86			skipDefaultVeto = cms.bool(True),
87			mode = cms.string('sum')
88			)
89			)
90			)
91
92			muPFIsoValueGamma03 = cms.EDProducer("CandIsolatorFromDeposits",
93			deposits = cms.VPSet(
94			cms.PSet(
95			src = cms.InputTag("muPFIsoDepositGamma"),
96			deltaR = cms.double(0.3),
97			weight = cms.string('1'),
98			vetos = cms.vstring('0.01','Threshold(0.5)'),
99			skipDefaultVeto = cms.bool(True),
100			mode = cms.string('sum')
101			)
102			)
103			)
104
105			muPFIsoValueNeutral03 = cms.EDProducer("CandIsolatorFromDeposits",
106			deposits = cms.VPSet(
107			cms.PSet(
108			src = cms.InputTag("muPFIsoDepositNeutral"),
109			deltaR = cms.double(0.3),
110			weight = cms.string('1'),
111			vetos = cms.vstring('0.01','Threshold(0.5)'),
112			skipDefaultVeto = cms.bool(True),
113			mode = cms.string('sum')
114			)
115			)
116			)
117
118			muPFIsoValuePU03 = cms.EDProducer("CandIsolatorFromDeposits",
119			deposits = cms.VPSet(
120			cms.PSet(
121			src = cms.InputTag("muPFIsoDepositPU"),
122			deltaR = cms.double(0.3),
123			weight = cms.string('1'),
124			vetos = cms.vstring('0.01','Threshold(0.5)'),
125			skipDefaultVeto = cms.bool(True),
126			mode = cms.string('sum')
127			)
128			)
129			)
130
131
132
133			muPFIsoValueCharged04 = cms.EDProducer("CandIsolatorFromDeposits",
134			deposits = cms.VPSet(
135			cms.PSet(
136			src = cms.InputTag("muPFIsoDepositCharged"),
137			deltaR = cms.double(0.4),
138			weight = cms.string('1'),
139			vetos = cms.vstring('0.0001','Threshold(0.0)'),
140			skipDefaultVeto = cms.bool(True),
141			mode = cms.string('sum')
142			)
143			)
144			)
145
146
147
148
149			muPFIsoValueChargedAll04 = cms.EDProducer("CandIsolatorFromDeposits",
150			deposits = cms.VPSet(
151			cms.PSet(
152			src = cms.InputTag("muPFIsoDepositChargedAll"),
153			deltaR = cms.double(0.4),
154			weight = cms.string('1'),
155			vetos = cms.vstring('0.0001','Threshold(0.0)'),
156			skipDefaultVeto = cms.bool(True),
157			mode = cms.string('sum')
158			)
159			)
160			)
161
162			muPFIsoValueGamma04 = cms.EDProducer("CandIsolatorFromDeposits",
163			deposits = cms.VPSet(
164			cms.PSet(
165			src = cms.InputTag("muPFIsoDepositGamma"),
166			deltaR = cms.double(0.4),
167			weight = cms.string('1'),
168			vetos = cms.vstring('0.01','Threshold(0.5)'),
169			skipDefaultVeto = cms.bool(True),
170			mode = cms.string('sum')
171			)
172			)
173			)
174
175
176			muPFIsoValueNeutral04 = cms.EDProducer("CandIsolatorFromDeposits",
177			deposits = cms.VPSet(
178			cms.PSet(
179			src = cms.InputTag("muPFIsoDepositNeutral"),
180			deltaR = cms.double(0.4),
181			weight = cms.string('1'),
182			vetos = cms.vstring('0.01','Threshold(0.5)'),
183			skipDefaultVeto = cms.bool(True),
184			mode = cms.string('sum')
185			)
186			)
187
188			)
189			muPFIsoValuePU04 = cms.EDProducer("CandIsolatorFromDeposits",
190			deposits = cms.VPSet(
191			cms.PSet(
192			src = cms.InputTag("muPFIsoDepositPU"),
193			deltaR = cms.double(0.4),
194			weight = cms.string('1'),
195			vetos = cms.vstring('0.01','Threshold(0.5)'),
196			skipDefaultVeto = cms.bool(True),
197			mode = cms.string('sum')
198			)
199			)
200			)
201
202			patMuons.isoDeposits = cms.PSet(
203			pfAllParticles = cms.InputTag("muPFIsoDepositChargedAll"),
204			pfChargedHadrons = cms.InputTag("muPFIsoDepositCharged"),
205			pfNeutralHadrons = cms.InputTag("muPFIsoDepositNeutral"),
206			pfPhotons = cms.InputTag("muPFIsoDepositGamma")
207			)
208
209			patMuons.isolationValues = cms.PSet(
210			pfAllParticles = cms.InputTag("muPFIsoValueChargedAll04"),
211			pfChargedHadrons = cms.InputTag("muPFIsoValueCharged04"),
212			pfNeutralHadrons = cms.InputTag("muPFIsoValueNeutral04"),
213			pfPhotons = cms.InputTag("muPFIsoValueGamma04"),
214			user = cms.VInputTag(
215			cms.InputTag("muPFIsoValueChargedAll03"),
216			cms.InputTag("muPFIsoValueCharged03"),
217			cms.InputTag("muPFIsoValueNeutral03"),
218			cms.InputTag("muPFIsoValueGamma03"),
219			cms.InputTag("muPFIsoValuePU03"),
220			cms.InputTag("muPFIsoValuePU04"),
221
222			)
223			)
224
225
226
227
228
229			muonPFIsolationSequence = cms.Sequence(muPFIsoDepositCharged+
230			muPFIsoDepositChargedAll+
231			muPFIsoDepositGamma+
232			muPFIsoDepositNeutral+
233			muPFIsoDepositPU+
234			##############################
235			muPFIsoValueCharged03+
236			muPFIsoValueChargedAll03+
237			muPFIsoValueGamma03+
238			muPFIsoValueNeutral03+
239			muPFIsoValuePU03+
240			##############################
241			muPFIsoValueCharged04+
242			muPFIsoValueChargedAll04+
243			muPFIsoValueGamma04+
244			muPFIsoValueNeutral04+
245			muPFIsoValuePU04
246			## * patMuons
247
248
249			)
250
251
252
253
254
255			######## ELECTRONS ###########
256			#Now prepare the iso deposits
257			elePFIsoDepositCharged=isoDepositReplace('pfSelectedElectrons','pfAllChargedHadrons')
258			elePFIsoDepositChargedAll=isoDepositReplace('pfSelectedElectrons','pfAllChargedCandidates')
259			elePFIsoDepositNeutral=isoDepositReplace('pfSelectedElectrons','pfAllNeutralHadrons')
260			elePFIsoDepositGamma=isoDepositReplace('pfSelectedElectrons','pfAllPhotons')
261			elePFIsoDepositPU=isoDepositReplace('pfSelectedElectrons','pfPUChargedCandidates')
262
263
264
265			#Now create isolation values for those isolation deposits
266
267
268			elePFIsoValueCharged03 = cms.EDProducer("CandIsolatorFromDeposits",
269			deposits = cms.VPSet(
270			cms.PSet(
271			src = cms.InputTag("elePFIsoDepositCharged"),
272			deltaR = cms.double(0.3),
273			weight = cms.string('1'),
274			vetos = cms.vstring('0.0001','Threshold(0.0)'),
275			skipDefaultVeto = cms.bool(True),
276			mode = cms.string('sum')
277			)
278			)
279			)
280
281			elePFIsoValueChargedAll03 = cms.EDProducer("CandIsolatorFromDeposits",
282			deposits = cms.VPSet(
283			cms.PSet(
284			src = cms.InputTag("elePFIsoDepositChargedAll"),
285			deltaR = cms.double(0.3),
286			weight = cms.string('1'),
287			vetos = cms.vstring('0.0001','Threshold(0.0)'),
288			skipDefaultVeto = cms.bool(True),
289			mode = cms.string('sum')
290			)
291			)
292			)
293
294			elePFIsoValueGamma03 = cms.EDProducer("CandIsolatorFromDeposits",
295			deposits = cms.VPSet(
296			cms.PSet(
297			src = cms.InputTag("elePFIsoDepositGamma"),
298			deltaR = cms.double(0.3),
299			weight = cms.string('1'),
300			vetos = cms.vstring('0.01','Threshold(0.5)'),
301			skipDefaultVeto = cms.bool(True),
302			mode = cms.string('sum')
303			)
304			)
305			)
306
307			elePFIsoValueNeutral03 = cms.EDProducer("CandIsolatorFromDeposits",
308			deposits = cms.VPSet(
309			cms.PSet(
310			src = cms.InputTag("elePFIsoDepositNeutral"),
311			deltaR = cms.double(0.3),
312			weight = cms.string('1'),
313			vetos = cms.vstring('0.01','Threshold(0.5)'),
314			skipDefaultVeto = cms.bool(True),
315			mode = cms.string('sum')
316			)
317			)
318			)
319
320			elePFIsoValuePU03 = cms.EDProducer("CandIsolatorFromDeposits",
321			deposits = cms.VPSet(
322			cms.PSet(
323			src = cms.InputTag("elePFIsoDepositPU"),
324			deltaR = cms.double(0.3),
325			weight = cms.string('1'),
326			vetos = cms.vstring('0.01','Threshold(0.5)'),
327			skipDefaultVeto = cms.bool(True),
328			mode = cms.string('sum')
329			)
330			)
331			)
332
333
334			elePFIsoValueCharged04 = cms.EDProducer("CandIsolatorFromDeposits",
335			deposits = cms.VPSet(
336			cms.PSet(
337			src = cms.InputTag("elePFIsoDepositCharged"),
338			deltaR = cms.double(0.4),
339			weight = cms.string('1'),
340			vetos = cms.vstring('0.0001','Threshold(0.0)'),
341			skipDefaultVeto = cms.bool(True),
342			mode = cms.string('sum')
343			)
344			)
345			)
346
347
348
349
350			elePFIsoValueChargedAll04 = cms.EDProducer("CandIsolatorFromDeposits",
351			deposits = cms.VPSet(
352			cms.PSet(
353			src = cms.InputTag("elePFIsoDepositChargedAll"),
354			deltaR = cms.double(0.4),
355			weight = cms.string('1'),
356			vetos = cms.vstring('0.0001','Threshold(0.0)'),
357			skipDefaultVeto = cms.bool(True),
358			mode = cms.string('sum')
359			)
360			)
361			)
362
363			elePFIsoValueGamma04 = cms.EDProducer("CandIsolatorFromDeposits",
364			deposits = cms.VPSet(
365			cms.PSet(
366			src = cms.InputTag("elePFIsoDepositGamma"),
367			deltaR = cms.double(0.4),
368			weight = cms.string('1'),
369			vetos = cms.vstring('0.01','Threshold(0.5)'),
370			skipDefaultVeto = cms.bool(True),
371			mode = cms.string('sum')
372			)
373			)
374			)
375
376
377			elePFIsoValueNeutral04 = cms.EDProducer("CandIsolatorFromDeposits",
378			deposits = cms.VPSet(
379			cms.PSet(
380			src = cms.InputTag("elePFIsoDepositNeutral"),
381			deltaR = cms.double(0.4),
382			weight = cms.string('1'),
383			vetos = cms.vstring('0.01','Threshold(0.5)'),
384			skipDefaultVeto = cms.bool(True),
385			mode = cms.string('sum')
386			)
387			)
388
389			)
390			elePFIsoValuePU04 = cms.EDProducer("CandIsolatorFromDeposits",
391			deposits = cms.VPSet(
392			cms.PSet(
393			src = cms.InputTag("elePFIsoDepositPU"),
394			deltaR = cms.double(0.4),
395			weight = cms.string('1'),
396			vetos = cms.vstring('0.01','Threshold(0.5)'),
397			skipDefaultVeto = cms.bool(True),
398			mode = cms.string('sum')
399			)
400			)
401			)
402
403			patElectrons.isoDeposits = cms.PSet(
404			pfAllParticles = cms.InputTag("elePFIsoDepositChargedAll"),
405			pfChargedHadrons = cms.InputTag("elePFIsoDepositCharged"),
406			pfNeutralHadrons = cms.InputTag("elePFIsoDepositNeutral"),
407			pfPhotons = cms.InputTag("elePFIsoDepositGamma")
408			)
409
410			patElectrons.isolationValues = cms.PSet(
411			pfAllParticles = cms.InputTag("elePFIsoValueChargedAll04"),
412			pfChargedHadrons = cms.InputTag("elePFIsoValueCharged04"),
413			pfNeutralHadrons = cms.InputTag("elePFIsoValueNeutral04"),
414			pfPhotons = cms.InputTag("elePFIsoValueGamma04"),
415			user = cms.VInputTag(
416			cms.InputTag("elePFIsoValueChargedAll03"),
417			cms.InputTag("elePFIsoValueCharged03"),
418			cms.InputTag("elePFIsoValueNeutral03"),
419			cms.InputTag("elePFIsoValueGamma03"),
420			cms.InputTag("elePFIsoValuePU03"),
421			cms.InputTag("elePFIsoValuePU04"),
422
423			)
424			)
425
426
427
428			electronPFIsolationSequence = cms.Sequence(elePFIsoDepositCharged+
429			elePFIsoDepositChargedAll+
430			elePFIsoDepositGamma+
431			elePFIsoDepositNeutral+
432			elePFIsoDepositPU+
433			##############################
434			elePFIsoValueCharged03+
435			elePFIsoValueChargedAll03+
436			elePFIsoValueGamma03+
437			elePFIsoValueNeutral03+
438			elePFIsoValuePU03+
439			##############################
440			elePFIsoValueCharged04+
441			elePFIsoValueChargedAll04+
442			elePFIsoValueGamma04+
443			elePFIsoValueNeutral04+
444			elePFIsoValuePU04
445			## patElectrons
446
447
448			)