def buildSequenceTauIdEffMeasSpecific(process,
patMuonCollectionName = "selectedPatMuonsForTauIdEffPFRelIsoCumulative",
tauIdAlgorithmName = None, patTauCollectionName = "patTaus", applyTauJEC = False,
savePatTaus = None,
patMEtCollectionName = "patType1CorrectedPFMet",
isMC = False, isEmbedded = False,
runSVfit = False):
#print("<buildSequenceTauIdEffMeasSpecific>:")
#print(" patTauCollectionName = %s" % patTauCollectionName)
#print(" isMC = %s" % isMC)
# check that tauIdAlgorithmName is defined, non-null and composed of two parts
if tauIdAlgorithmName is None or len(tauIdAlgorithmName) != 2:
raise ValueError("Undefined of invalid 'tauIdAlgorithmName' Parameter !!")
patTauProducerName = "".join(patTauCollectionName)
sequenceName = composeModuleName(["sequenceTauIdEffMeasSpecific", "".join(tauIdAlgorithmName)])
sequence = cms.Sequence()
setattr(process, sequenceName, sequence)
#--------------------------------------------------------------------------------
# define loose Tau-jet candidate selection
#--------------------------------------------------------------------------------
patTauSelectionModules = []
process.load("TauAnalysis.RecoTools.patLeptonSelection_cff")
selectedPatTausAntiOverlapWithMuonsVetoName = \
"selectedPat%ss%sAntiOverlapWithMuonsVeto" % (tauIdAlgorithmName[0], tauIdAlgorithmName[1])
selectedPatTausAntiOverlapWithMuonsVeto = process.selectedPatTausForMuTauAntiOverlapWithMuonsVeto.clone(
dRmin = cms.double(0.5),
srcNotToBeFiltered = cms.VInputTag(composeModuleName([patMuonCollectionName, "cumulative"]))
)
setattr(process, selectedPatTausAntiOverlapWithMuonsVetoName, selectedPatTausAntiOverlapWithMuonsVeto)
patTauSelectionModules.append(selectedPatTausAntiOverlapWithMuonsVeto)
process.load("RecoTauTag.RecoTau.PFRecoTauQualityCuts_cfi")
selectedPatPFTausForTauIdEffName = \
composeModuleName(["selectedPat%ss%s" % (tauIdAlgorithmName[0], tauIdAlgorithmName[1]), "ForTauIdEff"])
selectedPatPFTausForTauIdEff = cms.EDFilter("PATPFTauSelectorForTauIdEff",
minJetPt = cms.double(15.0),
maxJetEta = cms.double(2.3),
trackQualityCuts = process.PFTauQualityCuts.signalQualityCuts,
minLeadTrackPt = cms.double(5.0),
maxDzLeadTrack = cms.double(0.2),
maxLeadTrackPFElectronMVA = cms.double(0.6),
#applyECALcrackVeto = cms.bool(True),
applyECALcrackVeto = cms.bool(False),
minDeltaRtoNearestMuon = cms.double(0.5),
muonSelection = cms.string("isGlobalMuon() | isTrackerMuon() | isStandAloneMuon()"),
srcMuon = cms.InputTag('patMuons'),
pfIsolation = cms.PSet(
chargedParticleIso = cms.PSet(
ptMin = cms.double(1.0),
dRvetoCone = cms.double(0.15),
dRisoCone = cms.double(0.6)
),
neutralHadronIso = cms.PSet(
ptMin = cms.double(1000.),
dRvetoCone = cms.double(0.15),
dRisoCone = cms.double(0.)
),
photonIso = cms.PSet(
ptMin = cms.double(1.5),
dPhiVeto = cms.double(-1.), # asymmetric Eta x Phi veto region
dEtaVeto = cms.double(-1.), # to account for photon conversions in electron isolation case
dRvetoCone = cms.double(0.15),
dRisoCone = cms.double(0.6)
),
pileUpCorr = cms.PSet(
method = cms.string("deltaBeta"),
chargedToNeutralFactor = cms.double(0.50)
)
),
maxPFIsoPt = cms.double(5.0),
srcPFIsoCandidates = cms.InputTag('particleFlow'),
srcPFNoPileUpCandidates = cms.InputTag('pfNoPileUp'),
srcBeamSpot = cms.InputTag('offlineBeamSpot'),
srcVertex = cms.InputTag('offlinePrimaryVertices'),
filter = cms.bool(False)
)
# CV: comment-out for now, in order to make sure there is no bias
# on the tau id. efficiency measurement
#if savePatTaus is not None:
# setattr(selectedPatPFTausForTauIdEff, "save", cms.string(savePatTaus))
setattr(process, selectedPatPFTausForTauIdEffName, selectedPatPFTausForTauIdEff)
patTauSelectionModules.append(selectedPatPFTausForTauIdEff)
# for MC apply L1FastJet + L2 + L3 jet-energy corrections,
# for Data apply L1FastJet + L2 + L3 + L2/L3 residual corrections
#
# CV: Ztautau samples produced via MCEmbedding technique are technically "Data',
# L2/L3 residual jet energy corrections **must not** be applied, however,
# since the tau-jet response is taken from the Monte Carlo simulation
#
if isMC or isEmbedded:
setattr(selectedPatPFTausForTauIdEff, "jetEnergyCorrection", cms.string('ak5PFL1FastL2L3'))
else:
setattr(selectedPatPFTausForTauIdEff, "jetEnergyCorrection", cms.string('ak5PFL1FastL2L3Residual'))
patTauSelConfigurator = objSelConfigurator(
patTauSelectionModules,
src = patTauCollectionName,
pyModuleName = __name__,
doSelIndividual = False
)
patTauSelectionSequenceName = "selectPat%ss%sForTauIdEff" % (tauIdAlgorithmName[0], tauIdAlgorithmName[1])
patTauSelectionSequence = patTauSelConfigurator.configure(process = process)
setattr(process, patTauSelectionSequenceName, patTauSelectionSequence)
sequence += patTauSelectionSequence
selTauCollectionName = selectedPatPFTausForTauIdEffName
patTauCollections = []
for patTauSelectionModule in patTauSelectionModules:
patTauCollections.append(composeModuleName([patTauSelectionModule.label(), "cumulative"]))
patTauForTauIdEffCounter = cms.EDAnalyzer("PATCandViewCountAnalyzer",
src = cms.VInputTag(patTauCollections),
minNumEntries = cms.int32(1),
maxNumEntries = cms.int32(1000)
)
patTauForTauIdEffCounterName = "pat%s%sForTauIdEffCounter" % (tauIdAlgorithmName[0], tauIdAlgorithmName[1])
setattr(process, patTauForTauIdEffCounterName, patTauForTauIdEffCounter)
sequence += patTauForTauIdEffCounter
#--------------------------------------------------------------------------------
# produce collections of Tau-jet candidates shifted Up/Down in energy
#
# NOTE: Tau-jet energy shifts/smearing needs to be applied
# **after** PATPFTauSelectorForTauIdEff module is run,
# as the PATPFTauSelectorForTauIdEff module sets Tau-jet momentum to PFJet momentum,
# regardless of any shifts/smearing applied to Tau-jet momentum
#
#--------------------------------------------------------------------------------
tauSystematics = None
if isMC:
# CV: shift Tau-jet energy by 3 standard-deviations,
# so that template morphing remains an interpolation and no extrapolation is needed
patTausJECshiftUpModuleName = composeModuleName([patTauSelectionModule.label(), "TauJetEnUp", "cumulative"])
patTausJECshiftUpModule = cms.EDProducer("ShiftedPATTauJetProducer",
src = cms.InputTag(composeModuleName([selTauCollectionName, "cumulative"])),
jetCorrPayloadName = cms.string('AK5PF'),
jetCorrUncertaintyTag = cms.string('Uncertainty'),
addResidualJES = cms.bool(False),
shiftBy = cms.double(+3.)
)
setattr(process, patTausJECshiftUpModuleName, patTausJECshiftUpModule)
sequence += patTausJECshiftUpModule
patTausJECshiftDownModuleName = composeModuleName([patTauSelectionModule.label(), "TauJetEnDown", "cumulative"])
patTausJECshiftDownModule = patTausJECshiftUpModule.clone(
shiftBy = cms.double(-3.)
)
setattr(process, patTausJECshiftDownModuleName, patTausJECshiftDownModule)
sequence += patTausJECshiftDownModule
process.load("RecoMET.METProducers.METSigParams_cfi")
patTausJERshiftUpModuleName = composeModuleName([patTauSelectionModule.label(), "TauJetResUp", "cumulative"])
patTausJERshiftUpModule = cms.EDProducer("SmearedPATTauJetProducer",
src = cms.InputTag(composeModuleName([selTauCollectionName, "cumulative"])),
inputFileName = cms.FileInPath('PhysicsTools/PatUtils/data/pfJetResolutionMCtoDataCorrLUT.root'),
lutName = cms.string('pfJetResolutionMCtoDataCorrLUT'),
jetResolutions = process.METSignificance_params,
srcGenJets = cms.InputTag('ak5GenJetsNoNu'),
dRmaxGenJetMatch = cms.string('TMath::Min(0.5, 0.1 + 0.3*TMath::Exp(-0.05*(genJetPt - 10.)))'),
sigmaMaxGenJetMatch = cms.double(5.),
smearBy = cms.double(0.),
shiftBy = cms.double(+3.)
)
setattr(process, patTausJERshiftUpModuleName, patTausJERshiftUpModule)
sequence += patTausJERshiftUpModule
patTausJERshiftDownModuleName = composeModuleName([patTauSelectionModule.label(), "TauJetResDown", "cumulative"])
patTausJERshiftDownModule = patTausJERshiftUpModule.clone(
shiftBy = cms.double(-3.)
)
setattr(process, patTausJERshiftDownModuleName, patTausJERshiftDownModule)
sequence += patTausJERshiftDownModule
#--------------------------------------------------------------------------------
# define selection of Muon + Tau-jet candidate pairs
#--------------------------------------------------------------------------------
process.load("TauAnalysis.CandidateTools.muTauPairProduction_cff")
allMuTauPairsModuleName = composeModuleName(["allMu", "".join(tauIdAlgorithmName), "PairsForTauIdEff"])
allMuTauPairsModule = process.allMuTauPairs.clone(
srcLeg1 = cms.InputTag(composeModuleName([patMuonCollectionName, "cumulative"])),
srcLeg2 = cms.InputTag(composeModuleName([selTauCollectionName, "cumulative"])),
dRmin12 = cms.double(0.5),
srcMET = cms.InputTag(patMEtCollectionName),
doSVreco = cms.bool(runSVfit),
doPFMEtSign = cms.bool(runSVfit),
doMtautauMin = cms.bool(runSVfit)
)
if not runSVfit:
if hasattr(allMuTauPairsModule, "nSVfit"):
delattr(allMuTauPairsModule, "nSVfit")
if hasattr(allMuTauPairsModule, "pfMEtSign"):
delattr(allMuTauPairsModule, "pfMEtSign")
else:
# CV: for speed reasons, run NSVfit algorithm in "fit" mode only, not in "integration" mode
if hasattr(allMuTauPairsModule, "nSVfit") and hasattr(allMuTauPairsModule.nSVfit, "psKine_MEt_logM_int"):
delattr(allMuTauPairsModule.nSVfit, "psKine_MEt_logM_int")
if isMC:
setattr(allMuTauPairsModule, "srcGenParticles", cms.InputTag('genParticles'))
else:
setattr(allMuTauPairsModule, "srcGenParticles", cms.InputTag(''))
setattr(process, allMuTauPairsModuleName, allMuTauPairsModule)
sequence += allMuTauPairsModule
muTauPairProdConfigurator_systematics = None
if isMC:
muTauPairProdConfigurator_systematics = {
"TauJetEnUp" : {
"srcLeg2" : cms.InputTag(patTausJECshiftUpModuleName),
"srcMET" : cms.InputTag(composeModuleName([patMEtCollectionName, "JetEnUp"]))
},
"TauJetEnDown" : {
"srcLeg2" : cms.InputTag(patTausJECshiftDownModuleName),
"srcMET" : cms.InputTag(composeModuleName([patMEtCollectionName, "JetEnDown"]))
},
"TauJetResUp" : {
"srcLeg2" : cms.InputTag(patTausJERshiftUpModuleName),
"srcMET" : cms.InputTag(composeModuleName([patMEtCollectionName, "JetResUp"]))
},
"TauJetResDown" : {
"srcLeg2" : cms.InputTag(patTausJERshiftDownModuleName),
"srcMET" : cms.InputTag(composeModuleName([patMEtCollectionName, "JetResDown"]))
},
"JetEnUp" : {
"srcMET" : cms.InputTag(composeModuleName([patMEtCollectionName, "JetEnUp"]))
},
"JetEnDown" : {
"srcMET" : cms.InputTag(composeModuleName([patMEtCollectionName, "JetEnDown"]))
},
"UnclusteredEnUp" : {
"srcMET" : cms.InputTag(composeModuleName([patMEtCollectionName, "UnclusteredEnUp"]))
},
"UnclusteredEnDown" : {
"srcMET" : cms.InputTag(composeModuleName([patMEtCollectionName, "UnclusteredEnDown"]))
}
}
muTauPairProdConfigurator = objProdConfigurator(
allMuTauPairsModule,
pyModuleName = __name__
)
if isMC:
setattr(muTauPairProdConfigurator, "systematics", muTauPairProdConfigurator_systematics)
prodMuTauPairSequenceName = composeModuleName(["prodMu", "".join(tauIdAlgorithmName), "PairsForTauIdEff"])
prodMuTauPairSequence = muTauPairProdConfigurator.configure(process = process)
setattr(process, prodMuTauPairSequenceName, prodMuTauPairSequence)
sequence += prodMuTauPairSequence
muTauPairSystematicsForTauIdEff = {
"TauJetEnUp" : cms.InputTag(composeModuleName([allMuTauPairsModuleName, "TauJetEnUp"])),
"TauJetEnDown" : cms.InputTag(composeModuleName([allMuTauPairsModuleName, "TauJetEnDown"])),
"TauJetResUp" : cms.InputTag(composeModuleName([allMuTauPairsModuleName, "TauJetResUp"])),
"TauJetResDown" : cms.InputTag(composeModuleName([allMuTauPairsModuleName, "TauJetResDown"])),
"JetEnUp" : cms.InputTag(composeModuleName([allMuTauPairsModuleName, "JetEnUp"])),
"JetEnDown" : cms.InputTag(composeModuleName([allMuTauPairsModuleName, "JetEnDown"])),
"UnclusteredEnUp" : cms.InputTag(composeModuleName([allMuTauPairsModuleName, "UnclusteredEnUp"])),
"UnclusteredEnDown" : cms.InputTag(composeModuleName([allMuTauPairsModuleName, "UnclusteredEnDown"]))
}
#print("muTauPairSystematicsForTauIdEff:", muTauPairSystematicsForTauIdEff)
process.load("TauAnalysis.CandidateTools.muTauPairSelection_cfi")
selectedMuTauPairsAntiOverlapVetoModuleName = \
composeModuleName(["selectedMu", "".join(tauIdAlgorithmName), "PairsAntiOverlapVetoForTauIdEff"])
selectedMuTauPairsAntiOverlapVetoModule = process.selectedMuTauPairsAntiOverlapVeto.clone(
cut = cms.string('dR12 > 0.5')
)
setattr(process, selectedMuTauPairsAntiOverlapVetoModuleName, selectedMuTauPairsAntiOverlapVetoModule)
selectedMuTauPairsDzModuleName = \
composeModuleName(["selectedMu", "".join(tauIdAlgorithmName), "PairsDzForTauIdEff"])
selectedMuTauPairsDzModule = selectedMuTauPairsAntiOverlapVetoModule.clone(
#cut = cms.string('abs(leg1().vertex().z() - leg2().vertex().z()) < 0.2')
cut = cms.string('abs(leg1().vertex().z() - leg2().vertex().z()) < 1.e+3')
)
setattr(process, selectedMuTauPairsDzModuleName, selectedMuTauPairsDzModule)
muTauPairSelConfigurator = objSelConfigurator(
[ selectedMuTauPairsAntiOverlapVetoModule,
selectedMuTauPairsDzModule ],
src = allMuTauPairsModuleName,
pyModuleName = __name__,
doSelIndividual = False
)
if isMC:
setattr(muTauPairSelConfigurator, "systematics", muTauPairSystematicsForTauIdEff)
muTauPairSelectionSequenceName = composeModuleName(["selectMu", "".join(tauIdAlgorithmName), "PairsForTauIdEff"])
#print "muTauPairSelectionSequenceName = %s" % muTauPairSelectionSequenceName
muTauPairSelectionSequence = muTauPairSelConfigurator.configure(process = process)
setattr(process, muTauPairSelectionSequenceName, muTauPairSelectionSequence)
sequence += muTauPairSelectionSequence
muTauPairForTauIdEffCounter = cms.EDAnalyzer("PATCandViewCountAnalyzer",
src = cms.VInputTag(
allMuTauPairsModuleName,
composeModuleName([selectedMuTauPairsAntiOverlapVetoModuleName, "cumulative"]),
composeModuleName([selectedMuTauPairsDzModuleName, "cumulative"])
),
minNumEntries = cms.int32(1),
maxNumEntries = cms.int32(1000)
)
muTauPairForTauIdEffCounterName = composeModuleName(["mu", "".join(tauIdAlgorithmName), "PairForTauIdEffCounter"])
setattr(process, muTauPairForTauIdEffCounterName, muTauPairForTauIdEffCounter)
sequence += muTauPairForTauIdEffCounter
retVal = {}
retVal["sequence"] = sequence
retVal["patTauCollections"] = [
composeModuleName([selTauCollectionName, "cumulative"])
]
retVal["muTauPairCollections"] = [
composeModuleName([selectedMuTauPairsDzModuleName, "cumulative"])
]
if isMC:
retVal["patTauCollections"].extend([
composeModuleName([selTauCollectionName, "TauJetEnUp", "cumulative"]),
composeModuleName([selTauCollectionName, "TauJetEnDown", "cumulative"]),
composeModuleName([selTauCollectionName, "TauJetResUp", "cumulative"]),
composeModuleName([selTauCollectionName, "TauJetResDown", "cumulative"])
])
retVal["muTauPairCollections"].extend([
composeModuleName([selectedMuTauPairsDzModuleName, "TauJetEnUp", "cumulative"]),
composeModuleName([selectedMuTauPairsDzModuleName, "TauJetEnDown", "cumulative"]),
composeModuleName([selectedMuTauPairsDzModuleName, "TauJetResUp", "cumulative"]),
composeModuleName([selectedMuTauPairsDzModuleName, "TauJetResDown", "cumulative"]),
composeModuleName([selectedMuTauPairsDzModuleName, "JetEnUp", "cumulative"]),
composeModuleName([selectedMuTauPairsDzModuleName, "JetEnDown", "cumulative"]),
composeModuleName([selectedMuTauPairsDzModuleName, "UnclusteredEnUp", "cumulative"]),
composeModuleName([selectedMuTauPairsDzModuleName, "UnclusteredEnDown", "cumulative"])
])
return retVal
def configurePatTupleProductionTauIdEffMeasSpecific(
process,
patSequenceBuilder=buildGenericTauSequence,
hltProcess="HLT",
isMC=False,
isEmbedded=False,
runSVfit=False):
# check that patSequenceBuilder and patTauCleanerPrototype are defined and non-null
if patSequenceBuilder is None:
raise ValueError("Undefined 'patSequenceBuilder' Parameter !!")
#--------------------------------------------------------------------------------
# produce "basic" PAT objects
#--------------------------------------------------------------------------------
process.load("PhysicsTools.PatAlgos.cleaningLayer1.tauCleaner_cfi")
patCaloTauCleanerPrototype = process.cleanPatTaus.clone(
preselection=cms.string(''),
checkOverlaps=cms.PSet(),
finalCut=cms.string(
'caloTauTagInfoRef().jetRef().pt() > 5 & abs(caloTauTagInfoRef().jetRef().eta()) < 2.5'
))
patPFTauCleanerPrototype = process.cleanPatTaus.clone(
preselection=cms.string(''),
checkOverlaps=cms.PSet(),
finalCut=cms.string(
'pfJetRef().pt() > 5 & abs(pfJetRef().eta()) < 2.5'))
patTupleConfig = configurePatTupleProduction(process, patSequenceBuilder,
patPFTauCleanerPrototype,
patCaloTauCleanerPrototype,
True, hltProcess, isMC, False)
if isMC:
addJetCollection(
process,
cms.InputTag('smearedAK5PFJets'),
'SmearedAK5',
'PF',
doJTA=False,
doBTagging=True,
jetCorrLabel=
None, # CV: jet corrections already applied on reco::PFJet input
doType1MET=False,
genJetCollection=cms.InputTag("ak5GenJets"),
doJetID=True,
jetIdLabel="ak5",
outputModules=[])
else:
addJetCollection(
process,
cms.InputTag('calibratedAK5PFJets'),
'CalibratedAK5',
'PF',
doJTA=False,
doBTagging=True,
jetCorrLabel=
None, # CV: jet corrections already applied on reco::PFJet input
doType1MET=False,
doJetID=True,
jetIdLabel="ak5",
outputModules=[])
# add "raw" (uncorrected) CaloMET,
# needed to parametrize efficiency turn-on of HLT_IsoMu15_L1ETM20 cross-trigger
process.patCaloMet = process.patMETs.clone(
metSource=cms.InputTag('met'), addMuonCorrections=cms.bool(False))
process.patCaloMetNoHF = process.patMETs.clone(
metSource=cms.InputTag('metNoHF'), addMuonCorrections=cms.bool(False))
process.producePatTupleTauIdEffMeasSpecific = cms.Sequence(
process.patTupleProductionSequence + process.caloTauSequence
# store TaNC inputs as discriminators
#+ process.produceTancMVAInputDiscriminators
#+ process.pfTauSequenceFixedCone
#+ process.pfTauSequenceShrinkingCone
+ process.pfTauSequenceHPS + process.pfTauSequenceHPSpTaNC +
process.patCaloMet + process.patCaloMetNoHF)
#--------------------------------------------------------------------------------
# select "the" primary event Vertex
#--------------------------------------------------------------------------------
process.load("TauAnalysis.RecoTools.recoVertexSelection_cff")
process.producePatTupleTauIdEffMeasSpecific += process.selectPrimaryVertex
#--------------------------------------------------------------------------------
# produce collections of "global" and "stand-alone" Muons for di-Muon veto
#--------------------------------------------------------------------------------
process.selectedPatMuonsLoose = cms.EDFilter(
"PATMuonSelector",
src=cms.InputTag('patMuons'),
cut=cms.string(
'(isGlobalMuon() | isStandAloneMuon() | isTrackerMuon()) & pt > 5.0'
),
filter=cms.bool(False))
process.producePatTupleTauIdEffMeasSpecific += process.selectedPatMuonsLoose
#--------------------------------------------------------------------------------
# define Muon momentum scale corrections
#--------------------------------------------------------------------------------
process.load("TauAnalysis.RecoTools.patMuonMomentumCorrection_cfi")
if isMC:
process.poolDBESSourceMuScleFitCentralValue.toGet[0].tag = cms.string(
'MuScleFit_Scale_Z_MC_Startup_innerTrack')
else:
process.poolDBESSourceMuScleFitCentralValue.toGet[0].tag = cms.string(
'MuScleFit_Scale_Z_36_invPb_innerTrack_Dec22_v1')
process.patMuonsMuScleFitCorrectedMomentum.MuonLabel = cms.InputTag(
'selectedPatMuonsVBTFid')
# CV: MuScleFit muon momentum corrections do not work in CMSSW_5_2_x (May 4th 2012)
##process.producePatTupleTauIdEffMeasSpecific += process.patMuonsMuScleFitCorrectedMomentum
##process.load("TauAnalysis.RecoTools.patLeptonSystematics_cff")
##process.patMuonsMuScleFitCorrectedMomentumShiftUp.MuonLabel = process.patMuonsMuScleFitCorrectedMomentum.MuonLabel
##process.patMuonsMuScleFitCorrectedMomentumShiftDown.MuonLabel = process.patMuonsMuScleFitCorrectedMomentum.MuonLabel
##process.producePatTupleTauIdEffMeasSpecific += process.patMuonsMuScleFitCorrectedMomentumShiftUp
##process.producePatTupleTauIdEffMeasSpecific += process.patMuonsMuScleFitCorrectedMomentumShiftDown
#--------------------------------------------------------------------------------
# define Muon selection
#--------------------------------------------------------------------------------
process.selectedPatMuonsForTauIdEffPFRelIso = cms.EDFilter("PATMuonSelector",
cut = cms.string(
'(userIsolation("pat::User1Iso")' + \
' + max(0., userIsolation("pat::PfNeutralHadronIso") + userIsolation("pat::PfGammaIso")' + \
' - 0.5*userIsolation("pat::User2Iso"))) < 0.50*pt'
),
filter = cms.bool(False)
)
patMuonSelConfiguratorForTauIdEff = objSelConfigurator(
[process.selectedPatMuonsForTauIdEffPFRelIso],
# CV: MuScleFit muon momentum corrections do not work in CMSSW_5_2_x (May 4th 2012)
#src = "patMuonsMuScleFitCorrectedMomentum",
src="selectedPatMuonsVBTFid",
pyModuleName=__name__,
doSelIndividual=False)
setattr(patMuonSelConfiguratorForTauIdEff, "systematics", muonSystematics)
process.selectPatMuonsForTauIdEff = patMuonSelConfiguratorForTauIdEff.configure(
process=process)
process.producePatTupleTauIdEffMeasSpecific += process.selectPatMuonsForTauIdEff
#--------------------------------------------------------------------------------
# define Muon selection for di-Muon veto
#--------------------------------------------------------------------------------
process.selectedPatMuonsForTauIdEffZmumuHypotheses = cms.EDFilter(
"PATMuonSelector",
src=cms.InputTag("patMuons"),
cut=cms.string(
'isGlobalMuon() | isTrackerMuon() | isStandAloneMuon()'),
filter=cms.bool(False))
process.allDiMuPairForTauIdEffZmumuHypotheses = cms.EDProducer(
"PATDiMuPairProducer",
useLeadingTausOnly=cms.bool(False),
srcLeg1=cms.InputTag(
composeModuleName(
['selectedPatMuonsForTauIdEffPFRelIso', "cumulative"])),
srcLeg2=cms.InputTag('selectedPatMuonsForTauIdEffZmumuHypotheses'),
dRmin12=cms.double(0.01),
srcMET=cms.InputTag(''),
recoMode=cms.string(""),
verbosity=cms.untracked.int32(0))
process.selectedDiMuPairForTauIdEffZmumuHypotheses = cms.EDFilter(
"PATDiMuPairSelector",
src=cms.InputTag("allDiMuPairForTauIdEffZmumuHypotheses"),
cut=cms.string('charge = 0'),
filter=cms.bool(False))
process.produceDiMuPairsForTauIdEff = cms.Sequence(
process.selectedPatMuonsForTauIdEffZmumuHypotheses *
process.allDiMuPairForTauIdEffZmumuHypotheses *
process.selectedDiMuPairForTauIdEffZmumuHypotheses)
process.producePatTupleTauIdEffMeasSpecific += process.produceDiMuPairsForTauIdEff
#--------------------------------------------------------------------------------
# define Electron selection (needed for pat::Jet overlap removal)
#--------------------------------------------------------------------------------
process.load("TauAnalysis/RecoTools/patLeptonSelection_cff")
process.producePatTupleTauIdEffMeasSpecific += process.selectPatElectrons
#--------------------------------------------------------------------------------
# define Jet energy scale corrections
#--------------------------------------------------------------------------------
process.load("TauAnalysis.RecoTools.patJetSystematics_cff")
# CV: shift jet energy by 3 standard-deviations,
# so that template morphing remains an interpolation and no extrapolation is needed
setattr(process.patJetsJECshiftUp, "varyByNsigmas", cms.double(3.0))
setattr(process.patJetsJECshiftDown, "varyByNsigmas", cms.double(3.0))
process.producePatTupleTauIdEffMeasSpecific += process.prodSmearedJets
#--------------------------------------------------------------------------------
# produce collections of Tau-Jets and of Muon + Tau-jet candidate pairs
#--------------------------------------------------------------------------------
# CV: do not run SVFit and PFMetSignificance algorithms,
# as they use a significant amount of time (2011/05/27)
#retVal_pfTauFixedCone = \
# buildSequenceTauIdEffMeasSpecific(process,
# 'selectedPatMuonsForTauIdEffPFRelIso',
# [ "PFTau", "FixedCone" ], patTupleConfig["pfTauCollectionFixedCone"], False,
# None,
# 'patType1CorrectedPFMet',
# isMC = isMC, isEmbedded = isEmbedded,
# runSVfit = False)
#process.producePatTupleTauIdEffMeasSpecific += retVal_pfTauFixedCone["sequence"]
#retVal_pfTauShrinkingCone = \
# buildSequenceTauIdEffMeasSpecific(process,
# 'selectedPatMuonsForTauIdEffPFRelIso',
# [ "PFTau", "ShrinkingCone" ], patTupleConfig["pfTauCollectionShrinkingCone"], False,
# None,
# 'patType1CorrectedPFMet',
# isMC = isMC, isEmbedded = isEmbedded,
# runSVfit = False)
#process.producePatTupleTauIdEffMeasSpecific += retVal_pfTauShrinkingCone["sequence"]
# CV: save HPS taus passing the following tau id. discriminators
# for measurement of tau charge misidentification rate
savePFTauHPS = \
"pt > 15.0 & abs(eta) < 2.5 & " \
+ "tauID('decayModeFinding') > 0.5 & " \
+ "(tauID('byLooseIsolation') > 0.5 |" \
+ " tauID('byLooseIsolationDeltaBetaCorr') > 0.5 |" \
+ " tauID('byLooseCombinedIsolationDeltaBetaCorr') > 0.5) & " \
+ "tauID('againstElectronLoose') > 0.5 & " \
+ "tauID('againstMuonTight') > 0.5"
retVal_pfTauHPS = \
buildSequenceTauIdEffMeasSpecific(process,
'selectedPatMuonsForTauIdEffPFRelIso',
[ "PFTau", "HPS" ], patTupleConfig["pfTauCollectionHPS"], True,
savePFTauHPS,
'patType1CorrectedPFMet',
isMC = isMC, isEmbedded = isEmbedded,
runSVfit = runSVfit)
process.producePatTupleTauIdEffMeasSpecific += retVal_pfTauHPS["sequence"]
# CV: save HPS+TaNC taus passing the following tau id. discriminators
# for measurement of tau charge misidentification rate
#savePFTauHPSpTaNC = \
# "pt > 15.0 & abs(eta) < 2.5 & " \
# + "tauID('leadingTrackFinding') > 0.5 & " \
# + "tauID('byTaNCloose') > 0.5 & " \
# + "tauID('againstElectronLoose') > 0.5 & " \
# + "tauID('againstMuonTight') > 0.5"
#retVal_pfTauHPSpTaNC = \
# buildSequenceTauIdEffMeasSpecific(process,
# 'selectedPatMuonsForTauIdEffPFRelIso',
# [ "PFTau", "HPSpTaNC" ], patTupleConfig["pfTauCollectionHPSpTaNC"], True,
# savePFTauHPSpTaNC,
# 'patType1CorrectedPFMet',
# isMC = isMC, isEmbedded = isEmbedded,
# runSVfit = runSVfit)
#process.producePatTupleTauIdEffMeasSpecific += retVal_pfTauHPSpTaNC["sequence"]
retVal = {}
#retVal["pfTauFixedCone"] = retVal_pfTauFixedCone
#retVal["pfTauShrinkingCone"] = retVal_pfTauShrinkingCone
retVal["pfTauHPS"] = retVal_pfTauHPS
#retVal["pfTauHPSpTaNC"] = retVal_pfTauHPSpTaNC
retVal["algorithms"] = [
#"pfTauFixedCone",
#"pfTauShrinkingCone",
"pfTauHPS",
#"pfTauHPSpTaNC"
]
return retVal
selectedPatElectronsTrk = cms.EDFilter("PATElectronSelector",
cut = cms.string('gsfTrack.isNonnull'),
filter = cms.bool(False)
)
selectedPatElectronsTrkIP = cms.EDFilter("PATElectronIpSelector",
vertexSource = cms.InputTag("selectedPrimaryVertexPosition"),
IpMax = cms.double(0.05),
filter = cms.bool(False)
)
patElectronSelConfigurator = objSelConfigurator(
[
selectedPatElectronsId,
selectedPatElectronsAntiCrackCut,
selectedPatElectronsEta,
selectedPatElectronsPt,
selectedPatElectronsIso,
selectedPatElectronsTrk,
selectedPatElectronsTrkIP ],
src = "cleanPatElectrons",
pyModuleName = __name__,
doSelIndividual = True
)
selectPatElectrons = patElectronSelConfigurator.configure(pyNameSpace = locals())
#
# produce collections of pat::Muons passing different selection criteria
#
selectedPatMuonsGlobal = cms.EDFilter("PATMuonSelector",
cut = cms.string('isGlobalMuon'),
filter = cms.bool(False)
import FWCore.ParameterSet.Config as cms
import copy
from TauAnalysis.Configuration.producePatTuple_cff import *
from TauAnalysis.RecoTools.patLeptonSelection_cff import *
from TauAnalysis.RecoTools.patJetSelection_cff import *
from TauAnalysis.CandidateTools.elecMuPairProduction_cff import *
from TauAnalysis.CandidateTools.elecMuPairSelection_cfi import *
from TauAnalysis.CandidateTools.tools.objSelConfigurator import objSelConfigurator
# ------------------------------------- met --------------------------------------#
# ******* custom reco ********
patMETs.metSource = cms.InputTag("corMetType1Icone5Muons") # no tau jet specific correction
# ***** custom selection *****
selectedMETMax = cms.EDFilter("PATMETSelector", cut=cms.string("et < 60"), filter=cms.bool(False))
patMETSelConfigurator = objSelConfigurator([selectedMETMax], src="patMETs", pyModuleName=__name__, doSelIndividual=True)
selectLayer1METs = patMETSelConfigurator.configure(pyNameSpace=locals())
# ---------------------------------- electrons -----------------------------------#
# ******* custom reco ********
patElectrons.userIsolation.tracker.deltaR = cms.double(0.3)
patElectrons.userIsolation.tracker.vetos = cms.vstring("0.015", "Threshold(1.0)")
patElectrons.userIsolation.ecal.deltaR = cms.double(0.4)
patElectrons.userIsolation.ecal.vetos = cms.vstring(
"EcalBarrel:0.045", # 0.045 #egamma default
"EcalBarrel:RectangularEtaPhiVeto(-0.02,0.02,-0.5,0.5)", # -0.02,0.02,-0.5,0.5
"EcalEndcaps:0.1", # 0.07
"EcalEndcaps:RectangularEtaPhiVeto(-0.05,0.05,-0.5,0.5)", # -0.02,0.02,-0.5,0.5
"EcalBarrel:ThresholdFromTransverse(0.12)", # 0.08
"EcalEndcaps:ThresholdFromTransverse(0.3)",
)
