def addHEEPId(process): # Run the HEEP electron id. This must be done at PAT tuple making # time and cannot be done later unless some modifications are done # the GsfElectron/GsfElectronCore classes. from SHarper.HEEPAnalyzer.HEEPSelectionCuts_cfi import heepBarrelCuts, heepEndcapCuts from SHarper.HEEPAnalyzer.HEEPEventParameters_cfi import heepEventPara process.HEEPId = cms.EDProducer('HEEPIdValueMapProducer', eleLabel = cms.InputTag('gsfElectrons'), barrelCuts = heepBarrelCuts, endcapCuts = heepEndcapCuts, eleIsolEffectiveAreas = heepEventPara.eleIsolEffectiveAreas, applyRhoCorrToEleIsol = heepEventPara.applyRhoCorrToEleIsol, eleRhoCorrLabel = heepEventPara.eleRhoCorrTag, writeIdAsInt = cms.bool(True), ) # For isolation correction from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJetsForIsolation = kt4PFJets.clone( rParam = 0.6, doRhoFastjet = True ) process.kt6PFJetsForIsolation.Rho_EtaMax = cms.double(2.5) # Embed the HEEP cut bitwords into the userData of the # patElectrons so we can use it to cut on at dilepton-making time # instead of necessarily dropping them in the selectedPatElectrons # or cleanPatElectrons steps. process.patElectrons.userData.userInts.src.append('HEEPId') process.patDefaultSequence.replace(process.patElectrons, process.kt6PFJetsForIsolation * process.HEEPId * process.patElectrons)
def defineAnalysis(process,castorDir="",reRunRho=False) : # our MET producer process.ClusteredPFMetProducer = ClusteredPFMetProducer.clone() # # configure the analyzer (cf. base values are in the StandardSelections_cfi) # process.evAnalyzer = cms.EDAnalyzer("DileptonPlusMETEventAnalyzer", dtag=cms.string('llvv'), Trigger = BaseTriggerSelection.clone(), Generator = BaseGeneratorSelection.clone(), Vertices = BaseVertexSelection.clone(), Photons = BasePhotonsSelection.clone(), LooseMuons = BaseLooseMuonsSelection.clone(), Muons = BaseMuonsSelection.clone(), LooseElectrons = BaseLooseElectronsSelection.clone(), Electrons = BaseElectronsSelection.clone(), Dileptons = BaseDileptonSelection.clone(), Jets = BaseJetSelection.clone(), AssocJets = AssocJetSelection.clone(), MET = BaseMetSelection.clone() ) if(castorDir.find('12_03_13_HZZ2l2v_pat')>0): print ' Warning: applying PF muon patch to standard selection' process.evAnalyzer.Muons.source=cms.InputTag("selectedPatMuonsPFlow") process.evAnalyzer.Muons.sourceIsPF=cms.bool(True) process.evAnalyzer.LooseMuons.source=process.evAnalyzer.Muons.source process.evAnalyzer.LooseMuons.sourceIsPF=process.evAnalyzer.Muons.sourceIsPF #MVAs for IDs #process.load('EGamma.EGammaAnalysisTools.electronIdMVAProducer_cfi') #process.mvaIDs = cms.Sequence( process.mvaTrigV0 + process.mvaNonTrigV0 ) from JetMETCorrections.Configuration.JetCorrectionProducers_cff import ak5PFJetsL1L2L3 process.ak5PFJetsL1L2L3ForMVAMET=ak5PFJetsL1L2L3.clone() #rho for muon isolation if(reRunRho) : process.pfAllNeutralHadronsAndPhotons = pfAllNeutralHadronsAndPhotons.clone( src=cms.InputTag("particleFlow") ) process.kt6PFJetsCentralNeutral = kt4PFJets.clone( src = cms.InputTag("pfAllNeutralHadronsAndPhotons"), rParam = cms.double(0.6), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True), Ghost_EtaMax = cms.double(3.1), Rho_EtaMax = cms.double(2.5), inputEtMin = cms.double(0.5) ) process.rhoForIsolationSequence = cms.Sequence(process.pfAllNeutralHadronsAndPhotons*process.kt6PFJetsCentralNeutral) process.analysis = cms.Path( #process.mvaIDs + process.rhoForIsolationSequence + process.ak5PFJetsL1L2L3ForMVAMET + process.ClusteredPFMetProducer + process.evAnalyzer) else : process.analysis = cms.Path( #process.mvaIDs + process.ak5PFJetsL1L2L3ForMVAMET + process.ClusteredPFMetProducer + process.evAnalyzer)
def enablePileUpCorrectionInPF2PAT( process, postfix, sequence='PF2PAT'): """ Modifies the PF2PAT sequence according to the recipe of JetMET: """ # pile up subtraction getattr(process,"pfNoPileUp"+postfix).enable = True getattr(process,"pfPileUp"+postfix).Enable = True getattr(process,"pfPileUp"+postfix).checkClosestZVertex = False getattr(process,"pfPileUp"+postfix).Vertices = 'goodOfflinePrimaryVertices' getattr(process,"pfJets"+postfix).doAreaFastjet = True getattr(process,"pfJets"+postfix).doRhoFastjet = False from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets setattr( process, 'kt6PFJets'+postfix, kt4PFJets.clone( rParam = cms.double(0.6), src = cms.InputTag('pfNoElectron'+postfix), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True) # voronoiRfact = cms.double(0.9) ) ) # adding kt6PFJets getattr(process,'pfJetSequence'+postfix).replace( getattr(process,"pfJets"+postfix), getattr(process,"kt6PFJets"+postfix) + getattr(process,"pfJets"+postfix) ) # adding goodOfflinePrimaryVertices before pfPileUp process.load('CommonTools.ParticleFlow.goodOfflinePrimaryVertices_cfi') getattr(process, 'pfNoPileUpSequence'+postfix).replace( getattr(process,"pfPileUp"+postfix), process.goodOfflinePrimaryVertices + getattr(process,"pfPileUp"+postfix) )
def rho25(process) : #https://twiki.cern.ch/twiki/bin/view/CMS/EgammaEARhoCorrection #(also https://twiki.cern.ch/twiki/bin/view/CMS/Vgamma2011PhotonID) from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJetsForIsolation = kt4PFJets.clone( rParam = 0.6, doRhoFastjet = True ) process.kt6PFJetsForIsolation.Rho_EtaMax = cms.double(2.5) return cms.Path( process.kt6PFJetsForIsolation )
def applyFastJet(process,postfix): process.pfPileUpPFlow.Enable = True process.pfPileUpPFlow.checkClosestZVertex = cms.bool(False) process.pfPileUpPFlow.Vertices = cms.InputTag('goodOfflinePrimaryVertices') process.pfJetsPFlow.doAreaFastjet = True process.pfJetsPFlow.doRhoFastjet = False # Compute the mean pt per unit area (rho) from the # PFchs inputs from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJetsPFlow = kt4PFJets.clone( rParam = cms.double(0.6), src = cms.InputTag('pfNoElectron'+postfix), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True), #voronoiRfact = cms.double(0.9) ) process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJetsPFlow", "rho") # Add the PV selector and KT6 producer to the sequence getattr(process,"patPF2PATSequence"+postfix).replace( getattr(process,"pfNoElectron"+postfix), getattr(process,"pfNoElectron"+postfix)*process.kt6PFJetsPFlow )
process.PFCandidatesAll = cms.EDProducer('PFCand_NoPU_WithAM', PFCandidateCollection = cms.InputTag('particleFlow'), VertexCollection = cms.InputTag('offlinePrimaryVertices'), VertexTrackAssociationMap = cms.InputTag('Tracks2VertexAll'), ConversionsCollection = cms.InputTag('allConversions'), V0KshortCollection = cms.InputTag('generalV0Candidates','Kshort'), V0LambdaCollection = cms.InputTag('generalV0Candidates','Lambda'), NIVertexCollection = cms.InputTag('particleFlowDisplacedVertex'), ) from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJets1st = kt4PFJets.clone( src = cms.InputTag("PFCandidates1st"), rParam = cms.double(0.6), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True), Ghost_EtaMax = cms.double(6.5), ) process.kt6PFJetsAll = kt4PFJets.clone( src = cms.InputTag("PFCandidatesAll"), rParam = cms.double(0.6), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True), Ghost_EtaMax = cms.double(6.5) ) process.kt6GenJetsn = cms.EDProducer("CandViewNtpProducer", src = cms.InputTag("kt6GenJets"), lazyParser = cms.untracked.bool(True),
for name, pset in kappa_jets.iteritems(): setattr(process.kappaTuple.Jets, name, pset) process.kappaTuple.Jets.taggers = cms.vstring( "puJetIDFullDiscriminant", "puJetIDFullLoose", "puJetIDFullMedium", "puJetIDFullTight" ) #print reduce(lambda a, b: a * b, jet_resources + sorted(cmssw_jets.values())) #process.path *= reduce(lambda a, b: a * b, jet_resources + sorted(cmssw_jets.values())) # Gluon tagging? - https://twiki.cern.ch/twiki/bin/viewauth/CMS/GluonTag # B-tagging (for ak5 jets)? - https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookBTagging#DifferentJets # B-tagging for (ak5 CHS jets)? - https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookBTagging#DifferentJets # PileupDensity ######################## from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.pileupDensitykt6PFJets = kt4PFJets.clone(rParam=0.6, doRhoFastjet=True, Rho_EtaMax=2.5) process.kappaTuple.active += cms.vstring('Jets', 'PileupDensity') process.kappaTuple.PileupDensity.rename = cms.vstring("fixedGridRhoFastjetAll => pileupDensity") process.path *= (process.pileupDensitykt6PFJets) # MET correction ---------------------------------------------------------- #TODO check type 0 corrections from RecoMET.METProducers.PFMET_cfi import pfMet process.pfMETCHS = pfMet.clone(src=cms.InputTag(input_PFCandidates)) process.kappaTuple.active += cms.vstring('MET') # MET without forward region process.PFCandidatesNoHF = cms.EDFilter("CandPtrSelector", src = cms.InputTag(input_PFCandidates), cut = cms.string("abs(eta) < 3" )
def addPF2PAT(process, dataVersion, postfix="PFlow", doTauHLTMatching=True, matchingTauTrigger=None, ): # if hasattr(process, "patDefaultSequence"): # raise Exception("PAT should not exist before calling addPF2PAT at the moment") # Hack to not to crash if something in PAT assumes process.out hasOut = hasattr(process, "out") outputCommands = [] outputCommandsBackup = [] if hasOut: outputCommandsBackup = process.out.outputCommands[:] else: process.out = cms.OutputModule("PoolOutputModule", fileName = cms.untracked.string('dummy.root'), outputCommands = cms.untracked.vstring() ) outputCommands = [] # Jet modifications # PhysicsTools/PatExamples/test/patTuple_42x_jec_cfg.py jetCorrFactors = patJetCorrLevels(dataVersion, True) jetCorrPayload = "AK5PFchs" process.load("PhysicsTools.PatAlgos.patSequences_cff") pfTools.usePF2PAT(process, runPF2PAT=True, jetAlgo="AK5", jetCorrections=(jetCorrPayload, jetCorrFactors), runOnMC=dataVersion.isMC(), postfix=postfix) outputCommands = [ # "keep *_selectedPatPhotons%s_*_*" % postfix, # 'keep *_selectedPatElectrons%s_*_*' % postfix, 'keep *_selectedPatMuons%s_*_*' % postfix, 'keep *_selectedPatJets%s*_*_*' % postfix, 'keep *_selectedPatTaus%s_*_*' % postfix, 'keep *_selectedPatPFParticles%s_*_*' % postfix, 'keep *_selectedPatJets%s_pfCandidates_*' % postfix, 'drop *_*PF_caloTowers_*', 'drop *_*JPT_pfCandidates_*', 'drop *_*Calo_pfCandidates_*', 'keep *_patMETs%s_*_*' % postfix, ] # Enable PFnoPU getattr(process, "pfPileUp"+postfix).Enable = True getattr(process, "pfPileUp"+postfix).checkClosestZVertex = False getattr(process, "pfPileUp"+postfix).Vertices = "offlinePrimaryVertices" # Jet modifications # L1FastJet # https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#OffsetJEC # https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#JetEnCor2011 # https://hypernews.cern.ch/HyperNews/CMS/get/jes/184.html kt6name = "kt6PFJets"+postfix process.load('RecoJets.Configuration.RecoPFJets_cff') from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets setattr(process, kt6name, kt4PFJets.clone( rParam = 0.6, src = 'pfNoElectron'+postfix, doRhoFastjet = True, doAreaFastJet = cms.bool(True), )) getattr(process, "patPF2PATSequence"+postfix).replace( getattr(process, "pfNoElectron"+postfix), getattr(process, "pfNoElectron"+postfix) * getattr(process, kt6name)) getattr(process, "patJetCorrFactors"+postfix).rho = cms.InputTag(kt6name, "rho") getattr(process, "patJetCorrFactors"+postfix).useRho = True # ak5PFJets getattr(process, "pfJets"+postfix).doAreaFastjet = cms.bool(True) getattr(process, "pfJets"+postfix).doRhoFastjet = False # getattr(process, "pfJets"+postfix).Vertices = cms.InputTag("goodPrimaryVertices") setPatJetDefaults(getattr(process, "patJets"+postfix)) # Use HPS taus # Add and recalculate the discriminators addHChTauDiscriminators() if not hasattr(process, "hpsPFTauDiscriminationForChargedHiggsByLeadingTrackPtCut"): import RecoTauTag.RecoTau.PFRecoTauDiscriminationForChargedHiggs_cfi as HChPFTauDiscriminators import RecoTauTag.RecoTau.CaloRecoTauDiscriminationForChargedHiggs_cfi as HChCaloTauDiscriminators tauAlgos = ["hpsPFTau"] # tauAlgos = ["pfTaus"+postfix] HChPFTauDiscriminators.addPFTauDiscriminationSequenceForChargedHiggs(process, tauAlgos) HChPFTauDiscriminatorsCont.addPFTauDiscriminationSequenceForChargedHiggsCont(process, tauAlgos) PFTauTestDiscrimination.addPFTauTestDiscriminationSequence(process, tauAlgos) fixFlightPath(process, tauAlgos[0]) fixFlightPath(process, tauAlgos[0], "Cont") patHelpers.cloneProcessingSnippet(process, process.hpsPFTauHplusDiscriminationSequence, postfix) patHelpers.cloneProcessingSnippet(process, process.hpsPFTauHplusDiscriminationSequenceCont, postfix) patHelpers.cloneProcessingSnippet(process, process.hpsPFTauHplusTestDiscriminationSequence, postfix) patTauSeq = cms.Sequence( getattr(process, "hpsPFTauHplusDiscriminationSequence"+postfix) * getattr(process, "hpsPFTauHplusDiscriminationSequenceCont"+postfix) * getattr(process, "hpsPFTauHplusTestDiscriminationSequence"+postfix) # getattr(process, "pfTaus"+postfix+"HplusDiscriminationSequence") * # getattr(process, "pfTaus"+postfix+"HplusDiscriminationSequenceCont") * # getattr(process, "pfTaus"+postfix+"HplusTestDiscriminationSequence") ) setattr(process, "hplusPatTauSequence"+postfix, patTauSeq) patHelpers.massSearchReplaceParam(patTauSeq, "PFTauProducer", cms.InputTag("hpsPFTauProducer"), cms.InputTag("pfTaus"+postfix)) patHelpers.massSearchReplaceAnyInputTag(patTauSeq, cms.InputTag("hpsPFTauDiscriminationByDecayModeFinding"), cms.InputTag("hpsPFTauDiscriminationByDecayModeFinding"+postfix)) pfTools.adaptPFTaus(process, "hpsPFTau", postfix=postfix) setPatTauDefaults(getattr(process, "patTaus"+postfix), False) addPatTauIsolationEmbedding(process, getattr(process, "patDefaultSequence"+postfix), postfix) getattr(process, "selectedPatTaus"+postfix).cut = tauPreSelection # The prediscriminant of pfTausBaseDiscriminationByLooseIsolation # is missing from the default sequence, but since we don't want to # apply any tau selections as a part of PF2PAT anyway, let's just # remove this too getattr(process, "pfTaus"+postfix).discriminators = cms.VPSet() # getattr(process, "pfTauSequence"+postfix).remove(getattr(process, "pfTaus"+postfix)) # delattr(process, "pfTaus"+postfix) # getattr(process, "pfTausBaseSequence"+postfix).remove(getattr(process, "pfTausBaseDiscriminationByLooseIsolation"+postfix)) # Remove the shrinking cone altogether, we don't care about it # getattr(process, "patDefaultSequence"+postfix).remove(getattr(process, "patShrinkingConePFTauDiscrimination"+postfix)) # Override the tau source (this is WRONG in the standard PF2PAT, the expers should know it already) # getattr(process, "patTaus"+postfix).tauSource = "hpsPFTauProducer"+postfix # patHelpers.massSearchReplaceAnyInputTag(getattr(process, "patHPSPFTauDiscrimination"+postfix), # cms.InputTag("pfTaus"+postfix), # cms.InputTag("hpsPFTauProducer"+postfix)) # getattr(process, "pfNoTau"+postfix).topCollection = cms.InputTag("hpsPFTauProducer"+postfix) # Disable iso deposits, they take a LOT of space getattr(process, "patTaus"+postfix).isoDeposits = cms.PSet() # Disable tau top projection, the taus are identified and removed # from jets as a part of the analysis getattr(process, "pfNoTau"+postfix).enable = False # Lepton modifications setPatLeptonDefaults(getattr(process, "patMuons"+postfix), False) #setPatLeptonDefaults(getattr(process, "patElectrons"+postfix), False) #addPatElectronID(process, getattr(process, "patElectrons"+postfix), getattr(process, "makePatElectrons"+postfix)) # PATElectronProducer segfaults, and we don't really need them now getattr(process, "patDefaultSequence"+postfix).remove(getattr(process, "makePatElectrons"+postfix)) getattr(process, "patDefaultSequence"+postfix).remove(getattr(process, "selectedPatElectrons"+postfix)) getattr(process, "patDefaultSequence"+postfix).remove(getattr(process, "countPatElectrons"+postfix)) getattr(process, "patDefaultSequence"+postfix).remove(getattr(process, "countPatLeptons"+postfix)) # Disable muon and electron top projections, needs wider # discussion about lepton definitions getattr(process, "pfNoMuon"+postfix).enable = False getattr(process, "pfNoElectron"+postfix).enable = False # Remove photon MC matcher in order to avoid keeping photons in the event content #process.patDefaultSequencePFlow.remove(process.photonMatchPFlow) if hasOut: process.out.outputCommands = outputCommandsBackup process.out.outputCommands.extend(outputCommands) else: del process.out getattr(process, "patDefaultSequence"+postfix).replace( getattr(process, "patTaus"+postfix), patTauSeq * getattr(process, "patTaus"+postfix) ) sequence = cms.Sequence( getattr(process, "patPF2PATSequence"+postfix) ) if doTauHLTMatching: sequence *= HChTriggerMatching.addTauHLTMatching(process, matchingTauTrigger, collections=["selectedPatTaus"+postfix], postfix=postfix) return sequence
process.pfJetsPF2PAT.doAreaFastjet = True process.pfJetsPF2PAT.doRhoFastjet = False removeMCMatching(process, ['All']) removeIfInSequence(process, 'patJetGenJetMatchAK5JPT', "patDefaultSequence") removeIfInSequence(process, 'patJetPartonMatchAK5JPT', "patDefaultSequence") removeIfInSequence(process, 'patJetPartons', "patDefaultSequence") removeIfInSequence(process, 'patJetPartonAssociation', "patDefaultSequence") removeIfInSequence(process, 'patJetPartonAssociationAK5JPT', "patDefaultSequence") removeIfInSequence(process, 'patJetFlavourAssociation', "patDefaultSequence") removeIfInSequence(process, 'patJetFlavourAssociationAK5JPT', "patDefaultSequence") process.load('RecoJets.Configuration.RecoJets_cff') from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJets = kt4PFJets.clone() process.kt6PFJets.rParam = 0.6 process.kt6PFJets.src = cms.InputTag('pfNoElectron'+postfix) process.kt6PFJets.Rho_EtaMax = cms.double( 4.4) process.kt6PFJets.doRhoFastjet = True process.kt6PFJets.doAreaFastjet = True #process.kt6PFJets.voronoiRfact = 0.9 #process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJets", "rho") getattr(process,"patJetCorrFactors"+postfix).rho = cms.InputTag("kt6PFJets", "rho") process.load("MiniTree.MiniTreeProducer.neutralpfcandidates_cfi") process.kt6NeutralPFJets = kt4PFJets.clone() process.kt6NeutralPFJets.rParam = 0.6 process.kt6NeutralPFJets.Rho_EtaMax = cms.double( 4.4)
removeSpecificPATObjects(process, ['Electrons', 'Muons']) removeCleaning(process) process.pfAllMuons.src = cms.InputTag("particleFlow") process.patJetsAK5PF.discriminatorSources = cms.VInputTag( cms.InputTag("simpleSecondaryVertexHighEffBJetTagsAK5PF"), cms.InputTag("simpleSecondaryVertexHighPurBJetTagsAK5PF"), cms.InputTag("combinedSecondaryVertexBJetTagsAK5PF"), ) if (release == '42X'): # process.PFTau = process.recoTauClassicHPSSequence from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJets = kt4PFJets.clone( rParam = cms.double(0.6), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True) ) process.patJetCorrFactorsAK5PF.rho = cms.InputTag("kt6PFJets", "rho") #if isEmbedded: # process.jetTracksAssociatorAtVertexAK5PF.tracks = cms.InputTag("tmfTracks") process.btaggingAK5PF = cms.Sequence( process.impactParameterTagInfosAK5PF +process.secondaryVertexTagInfosAK5PF +process.simpleSecondaryVertexHighEffBJetTagsAK5PF +process.simpleSecondaryVertexHighPurBJetTagsAK5PF +process.combinedSecondaryVertexBJetTagsAK5PF )
else: usePF2PAT(process,runPF2PAT=True, jetAlgo=jetAlgo, runOnMC=runOnMC, postfix=postfix, jetCorrections=('AK5PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual']) ) applyPostfix(process,"pfPileUp",postfix).checkClosestZVertex = cms.bool(False) from PhysicsTools.PatAlgos.tools.metTools import * process.pfPileUpPF2PAT.Enable = True process.pfPileUpPF2PAT.Vertices = cms.InputTag('goodOfflinePrimaryVertices') process.load('RecoJets.Configuration.RecoJets_cff') from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJets = kt4PFJets.clone() process.kt6PFJets.rParam = 0.6 #process.kt6PFJets.src = cms.InputTag('pfNoElectron'+postfix) process.kt6PFJets.Rho_EtaMax = cms.double( 4.4) process.kt6PFJets.doRhoFastjet = True process.kt6PFJets.doAreaFastjet = True #process.kt6PFJets.voronoiRfact = 0.9 #process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJets", "rho") getattr(process,"patJetCorrFactors"+postfix).rho = cms.InputTag("kt6PFJets", "rho") #------------------------------------- #Redo the primary vertex from PhysicsTools.SelectorUtils.pvSelector_cfi import pvSelector
def configure( dataset, sourceNames=[], hltPaths=[], maxEvents = -1, outputName = '', runNoPUMVAMetSequence=False ): """ This is the main routine used to configure the nTuplizer. Please check the correctness of all relevant default parameters. dataset: Please choose one of the entries in the lists. sourceNames: list of AOD filenames hltPaths: list of trigger hlt paths (will be ignored for MC) maxEvents: maximal number of events runNoPUMVAMetSequence: please read README for more details """ collisionDatasets = [ '52xPrompt', # Run2012[AB]{C}-PromptReco{_v1} '52x23May2012', # Run2012A-23May2012 '53xPromptC', # Run2012C-PromptReco-v2 '53xPromptD', # Run2012D-PromptReco '53x13July2012', # Run2012[AB]-13Jul2012 '53x06Aug2012', # Run2012A-06Aug2012 '53x24Aug2012', # Run2012C-24Aug2012 '53x11Dec2012', # Run2012C-EcalRecover_11Dec2012 '53x16Jan2013', # Run2012D-16Jan2013 '53x22Jan2013' # Run2012[ABCD]-22Jan2013 ] mcDatasets = [ '52xFullSim', '52xFastSim', '53xFullSim', '53xFastSim' ] isRealData = dataset in collisionDatasets isMC = dataset in mcDatasets isFastSim = isMC and 'FastSim' in dataset is53x = '53x' in dataset is52x = '52x' in dataset if not isRealData and not isMC: raise RuntimeError("Dataset " + dataset + " not defined") import FWCore.ParameterSet.Config as cms ########################## ### Initialize process ### ########################## process = cms.Process("RA3") process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(maxEvents)) process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(False), FailPath = cms.untracked.vstring( 'FatalRootError' ) ) process.source = cms.Source("PoolSource", noEventSort = cms.untracked.bool(True), duplicateCheckMode = cms.untracked.string('noDuplicateCheck'), fileNames = cms.untracked.vstring(sourceNames) ) ##################### ### MessageLogger ### ##################### process.load('FWCore.MessageService.MessageLogger_cfi') process.MessageLogger.cerr.FwkReport.reportEvery = 1000 process.MessageLogger.suppressWarning = cms.untracked.vstring( 'newSecondaryVertexTagInfos', 'chsSecondaryVertexTagInfos', 'pfCandidateToVertexAssoc', 'manystripclus53X', 'toomanystripclus53X' ) process.MessageLogger.suppressError = cms.untracked.vstring('ecalLaserCorrFilter') process.MessageLogger.categories.append('SusyNtuplizer') process.MessageLogger.cerr.SusyNtuplizer = cms.untracked.PSet( limit = cms.untracked.int32(100) ) ############################# ### Conditions & Services ### ############################# process.load('Configuration.Geometry.GeometryIdeal_cff') process.load('Configuration.StandardSequences.MagneticField_38T_cff') process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') # The following global tags are the latest as of April 8th 2013. The user is strongly recommended to check the # SWGuideFrontierConditions twiki before running the configuration. if dataset == '52xPrompt': process.GlobalTag.globaltag = 'GR_P_V39_AN3::All' elif dataset == '52x23May2012': process.GlobalTag.globaltag = 'FT_P_V32B_AN4::All' elif dataset == '53xPromptC' or dataset == '53xPromptD': process.GlobalTag.globaltag = 'GR_P_V42_AN4::All' elif dataset == '53x13July2012': process.GlobalTag.globaltag = 'FT_53_V6C_AN4::All' elif dataset == '53x06Aug2012': process.GlobalTag.globaltag = 'FT_53_V6C_AN4::All' elif dataset == '53x24Aug2012': process.GlobalTag.globaltag = 'FT53_V10A_AN4::All' elif dataset == '53x11Dec2012': process.GlobalTag.globaltag = 'FT_P_V42C_AN4::All' elif dataset == '53x16Jan2013': process.GlobalTag.globaltag = 'FT_P_V43E_AN4::All' elif dataset == '53x22Jan2013': process.GlobalTag.globaltag = 'FT_53_V21_AN4::All' elif isMC and is52x: process.GlobalTag.globaltag = 'START52_V16::All' elif isMC and is53x: process.GlobalTag.globaltag = 'START53_V25::All' ##################### ### SusyNtuplizer ### ##################### process.load("SUSYPhotonAnalysis.SusyNtuplizer.susyNtuplizer_cfi") process.susyNtuplizer.debugLevel = 0 process.susyNtuplizer.isFastSim = isFastSim process.susyNtuplizer.caloJetCollectionTags = [] if outputName: process.susyNtuplizer.outputFileName = outputName ######################### ### HLT result filter ### ######################### if len(hltPaths) != 0: process.load("HLTrigger.HLTfilters.hltHighLevel_cfi") process.hltHighLevel.HLTPaths = hltPaths else: process.hltHighLevel = cms.Sequence() # placeholder ########################################## ### Good vertex collection (transient) ### ########################################## process.goodVertices = cms.EDFilter("VertexSelector", filter = cms.bool(False), src = cms.InputTag("offlinePrimaryVertices"), cut = cms.string("!isFake && ndof >= 4 && abs(z) <= 24 && position.rho < 2") ) process.primaryVertex = cms.EDFilter("PATSingleVertexSelector", mode = cms.string('firstVertex'), vertices = cms.InputTag('goodVertices'), filter = cms.bool(False) ) process.vertexSelectionSequence = cms.Sequence( process.goodVertices + process.primaryVertex ) ########################### ### PU Rho calculations ### ########################### from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets #Calculate rho restricted to barrel for photon pileup subtraction process.kt6PFJetsRhoBarrelOnly = kt4PFJets.clone( src = cms.InputTag('particleFlow'), rParam = cms.double(0.6), #Eta range of jets to be considered for Rho calculation #Should be at most (jet acceptance - jet radius) doRhoFastjet = cms.bool(True), Rho_EtaMax=cms.double(1.4442), #Eta range of ghost jets to be considered for Rho calculation - must be greater than Rho_EtaMax Ghost_EtaMax=cms.double(2.5) ) #Calculate rho restricted to barrel for photon pileup subtraction process.kt6PFJetsRho25 = kt4PFJets.clone( src = cms.InputTag('particleFlow'), rParam = cms.double(0.6), #Eta range of jets to be considered for Rho calculation #Should be at most (jet acceptance - jet radius) doRhoFastjet = cms.bool(True), Rho_EtaMax=cms.double(2.5) ) process.puRhoSequence = cms.Sequence( process.kt6PFJetsRhoBarrelOnly + process.kt6PFJetsRho25 ) ############################### ### PF-based reconstruction ### ############################### # Run the full event reconstruction starting from the full list of PFCandidates (particleFlow). # Serves as inputs to isoDeposit, CHS jets, and NoPUMET. process.load("CommonTools.ParticleFlow.PFBRECO_cff") process.pfPileUp.Vertices = cms.InputTag("goodVertices") process.pfPileUp.checkClosestZVertex = False process.pfBasedRecoSequence = cms.Sequence( process.pfNoPileUpSequence + process.pfParticleSelectionSequence + process.pfPhotonSequence + process.pfMuonSequence + process.pfNoMuon + process.pfElectronSequence + process.pfNoElectron ) #################################### ### Photon & electron isoDeposit ### #################################### # Runs PU identificaton over particleFlow, then calculates isodeposits around # the given particles using the NoPU collection. # The end product is equivalent to running setupPFIso in # CommonTools.ParticleFlow.Tools.pfIsolation, just with fewer modules to run. process.photonPFIsoDepositCharged = process.phPFIsoDepositCharged.clone(src = 'photons') process.photonPFIsoDepositNeutral = process.phPFIsoDepositNeutral.clone(src = 'photons') process.photonPFIsoDepositGamma = process.phPFIsoDepositGamma.clone(src = 'photons') process.gsfElectronPFIsoDepositCharged = process.elPFIsoDepositCharged.clone(src = 'gsfElectrons') process.gsfElectronPFIsoDepositNeutral = process.elPFIsoDepositNeutral.clone(src = 'gsfElectrons') process.gsfElectronPFIsoDepositGamma = process.elPFIsoDepositGamma.clone(src = 'gsfElectrons') process.photonPFIsoValueCharged03 = process.phPFIsoValueCharged03PFId.clone() process.photonPFIsoValueCharged03.deposits[0].src = cms.InputTag('photonPFIsoDepositCharged') process.photonPFIsoValueNeutral03 = process.phPFIsoValueNeutral03PFId.clone() process.photonPFIsoValueNeutral03.deposits[0].src = cms.InputTag('photonPFIsoDepositNeutral') process.photonPFIsoValueGamma03 = process.phPFIsoValueGamma03PFId.clone() process.photonPFIsoValueGamma03.deposits[0].src = cms.InputTag('photonPFIsoDepositGamma') process.gsfElectronPFIsoValueCharged03 = process.elPFIsoValueCharged03PFId.clone() process.gsfElectronPFIsoValueCharged03.deposits[0].src = cms.InputTag('gsfElectronPFIsoDepositCharged') process.gsfElectronPFIsoValueNeutral03 = process.elPFIsoValueNeutral03PFId.clone() process.gsfElectronPFIsoValueNeutral03.deposits[0].src = cms.InputTag('gsfElectronPFIsoDepositNeutral') process.gsfElectronPFIsoValueGamma03 = process.elPFIsoValueGamma03PFId.clone() process.gsfElectronPFIsoValueGamma03.deposits[0].src = cms.InputTag('gsfElectronPFIsoDepositGamma') process.photonIsoDepositSequence = cms.Sequence( process.photonPFIsoDepositCharged + process.photonPFIsoDepositNeutral + process.photonPFIsoDepositGamma + process.photonPFIsoValueCharged03 + process.photonPFIsoValueNeutral03 + process.photonPFIsoValueGamma03 ) process.gsfElectronIsoDepositSequence = cms.Sequence( process.gsfElectronPFIsoDepositCharged + process.gsfElectronPFIsoDepositNeutral + process.gsfElectronPFIsoDepositGamma + process.gsfElectronPFIsoValueCharged03 + process.gsfElectronPFIsoValueNeutral03 + process.gsfElectronPFIsoValueGamma03 ) process.pfIsolationSequence = cms.Sequence( process.photonIsoDepositSequence + process.gsfElectronIsoDepositSequence ) ############################################### ### PFchs (charged hadron subtraction) jets ### ############################################### # pfJets comes from PFBRECO. process.ak5PFchsJets = process.pfJets.clone() process.ak5PFchsJets.doAreaFastjet = True process.pfCHSJetSequence = cms.Sequence( process.ak5PFchsJets ) ########### ### JEC ### ########### process.load("JetMETCorrections.Configuration.DefaultJEC_cff") process.load("JetMETCorrections.Configuration.JetCorrectionServices_cff") # Setting up JEC ESProducers for ak5PFchs. This block will be included in the JetCorrectionServices_cff # in a future tag by JetMET (April 8, 2013) process.ak5PFchsL1Fastjet = process.ak5PFL1Fastjet.clone(algorithm = cms.string('AK5PFchs')) process.ak5PFchsL2Relative = process.ak5PFL2Relative.clone(algorithm = cms.string('AK5PFchs')) process.ak5PFchsL3Absolute = process.ak5PFL3Absolute.clone(algorithm = cms.string('AK5PFchs')) process.ak5PFchsResidual = process.ak5PFResidual.clone(algorithm = cms.string('AK5PFchs')) process.ak5PFchsL2L3 = cms.ESProducer('JetCorrectionESChain', correctors = cms.vstring('ak5PFchsL2Relative', 'ak5PFchsL3Absolute') ) process.ak5PFchsL2L3Residual = process.ak5PFchsL2L3.clone() process.ak5PFchsL2L3Residual.correctors.append('ak5PFchsResidual') process.ak5PFchsL1FastL2L3 = process.ak5PFchsL2L3.clone() process.ak5PFchsL1FastL2L3.correctors.insert(0, 'ak5PFchsL1Fastjet') process.ak5PFchsL1FastL2L3Residual = process.ak5PFchsL1FastL2L3.clone() process.ak5PFchsL1FastL2L3Residual.correctors.append('ak5PFchsResidual') ############################### ### Corrected MET producers ### ############################### process.load("JetMETCorrections.Type1MET.caloMETCorrections_cff") process.load("JetMETCorrections.Type1MET.pfMETCorrections_cff") if isRealData: process.caloJetMETcorr.jetCorrLabel = cms.string("ak5CaloL2L3Residual") process.pfJetMETcorr.jetCorrLabel = cms.string("ak5PFL1FastL2L3Residual") else: process.caloJetMETcorr.jetCorrLabel = cms.string("ak5CaloL2L3") process.pfJetMETcorr.jetCorrLabel = cms.string("ak5PFL1FastL2L3") from JetMETCorrections.Type1MET.pfMETsysShiftCorrections_cfi import pfMEtSysShiftCorr process.pfMEtSysShiftCorr = pfMEtSysShiftCorr.clone( srcVertices = cms.InputTag('goodVertices') ) # http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/JetMETCorrections/Type1MET/python/pfMETsysShiftCorrections_cfi.py?revision=1.6&view=markup # pfMEtSysShiftCorrParameters_2012runABCvsNvtx_data (_mc) if isRealData: process.pfMEtSysShiftCorr.parameter = cms.PSet( px = cms.string("+0.2661 + 0.3217*Nvtx"), py = cms.string("-0.2251 - 0.1747*Nvtx") ) else: process.pfMEtSysShiftCorr.parameter = cms.PSet( px = cms.string("+0.1166 + 0.0200*Nvtx"), py = cms.string("+0.2764 - 0.1280*Nvtx") ) # Remove the track-based type 0 correction process.producePFMETCorrections.remove(process.pfchsMETcorr) # Use PF-based type 0 correction. Reference: AN-2012/333 # Note that type 0 and type 1 are not truly orthogonal; the implicit assumption is that the PU # contributions are fully captured in the high-pt jet offset, low-pt jet, and non-clustering # energy terms in the type 1 MET correction formula. from CommonTools.RecoUtils.pfcand_assomap_cfi import PFCandAssoMap from JetMETCorrections.Type1MET.pfMETCorrectionType0_cfi import pfMETcorrType0 # Full implementation requires the reconstruction of displaced vertex, which we are skipping here. # (Displaced vertex reconstruction requires TrackExtra information and is impossible from AOD) process.pfCandidateToVertexAssoc = PFCandAssoMap.clone() # Attention: Type0PFMETcorrInputProducer does not produce sumEt of the correction. process.pfType0MetCorrection = pfMETcorrType0.clone( srcPFCandidateToVertexAssociations = cms.InputTag('pfCandidateToVertexAssoc'), srcHardScatterVertex = cms.InputTag('primaryVertex') ) process.pfType01CorrectedMet = process.pfType1CorrectedMet.clone( srcType1Corrections = cms.VInputTag( cms.InputTag('pfType0MetCorrection'), cms.InputTag('pfJetMETcorr', 'type1') ) ) process.pfType01p2CorrectedMet = process.pfType1p2CorrectedMet.clone( srcType1Corrections = cms.VInputTag( cms.InputTag('pfType0MetCorrection'), cms.InputTag('pfJetMETcorr', 'type1') ) ) process.pfSysShiftCorrectedMet = process.pfType1CorrectedMet.clone( srcType1Corrections = cms.VInputTag( cms.InputTag('pfMEtSysShiftCorr') ) ) process.pfType01SysShiftCorrectedMet = process.pfType1CorrectedMet.clone( srcType1Corrections = cms.VInputTag( cms.InputTag('pfType0MetCorrection'), cms.InputTag('pfJetMETcorr', 'type1'), cms.InputTag('pfMEtSysShiftCorr') ) ) process.correctedMetSequence = cms.Sequence( process.produceCaloMETCorrections + process.producePFMETCorrections + process.pfCandidateToVertexAssoc + process.pfType0MetCorrection + process.pfType01CorrectedMet + process.pfType01p2CorrectedMet + process.pfMEtSysShiftCorr + process.pfSysShiftCorrectedMet + process.pfType01SysShiftCorrectedMet ) ############################# ### MVA-based electron ID ### ############################# process.load('EGamma.EGammaAnalysisTools.electronIdMVAProducer_cfi') process.eidMVASequence = cms.Sequence( process.mvaTrigV0 * process.mvaNonTrigV0 ) ################# ### PU jet ID ### ################# from RecoJets.JetProducers.PileupJetIDParams_cfi import full_5x, full_5x_chs, cutbased from RecoJets.JetProducers.PileupJetID_cfi import pileupJetIdProducer, pileupJetIdProducerChs process.recoPuJetId = pileupJetIdProducer.clone( jets = cms.InputTag("ak5PFJets"), algos = cms.VPSet(full_5x, cutbased), applyJec = cms.bool(True), inputIsCorrected = cms.bool(False), residualsTxt = cms.FileInPath("RecoJets/JetProducers/data/mva_JetID_v1.weights.xml") # not used, but has to point to an existing file ) process.recoPuJetIdChs = pileupJetIdProducerChs.clone( jets = cms.InputTag("ak5PFchsJets"), algos = cms.VPSet(full_5x_chs, cutbased), applyJec = cms.bool(True), inputIsCorrected = cms.bool(False), residualsTxt = cms.FileInPath("RecoJets/JetProducers/data/mva_JetID_v1.weights.xml") # not used, but has to point to an existing file ) process.recoPuJetIdSequence = cms.Sequence( process.recoPuJetId + process.recoPuJetIdChs ) ################################## ### Jet-parton matching for MC ### ################################## if isMC: process.myPartons = cms.EDProducer("PartonSelector", withLeptons = cms.bool(False), src = cms.InputTag("genParticles") ) process.flavourByRef = cms.EDProducer("JetPartonMatcher", jets = cms.InputTag("ak5PFJets"), coneSizeToAssociate = cms.double(0.3), partons = cms.InputTag("myPartons") ) process.flavourAssociationAlg = cms.EDProducer("JetFlavourIdentifier", srcByReference = cms.InputTag("flavourByRef"), physicsDefinition = cms.bool(False) ) process.flavourAssociationPhy = cms.EDProducer("JetFlavourIdentifier", srcByReference = cms.InputTag("flavourByRef"), physicsDefinition = cms.bool(True) ) process.flavourByRefCHS = cms.EDProducer("JetPartonMatcher", jets = cms.InputTag("ak5PFchsJets"), coneSizeToAssociate = cms.double(0.3), partons = cms.InputTag("myPartons") ) process.flavourAssociationCHSAlg = cms.EDProducer("JetFlavourIdentifier", srcByReference = cms.InputTag("flavourByRefCHS"), physicsDefinition = cms.bool(False) ) process.flavourAssociationCHSPhy = cms.EDProducer("JetFlavourIdentifier", srcByReference = cms.InputTag("flavourByRefCHS"), physicsDefinition = cms.bool(True) ) process.JetFlavourMatchingSequence = cms.Sequence( process.myPartons * process.flavourByRef * process.flavourByRefCHS * process.flavourAssociationAlg * process.flavourAssociationPhy * process.flavourAssociationCHSAlg * process.flavourAssociationCHSPhy ) else: process.JetFlavourMatchingSequence = cms.Sequence() # placeholder ################# ### b-tagging ### ################# # Re-run b-tagging with PFJets as input # b-tagging general configuration process.load("RecoJets.JetAssociationProducers.ic5PFJetTracksAssociatorAtVertex_cfi") process.load("RecoBTag.Configuration.RecoBTag_cff") # create a new jets and tracks associaiton process.newJetTracksAssociatorAtVertex = process.ic5PFJetTracksAssociatorAtVertex.clone( jets = cms.InputTag("ak5PFJets"), tracks = cms.InputTag("generalTracks") ) process.chsJetTracksAssociatorAtVertex = process.ic5PFJetTracksAssociatorAtVertex.clone( jets = cms.InputTag("ak5PFchsJets"), tracks = cms.InputTag("generalTracks") ) # impact parameter b-tag process.newImpactParameterTagInfos = process.impactParameterTagInfos.clone( jetTracks = cms.InputTag("newJetTracksAssociatorAtVertex") ) process.chsImpactParameterTagInfos = process.impactParameterTagInfos.clone( jetTracks = cms.InputTag("chsJetTracksAssociatorAtVertex") ) # TCHE process.newTrackCountingHighEffBJetTags = process.trackCountingHighEffBJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("newImpactParameterTagInfos") ) ) process.chsTrackCountingHighEffBJetTags = process.trackCountingHighEffBJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("chsImpactParameterTagInfos") ) ) # TCHP process.newTrackCountingHighPurBJetTags = process.trackCountingHighPurBJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("newImpactParameterTagInfos") ) ) process.chsTrackCountingHighPurBJetTags = process.trackCountingHighPurBJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("chsImpactParameterTagInfos") ) ) # JP process.newJetProbabilityBJetTags = process.jetProbabilityBJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("newImpactParameterTagInfos") ) ) process.chsJetProbabilityBJetTags = process.jetProbabilityBJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("chsImpactParameterTagInfos") ) ) # JBP process.newJetBProbabilityBJetTags = process.jetBProbabilityBJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("newImpactParameterTagInfos") ) ) process.chsJetBProbabilityBJetTags = process.jetBProbabilityBJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("chsImpactParameterTagInfos") ) ) # secondary vertex b-tag process.newSecondaryVertexTagInfos = process.secondaryVertexTagInfos.clone( trackIPTagInfos = cms.InputTag("newImpactParameterTagInfos") ) process.chsSecondaryVertexTagInfos = process.secondaryVertexTagInfos.clone( trackIPTagInfos = cms.InputTag("chsImpactParameterTagInfos") ) # SSV process.newSimpleSecondaryVertexBJetTags = process.simpleSecondaryVertexBJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("newSecondaryVertexTagInfos") ) ) process.chsSimpleSecondaryVertexBJetTags = process.simpleSecondaryVertexBJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("chsSecondaryVertexTagInfos") ) ) # CSV process.newCombinedSecondaryVertexBJetTags = process.combinedSecondaryVertexBJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("newImpactParameterTagInfos"), cms.InputTag("newSecondaryVertexTagInfos") ) ) process.chsCombinedSecondaryVertexBJetTags = process.combinedSecondaryVertexBJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("chsImpactParameterTagInfos"), cms.InputTag("chsSecondaryVertexTagInfos") ) ) # CSVMVA process.newCombinedSecondaryVertexMVABJetTags = process.combinedSecondaryVertexMVABJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("newImpactParameterTagInfos"), cms.InputTag("newSecondaryVertexTagInfos") ) ) process.chsCombinedSecondaryVertexMVABJetTags = process.combinedSecondaryVertexMVABJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("chsImpactParameterTagInfos"), cms.InputTag("chsSecondaryVertexTagInfos") ) ) # soft electron b-tag process.newSoftElectronTagInfos = process.softElectronTagInfos.clone( jets = "ak5PFJets" ) process.newSoftElectronBJetTags = process.softElectronBJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("newSoftElectronTagInfos") ) ) process.chsSoftElectronTagInfos = process.softElectronTagInfos.clone( jets = "ak5PFchsJets" ) process.chsSoftElectronBJetTags = process.softElectronBJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("chsSoftElectronTagInfos") ) ) # soft muon b-tag process.newSoftMuonTagInfos = process.softMuonTagInfos.clone( jets = "ak5PFJets" ) process.newSoftMuonBJetTags = process.softMuonBJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("newSoftMuonTagInfos") ) ) process.newSoftMuonByIP3dBJetTags = process.softMuonByIP3dBJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("newSoftMuonTagInfos") ) ) process.newSoftMuonByPtBJetTags = process.softMuonByPtBJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("newSoftMuonTagInfos") ) ) process.chsSoftMuonTagInfos = process.softMuonTagInfos.clone( jets = "ak5PFchsJets" ) process.chsSoftMuonBJetTags = process.softMuonBJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("chsSoftMuonTagInfos") ) ) process.chsSoftMuonByIP3dBJetTags = process.softMuonByIP3dBJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("chsSoftMuonTagInfos") ) ) process.chsSoftMuonByPtBJetTags = process.softMuonByPtBJetTags.clone( tagInfos = cms.VInputTag( cms.InputTag("chsSoftMuonTagInfos") ) ) process.newJetTracksAssociator = cms.Sequence( process.newJetTracksAssociatorAtVertex ) process.chsJetTracksAssociator = cms.Sequence( process.chsJetTracksAssociatorAtVertex ) process.newJetBtaggingIP = cms.Sequence( process.newImpactParameterTagInfos * ( process.newTrackCountingHighEffBJetTags + process.newTrackCountingHighPurBJetTags + process.newJetProbabilityBJetTags + process.newJetBProbabilityBJetTags ) ) process.chsJetBtaggingIP = cms.Sequence( process.chsImpactParameterTagInfos * ( process.chsTrackCountingHighEffBJetTags + process.chsTrackCountingHighPurBJetTags + process.chsJetProbabilityBJetTags + process.chsJetBProbabilityBJetTags ) ) process.newJetBtaggingSV = cms.Sequence( process.newImpactParameterTagInfos * process.newSecondaryVertexTagInfos * ( process.newSimpleSecondaryVertexBJetTags + process.newCombinedSecondaryVertexBJetTags + process.newCombinedSecondaryVertexMVABJetTags ) ) process.chsJetBtaggingSV = cms.Sequence( process.chsImpactParameterTagInfos * process.chsSecondaryVertexTagInfos * ( process.chsSimpleSecondaryVertexBJetTags + process.chsCombinedSecondaryVertexBJetTags + process.chsCombinedSecondaryVertexMVABJetTags ) ) process.newJetBtaggingEle = cms.Sequence( process.softElectronCands * process.newSoftElectronTagInfos * process.newSoftElectronBJetTags ) process.chsJetBtaggingEle = cms.Sequence( process.softElectronCands * process.chsSoftElectronTagInfos * process.chsSoftElectronBJetTags ) process.newJetBtaggingMu = cms.Sequence( process.newSoftMuonTagInfos * ( process.newSoftMuonBJetTags + process.newSoftMuonByIP3dBJetTags + process.newSoftMuonByPtBJetTags ) ) process.chsJetBtaggingMu = cms.Sequence( process.chsSoftMuonTagInfos * ( process.chsSoftMuonBJetTags + process.chsSoftMuonByIP3dBJetTags + process.chsSoftMuonByPtBJetTags ) ) process.newJetBtagging = cms.Sequence( process.newJetBtaggingIP + process.newJetBtaggingSV + process.newJetBtaggingEle + process.newJetBtaggingMu ) process.chsJetBtagging = cms.Sequence( process.chsJetBtaggingIP + process.chsJetBtaggingSV + process.chsJetBtaggingEle + process.chsJetBtaggingMu ) # These are fixes for the JetProbability b-tagger calibrations as recommended by BTV. # See https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideBTagJetProbabilityCalibration#Calibration_in_52x_Data_and_MC useSpecialBTagCalibration = True if isRealData and is52x: btagTrackProbability2DTag = "TrackProbabilityCalibration_2D_2012DataTOT_v1_offline" btagTrackProbability3DTag = "TrackProbabilityCalibration_3D_2012DataTOT_v1_offline" elif isRealData and is53x: btagTrackProbability2DTag = "TrackProbabilityCalibration_2D_Data53X_v2" btagTrackProbability3DTag = "TrackProbabilityCalibration_3D_Data53X_v2" elif isMC and is53x: btagTrackProbability2DTag = "TrackProbabilityCalibration_2D_MC53X_v2" btagTrackProbability3DTag = "TrackProbabilityCalibration_3D_MC53X_v2" else: useSpecialBTagCalibration = False if useSpecialBTagCalibration: process.GlobalTag.toGet = cms.VPSet( cms.PSet(record = cms.string("BTagTrackProbability2DRcd"), tag = cms.string(btagTrackProbability2DTag), connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_BTAU") ), cms.PSet(record = cms.string("BTagTrackProbability3DRcd"), tag = cms.string(btagTrackProbability3DTag), connect = cms.untracked.string("frontier://FrontierPrep/CMS_COND_BTAU") ) ) ########################### ### Quark-gluon tagging ### ########################### from QuarkGluonTagger.EightTeV.QGTagger_RecoJets_cff import goodOfflinePrimaryVerticesQG, QGTagger process.goodOfflinePrimaryVerticesQG = goodOfflinePrimaryVerticesQG process.QGTaggerAK5 = QGTagger.clone( srcJets = cms.InputTag('ak5PFJets'), srcRho = cms.InputTag('kt6PFJets', 'rho'), srcRhoIso = cms.InputTag('kt6PFJetsRho25', 'rho') ) process.QGTaggerAK5chs = QGTagger.clone( srcJets = cms.InputTag('ak5PFchsJets'), useCHS = cms.untracked.bool(True), srcRho = cms.InputTag('kt6PFJets', 'rho'), srcRhoIso = cms.InputTag('kt6PFJetsRho25', 'rho') ) if isRealData: process.QGTaggerAK5.jec = cms.untracked.string('ak5PFL1FastL2L3Residual') process.QGTaggerAK5chs.jec = cms.untracked.string('ak5PFchsL1FastL2L3Residual') else: process.QGTaggerAK5.jec = cms.untracked.string('ak5PFL1FastL2L3') process.QGTaggerAK5chs.jec = cms.untracked.string('ak5PFchsL1FastL2L3') process.QGTaggingSequence = cms.Sequence( process.goodOfflinePrimaryVerticesQG + process.QGTaggerAK5 + process.QGTaggerAK5chs ) ################### ### MET filters ### ################### # HBHENoiseFilterResultProducer process.load('CommonTools.RecoAlgos.HBHENoiseFilterResultProducer_cfi') # HCAL laser events filter process.load("RecoMET.METFilters.hcalLaserEventFilter_cfi") process.hcalLaserEventFilter.taggingMode = cms.bool(True) # EcalDeadCellTriggerPrimitiveFilter process.load('RecoMET.METFilters.EcalDeadCellTriggerPrimitiveFilter_cfi') process.EcalDeadCellTriggerPrimitiveFilter.taggingMode = cms.bool(True) # EcalDeadCellBoundaryEnergyFilter process.load('RecoMET.METFilters.EcalDeadCellBoundaryEnergyFilter_cfi') process.EcalDeadCellBoundaryEnergyFilter.taggingMode = cms.bool(True) # Tracking failure filter process.load('RecoMET.METFilters.trackingFailureFilter_cfi') process.trackingFailureFilter.taggingMode = cms.bool(True) # EE Bad SC Filter process.load('RecoMET.METFilters.eeBadScFilter_cfi') process.eeBadScFilter.taggingMode = cms.bool(True) # EE ring of fire process.load('RecoMET.METFilters.eeNoiseFilter_cfi') process.eeNoiseFilter.taggingMode = cms.bool(True) # Inconsistent muon pf candidate filter process.load('RecoMET.METFilters.inconsistentMuonPFCandidateFilter_cfi') process.inconsistentMuonPFCandidateFilter.taggingMode = cms.bool(True) # Greedy muon pf candidate filter process.load('RecoMET.METFilters.greedyMuonPFCandidateFilter_cfi') process.greedyMuonPFCandidateFilter.taggingMode = cms.bool(True) # The ECAL laser correction filter (needs correct GT to work) process.load('RecoMET.METFilters.ecalLaserCorrFilter_cfi') process.ecalLaserCorrFilter.taggingMode = cms.bool(True) # The tracking POG filters process.load('RecoMET.METFilters.trackingPOGFilters_cff') process.manystripclus53X.taggedMode = cms.untracked.bool(True) process.toomanystripclus53X.taggedMode = cms.untracked.bool(True) process.logErrorTooManyClusters.taggedMode = cms.untracked.bool(True) process.logErrorTooManyTripletsPairs.taggedMode = cms.untracked.bool(True) process.logErrorTooManySeeds.taggedMode = cms.untracked.bool(True) #Add up all MET filters process.metFiltersSequence = cms.Sequence( process.HBHENoiseFilterResultProducer + process.hcalLaserEventFilter + process.EcalDeadCellTriggerPrimitiveFilter + process.EcalDeadCellBoundaryEnergyFilter + process.trackingFailureFilter + process.eeBadScFilter + process.eeNoiseFilter + process.inconsistentMuonPFCandidateFilter + process.greedyMuonPFCandidateFilter + process.ecalLaserCorrFilter + process.manystripclus53X + process.toomanystripclus53X + process.logErrorTooManyClusters + process.logErrorTooManyTripletsPairs + process.logErrorTooManySeeds ) ###################### ### NoPU & MVA MET ### ###################### if runNoPUMVAMetSequence: from RecoJets.JetProducers.PileupJetIDParams_cfi import JetIdParams from JetMETCorrections.Configuration.JetCorrectionProducers_cff import ak5PFJetsL1 if isRealData: process.ak5PFJetsL123Corrected = ak5PFJetsL1.clone(correctors = ['ak5PFL1FastL2L3Residual']) else: process.ak5PFJetsL123Corrected = ak5PFJetsL1.clone(correctors = ['ak5PFL1FastL2L3']) process.recoPuJetIdCorrected = pileupJetIdProducer.clone( jets = cms.InputTag("ak5PFJetsL123Corrected"), algos = cms.VPSet(full_5x, cutbased), residualsTxt = cms.FileInPath("RecoJets/JetProducers/data/mva_JetID_v1.weights.xml") # not used, but has to point to an existing file ) # NoPU MET from JetMETCorrections.METPUSubtraction.noPileUpPFMET_cff import noPileUpPFMEtData, noPileUpPFMEt process.pfNoPileUpMetData = noPileUpPFMEtData.clone( srcJets = cms.InputTag('ak5PFJetsL123Corrected'), srcJetIds = cms.InputTag('recoPuJetIdCorrected', 'fullId'), srcPFCandToVertexAssociations = cms.InputTag('pfCandidateToVertexAssoc'), srcHardScatterVertex = cms.InputTag('primaryVertex') ) process.pfNoPileUpMet = noPileUpPFMEt.clone( srcMVAMEtData = cms.InputTag('pfNoPileUpMetData'), srcLeptons = cms.VInputTag( 'pfIsolatedPhotons', 'pfIsolatedMuons', 'pfIsolatedElectrons' ), srcType0Correction = cms.InputTag('pfType0MetCorrection'), saveInputs = cms.bool(False) ) # MVA MET from JetMETCorrections.METPUSubtraction.mvaPFMET_cff import pfMEtMVA process.pfMVAMet = pfMEtMVA.clone( srcCorrJets = cms.InputTag('ak5PFJetsL123Corrected'), srcLeptons = cms.VInputTag( 'pfIsolatedPhotons', 'pfIsolatedMuons', 'pfIsolatedElectrons' ) ) process.noPUMVAMetSequence = cms.Sequence( process.ak5PFJetsL123Corrected + process.recoPuJetIdCorrected + process.pfNoPileUpMetData + process.pfNoPileUpMet + process.pfMVAMet ) else: process.noPUMVAMetSequence = cms.Sequence() # placeholder ################################################################### ### Dataset-dependent sequence and event content configurations ### ################################################################### if isRealData: process.susyNtuplizer.metCollectionTags.remove('genMetTrue') process.susyNtuplizer.jetFlavourMatchingTags = cms.PSet() process.susyNtuplizer.gridParams = cms.vstring() if isFastSim: process.susyNtuplizer.muonCollectionTags = cms.vstring("muons") process.susyNtuplizer.muonIdTags = cms.PSet() process.metFiltersSequence.remove(process.HBHENoiseFilterResultProducer) process.metFiltersSequence.remove(process.logErrorTooManyClusters) process.metFiltersSequence.remove(process.logErrorTooManyTripletsPairs) process.metFiltersSequence.remove(process.logErrorTooManySeeds) # met filters with run = False will automatically be default = False process.susyNtuplizer.metFilters.CSCBeamHalo.run = False process.susyNtuplizer.metFilters.HcalNoise.run = False process.susyNtuplizer.metFilters.LogErrorTooManyClusters.run = False process.susyNtuplizer.metFilters.LogErrorTooManyTripletsPairs.run = False process.susyNtuplizer.metFilters.LogErrorTooManySeeds.run = False if is52x or isFastSim: process.metFiltersSequence.remove(process.manystripclus53X) process.metFiltersSequence.remove(process.toomanystripclus53X) process.susyNtuplizer.metFilters.ManyStripClus53X.run = False process.susyNtuplizer.metFilters.TooManyStripClus53X.run = False if not runNoPUMVAMetSequence: process.susyNtuplizer.metCollectionTags.remove('pfNoPileUpMet') process.susyNtuplizer.metCollectionTags.remove('pfMVAMet') if dataset in ['52xPrompt', '52x23May2012', '53xPromptC', '53x13July2012', '53x06Aug2012', '53x24Aug2012', '53x11Dec2013']: process.susyNtuplizer.metFilters.HcalLaserEventList.default = True if dataset in ['53xPromptD', '53x16Jan2013']: process.susyNtuplizer.metFilters.HcalLaserOccupancy.default = True if dataset == '53x22Jan2013': process.susyNtuplizer.metFilters.HcalLaserRECOUserStep.default = True else: process.susyNtuplizer.metFilters.HcalLaserRECOUserStep.run = False if dataset in ['53x13July2012', '53x24Aug2012']: process.susyNtuplizer.metFilters.EcalLaserCorr.default = True process.susyNtuplizer.storeLumiInfo = cms.bool(False) if dataset == '53x22Jan2013': process.correctedMetSequence.remove(process.pfMEtSysShiftCorr) process.correctedMetSequence.remove(process.pfSysShiftCorrectedMet) process.correctedMetSequence.remove(process.pfType01SysShiftCorrectedMet) process.susyNtuplizer.metCollectionTags.remove('pfSysShiftCorrectedMet') process.susyNtuplizer.metCollectionTags.remove('pfType01SysShiftCorrectedMet') ##################### ### Finalize path ### ##################### process.standard_step = cms.Path( process.hltHighLevel + process.vertexSelectionSequence + process.puRhoSequence + process.pfBasedRecoSequence + process.pfIsolationSequence + process.pfCHSJetSequence + process.correctedMetSequence + process.eidMVASequence + process.recoPuJetIdSequence + process.JetFlavourMatchingSequence + process.newJetTracksAssociator + process.chsJetTracksAssociator + process.newJetBtagging + process.chsJetBtagging + process.QGTaggingSequence + process.metFiltersSequence ) process.optional_step = cms.Path( process.hltHighLevel + process.noPUMVAMetSequence ) process.ntuplizer_step = cms.Path( process.hltHighLevel + process.susyNtuplizer ) process.schedule = cms.Schedule(process.standard_step,process.optional_step,process.ntuplizer_step) return process
from FWCore.MessageService.MessageLogger_cfi import MessageLogger process.MessageLogger = MessageLogger process.MessageLogger.cerr.FwkReport.reportEvery = 100 # Report status ever 100 events process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(-1) ) # Output file process.TFileService = cms.Service("TFileService", fileName = cms.string("test.root") ) # rho value for isolation from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets # the 4 references the rParam = 0.4 process.kt6PFJetsForIsolation = kt4PFJets.clone( rParam = 0.6, doRhoFastjet = True, Rho_EtaMax = cms.double(2.5) ) # Energy and calibrations for electrons process.load('Configuration.StandardSequences.GeometryDB_cff') process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') process.GlobalTag.globaltag = 'GR_P_V42_AN3::All' from ZFinder.Event.electron_regression_cfi import RandomNumberGeneratorService # Set up random numbers (needed for the electron regression) process.RandomNumberGeneratorService = RandomNumberGeneratorService # Run on MC
def addPATSequences(process,runMC): # Load the PAT config from PhysicsTools.PatAlgos.patEventContent_cff import patEventContent process.out = cms.OutputModule("PoolOutputModule", fileName = cms.untracked.string('patTuple.root'), SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring('pat_step') ), outputCommands = cms.untracked.vstring('drop *', *patEventContent ) ) ### process.load('PhysicsTools.PatAlgos.patSequences_cff') from PhysicsTools.PatAlgos.tools.pfTools import usePF2PAT postfix = "PFlow" jetAlgo="AK5" jetCorrections = None if runMC: jetCorrections = ('AK5PFchs', ['L1FastJet','L2Relative','L3Absolute']) else: jetCorrections = ('AK5PFchs', ['L1FastJet','L2Relative','L3Absolute','L2L3Residual']) usePF2PAT(process,runPF2PAT=True, jetAlgo=jetAlgo, runOnMC=runMC, postfix=postfix,jetCorrections=jetCorrections) #from PhysicsTools.PatAlgos.tools.coreTools import removeMCMatching #if not runMC: # removeMCMatching(process, ['All'],"") #-----------------Customization---------------- process.pfPileUpPFlow.Enable = True process.pfPileUpPFlow.checkClosestZVertex = False process.pfPileUpPFlow.Vertices = cms.InputTag('goodOfflinePrimaryVertices') process.pfPileUpPFlow.verbose = True process.pfJetsPFlow.doAreaFastjet = True process.pfJetsPFlow.doRhoFastjet = False from PhysicsTools.SelectorUtils.pvSelector_cfi import pvSelector process.goodOfflinePrimaryVertices = cms.EDFilter( "PrimaryVertexObjectFilter", filterParams = pvSelector.clone( minNdof = cms.double(4.0), maxZ = cms.double(24.0) ), src=cms.InputTag('offlinePrimaryVertices') ) # Compute the mean pt per unit area (rho) from the PFCHS inputs #from RecoJets.Configuration.RecoPFJets_cff import kt6PFJets,ak5PFJets #process.kt6PFJetsPFlow = kt6PFJets.clone( # src = cms.InputTag('pfNoElectron'+postfix), # doAreaFastjet = cms.bool(True), # doRhoFastjet = cms.bool(True) # ) #process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJetsPFlow", "rho") from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJetsForPAT = kt4PFJets.clone( rParam = cms.double(0.6), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True) ) process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJetsForPAT", "rho") from RecoJets.JetProducers.ak5PFJets_cfi import ak5PFJets process.ak5PFJetsPileUp = ak5PFJets.clone( src = cms.InputTag('pfPileUp'+postfix) ) # Switch on PAT trigger from PhysicsTools.PatAlgos.tools.trigTools import switchOnTrigger #switchOnTrigger( process,triggerProducer = 'patTrigger', triggerEventProducer = 'patTriggerEvent', sequence = 'patPF2PATSequence',hltProcess = 'HLT', outputModule = 'out') switchOnTrigger( process ,sequence ='patPF2PATSequence'+postfix) process.patTrigger.addL1Algos = cms.bool( True ) switchOnTrigger( process ,sequence = 'patPF2PATSequence'+postfix) # to fix event content #------------------------------------------------------------------------------------------------------------- # Add modules to default sequence #if runMC: # getattr(process, "patElectrons"+postfix).embedGenMatch = True # getattr(process, "patMuons"+postfix).embedGenMatch = True #else: # getattr(process, "patElectrons"+postfix).embedGenMatch = False # getattr(process, "patMuons"+postfix).embedGenMatch = False # Add modules to default sequence getattr(process,"patPF2PATSequence"+postfix).replace( getattr(process,"pfNoElectron"+postfix), getattr(process,"pfNoElectron"+postfix)*process.kt6PFJetsForPAT ) getattr(process,"patPF2PATSequence"+postfix).replace( getattr(process,"pfNoPileUp"+postfix), getattr(process,"pfNoPileUp"+postfix) * process.ak5PFJetsPileUp ) #---------------------------------------------- # Let it run process.pat_step = cms.Path( process.goodOfflinePrimaryVertices * #process.patDefaultSequence + getattr(process,"patPF2PATSequence"+postfix) ) # Add PatTrigger output to the created file from PhysicsTools.PatAlgos.patEventContent_cff import patTriggerEventContent # Add PF2PAT output to the created file from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning patOutputCommands = cms.untracked.vstring('drop *', 'keep recoPFCandidates_particleFlow_*_*', *patEventContentNoCleaning) # Adjust the event content patOutputCommands += [ #'keep *_selectedPat*_*_*', 'keep *_genParticles*_*_*', 'keep *_offlinePrimaryVertices*_*_*', 'keep *_goodOfflinePrimaryVertices*_*_*', #'keep *_pileUpN*PrimaryVertices_*_*', #'keep *_pfPileUpExclN*_*_*', 'keep *_pfPileUpPFlow*_*_*', 'keep *_pfNoPileUpPFlow*_*_*', 'keep *_ak5PFJetsPileUp_*_*', 'keep *_ak5PFJets_*_*', 'keep recoTracks_generalTracks_*_*', 'keep HcalNoiseSummary_hcalnoise_*_*', 'keep *_BeamHaloSummary_*_*', #------- Trigger collections ------ 'keep edmTriggerResults_TriggerResults_*_*', 'keep *_hltTriggerSummaryAOD_*_*', 'keep L1GlobalTriggerObjectMapRecord_*_*_*', 'keep L1GlobalTriggerReadoutRecord_*_*_*', #------- CASTOR rec hits ------ 'keep *_logErrorHarvester_*_*', 'keep *_castorreco_*_*', #------- Calo towers (just for now) ------ 'keep *_towerMaker_*_*', #---------------PatTrigger---------------- 'keep patTriggerObjects_patTrigger*_*_*', 'keep patTriggerFilters_patTrigger*_*_*', 'keep patTriggerPaths_patTrigger*_*_*', 'keep patTriggerEvent_patTriggerEvent*_*_*' ] process.out.outputCommands = patOutputCommands # top projections in PF2PAT: getattr(process,"pfNoPileUp"+postfix).enable = True getattr(process,"pfNoMuon"+postfix).enable = True getattr(process,"pfNoElectron"+postfix).enable = True getattr(process,"pfNoTau"+postfix).enable = False getattr(process,"pfNoJet"+postfix).enable = True # verbose flags for the PF2PAT modules getattr(process,"pfNoJet"+postfix).verbose = False
# PF2PAT with only charged hadrons from first PV postfixPUSubAK5 = "PFlowPUSubAK5" usePF2PAT(process, runPF2PAT=True, jetAlgo="AK5", runOnMC=not options.useData, postfix=postfixPUSubAK5) process.pfPileUpPFlowPUSubAK5.Enable = True process.pfPileUpPFlowPUSubAK5.Vertices = cms.InputTag("goodOfflinePrimaryVertices") process.pfJetsPFlowPUSubAK5.doAreaFastjet = True process.pfJetsPFlowPUSubAK5.doRhoFastjet = False process.pfJetsPFlowPUSubAK5.Ghost_EtaMax = 6.5 from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJets = kt4PFJets.clone( src=cms.InputTag("pfNoElectronPFlowAK5"), rParam=cms.double(0.6), doAreaFastjet=cms.bool(True), doRhoFastjet=cms.bool(True), Ghost_EtaMax=cms.double(6.5), ) process.kt6PFJetsPUSub = kt4PFJets.clone( src=cms.InputTag("pfNoElectronPFlowPUSubAK5"), rParam=cms.double(0.6), doAreaFastjet=cms.bool(True), doRhoFastjet=cms.bool(True), Ghost_EtaMax=cms.double(6.5), ) removeSpecificPATObjects(process, ["Taus"], postfix=postfixAK5) removeSpecificPATObjects(process, ["Taus"], postfix=postfixPUSubAK5) # turn to false when running on data
#--- Jet Corrections using PF and PF2PAT ---# #--- twiki reference: CMSPublic/WorkBookJetEnergyCorrections ---# #--- See also: PhysicsTools/PatExamples/test/patTuple_42x_jec_cfg.py ---# #-----------------------------------------------------------------------# from PhysicsTools.SelectorUtils.pvSelector_cfi import pvSelector process.goodOfflinePrimaryVertices = cms.EDFilter( "PrimaryVertexObjectFilter", filterParams = pvSelector.clone( minNdof = cms.double(4.0), maxZ = cms.double(24.0) ), src=cms.InputTag('offlinePrimaryVertices') ) # Compute the mean pt per unit area (rho) from the PFchs inputs from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJetsPFlow = kt4PFJets.clone( rParam = cms.double(0.6), src = cms.InputTag('pfNoElectron'+postfix), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True) ) process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJetsPFlow", "rho") # Needed for AOD PF jets ##-------------------- Import the JEC services ----------------------- process.load('JetMETCorrections.Configuration.DefaultJEC_cff') process.kt6PFJets = kt4PFJets.clone( rParam = cms.double(0.6), src = cms.InputTag('pfNoElectron'), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True) ) # Add the PV selector and KT6 producer to the sequence getattr(process,"patPF2PATSequence"+postfix).replace(
process.pfJetsPF2PAT.doAreaFastjet = True process.pfJetsPF2PAT.doRhoFastjet = False removeMCMatching(process, ['All']) removeIfInSequence(process, 'patJetGenJetMatchAK5JPT', "patDefaultSequence") removeIfInSequence(process, 'patJetPartonMatchAK5JPT', "patDefaultSequence") removeIfInSequence(process, 'patJetPartons', "patDefaultSequence") removeIfInSequence(process, 'patJetPartonAssociation', "patDefaultSequence") removeIfInSequence(process, 'patJetPartonAssociationAK5JPT', "patDefaultSequence") removeIfInSequence(process, 'patJetFlavourAssociation', "patDefaultSequence") removeIfInSequence(process, 'patJetFlavourAssociationAK5JPT', "patDefaultSequence") process.load('RecoJets.Configuration.RecoJets_cff') from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJets = kt4PFJets.clone() process.kt6PFJets.rParam = 0.6 process.kt6PFJets.src = cms.InputTag('pfNoElectron'+postfix) process.kt6PFJets.Rho_EtaMax = cms.double( 4.4) process.kt6PFJets.doRhoFastjet = True process.kt6PFJets.doAreaFastjet = True #process.kt6PFJets.voronoiRfact = 0.9 #process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJets", "rho") getattr(process,"patJetCorrFactors"+postfix).rho = cms.InputTag("kt6PFJets", "rho") process.load("TopQuarkAnalysis.MiniTreeProducer.neutralpfcandidates_cfi") process.kt6NeutralPFJets = kt4PFJets.clone() process.kt6NeutralPFJets.rParam = 0.6 process.kt6NeutralPFJets.Rho_EtaMax = cms.double( 4.4)
#configure the pat to load the id in process.load("PhysicsTools.PatAlgos.patSequences_cff"); ### Taus are currently broken in 523, luckly I copied this example from a 41X config file where taus were also broken from PhysicsTools.PatAlgos.tools.coreTools import * removeSpecificPATObjects( process, ['Taus'] ) process.patDefaultSequence.remove( process.patTaus ) if isMC==False: removeMCMatching(process, ['All']) process.patElectrons.userData.userInts.src = cms.VInputTag('HEEPId') #for isolation correction from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJetsForIsolation = kt4PFJets.clone( rParam = 0.6, doRhoFastjet = True ) process.kt6PFJetsForIsolation.Rho_EtaMax = cms.double(2.5) #little example analyzer process.heepAnalyzer = cms.EDAnalyzer("HEEPAnalyzerPATHEEPId", eleLabel=cms.InputTag("patElectrons") ) process.p = cms.Path(process.kt6PFJetsForIsolation* process.HEEPId* #makes the HEEPID value map process.patDefaultSequence* #runs pat process.heepAnalyzer #example analyser module )
#process.patJetsPF2PAT.getJetMCFlavour = True #process.patJetsPF2PAT.addGenPartonMatch = True # Add the calo towers and PFCandidates. process.patJetsPF2PAT.embedCaloTowers = True process.patJetsPF2PAT.embedPFCandidates = True process.patJetsPF2PAT.tagInfoSources = cms.VInputTag( cms.InputTag("secondaryVertexTagInfosAODPF2PAT")) ############################### ###### Bare KT 0.6 jets ####### ############################### from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJetsPF2PAT = kt4PFJets.clone( rParam=cms.double(0.6), src=cms.InputTag('pfNoElectronPF2PAT'), doAreaFastjet=cms.bool(True), doRhoFastjet=cms.bool(True)) getattr(process, "patPF2PATSequencePF2PAT").replace( getattr(process, "pfNoElectronPF2PAT"), getattr(process, "pfNoElectronPF2PAT") * getattr(process, "kt6PFJetsPF2PAT")) # addJetCollection stuff from PhysicsTools.PatAlgos.tools.jetTools import * addJetCollection( process, cms.InputTag('ak5PFJets'), 'AK5',
# if release in ['72X']: # process.ic72XSequence += process.PFTau # if release in ['70XMINIAOD', '72XMINIAOD']: # process.load('PhysicsTools.PatAlgos.slimming.unpackedTracksAndVertices_cfi') # process.icMiniAODSequence += process.unpackedTracksAndVertices #switchOnTrigger(process, outputModule="") ################################################################ # Need to create kt6PFJets in 42X for L1FastJet correction ################################################################ if release in ['72X', '72XMINIAOD']: from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJets = kt4PFJets.clone(rParam=cms.double(0.6), doAreaFastjet=cms.bool(True), doRhoFastjet=cms.bool(True)) process.ic72XSequence += process.kt6PFJets from PhysicsTools.SelectorUtils.pvSelector_cfi import pvSelector process.goodOfflinePrimaryVertices = cms.EDFilter( "PrimaryVertexObjectFilter", filterParams=pvSelector.clone(minNdof=cms.double(4.0), maxZ=cms.double(24.0)), src=cms.InputTag('offlinePrimaryVertices')) process.load("PhysicsTools.PatAlgos.patSequences_cff") from PhysicsTools.PatAlgos.tools.coreTools import * from PhysicsTools.PatAlgos.tools.pfTools import * from PhysicsTools.PatAlgos.tools.tauTools import * from PhysicsTools.PatAlgos.tools.jetTools import *
from RecoJets.JetProducers.ca4PFJets_cfi import ca4PFJets from RecoJets.JetProducers.fixedGridRhoProducer_cfi import fixedGridRhoAll from RecoJets.JetProducers.fixedGridRhoProducerFastjet_cfi import fixedGridRhoFastjetAll from RecoJets.JetProducers.caTopTaggers_cff import * from RecoJets.JetProducers.ak8PFJetsCHS_groomingValueMaps_cfi import ak8PFJetsCHSPrunedLinks, ak8PFJetsCHSFilteredLinks, ak8PFJetsCHSTrimmedLinks, ak8PFJetsCHSSoftDropLinks from RecoJets.JetProducers.ca8PFJetsCHS_groomingValueMaps_cfi import ca8PFJetsCHSPrunedLinks, ca8PFJetsCHSFilteredLinks, ca8PFJetsCHSTrimmedLinks, ca8PFJetsCHSSoftDropLinks from CommonTools.PileupAlgos.Puppi_cff import puppi from CommonTools.PileupAlgos.softKiller_cfi import softKiller from RecoJets.JetProducers.ak4PFJetsPuppi_cfi import ak4PFJetsPuppi from RecoJets.JetProducers.ak4PFJetsSK_cfi import ak4PFJetsSK sisCone7PFJets = sisCone5PFJets.clone( rParam = 0.7 ) ak7PFJets = ak5PFJets.clone( rParam = 0.7 ) ak8PFJets = ak5PFJets.clone( rParam = 0.8 ) gk7PFJets = gk5PFJets.clone( rParam = 0.7 ) kt6PFJets = kt4PFJets.clone( rParam = 0.6 ) ca8PFJets = ca4PFJets.clone( rParam = 0.8 ) #compute areas for Fastjet PU subtraction kt6PFJets.doRhoFastjet = True kt6PFJets.doAreaFastjet = True #use active areas and not Voronoi tessellation for the moment kt6PFJets.voronoiRfact = 0.9 ak4PFJets.doAreaFastjet = True ak5PFJets.doAreaFastjet = True ak5PFJetsTrimmed.doAreaFastjet = True ak7PFJets.doAreaFastjet = True ak8PFJets.doAreaFastjet = True ak4PFJetsSK.doAreaFastjet = True kt6PFJetsCentralChargedPileUp = kt6PFJets.clone(
def setup_jets(process, cms, options, postfix="PFlow"): print "=" * 60 print "Setting up Jets" print "=" * 60 # MC setup inputJetCorrLabel = ("AK5PFchs", ["L1FastJet", "L2Relative", "L3Absolute"]) if options.useData: # data set up inputJetCorrLabel = ("AK5PFchs", ["L1FastJet", "L2Relative", "L3Absolute", "L2L3Residual"]) print "Using jet energy corrections: " print "PF Jets" print inputJetCorrLabel if options.CMSSW == "44X": process.patJetCorrFactorsPFlow.payload = inputJetCorrLabel[0] process.patJetCorrFactorsPFlow.levels = inputJetCorrLabel[1] process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJets", "rho") ############################### #### Jet RECO includes ######## ############################### from RecoJets.JetProducers.SubJetParameters_cfi import SubJetParameters ############################### ###### Bare KT 0.6 jets ####### ############################### from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJets = kt4PFJets.clone( rParam=cms.double(0.6), doAreaFastjet=cms.bool(True), doRhoFastjet=cms.bool(True) ) process.kt6PFJetsPFlow = kt4PFJets.clone( rParam=cms.double(0.6), src=cms.InputTag("pfNoElectron" + postfix), doAreaFastjet=cms.bool(True), doRhoFastjet=cms.bool(True), ) process.kt4PFJetsPFlow = kt4PFJets.clone( rParam=cms.double(0.4), src=cms.InputTag("pfNoElectron" + postfix), doAreaFastjet=cms.bool(True), doRhoFastjet=cms.bool(True), ) ############################### ### TagInfo and Matching Setup# ############################### # Do some configuration of the jet substructure things for jetcoll in [process.patJetsPFlow]: if options.useData == False: jetcoll.embedGenJetMatch = True jetcoll.getJetMCFlavour = True jetcoll.addGenPartonMatch = True # Add CATopTag info... piggy-backing on b-tag functionality jetcoll.addBTagInfo = True jetcoll.embedCaloTowers = True jetcoll.embedPFCandidates = True additionalJets = [ getattr(process, "kt6PFJets"), getattr(process, "kt6PFJets" + postfix), getattr(process, "kt4PFJets" + postfix), ] pfNoElectron = getattr(process, "pfNoElectron" + postfix) for module in additionalJets: getattr(process, "patPF2PATSequence" + postfix).replace(pfNoElectron, pfNoElectron * module)
#process.patJetsPF2PAT.embedGenJetMatch = True #process.patJetsPF2PAT.getJetMCFlavour = True #process.patJetsPF2PAT.addGenPartonMatch = True # Add the calo towers and PFCandidates. process.patJetsPF2PAT.embedCaloTowers = True process.patJetsPF2PAT.embedPFCandidates = True process.patJetsPF2PAT.tagInfoSources = cms.VInputTag( cms.InputTag("secondaryVertexTagInfosAODPF2PAT") ) ############################### ###### Bare KT 0.6 jets ####### ############################### from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJetsPF2PAT = kt4PFJets.clone( rParam = cms.double(0.6), src = cms.InputTag('pfNoElectronPF2PAT'), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True) ) getattr(process,"patPF2PATSequencePF2PAT").replace( getattr(process,"pfNoElectronPF2PAT"), getattr(process,"pfNoElectronPF2PAT")*getattr(process,"kt6PFJetsPF2PAT") ) # addJetCollection stuff #from PhysicsTools.PatAlgos.tools.jetTools import * #addJetCollection(process,cms.InputTag('ak5PFJets'), # 'AK5', 'PF', # doJTA = True, # doBTagging = True, # jetCorrLabel = ('AK5PF', cms.vstring(['L1Offset', 'L2Relative', 'L3Absolute'])), # doType1MET = False,
def getBaseConfig( globaltag, testfile, maxevents, nickname, outputfilename, kappaverbosity, ): from Kappa.Skimming.KSkimming_template_cfg import process process.source.fileNames = testfile process.maxEvents.input = maxevents ## number of events to be processed (-1 = all in file) process.kappaTuple.outputFile = outputfilename ## name of output file process.kappaTuple.verbose = cms.int32(kappaverbosity) ## verbosity level process.kappaTuple.profile = cms.bool(False) if not globaltag.lower() == 'auto' : process.GlobalTag.globaltag = globaltag data = datasetsHelper.isData(nickname) centerOfMassEnergy = datasetsHelper.getCenterOfMassEnergy(nickname) process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(False) ) ## some infos print "\n--------CONFIGURATION----------" print "input: ", testfile print "nickname: ", nickname print "global tag: ", process.GlobalTag.globaltag print "max events: ", maxevents print "output filename:", outputfilename print "------------------\n" process.p = cms.Path ( ) ## ------------------------------------------------------------------------ # Configure Metadata describing the file process.kappaTuple.active = cms.vstring('TreeInfo') process.kappaTuple.TreeInfo.parameters = cms.PSet( dataset = cms.string(datasetsHelper.getDatasetName(nickname)), generator = cms.string(datasetsHelper.getGenerator(nickname)), productionProcess = cms.string(datasetsHelper.getProcess(nickname)), globalTag = cms.string(globaltag), prodCampaignGlobalTag = cms.string(datasetsHelper.getProductionCampaignGlobalTag(nickname, centerOfMassEnergy)), runPeriod = cms.string(datasetsHelper.getRunPeriod(nickname)), jetMultiplicity = cms.int32(datasetsHelper.getJetMultiplicity(nickname)), centerOfMassEnergy = cms.int32(centerOfMassEnergy), puScenario = cms.string(datasetsHelper.getPuScenario(nickname, centerOfMassEnergy)), isData = cms.bool(data) ) ## ------------------------------------------------------------------------ # General configuration process.kappaTuple.active += cms.vstring('VertexSummary') ## save VertexSummary, process.kappaTuple.VertexSummary.whitelist = cms.vstring('goodOfflinePrimaryVertices') #process.kappaTuple.active += cms.vstring('BeamSpot') ## save Beamspot, #process.kappaTuple.active += cms.vstring('TriggerObjects') if data: process.kappaTuple.active+= cms.vstring('DataInfo') ## produce Metadata for data, else: process.kappaTuple.active+= cms.vstring('GenInfo') ## produce Metadata for MC, process.kappaTuple.active+= cms.vstring('GenParticles') process.kappaTuple.Info.hltWhitelist = cms.vstring( ## HLT selection # can be tested at http://regexpal.com # matches 'HLT_Mu17_Mu8_v7' etc. '^HLT_(Double)?Mu([0-9]+)_(Double)?Mu([0-9]+)(_v[[:digit:]]+)?$', # matches 'HLT_DoubleMu7_v8' etc. '^HLT_(Double)?Mu([0-9]+)(_v[[:digit:]]+)?$', ) ## ------------------------------------------------------------------------ # Configure PFCandidates and offline PV # PFCandidates ------------------------------------------------------------ process.load('Kappa.Skimming.KPFCandidates_cff') # Modifications for new particleFlow Pointers #process.pfPileUp.PFCandidates = cms.InputTag('particleFlowPtrs') #process.pfPileUpIso.PFCandidates = cms.InputTag('particleFlowPtrs') #process.pfNoPileUp.bottomCollection = cms.InputTag('particleFlowPtrs') #process.pfNoPileUpIso.bottomCollection = cms.InputTag('particleFlowPtrs') process.pfJetTracksAssociatorAtVertex.jets= cms.InputTag('ak5PFJets') process.p *= (process.goodOfflinePrimaryVertices * process.pfPileUp * process.pfNoPileUp)# process.makePFBRECO * process.makeKappaPFCandidates) ## ------------------------------------------------------------------------ # Configure Muons process.load('Kappa.Skimming.KMuons_cff') process.kappaTuple.active += cms.vstring('Muons') ## produce/save KappaMuons #process.kappaTuple.Muons.minPt = cms.double(8.0) process.goodMuons = cms.EDFilter('CandViewSelector', src = cms.InputTag('muons'), cut = cms.string("pt > 15.0 & abs(eta) < 8.0"),# & isGlobalMuon()"), ) process.twoGoodMuons = cms.EDFilter('CandViewCountFilter', src = cms.InputTag('goodMuons'), minNumber = cms.uint32(2), ) process.p *= (#process.goodMuons * process.twoGoodMuons * process.makeKappaMuons) ## for muon iso # https://github.com/ajgilbert/ICHiggsTauTau/blob/master/test/higgstautau_new_cfg.py#L430-L460 process.load('CommonTools.ParticleFlow.Isolation.pfMuonIsolation_cff') process.muPFIsoValueCharged04PFIso = process.muPFIsoValueCharged04.clone() process.muPFIsoValueChargedAll04PFIso = process.muPFIsoValueChargedAll04.clone() process.muPFIsoValueGamma04PFIso = process.muPFIsoValueGamma04.clone() process.muPFIsoValueNeutral04PFIso = process.muPFIsoValueNeutral04.clone() process.muPFIsoValuePU04PFIso = process.muPFIsoValuePU04.clone() process.muonPFIsolationValuesSequence = cms.Sequence( process.muPFIsoValueCharged04PFIso+ process.muPFIsoValueChargedAll04PFIso+ process.muPFIsoValueGamma04PFIso+ process.muPFIsoValueNeutral04PFIso+ process.muPFIsoValuePU04PFIso ) process.muPFIsoDepositCharged.src = cms.InputTag('muons') process.muPFIsoDepositChargedAll.src = cms.InputTag('muons') process.muPFIsoDepositNeutral.src = cms.InputTag('muons') process.muPFIsoDepositGamma.src = cms.InputTag('muons') process.muPFIsoDepositPU.src = cms.InputTag('muons') ## ------------------------------------------------------------------------ ## KappaJets process.load('Kappa.Skimming.KJets_cff') process.kappaTuple.active += cms.vstring('Jets', 'PileupDensity') process.kappaTuple.Jets = cms.PSet( process.kappaNoCut, process.kappaNoRegEx, taggers = cms.vstring( # 'QGlikelihood', # 'QGmlp', 'TrackCountingHighEffBJetTags', 'TrackCountingHighPurBJetTags', 'JetProbabilityBJetTags', 'JetBProbabilityBJetTags', 'SoftElectronBJetTags', 'SoftMuonBJetTags', 'SoftMuonByIP3dBJetTags', 'SoftMuonByPtBJetTags', 'SimpleSecondaryVertexBJetTags', 'CombinedSecondaryVertexBJetTags', 'CombinedSecondaryVertexMVABJetTags', 'puJetIDFullDiscriminant', 'puJetIDFullLoose', 'puJetIDFullMedium', 'puJetIDFullTight', #'puJetIDCutbasedDiscriminant', #'puJetIDCutbasedLoose', #'puJetIDCutbasedMedium', #'puJetIDCutbasedTight' ), AK5PFTaggedJets = cms.PSet( src = cms.InputTag('ak5PFJets'), #QGtagger = cms.InputTag('AK5PFJetsQGTagger'), QGtagger = cms.InputTag(''), Btagger = cms.InputTag('ak5PF'), PUJetID = cms.InputTag('ak5PFPuJetMva'), PUJetID_full = cms.InputTag('full'), ), AK5PFTaggedJetsCHS = cms.PSet( src = cms.InputTag('ak5PFJetsCHS'), #QGtagger = cms.InputTag('AK5PFJetsCHSQGTagger'), QGtagger = cms.InputTag(''), Btagger = cms.InputTag('ak5PFCHS'), PUJetID = cms.InputTag('ak5PFCHSPuJetMva'), PUJetID_full = cms.InputTag('full'), ), ) #process.kappaTuple.Jets.minPt = cms.double(5.0) if not data: process.kappaTuple.active += cms.vstring('GenJets') process.kappaTuple.GenJets.whitelist = cms.vstring('ak5GenJets') process.kappaTuple.GenJets.rename = cms.vstring('ak => AK') # add kt6PFJets, needed for the PileupDensity from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJets = kt4PFJets.clone( rParam = 0.6, doRhoFastjet = True ) process.kt6PFJets.Rho_EtaMax = cms.double(2.5) process.p *= ( process.makePFJets * process.makePFJetsCHS * process.kt6PFJets * # process.makeQGTagging * process.makeBTagging * process.makePUJetID ) ## ------------------------------------------------------------------------ ## MET # MET correction ---------------------------------------------------------- process.load('JetMETCorrections.Type1MET.pfMETCorrectionType0_cfi') process.p *= ( process.type0PFMEtCorrection ) #TODO check type 0 corrections process.kappaTuple.active += cms.vstring('MET') ## produce/save KappaPFMET process.kappaTuple.MET.whitelist = cms.vstring('pfChMet', '_pfMet_') #process.kappaTuple.MET.rename = cms.vstring('pfChMet => PFMETCHS', 'pfMet => PFMET') # MET correction ---------------------------------------------------------- process.load("JetMETCorrections.Type1MET.pfMETCorrections_cff") process.pfchsMETcorr.src = cms.InputTag('goodOfflinePrimaryVertices') # Type-0 process.pfMETCHS = process.pfType1CorrectedMet.clone( applyType1Corrections = cms.bool(False), applyType0Corrections = cms.bool(True) ) # MET Path process.p *= ( process.producePFMETCorrections * process.pfMETCHS ) process.kappaTuple.MET.whitelist += cms.vstring("pfMETCHS") ## ------------------------------------------------------------------------ ## And let it run process.p *= ( process.kappaOut ) print process.p return process
process.vertexSelectionSequence = cms.Sequence( process.goodVertices + process.primaryVertex ) ########################### ### PU Rho calculations ### ########################### from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets #Calculate rho restricted to barrel for photon pileup subtraction process.kt6PFJetsRhoBarrelOnly = kt4PFJets.clone( src = cms.InputTag('particleFlow'), rParam = cms.double(0.6), #Eta range of jets to be considered for Rho calculation #Should be at most (jet acceptance - jet radius) doRhoFastjet = cms.bool(True), Rho_EtaMax=cms.double(1.4442), #Eta range of ghost jets to be considered for Rho calculation - must be greater than Rho_EtaMax Ghost_EtaMax=cms.double(2.5) ) #Calculate rho restricted to barrel for photon pileup subtraction process.kt6PFJetsRho25 = kt4PFJets.clone( src = cms.InputTag('particleFlow'), rParam = cms.double(0.6), #Eta range of jets to be considered for Rho calculation #Should be at most (jet acceptance - jet radius) doRhoFastjet = cms.bool(True), Rho_EtaMax=cms.double(2.5) )
def initTP_Electrons(process, mcInfo=False, hltName="HLT", is7X=True): ################################################################################################################################ # ___ ____ ____ ____ _ _ ___ ___ ____ ____ ___ ____ # | |__| | __ |__| |\ | | \ |__] |__/ | | |__] |___ # | | | |__] | | | \| |__/ | | \ |__| |__] |___ ################################################################################################################################ process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi") ################################################################################################################################ # ____ _ _ ___ ____ # | | | | [__ # |___ |__| | ___] SC_COLL_EB = "correctedHybridSuperClusters" SC_COLL_EE = "correctedMulti5x5SuperClustersWithPreshower" ELE_COLL = "gedGsfElectrons" if is7X else "gsfElectrons" JET_COLL = "cleanPatJets" if is7X else "cleanPatJetsAK5PF" TAG_CUTS = "p4().Pt() > 10 && abs(eta) < 2.5 && electronID('simpleEleId80relIso') == 7" SC_PROBE_CUTS = "et>5 && abs(eta)<2.5" GSF_PROBE_CUTS = "(ecalEnergy*sin(superClusterPosition.theta))>5 && abs(superCluster.eta) <= 2.5 && ecalDrivenSeed==1" PAT_PROBE_CUTS = ("(isEB||isEE) && (abs(eta())<= 2.5) " "&& (gsfTrack.trackerExpectedHitsInner.numberOfHits <= 1)" "&& ( (isEB" " && (sigmaIetaIeta<0.01)" " && ( abs(deltaPhiSuperClusterTrackAtVtx)<0.06 )" " && ( abs(deltaEtaSuperClusterTrackAtVtx)<0.004 )" " && (hadronicOverEm<0.12)" " )" " || (isEE" " && (sigmaIetaIeta<0.03)" " && ( abs(deltaPhiSuperClusterTrackAtVtx)<0.03 )" " && ( abs(deltaEtaSuperClusterTrackAtVtx)<0.007 )" " && (hadronicOverEm<0.1) " " )" " )" "&& passConversionVeto") JET_CUTS = ("pt() >= 40.0 && abs(eta()) <= 2.4 " " && neutralHadronEnergyFraction() < 0.99 " " && neutralEmEnergyFraction() < 0.99 " " && chargedEmEnergyFraction() < 0.99 " " && chargedHadronEnergyFraction() > 0 " " && chargedMultiplicity() > 0 " " && (chargedMultiplicity() + neutralMultiplicity() + muonMultiplicity()) > 1") # 2012 SingleElectron Triggers PASS_ANY = '!triggerObjectMatchesByType("TriggerElectron").empty() && (' PASS_ANY += '!triggerObjectMatchesByPath("HLT_Ele22_CaloIdL_CaloIsoVL_v*" ,1,0).empty() || ' PASS_ANY += '!triggerObjectMatchesByPath("HLT_Ele27_CaloIdL_CaloIsoVL_v*" ,1,0).empty() || ' PASS_ANY += '!triggerObjectMatchesByPath("HLT_Ele27_WP80_v*" ,1,0).empty() || ' PASS_ANY += '!triggerObjectMatchesByPath("HLT_Ele30_CaloIdVT_TrkIdT_v*" ,1,0).empty() || ' PASS_ANY += '!triggerObjectMatchesByPath("HLT_Ele32_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_v*",1,0).empty() || ' PASS_ANY += '!triggerObjectMatchesByPath("HLT_Ele80_CaloIdVT_GsfTrkIdT_v*" ,0,1).empty() || ' PASS_ANY += '!triggerObjectMatchesByPath("HLT_Ele90_CaloIdVT_GsfTrkIdT_v*" ,0,1).empty() || ' # 2012 EleHad Triggers PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v*" ,0,1).empty() || ' PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v*" ,0,1).empty() || ' PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v*" ,0,1).empty() || ' PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v*" ,0,1).empty() || ' PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v*" ,0,1).empty() || ' PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v*" ,0,1).empty() || ' PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v*",0,1).empty() || ' PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v*",0,1).empty() || ' PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFHT300_Ele40_CaloIdVT_TrkIdT_v*" ,1,0).empty() || ' PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFHT300_Ele60_CaloIdVT_TrkIdT_v*" ,1,0).empty() || ' PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT300_Ele40_CaloIdVT_TrkIdT_v*" ,1,0).empty() || ' PASS_ANY += '!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT300_Ele60_CaloIdVT_TrkIdT_v*" ,1,0).empty() ' PASS_ANY += ')' AllTriggerFlags = cms.PSet( ############################################################ # DO NOT USE LONG VARIABLE NAMES - THERE'S A BUG ! ! ! # ############################################################ # 2012 SingleElectron Triggers passing_HLT_Ele22 = cms.string('!triggerObjectMatchesByPath("HLT_Ele22_CaloIdL_CaloIsoVL_v*" ,1,0).empty()'), passing_HLT_Ele27 = cms.string('!triggerObjectMatchesByPath("HLT_Ele27_CaloIdL_CaloIsoVL_v*" ,1,0).empty()'), passing_HLT_Ele27_WP80 = cms.string('!triggerObjectMatchesByPath("HLT_Ele27_WP80_v*" ,1,0).empty()'), passing_HLT_Ele30 = cms.string('!triggerObjectMatchesByPath("HLT_Ele30_CaloIdVT_TrkIdT_v*" ,1,0).empty()'), passing_HLT_Ele32 = cms.string('!triggerObjectMatchesByPath("HLT_Ele32_CaloIdL_CaloIsoVL_TrkIdVL_TrkIsoVL_v*" ,1,0).empty()'), passing_HLT_Ele80 = cms.string('!triggerObjectMatchesByPath("HLT_Ele80_CaloIdVT_GsfTrkIdT_v*" ,0,1).empty()'), passing_HLT_Ele90 = cms.string('!triggerObjectMatchesByPath("HLT_Ele90_CaloIdVT_GsfTrkIdT_v*" ,0,1).empty()'), # 2012 EleHad Triggers passing_HLT_CleanPFHT350_Ele5_PFMET45 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v*" ,0,1).empty()'), passing_HLT_CleanPFHT350_Ele5_PFMET50 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v*" ,0,1).empty()'), passing_HLT_CleanPFNoPUHT350_Ele5_PFMET45 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v*" ,0,1).empty()'), passing_HLT_CleanPFNoPUHT350_Ele5_PFMET50 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v*" ,0,1).empty()'), passing_HLT_CleanPFHT300_Ele15_PFMET45 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v*" ,0,1).empty()'), passing_HLT_CleanPFHT300_Ele15_PFMET50 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v*" ,0,1).empty()'), passing_HLT_CleanPFNoPUHT300_Ele15_PFMET45 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v*",0,1).empty()'), passing_HLT_CleanPFNoPUHT300_Ele15_PFMET50 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v*",0,1).empty()'), passing_HLT_CleanPFHT300_Ele40 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFHT300_Ele40_CaloIdVT_TrkIdT_v*" ,0,1).empty()'), passing_HLT_CleanPFHT300_Ele60 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFHT300_Ele60_CaloIdVT_TrkIdT_v*" ,0,1).empty()'), passing_HLT_CleanPFNoPUHT300_Ele40 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT300_Ele40_CaloIdVT_TrkIdT_v*" ,0,1).empty()'), passing_HLT_CleanPFNoPUHT300_Ele60 = cms.string('!triggerObjectMatchesByPath("HLT_CleanPFNoPUHT300_Ele60_CaloIdVT_TrkIdT_v*" ,0,1).empty()'), ) ################################################################################################################################ # ___ ____ ____ ____ # | |__| | __ [__ # | | | |__] ___] process.tagPATElectrons = cms.EDFilter("PATElectronRefSelector", src = cms.InputTag("cleanPatElectronsTriggerMatch"), cut = cms.string( TAG_CUTS + " && " + PASS_ANY ) ) ################################################################################################################################ # ___ ____ ____ ___ ____ ____ # |__] |__/ | | |__] |___ [__ # | | \ |__| |__] |___ ___] ## ____ ____ _ _ ## / ___| _ _ _ __ ___ _ __ / ___| |_ _ ___| |_ ___ _ __ ## \___ \| | | | '_ \ / _ \ '__| | | | | | / __| __/ _ \ '__| ## ___) | |_| | |_) | __/ | | |___| | |_| \__ \ || __/ | ## |____/ \__,_| .__/ \___|_| \____|_|\__,_|___/\__\___|_| ## # probe1: superclusters # SuperClusters ################ process.superClusters = cms.EDProducer("SuperClusterMerger", src = cms.VInputTag(cms.InputTag( SC_COLL_EB ), cms.InputTag( SC_COLL_EE) ) ) process.superClusterCands = cms.EDProducer("ConcreteEcalCandidateProducer", src = cms.InputTag("superClusters"), particleType = cms.int32(11), ) # Get the above SC's Candidates and place a cut on their Et and eta process.goodSuperClusters = cms.EDFilter("CandViewSelector", src = cms.InputTag("superClusterCands"), cut = cms.string( SC_PROBE_CUTS ), filter = cms.bool(True) ) #### remove real jets (with high hadronic energy fraction) from SC collection ##### this improves the purity of the probe sample without affecting efficiency process.JetsToRemoveFromSuperCluster = cms.EDFilter("CaloJetSelector", src = cms.InputTag("ak5CaloJets"), cut = cms.string('pt>5 && energyFractionHadronic > 0.15') ) process.goodSuperClustersClean = cms.EDProducer("CandViewCleaner", srcObject = cms.InputTag("goodSuperClusters"), module_label = cms.string(''), srcObjectsToRemove = cms.VInputTag(cms.InputTag("JetsToRemoveFromSuperCluster")), deltaRMin = cms.double(0.1) ) ## ____ __ _____ _ _ ## / ___|___ / _| ____| | ___ ___| |_ _ __ ___ _ __ ## | | _/ __| |_| _| | |/ _ \/ __| __| '__/ _ \| '_ \ ## | |_| \__ \ _| |___| | __/ (__| |_| | | (_) | | | | ## \____|___/_| |_____|_|\___|\___|\__|_| \___/|_| |_| ## # probe2: GsfElectrons # GsfElectron ################ process.goodElectrons = cms.EDFilter("GsfElectronRefSelector", src = cms.InputTag(ELE_COLL), cut = cms.string( GSF_PROBE_CUTS ) ) # probe3: Pat Electrons process.goodPATElectrons = cms.EDFilter("PATElectronRefSelector", src = cms.InputTag("cleanPatElectronsTriggerMatch"), cut = cms.string( PAT_PROBE_CUTS ), ) process.allEleTagsAndProbes = cms.Sequence( process.tagPATElectrons + (process.superClusters * process.superClusterCands * (process.goodSuperClusters + process.JetsToRemoveFromSuperCluster) * process.goodSuperClustersClean) + process.goodElectrons + process.goodPATElectrons ) ################################################################################################################################ # ___ ____ ____ _ _ ___ ____ ____ ___ ____ ___ ____ _ ____ ____ # | |__| | __ |\ | |__] |__/ | | |__] |___ |__] |__| | |__/ [__ # | | | |__] | \| | | \ |__| |__] |___ | | | | | \ ___] # ## _____ ___ ____ ____ _ ## |_ _( _ ) | _ \ | _ \ __ _(_)_ __ ___ ## | | / _ \/\ |_) | | |_) / _` | | '__/ __| ## | || (_> < __/ | __/ (_| | | | \__ \ ## |_| \___/\/_| |_| \__,_|_|_| |___/ ## ## # Tag & probe selection ###### process.tagPATSC = cms.EDProducer("CandViewShallowCloneCombiner", decay = cms.string("tagPATElectrons@+ goodSuperClustersClean@-"), checkCharge = cms.bool(False), cut = cms.string("40 < mass < 140"), ) process.tagPATGsf = process.tagPATSC.clone() process.tagPATGsf.decay = cms.string("tagPATElectrons@+ goodElectrons@-") process.tagPATGoodPATElectron = process.tagPATSC.clone() process.tagPATGoodPATElectron.decay = cms.string("tagPATElectrons@+ goodPATElectrons@-") process.allEleTPPairs = cms.Sequence( process.tagPATSC + process.tagPATGsf + process.tagPATGoodPATElectron ) ################################################################################################################################ # _ _ ____ ___ ____ _ _ ____ _ _ ___ ___ ____ ____ ____ # |\/| |__| | | |__| |__| |\ | | \ |__] |__| [__ [__ # | | | | | |___ | | | | | \| |__/ | | | ___] ___] ## ____ ____ __ ____ __ ## / ___| / ___| \ \ / ___|___ / _| ## \___ \| | _____\ \ | | _/ __| |_ ## ___) | |___ |_____/ / | |_| \__ \ _| ## |____/ \____| /_/ \____|___/_| ## # passing1: Superclusters passing as Gsf Electrons process.GsfMatchedSuperClusterCands = cms.EDProducer("ElectronMatchedCandidateProducer", src = cms.InputTag("goodSuperClustersClean"), ReferenceElectronCollection = cms.untracked.InputTag("goodElectrons"), deltaR = cms.untracked.double(0.3) ) ## ____ __ __ ___ ___ _ ## / ___|___ / _| \ \ |_ _|___ ___ |_ _|__| | ## | | _/ __| |_ _____\ \ | |/ __|/ _ \ | |/ _` | ## | |_| \__ \ _| |_____/ / | |\__ \ (_) | _ | | (_| | ## \____|___/_| /_/ |___|___/\___/ ( ) |___\__,_| ## |/ # passing2: Gsf electrons passing isolation, ID cuts (Pat electrons) if is7X: process.GSFtoPATMatchedElectrons = cms.EDProducer("PatMatchedGsfElectronProducer", srcObject = cms.InputTag("goodElectrons"), srcObjectsToMatch = cms.VInputTag(cms.InputTag("goodPATElectrons")), deltaRMax = cms.double(0.1), # Because Pat Electrons are Gsf Electrons ) # 0.01 process.GSFPassingGoodPat = cms.EDProducer("ElectronMatchedCandidateProducer", src = cms.InputTag("goodElectrons"), ReferenceElectronCollection = cms.untracked.InputTag("GSFtoPATMatchedElectrons"), deltaR = cms.untracked.double(0.3) ) process.GSFtoPATMatchedSuperClusterCandsClean = cms.EDProducer("ElectronMatchedCandidateProducer", src = cms.InputTag("goodSuperClustersClean"), ReferenceElectronCollection = cms.untracked.InputTag("GSFtoPATMatchedElectrons"), deltaR = cms.untracked.double(0.3) ) process.allElePassingProbes = cms.Sequence( process.GsfMatchedSuperClusterCands + process.GSFtoPATMatchedElectrons * ( process.GSFtoPATMatchedSuperClusterCandsClean + process.GSFPassingGoodPat ) ) else: process.GSFPassingGoodPat = cms.EDProducer("MatchGsfElectronsToPAT", electrons = cms.InputTag("goodElectrons"), pat = cms.InputTag("goodPATElectrons"), patCut = cms.string("pt>0"), matchByReference = cms.bool(False) ) process.GSFtoPATMatchedSuperClusterCandsClean = cms.EDProducer("ElectronMatchedCandidateProducer", src = cms.InputTag("goodSuperClustersClean"), ReferenceElectronCollection = cms.untracked.InputTag("GSFPassingGoodPat"), deltaR = cms.untracked.double(0.3) ) process.allElePassingProbes = cms.Sequence( process.GsfMatchedSuperClusterCands + process.GSFPassingGoodPat * process.GSFtoPATMatchedSuperClusterCandsClean ) ## ___ _ __ _ _ _ _____ ## |_ _|__| | \ \ | | | | | |_ _| ## | |/ _` | _____\ \ | |_| | | | | ## | | (_| | |_____/ / | _ | |___| | ## |___\__,_| /_/ |_| |_|_____|_| ## # passing 3: ID electrons passing HLT paths # corresponding matches and passes can be found in the top CUTS sections # Additional variable to check if event passed the specific cross trigger process.patEventPassingHLTCleanPFHT350Ele5PFMET45 = cms.EDProducer("HLTResultProducer", probes = cms.InputTag("cleanPatElectronsTriggerMatch"), TriggerResultsTag = cms.InputTag("TriggerResults","",hltName), HLTPaths = cms.vstring("HLT_CleanPFHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v.*"), andOr = cms.bool(True) ) process.patEventPassingHLTCleanPFHT350Ele5PFMET50 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v.*")) process.patEventPassingHLTCleanPFHT300Ele15PFMET45 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v.*")) process.patEventPassingHLTCleanPFHT300Ele15PFMET50 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v.*")) process.patEventPassingHLTCleanPFHT300Ele40 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFHT300_Ele40_CaloIdVT_TrkIdT_v.*")) process.patEventPassingHLTCleanPFHT300Ele60 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFHT300_Ele60_CaloIdVT_TrkIdT_v.*")) process.patEventPassingHLTCleanPFNoPUHT350Ele5PFMET45 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFNoPUHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v.*")) process.patEventPassingHLTCleanPFNoPUHT350Ele5PFMET50 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFNoPUHT350_Ele5_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v.*")) process.patEventPassingHLTCleanPFNoPUHT300Ele15PFMET45 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFNoPUHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET45_v.*")) process.patEventPassingHLTCleanPFNoPUHT300Ele15PFMET50 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFNoPUHT300_Ele15_CaloIdT_CaloIsoVL_TrkIdT_TrkIsoVL_PFMET50_v.*")) process.patEventPassingHLTCleanPFNoPUHT300Ele40 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFNoPUHT300_Ele40_CaloIdVT_TrkIdT_v.*")) process.patEventPassingHLTCleanPFNoPUHT300Ele60 = process.patEventPassingHLTCleanPFHT350Ele5PFMET45.clone(HLTPaths = cms.vstring("HLT_CleanPFNoPUHT300_Ele60_CaloIdVT_TrkIdT_v.*")) process.allEleHLTResults = cms.Sequence( process.patEventPassingHLTCleanPFHT350Ele5PFMET45 + process.patEventPassingHLTCleanPFHT350Ele5PFMET50 + process.patEventPassingHLTCleanPFHT300Ele15PFMET45 + process.patEventPassingHLTCleanPFHT300Ele15PFMET50 + process.patEventPassingHLTCleanPFHT300Ele40 + process.patEventPassingHLTCleanPFHT300Ele60 + process.patEventPassingHLTCleanPFNoPUHT350Ele5PFMET45 + process.patEventPassingHLTCleanPFNoPUHT350Ele5PFMET50 + process.patEventPassingHLTCleanPFNoPUHT300Ele15PFMET45 + process.patEventPassingHLTCleanPFNoPUHT300Ele15PFMET50 + process.patEventPassingHLTCleanPFNoPUHT300Ele40 + process.patEventPassingHLTCleanPFNoPUHT300Ele60 ) ## __ __ ____ __ __ _ _ ## | \/ |/ ___| | \/ | __ _| |_ ___| |__ ___ ___ ## | |\/| | | | |\/| |/ _` | __/ __| '_ \ / _ \/ __| ## | | | | |___ | | | | (_| | || (__| | | | __/\__ \ ## |_| |_|\____| |_| |_|\__,_|\__\___|_| |_|\___||___/ ## process.McMatchSC = cms.EDProducer("MCTruthDeltaRMatcherNew", matchPDGId = cms.vint32(11), src = cms.InputTag("goodSuperClustersClean"), distMin = cms.double(0.3), matched = cms.InputTag("genParticles") ) process.McMatchGsf = process.McMatchSC.clone() process.McMatchGsf.src = cms.InputTag("goodElectrons") process.McMatchGSF = process.McMatchSC.clone() process.McMatchGSF.src = cms.InputTag(ELE_COLL) process.McMatchPATElectron = process.McMatchSC.clone() process.McMatchPATElectron.src = cms.InputTag("goodPATElectrons") process.McMatchTagPATElectron = process.McMatchSC.clone() process.McMatchTagPATElectron.src = cms.InputTag("tagPATElectrons") process.allEleMcMatches = cms.Sequence( process.McMatchSC + process.McMatchGSF + process.McMatchGsf + process.McMatchPATElectron + process.McMatchTagPATElectron ) ################################################################################################################################ ## _____ _ _ __ __ ## | ____|_ _| |_ ___ _ __ _ __ __ _| | \ \ / /_ _ _ __ ___ ## | _| \ \/ / __/ _ \ '__| '_ \ / _` | | \ \ / / _` | '__/ __| ## | |___ > <| || __/ | | | | | (_| | | \ V / (_| | | \__ \ ## |_____/_/\_\\__\___|_| |_| |_|\__,_|_| \_/ \__,_|_| |___/ ## ################################################################################################################################ # Vertices process.scNvertices = cms.EDProducer("VertexMultiplicityCounter", probes = cms.InputTag("goodSuperClusters"), objects = cms.InputTag("offlinePrimaryVertices"), objectSelection = cms.string("!isFake && ndof > 4 && abs(z) <= 24 && position.Rho <= 2"), ) process.gsfNvertices = process.scNvertices.clone(probes = ELE_COLL) process.patNvertices = process.scNvertices.clone(probes = "cleanPatElectronsTriggerMatch") process.allEleVertices = cms.Sequence( process.scNvertices + process.gsfNvertices + process.patNvertices ) ################################################################################################################################ # PU Reweighting process.scPileup = cms.EDProducer("PileupWeightComputer", probes = cms.InputTag("goodSuperClusters"), isMC = cms.bool(mcInfo), dataPileupFile = cms.string("PileupHistogram_2012Data_FlatPU_50bins.root"), mcPileupFile = cms.string("PileupHistogram_2012Data_FlatPU_50bins.root"), dataPileupHistoName = cms.string("pileup"), mcPileupHistoName = cms.string("mcpileup"), mcLumiScale = cms.double(221.95), dataPileupInputFile = cms.string("run_ls_instlumi_pileup_2012.txt"), ) process.gsfPileup = process.scPileup.clone(probes = cms.InputTag(ELE_COLL)) process.patPileup = process.scPileup.clone(probes = cms.InputTag("cleanPatElectronsTriggerMatch")) process.allElePileup = cms.Sequence( process.scPileup + process.gsfPileup + process.patPileup ) ################################################################################################################################ # _ _ _ ___ ____ ____ ___ ___ ____ ____ ____ _ _ ____ ___ ____ ____ # | |\/| |__] |__| | | |__] |__| |__/ |__| |\/| |___ | |___ |__/ # | | | | | | |___ | | | | | \ | | | | |___ | |___ | \ process.gsfImpactParameter = cms.EDProducer("GsfElectronImpactParameter", probes = cms.InputTag(ELE_COLL), ) process.patImpactParameter = cms.EDProducer("PatElectronImpactParameter", probes = cms.InputTag("cleanPatElectronsTriggerMatch"), ) process.allEleImpactParameters = cms.Sequence( process.gsfImpactParameter + process.patImpactParameter ) ################################################################################################################################ # _ ____ ___ ____ # | |___ | [__ # _| |___ | ___] process.selectedJets = cms.EDFilter("PATJetSelector", src = cms.InputTag( JET_COLL ), cut = cms.string( JET_CUTS ), # <= anpassen ) # DeltaR process.scDRToNearestJet = cms.EDProducer("minCutDeltaRNearestPatJetComputer", probes = cms.InputTag("goodSuperClusters"), objects = cms.InputTag("selectedJets"), minDeltaR = cms.double(0.3), objectSelection = cms.InputTag(""), ) process.gsfDRToNearestJet = process.scDRToNearestJet.clone(probes = cms.InputTag(ELE_COLL)) process.patDRToNearestJet = process.scDRToNearestJet.clone(probes = cms.InputTag("cleanPatElectronsTriggerMatch")) # Njet process.scJetMultiplicity = cms.EDProducer("PatJetMultiplicityCounter", probes = cms.InputTag("goodSuperClusters"), objects = cms.InputTag("selectedJets"), minDeltaR = cms.double(0.3), objectSelection = cms.InputTag(""), ) process.gsfJetMultiplicity = process.scJetMultiplicity.clone(probes = cms.InputTag(ELE_COLL)) process.patJetMultiplicity = process.scJetMultiplicity.clone(probes = cms.InputTag("cleanPatElectronsTriggerMatch")) # HT process.scHT = cms.EDProducer("PatJetHTComputer", probes = cms.InputTag("goodSuperClusters"), objects = cms.InputTag("selectedJets"), objectSelection = cms.InputTag(""), ) process.gsfHT = process.scHT.clone(probes = cms.InputTag(ELE_COLL)) process.patHT = process.scHT.clone(probes = cms.InputTag("cleanPatElectronsTriggerMatch")) # MET process.scMet = cms.EDProducer("PatMetAssociator", probes = cms.InputTag("goodSuperClusters"), metTag = cms.InputTag("patMETsPF"), ) process.gsfMet = process.scMet.clone(probes = cms.InputTag(ELE_COLL)) process.patMet = process.scMet.clone(probes = cms.InputTag("cleanPatElectronsTriggerMatch")) # ST process.gsfST = cms.EDProducer("PatMetSTComputer", probes = cms.InputTag(ELE_COLL), metTag = cms.InputTag("patMETsPF"), ) process.patST = process.gsfST.clone(probes = cms.InputTag("cleanPatElectronsTriggerMatch")) process.allEleJets = cms.Sequence( process.selectedJets* (process.scDRToNearestJet + process.gsfDRToNearestJet + process.patDRToNearestJet + process.scJetMultiplicity + process.gsfJetMultiplicity + process.patJetMultiplicity + process.scHT + process.gsfHT + process.patHT) ) process.allEleMet = cms.Sequence( process.scMet + process.gsfMet + process.patMet ) process.allEleST = cms.Sequence( process.gsfST + process.patST ) ################################################################################################################################ # _ ____ ____ _ ____ ___ _ ____ _ _ ____ # | [__ | | | |__| | | | | |\ | [__ # | ___] |__| |___ | | | | |__| | \| ___] #compute rho for 2011 effective area Egamma isolation corrections from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJetsForIsolation = kt4PFJets.clone( rParam = 0.6, doRhoFastjet = True ) process.kt6PFJetsForIsolation.Rho_EtaMax = cms.double(2.5) # Rho Corrected Relative Isolation process.gsfRelIso = cms.EDProducer("GsfElectronRelIsoProducer", isMC = cms.bool(mcInfo), ElectronProbes = cms.InputTag(ELE_COLL), rhoIsoInputTag = cms.InputTag("kt6PFJetsForIsolation", "rho"), isoValInputTags = cms.VInputTag( cms.InputTag('elPFIsoValueCharged03PFIdPFIso'), cms.InputTag('elPFIsoValueGamma03PFIdPFIso'), cms.InputTag('elPFIsoValueNeutral03PFIdPFIso') ), ) process.patRelIso = cms.EDProducer("PatElectronRelIsoProducer", isMC = cms.bool(mcInfo), ElectronProbes = cms.InputTag("cleanPatElectronsTriggerMatch"), rhoIsoInputTag = cms.InputTag("kt6PFJetsForIsolation", "rho"), isoValInputTags = cms.VInputTag( cms.InputTag('elPFIsoValueCharged03PFIdPFIso'), cms.InputTag('elPFIsoValueGamma03PFIdPFIso'), cms.InputTag('elPFIsoValueNeutral03PFIdPFIso') ), ) if is7X: process.gsfRelIso.isoValInputTags = cms.VInputTag( cms.InputTag('elPFIsoValueCharged03PFId'), cms.InputTag('elPFIsoValueGamma03PFId'), cms.InputTag('elPFIsoValueNeutral03PFId') ) process.patRelIso.isoValInputTags = cms.VInputTag( cms.InputTag('elPFIsoValueCharged03PFId'), cms.InputTag('elPFIsoValueGamma03PFId'), cms.InputTag('elPFIsoValueNeutral03PFId') ) process.allEleRelIso = cms.Sequence( process.kt6PFJetsForIsolation * ( process.gsfRelIso + process.patRelIso ) ) ################################################################################################################################ # Delta Reco-PF Electron Pt process.gsfDeltaPfRecoPt = cms.EDProducer("GsfElectronDeltaPfRecoPt", probes = cms.InputTag(ELE_COLL), ) process.patDeltaPfRecoPt = cms.EDProducer("ElectronDeltaPfRecoPt", probes = cms.InputTag("cleanPatElectronsTriggerMatch"), ) process.allEleDeltaPfRecoPt = cms.Sequence( process.gsfDeltaPfRecoPt + process.patDeltaPfRecoPt ) ################################################################################################################################ # Conversion Rejection #process.gsfConvRejVars = cms.EDProducer("ElectronConversionRejectionVars", # probes = cms.InputTag(ELE_COLL) #) ################################################################################################################################ # ___ ____ ____ ____ _ _ ____ ___ ____ ____ ____ # |__] |__| |__/ |__| |\/| |___ | |___ |__/ [__ # | | | | \ | | | | |___ | |___ | \ ___] if mcInfo: mcTruthCommonStuff = cms.PSet( isMC = cms.bool(True), addRunLumiInfo = cms.bool(False), makeMCUnbiasTree = cms.bool(False), checkMotherInUnbiasEff = cms.bool(True), motherPdgId = cms.vint32(22,23), # Gamma or Z tagMatches = cms.InputTag("McMatchTagPATElectron"), #mcVariables = cms.PSet( # mass = cms.string("mass"), # mt = cms.string("mt"), # pt = cms.string("pt"), # et = cms.string("et"), # phi = cms.string("phi"), # eta = cms.string("eta"), # e = cms.string("energy"), # p = cms.string("p"), # px = cms.string("px"), # py = cms.string("py"), # pz = cms.string("pz"), # theta = cms.string("theta"), # vx = cms.string("vx"), # vy = cms.string("vy"), # vz = cms.string("vz"), # charge = cms.string("charge"), # rapidity = cms.string("rapidity"), #), #mcFlags = cms.PSet( # flag = cms.string("pt>0") #), ) else: mcTruthCommonStuff = cms.PSet( isMC = cms.bool(False), addRunLumiInfo = cms.bool(True), ) commonStuff = cms.PSet( mcTruthCommonStuff, addEventVariablesInfo = cms.bool(False), ignoreExceptions = cms.bool(False), arbitration = cms.string("Random2"), #pairFlags = cms.PSet( # mass60to120 = cms.string("60 < mass < 120") #), #pairVariables = cms.PSet( # #mass = cms.string("mass"), # created automatically # mt = cms.string("mt"), # pt = cms.string("pt"), # et = cms.string("et"), # phi = cms.string("phi"), # eta = cms.string("eta"), # abs_eta = cms.string("abs(eta)"), # #e = cms.string("energy"), # #p = cms.string("p"), # #px = cms.string("px"), # #py = cms.string("py"), # #pz = cms.string("pz"), # #theta = cms.string("theta"), # #vx = cms.string("vx"), # #vy = cms.string("vy"), # #vz = cms.string("vz"), # #rapidity = cms.string("rapidity"), #), ) scParameters = cms.PSet( variables = cms.PSet( pt = cms.string("pt"), et = cms.string("et"), phi = cms.string("phi"), eta = cms.string("eta"), abs_eta = cms.string("abs(eta)"), nvtx = cms.InputTag("scNvertices"), pileup = cms.InputTag("scPileup","pileup"), instlumi = cms.InputTag("scPileup","instlumi"), weight = cms.InputTag("scPileup","weight"), drjet = cms.InputTag("scDRToNearestJet"), njet = cms.InputTag("scJetMultiplicity"), ht = cms.InputTag("scHT"), met = cms.InputTag("scMet"), #e = cms.string("energy"), #p = cms.string("p"), #px = cms.string("px"), #py = cms.string("py"), #pz = cms.string("pz"), #theta = cms.string("theta"), ), tagVariables = cms.PSet(), flags = cms.PSet( # The flags below somehow don't work in 7X passing_gsf = cms.InputTag("GsfMatchedSuperClusterCands"), passing_pat = cms.InputTag("GSFtoPATMatchedSuperClusterCandsClean"), ), tagFlags = cms.PSet(), ) gsfParameters = cms.PSet( variables = cms.PSet( pt = cms.string("pt"), et = cms.string("et"), phi = cms.string("phi"), eta = cms.string("eta"), abs_eta = cms.string("abs(eta)"), sc_et = cms.string("superCluster.energy*sin(superClusterPosition.theta)"), sc_phi = cms.string("superCluster.phi"), sc_eta = cms.string("superCluster.eta"), track_pt = cms.string("gsfTrack.pt"), track_phi = cms.string("gsfTrack.phi"), track_eta = cms.string("gsfTrack.eta"), nvtx = cms.InputTag("gsfNvertices"), pileup = cms.InputTag("gsfPileup","pileup"), instlumi = cms.InputTag("gsfPileup","instlumi"), weight = cms.InputTag("gsfPileup","weight"), d0_v = cms.InputTag("gsfImpactParameter","d0v"), d0_b = cms.InputTag("gsfImpactParameter","d0b"), dz_v = cms.InputTag("gsfImpactParameter","dzv"), dz_b = cms.InputTag("gsfImpactParameter","dzb"), drjet = cms.InputTag("gsfDRToNearestJet"), njet = cms.InputTag("gsfJetMultiplicity"), ht = cms.InputTag("gsfHT"), met = cms.InputTag("gsfMet"), st = cms.InputTag("gsfST"), absdeltapt = cms.InputTag("gsfDeltaPfRecoPt","absdeltapt"), # -9999: under 10 GeV reliso = cms.InputTag("gsfRelIso","reliso"), #passConvRej = cms.InputTag("gsfConvRejVars","passConvRej"), #conv_dist = cms.InputTag("gsfConvRejVars","dist"), #conv_dcot = cms.InputTag("gsfConvRejVars","dcot"), #conv_radius = cms.InputTag("gsfConvRejVars","convradius"), #theta = cms.string("theta"), #rapidity = cms.string("rapidity"), #e = cms.string("energy"), #p = cms.string("p"), #px = cms.string("px"), #py = cms.string("py"), #pz = cms.string("pz"), #charge = cms.string("charge"), #missingHits = cms.string("gsfTrack.trackerExpectedHitsInner.numberOfHits"), #convDist = cms.string("convDist"), #convDcot = cms.string("convDcot"), #convRadius = cms.string("convRadius"), #hasL1BPixHit = cms.string("gsfTrack.hitPattern.hasValidHitInFirstPixelBarrel"), ## super cluster quantities #sc_e = cms.string("superCluster.energy"), #sc_x = cms.string("superCluster.x"), #sc_y = cms.string("superCluster.y"), #sc_z = cms.string("superCluster.z"), #sc_theta = cms.string("superClusterPosition.theta"), #sc_nhit = cms.string("superCluster.size"), ## track quantities #track_p = cms.string("gsfTrack.p"), #track_px = cms.string("gsfTrack.px"), #track_py = cms.string("gsfTrack.py"), #track_pz = cms.string("gsfTrack.pz"), #track_theta = cms.string("gsfTrack.theta"), #track_vx = cms.string("gsfTrack.vx"), #track_vy = cms.string("gsfTrack.vy"), #track_vz = cms.string("gsfTrack.vz"), #track_dxy = cms.string("gsfTrack.dxy"), #track_d0 = cms.string("gsfTrack.d0"), #track_dsz = cms.string("gsfTrack.dsz"), #track_charge = cms.string("gsfTrack.charge"), #track_qoverp = cms.string("gsfTrack.qoverp"), #track_normChi2 = cms.string("gsfTrack.normalizedChi2"), ## isolation #trackiso = cms.string("dr03TkSumPt"), #ecaliso = cms.string("dr03EcalRecHitSumEt"), #hcaliso = cms.string("dr03HcalTowerSumEt"), ## classification, location, etc. #classification = cms.string("classification"), #numberOfBrems = cms.string("numberOfBrems"), #bremFraction = cms.string("fbrem"), #mva = cms.string("mva"), #deltaEta = cms.string("deltaEtaSuperClusterTrackAtVtx"), #deltaPhi = cms.string("deltaPhiSuperClusterTrackAtVtx"), #deltaPhiOut = cms.string("deltaPhiSeedClusterTrackAtCalo"), #deltaEtaOut = cms.string("deltaEtaSeedClusterTrackAtCalo"), #isEB = cms.string("isEB"), #isEE = cms.string("isEE"), #isGap = cms.string("isGap"), ## Hcal energy over Ecal Energy #HoverE = cms.string("hcalOverEcal"), #EoverP = cms.string("eSuperClusterOverP"), #eSeedClusterOverP = cms.string("eSeedClusterOverP"), ## Cluster shape information #sigmaEtaEta = cms.string("sigmaEtaEta"), #sigmaIetaIeta = cms.string("sigmaIetaIeta"), #e1x5 = cms.string("e1x5"), #e2x5Max = cms.string("e2x5Max"), #e5x5 = cms.string("e5x5"), ## is ECAL driven ? is Track driven ? #ecalDrivenSeed = cms.string("ecalDrivenSeed"), #trackerDrivenSeed = cms.string("trackerDrivenSeed"), ), tagVariables = cms.PSet(), flags = cms.PSet( passing_pat = cms.InputTag("GSFPassingGoodPat"), ), tagFlags = cms.PSet(), ) patParameters = cms.PSet( variables = cms.PSet( pt = cms.string("pt"), et = cms.string("et"), phi = cms.string("phi"), eta = cms.string("eta"), abs_eta = cms.string("abs(eta)"), sc_et = cms.string("superCluster.energy*sin(superClusterPosition.theta)"), sc_phi = cms.string("superCluster.phi"), sc_eta = cms.string("superCluster.eta"), track_pt = cms.string("gsfTrack.pt"), track_phi = cms.string("gsfTrack.phi"), track_eta = cms.string("gsfTrack.eta"), nvtx = cms.InputTag("patNvertices"), pileup = cms.InputTag("patPileup","pileup"), instlumi = cms.InputTag("patPileup","instlumi"), weight = cms.InputTag("patPileup","weight"), d0_v = cms.InputTag("patImpactParameter","d0v"), d0_b = cms.InputTag("patImpactParameter","d0b"), dz_v = cms.InputTag("patImpactParameter","dzv"), dz_b = cms.InputTag("patImpactParameter","dzb"), drjet = cms.InputTag("patDRToNearestJet"), njet = cms.InputTag("patJetMultiplicity"), ht = cms.InputTag("patHT"), met = cms.InputTag("patMet"), st = cms.InputTag("patST"), absdeltapt = cms.InputTag("patDeltaPfRecoPt","absdeltapt"), # -9999: under 10 GeV reliso = cms.InputTag("patRelIso","reliso"), #charge = cms.string("charge"), #isEB = cms.string("isEB"), #isEE = cms.string("isEE"), #isGap = cms.string("isGap"), #trackiso = cms.string("dr03TkSumPt"), #ecaliso = cms.string("dr03EcalRecHitSumEt"), #hcaliso = cms.string("dr03HcalTowerSumEt"), event_passing_HLT_CleanPFHT350_Ele5_PFMET45 = cms.InputTag("patEventPassingHLTCleanPFHT350Ele5PFMET45"), event_passing_HLT_CleanPFHT350_Ele5_PFMET50 = cms.InputTag("patEventPassingHLTCleanPFHT350Ele5PFMET50"), event_passing_HLT_CleanPFHT300_Ele15_PFMET45 = cms.InputTag("patEventPassingHLTCleanPFHT300Ele15PFMET45"), event_passing_HLT_CleanPFHT300_Ele15_PFMET50 = cms.InputTag("patEventPassingHLTCleanPFHT300Ele15PFMET50"), event_passing_HLT_CleanPFHT300_Ele40 = cms.InputTag("patEventPassingHLTCleanPFHT300Ele40"), event_passing_HLT_CleanPFHT300_Ele60 = cms.InputTag("patEventPassingHLTCleanPFHT300Ele60"), event_passing_HLT_CleanPFNoPUHT350_Ele5_PFMET45 = cms.InputTag("patEventPassingHLTCleanPFNoPUHT350Ele5PFMET45"), event_passing_HLT_CleanPFNoPUHT350_Ele5_PFMET50 = cms.InputTag("patEventPassingHLTCleanPFNoPUHT350Ele5PFMET50"), event_passing_HLT_CleanPFNoPUHT300_Ele15_PFMET45 = cms.InputTag("patEventPassingHLTCleanPFNoPUHT300Ele15PFMET45"), event_passing_HLT_CleanPFNoPUHT300_Ele15_PFMET50 = cms.InputTag("patEventPassingHLTCleanPFNoPUHT300Ele15PFMET50"), event_passing_HLT_CleanPFNoPUHT300_Ele40 = cms.InputTag("patEventPassingHLTCleanPFNoPUHT300Ele40"), event_passing_HLT_CleanPFNoPUHT300_Ele60 = cms.InputTag("patEventPassingHLTCleanPFNoPUHT300Ele60"), ), tagVariables = cms.PSet(), flags = cms.PSet( AllTriggerFlags ), tagFlags = cms.PSet( AllTriggerFlags ), ) ################################################################################################################################ # ____ _ ___ ___ ____ ____ ____ ___ ____ ____ ___ _ _ ____ ____ ____ # |___ | | | |__/ |___ |___ |__] |__/ | | | \ | | | |___ |__/ # | | | | | \ |___ |___ | | \ |__| |__/ |__| |___ |___ | \ ## ____ ____ __ ____ __ ## / ___| / ___| \ \ / ___|___ / _| ## \___ \| | _____\ \ | | _/ __| |_ ## ___) | |___ |_____/ / | |_| \__ \ _| ## |____/ \____| /_/ \____|___/_| ## process.SuperClusterToGsfElectronPATTag = cms.EDAnalyzer("TagProbeFitTreeProducer", commonStuff, scParameters, tagProbePairs = cms.InputTag("tagPATSC"), allProbes = cms.InputTag("goodSuperClustersClean"), probeMatches = cms.InputTag("McMatchSC"), ) ## ____ __ __ ___ ___ _ ## / ___|___ / _| \ \ |_ _|___ ___ |_ _|__| | ## | | _/ __| |_ _____\ \ | |/ __|/ _ \ | |/ _` | ## | |_| \__ \ _| |_____/ / | |\__ \ (_) | _ | | (_| | ## \____|___/_| /_/ |___|___/\___/ ( ) |___\__,_| ## |/ process.GsfElectronToIdPATTag = cms.EDAnalyzer("TagProbeFitTreeProducer", commonStuff, gsfParameters, tagProbePairs = cms.InputTag("tagPATGsf"), allProbes = cms.InputTag("goodElectrons"), probeMatches = cms.InputTag("McMatchGsf"), ) ## ___ _ __ _ _ _ _____ ## |_ _|__| | \ \ | | | | | |_ _| ## | |/ _` | _____\ \ | |_| | | | | ## | | (_| | |_____/ / | _ | |___| | ## |___\__,_| /_/ |_| |_|_____|_| ## process.goodPATEleToHLT = cms.EDAnalyzer("TagProbeFitTreeProducer", commonStuff, patParameters, tagProbePairs = cms.InputTag("tagPATGoodPATElectron"), allProbes = cms.InputTag("goodPATElectrons"), probeMatches = cms.InputTag("McMatchPATElectron"), ) process.allEleTPTrees = cms.Sequence( process.SuperClusterToGsfElectronPATTag + process.GsfElectronToIdPATTag + process.goodPATEleToHLT ) ############################################################################################################## ## ____ _ _ ## | _ \ __ _| |_| |__ ## | |_) / _` | __| '_ \ ## | __/ (_| | |_| | | | ## |_| \__,_|\__|_| |_| ## if mcInfo: process.TagAndProbe_Electrons = cms.Sequence( process.allEleTagsAndProbes * ( process.allEleTPPairs + process.allElePassingProbes + process.allEleHLTResults + process.allEleMcMatches + process.allEleVertices + process.allElePileup + process.allEleImpactParameters + process.allEleJets + process.allEleMet + process.allEleST + process.allEleDeltaPfRecoPt + process.allEleRelIso #process.gsfConvRejVars )*process.allEleTPTrees ) else: process.TagAndProbe_Electrons = cms.Sequence( process.allEleTagsAndProbes * ( process.allEleTPPairs + process.allElePassingProbes + process.allEleHLTResults + process.allEleVertices + process.allElePileup + process.allEleImpactParameters + process.allEleJets + process.allEleMet + process.allEleST + process.allEleDeltaPfRecoPt + process.allEleRelIso #process.gsfConvRejVars )*process.allEleTPTrees )
postfix = "PFlow" usePF2PAT(process,runPF2PAT=True,jetAlgo='AK5',runOnMC=True,postfix = postfix,jetCorrections=('AK5PFchs',['L1FastJet','L2Relative','L3Absol\ ute','L2L3Residual'])) process.pfPileUpPFlow.Enable = True process.pfPileUpPFlow.Vertices = 'goodOfflinePrimaryVertices' process.pfJetsPFlow.doAreaFastjet = True process.pfJetsPFlow.doRhoFastjet = False process.pfPileUpPFlow.checkClosestZVertex = cms.bool(False) process.patJetCorrFactorsPFlow.rho = cms.InputTag("kt6PFJetsPFlow","rho") # Compute the mean pt per unit area (rho) from the PF chs inputs from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJetsPFlow = kt4PFJets.clone( rParam = cms.double(0.6), src = cms.InputTag('pfNoElectron'+postfix), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True), ) process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(100) ) process.source = cms.Source("PoolSource", # replace 'myfile.root' with the source file you want to use fileNames = cms.untracked.vstring( '/store/data/Run2011A/Photon/AOD/May10ReReco-v1/0000/00372EF6-C37B-E011-983B-001A64789E0C.root' ) ) #process.load("DelPanj.TreeMaker.patTuples_ZmmMadgraph_cfi") baseJetSel = cms.PSet( Jets=cms.InputTag("selectedPatJetsPFlow") #Jets=cms.InputTag("selectedPatJetsAK5PF")
def getBaseConfig( globaltag, testfile, maxevents, nickname, outputfilename, channel='mm', is_data=None, ): # Config parameters ############################################## cmssw_version = os.environ["CMSSW_VERSION"].split('_') cmssw_version = tuple([int(i) for i in cmssw_version[1:4]] + cmssw_version[4:]) autostr = "" if globaltag.lower() == 'auto': from Configuration.AlCa.autoCond import autoCond globaltag = autoCond['startup'] autostr = " (from autoCond)" if is_data is None: data = any([name in testfile[0] for name in 'SingleMu', 'DoubleMu', 'DoubleElectron', 'MuEG']) else: data = is_data miniaod = False ## print information print "\n------- CONFIGURATION 1 ---------" print "input: ", testfile[0], "... (%d files)" % len(testfile) if len(testfile) > 1 else "" print "file type: ", "miniAOD" if miniaod else "AOD" print "data: ", data print "output: ", outputfilename print "nickname: ", nickname print "global tag: ", globaltag + autostr print "max events: ", maxevents print "cmssw version: ", '.'.join([str(i) for i in cmssw_version]) print "channel: ", channel print "---------------------------------" print ############################################################################ # Basic Process Setup ############################################################################ process = cms.Process("KAPPA") ## MessageLogger process.load("FWCore.MessageLogger.MessageLogger_cfi") process.MessageLogger.default = cms.untracked.PSet( ERROR = cms.untracked.PSet(limit = cms.untracked.int32(5)) #suppressError = cms.untracked.vstring("electronIdMVAProducer") ) process.MessageLogger.cerr.FwkReport.reportEvery = 50 ## Options and Output Report process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(True) ) ## Source process.source = cms.Source("PoolSource", fileNames = cms.untracked.vstring() ) ## Maximal number of Events process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(100) ) ## Geometry and Detector Conditions (needed for a few patTuple production steps) import Kappa.Skimming.tools as tools cmssw_version_number = tools.get_cmssw_version_number() process.load("Configuration.Geometry.GeometryIdeal_cff") process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") from Configuration.AlCa.autoCond import autoCond process.GlobalTag.globaltag = cms.string(autoCond['startup']) # print the global tag until it is clear whether this auto global tag is fine print "GT from autoCond:", process.GlobalTag.globaltag process.load("Configuration.StandardSequences.MagneticField_cff") ############################################################################ # KAPPA ############################################################################ process.load('Kappa.Producers.KTuple_cff') process.kappaTuple = cms.EDAnalyzer('KTuple', process.kappaTupleDefaultsBlock, outputFile = cms.string("kappaTuple.root"), ) process.kappaTuple.active = cms.vstring() process.kappaTuple.outputFile = outputfilename ## name of output file process.kappaTuple.verbose = 0 ## verbosity level process.kappaTuple.profile = cms.bool(False) process.kappaOut = cms.Sequence(process.kappaTuple) process.path = cms.Path() process.source.fileNames = testfile process.maxEvents.input = maxevents ## number of events to be processed (-1 = all in file) if not globaltag.lower() == 'auto' : process.GlobalTag.globaltag = globaltag data = datasetsHelper.isData(nickname) process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(False) ) ############################################################################ # Basic Objects ############################################################################ process.kappaTuple.active += cms.vstring('VertexSummary') ## save VertexSummary, process.kappaTuple.VertexSummary.whitelist = cms.vstring('goodOfflinePrimaryVertices') #process.kappaTuple.active += cms.vstring('BeamSpot') ## save Beamspot, #process.kappaTuple.active += cms.vstring('TriggerObjects') if data: process.kappaTuple.active+= cms.vstring('DataInfo') ## produce Metadata for data, else: process.kappaTuple.active+= cms.vstring('GenInfo') ## produce Metadata for MC, process.kappaTuple.active+= cms.vstring('GenParticles') #Trigger trigger_dict = { 'mtrigger': ['^HLT_(Double)?Mu([0-9]+)_(Double)?Mu([0-9]+)(_v[[:digit:]]+)?$'], 'etrigger': ['HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL.*'], 'emtrigger': ["HLT_Mu17_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL.*", "HLT_Mu8_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL.*",] } channel_dict = { 'ee': ['etrigger'], 'mm': ['mtrigger'], 'eemm': ['etrigger', 'mtrigger'], 'em': ['emtrigger'] } process.kappaTuple.Info.hltWhitelist = cms.vstring("") for triggers in channel_dict[channel]: for trigger in trigger_dict[triggers]: process.kappaTuple.Info.hltWhitelist += cms.vstring(trigger) ############################################################################ # PFCandidates ############################################################################ process.load('Kappa.Skimming.KPFCandidates_cff') process.path *= ( process.goodOfflinePrimaryVertices * process.pfPileUp * process.pfNoPileUp #* process.makePFBRECO #* process.makeKappaPFCandidates ) if 'm' in channel: ############################################################################ # Muons ############################################################################ process.kappaTuple.active += cms.vstring('Muons') ## produce/save KappaMuons process.kappaTuple.Muons.minPt = cms.double(8.0) ## Isodeposits for muons process.load('TrackPropagation.SteppingHelixPropagator.SteppingHelixPropagatorAny_cfi') process.load('TrackPropagation.SteppingHelixPropagator.SteppingHelixPropagatorAlong_cfi') process.load('TrackPropagation.SteppingHelixPropagator.SteppingHelixPropagatorOpposite_cfi') process.pfmuIsoDepositPFCandidates = cms.EDProducer( "CandIsoDepositProducer", src = cms.InputTag("muons"), MultipleDepositsFlag = cms.bool(False), trackType = cms.string('candidate'), ExtractorPSet = cms.PSet( Diff_z = cms.double(99999.99), ComponentName = cms.string('CandViewExtractor'), DR_Max = cms.double(1.0), Diff_r = cms.double(99999.99), inputCandView = cms.InputTag("particleFlow"), DR_Veto = cms.double(1e-05), DepositLabel = cms.untracked.string('') ) ) process.path *= (process.pfmuIsoDepositPFCandidates) process.goodMuons = cms.EDFilter('CandViewSelector', src = cms.InputTag('muons'), cut = cms.string("pt > 15.0"), ) process.oneGoodMuon = cms.EDFilter('CandViewCountFilter', src = cms.InputTag('goodMuons'), minNumber = cms.uint32(1), ) process.twoGoodMuons = cms.EDFilter('CandViewCountFilter', src = cms.InputTag('goodMuons'), minNumber = cms.uint32(2), ) if 'mm' in channel: process.path *= (process.goodMuons * process.twoGoodMuons) if 'e' in channel: ############################################################################ # Electrons ############################################################################ #TODO Add Electron process.load('EgammaAnalysis.ElectronTools.electronIdMVAProducer_cfi') process.load('TrackingTools.TransientTrack.TransientTrackBuilder_cfi') process.load('PhysicsTools.PatAlgos.producersLayer1.electronProducer_cfi') process.patElectrons.electronIDSources = cms.PSet( ## default cut based Id eidRobustLoose = cms.InputTag("eidRobustLoose" ), eidRobustTight = cms.InputTag("eidRobustTight" ), eidLoose = cms.InputTag("eidLoose" ), eidTight = cms.InputTag("eidTight" ), eidRobustHighEnergy = cms.InputTag("eidRobustHighEnergy"), ## MVA based Id idMvaTrigV0 = cms.InputTag("mvaTrigV0" ), idMvaTrigNoIPV0 = cms.InputTag("mvaTrigNoIPV0" ), idMvaNonTrigV0 = cms.InputTag("mvaNonTrigV0" ), ) process.patElectrons.genParticleMatch = "" process.patElectrons.addGenMatch = False process.patElectrons.embedGenMatch = False process.patElectrons.embedGsfElectronCore = True process.patElectrons.embedGsfTrack = True process.patElectrons.embedSuperCluster = True process.patElectrons.embedPflowSuperCluster = True process.patElectrons.embedSeedCluster = True process.patElectrons.embedBasicClusters = True process.patElectrons.embedPreshowerClusters = True process.patElectrons.embedPflowBasicClusters = True process.patElectrons.embedPflowPreshowerClusters = True process.patElectrons.embedPFCandidate = True process.patElectrons.embedTrack = True process.patElectrons.embedRecHits = True process.patElectrons.embedHighLevelSelection.pvSrc = "goodOfflinePrimaryVertices" process.electronIdMVA = cms.Sequence( process.mvaTrigV0+ process.mvaTrigNoIPV0+ process.mvaNonTrigV0 ) process.makeKappaElectrons = cms.Sequence( process.electronIdMVA * process.patElectrons ) process.path *= (process.makeKappaElectrons) ## CALIBRATIONS # momentum corrections process.load('EgammaAnalysis.ElectronTools.electronRegressionEnergyProducer_cfi') process.eleRegressionEnergy.inputElectronsTag = cms.InputTag('patElectrons') process.eleRegressionEnergy.inputCollectionType = cms.uint32(1) process.load("Configuration.StandardSequences.Services_cff") process.RandomNumberGeneratorService = cms.Service("RandomNumberGeneratorService", calibratedPatElectrons = cms.PSet( initialSeed = cms.untracked.uint32(1), engineName = cms.untracked.string('TRandom3') ), ) # calibrate pat electrons process.load("EgammaAnalysis.ElectronTools.calibratedPatElectrons_cfi") if data: inputDataset = "22Jan2013ReReco" else: #inputDataset = "Summer12_DR53X_HCP2012" inputDataset = "Summer12_LegacyPaper" print "Using electron calibration", inputDataset process.calibratedPatElectrons.inputDataset = cms.string(inputDataset) process.calibratedPatElectrons.isMC = cms.bool(not data) ## for cutbased ID from CommonTools.ParticleFlow.Tools.pfIsolation import setupPFElectronIso, setupPFMuonIso process.calibeleIsoSequence = setupPFElectronIso(process, 'calibratedPatElectrons', "PFIsoCal") process.eleIsoSequence = setupPFElectronIso(process, 'patElectrons') process.pfiso = cms.Sequence(process.pfParticleSelectionSequence + process.eleIsoSequence + process.calibeleIsoSequence ) # rho for e isolation from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJetsForIsolation = kt4PFJets.clone( rParam = 0.6, doRhoFastjet = True ) process.kt6PFJetsForIsolation.Rho_EtaMax = cms.double(2.5) process.path *= ( process.eleRegressionEnergy * process.calibratedPatElectrons * process.pfiso * process.kt6PFJetsForIsolation ) #add to Kappa process.kappaTuple.active += cms.vstring('Electrons') process.kappaTuple.Electrons = cms.PSet( process.kappaNoCut, process.kappaNoRegEx, ids = cms.vstring(), srcIds = cms.string("pat"), electrons = cms.PSet( src = cms.InputTag("patElectrons"), allConversions = cms.InputTag("allConversions"), offlineBeamSpot = cms.InputTag("offlineBeamSpot"), vertexcollection = cms.InputTag("goodOfflinePrimaryVertices"), isoValInputTags = cms.VInputTag( cms.InputTag('elPFIsoValueChargedAll04PFIdPFIso'), cms.InputTag('elPFIsoValueGamma04PFIdPFIso'), cms.InputTag('elPFIsoValueNeutral04PFIdPFIso'), cms.InputTag('elPFIsoValuePU04PFIdPFIso')), rhoIsoInputTag = cms.InputTag("kt6PFJetsForIsolation", "rho"), ), ) process.kappaTuple.Electrons.correlectrons = process.kappaTuple.Electrons.electrons.clone( src = cms.InputTag("calibratedPatElectrons"), isoValInputTags = cms.VInputTag( cms.InputTag('elPFIsoValueChargedAll04PFIdPFIsoCal'), cms.InputTag('elPFIsoValueGamma04PFIdPFIsoCal'), cms.InputTag('elPFIsoValueNeutral04PFIdPFIsoCal'), cms.InputTag('elPFIsoValuePU04PFIdPFIsoCal')), ) #process.kappaTuple.Electrons.ids = cms.VInputTag("mvaTrigV0", "mvaTrigNoIPV0", "mvaNonTrigV0") process.kappaTuple.Electrons.ids = cms.VInputTag('idMvaNonTrigV0', 'idMvaTrigNoIPV0', 'idMvaTrigV0') process.kappaTuple.Electrons.minPt = cms.double(8.0) ### Filter process.goodElectrons = cms.EDFilter('CandViewSelector', src = cms.InputTag('calibratedPatElectrons'), cut = cms.string("pt > 15.0"), ) process.oneGoodElectron = cms.EDFilter('CandViewCountFilter', src = cms.InputTag('goodElectrons'), minNumber = cms.uint32(1), ) process.twoGoodElectrons = cms.EDFilter('CandViewCountFilter', src = cms.InputTag('goodElectrons'), minNumber = cms.uint32(2), ) if 'ee' in channel: process.path *= (process.goodElectrons * process.twoGoodElectrons) if 'em' in channel: process.path *= (process.goodElectrons * process.oneGoodElectron * process.goodMuons * process.oneGoodMuon) ############################################################################ # Jets ############################################################################ process.load('RecoJets.JetProducers.ak5PFJets_cfi') process.ak5PFJets.srcPVs = cms.InputTag('goodOfflinePrimaryVertices') process.ak5PFJetsCHS = process.ak5PFJets.clone( src = cms.InputTag('pfNoPileUp') ) process.kappaTuple.active += cms.vstring('Jets', 'PileupDensity') process.kappaTuple.Jets = cms.PSet( process.kappaNoCut, process.kappaNoRegEx, taggers = cms.vstring(), ak5PFJets = cms.PSet( src = cms.InputTag('ak5PFJets'), QGtagger = cms.InputTag('AK5PFJetsQGTagger'), Btagger = cms.InputTag('ak5PF'), PUJetID = cms.InputTag('ak5PFPuJetMva'), PUJetID_full = cms.InputTag('full'), ), ak5PFJetsCHS = cms.PSet( src = cms.InputTag('ak5PFJetsCHS'), QGtagger = cms.InputTag('AK5PFJetsCHSQGTagger'), Btagger = cms.InputTag('ak5PFCHS'), PUJetID = cms.InputTag('ak5PFCHSPuJetMva'), PUJetID_full = cms.InputTag('full'), ), ) process.kappaTuple.Jets.minPt = cms.double(5.0) if not data: process.load('RecoJets.JetProducers.ak5GenJets_cfi') process.path *= ( process.genParticlesForJetsNoNu * process.ak5GenJetsNoNu ) process.kappaTuple.active += cms.vstring('LV') process.kappaTuple.LV.rename = cms.vstring('ak => AK') process.kappaTuple.LV.whitelist = cms.vstring('ak5GenJetsNoNu') # add kt6PFJets, needed for the PileupDensity from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJets = kt4PFJets.clone( rParam = 0.6, doRhoFastjet = True ) process.kt6PFJets.Rho_EtaMax = cms.double(2.5) process.path *= ( process.ak5PFJets * process.ak5PFJetsCHS * process.kt6PFJets ) ############################################################################ # MET ############################################################################ # MET correction ---------------------------------------------------------- process.load('JetMETCorrections.Type1MET.pfMETCorrectionType0_cfi') process.path *= ( process.type0PFMEtCorrection ) #TODO check type 0 corrections process.kappaTuple.active += cms.vstring('MET') ## produce/save KappaPFMET process.kappaTuple.MET.whitelist = cms.vstring('pfChMet', '_pfMet_') if cmssw_version_number.startswith("5"): # MET correction ---------------------------------------------------------- process.load("JetMETCorrections.Type1MET.pfMETCorrections_cff") process.pfchsMETcorr.src = cms.InputTag('goodOfflinePrimaryVertices') # Type-0 process.pfMETCHS = process.pfType1CorrectedMet.clone( applyType1Corrections = cms.bool(False), applyType0Corrections = cms.bool(True) ) # MET Path process.path *= ( process.producePFMETCorrections * process.pfMETCHS ) process.kappaTuple.MET.whitelist += cms.vstring("pfMETCHS") ############################################################################ # Almost done ... ############################################################################ process.path *= ( process.kappaOut ) return process
) elPFIsoDepositCharged.src = cms.InputTag("patElectrons") elPFIsoDepositChargedAll.src = cms.InputTag("patElectrons") elPFIsoDepositNeutral.src = cms.InputTag("patElectrons") elPFIsoDepositGamma.src = cms.InputTag("patElectrons") elPFIsoDepositPU.src = cms.InputTag("patElectrons") # electron/muon PF iso sequence pfElectronIso = cms.Sequence( electronPFIsolationDepositsSequence + electronPFIsolationValuesSequence ) # rho for electron iso from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets kt6PFJetsForIsolation = kt4PFJets.clone( rParam = 0.6, doRhoFastjet = True ) kt6PFJetsForIsolation.Rho_EtaMax = cms.double(2.5) ## ------------------------------------------------------------------------ ## Definition of sequences ## run this to produce patElectrons w/o generator match or trigger match ## and with MVA electron ID makeKappaElectrons = cms.Sequence( egmGsfElectronIDSequence * patElectrons * pfElectronIso * kt6PFJetsForIsolation )
import FWCore.ParameterSet.Config as cms from RecoMET.METPUSubtraction.objectSelection_cff import * ##================================================ ## MVA MET sequence ##================================================ from JetMETCorrections.Configuration.JetCorrectionServicesAllAlgos_cff import * from JetMETCorrections.Configuration.DefaultJEC_cff import * from RecoJets.JetProducers.PileupJetIDParams_cfi import JetIdParams from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets kt6PFJets = kt4PFJets.clone(rParam = cms.double(0.6), doRhoFastjet = True ) calibratedAK4PFJetsForPFMVAMEt = cms.EDProducer('PFJetCorrectionProducer', src = cms.InputTag('ak4PFJets'), correctors = cms.vstring("ak4PFL1FastL2L3") # NOTE: use "ak5PFL1FastL2L3" for MC / "ak5PFL1FastL2L3Residual" for Data ) pfMVAMEt = cms.EDProducer("PFMETProducerMVA", srcCorrJets = cms.InputTag('calibratedAK4PFJetsForPFMVAMEt'), srcUncorrJets = cms.InputTag('ak4PFJets'), srcPFCandidates = cms.InputTag('particleFlow'), srcVertices = cms.InputTag('offlinePrimaryVertices'), srcLeptons = cms.VInputTag('selectedElectrons', 'selectedMuons', 'selectedTaus', 'selectedPhotons', 'selectedJets'), minNumLeptons = cms.int32(0),
process.pfPileUp.Enable = True process.pfPileUp.checkClosestZVertex = cms.bool(False) process.pfPileUp.Vertices = cms.InputTag('goodOfflinePrimaryVertices') process.pfJets.doAreaFastjet = True process.pfJets.doRhoFastjet = False #process.pfJets.Rho_EtaMax = cms.double(4.4) #Compute the mean pt per unit area (rho) from the #PFchs inputs from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJets = kt4PFJets.clone( rParam = cms.double(0.6), src = cms.InputTag('pfNoElectron'+postfix), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True), # voronoiRfact = cms.double(0.9), # Rho_EtaMax = cms.double(4.4) ) process.patJetCorrFactors.rho = cms.InputTag("kt6PFJets", "rho") inputJetCorrLabel = ('AK5PFchs', ['L1FastJet', 'L2Relative', 'L3Absolute','L2L3Residual']) process.patJetCorrFactors.payload = inputJetCorrLabel[0] process.patJetCorrFactors.levels = inputJetCorrLabel[1] coneOpening = cms.double(0.4) defaultIsolationCut = cms.double(0.2) #coneOpening = process.coneOpening #defaultIsolationCut = process.coneOpening
getattr(process,"pfNoJet"+postfix).enable = True # this i guess it's for photons... #add q/g discriminator process.load('QuarkGluonTagger.EightTeV.QGTagger_RecoJets_cff') process.QGTagger.srcJets = cms.InputTag("selectedPatJets"+postfix) process.QGTagger.isPatJet = cms.untracked.bool(True) process.QGTagger.useCHS = cms.untracked.bool(True) process.QGTagger.srcRho = cms.InputTag('kt6PFJets','rho') process.QGTagger.srcRhoIso = cms.InputTag('kt6PFJetsCentral','rho') process.qgSequence=cms.Sequence(process.goodOfflinePrimaryVerticesQG+process.QGTagger) #compute rho from central pf candidates only from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJetsCentral = kt4PFJets.clone( rParam = cms.double(0.6), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True), Rho_EtaMax = cms.double(2.5), Ghost_EtaMax = cms.double(2.5) ) from UserCode.llvv_fwk.btvDefaultSequence_cff import * btvDefaultSequence(process,isMC,"selectedPatJets"+postfix,"goodOfflinePrimaryVertices") # cf. https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMetAnalysis process.load("JetMETCorrections.Type1MET.pfMETCorrections_cff") process.load("JetMETCorrections.Type1MET.pfMETCorrectionType0_cfi") process.pfType1CorrectedMet.applyType0Corrections = cms.bool(False) process.pfType1CorrectedMet.srcType1Corrections = cms.VInputTag( cms.InputTag('pfMETcorrType0'), cms.InputTag('pfJetMETcorr', 'type1') )
def getBaseConfig(globaltag= 'START53_V15A::All', testfile=cms.untracked.vstring(""), maxevents=100, nickname = 'SM_VBFHToTauTau_M_90_powheg_pythia_8TeV', kappaTag = 'Kappa_1_0_0'): from Kappa.Skimming.KSkimming_template_cfg import process process.source.fileNames = testfile process.maxEvents.input = maxevents ## number of events to be processed (-1 = all in file) process.kappaTuple.outputFile = 'kappaTuple.root' ## name of output file process.kappaTuple.verbose = cms.int32(0) ## verbosity level process.kappaTuple.profile = cms.bool(True) if not globaltag.lower() == 'auto' : process.GlobalTag.globaltag = globaltag print "GT (overwritten):", process.GlobalTag.globaltag data = datasetsHelper.isData(nickname) centerOfMassEnergy = datasetsHelper.getCenterOfMassEnergy(nickname) isEmbedded = datasetsHelper.getIsEmbedded(nickname) process.p = cms.Path() ## ------------------------------------------------------------------------ # Configure Metadata describing the file process.kappaTuple.active = cms.vstring('TreeInfo') process.kappaTuple.TreeInfo.parameters = cms.PSet( dataset = cms.string(datasetsHelper.getDatasetName(nickname)), generator = cms.string(datasetsHelper.getGenerator(nickname)), productionProcess = cms.string(datasetsHelper.getProcess(nickname)), globalTag = cms.string(globaltag), prodCampaignGlobalTag = cms.string(datasetsHelper.getProductionCampaignGlobalTag(nickname, centerOfMassEnergy)), runPeriod = cms.string(datasetsHelper.getRunPeriod(nickname)), kappaTag = cms.string(kappaTag), isEmbedded = cms.bool(isEmbedded), jetMultiplicity = cms.int32(datasetsHelper.getJetMultiplicity(nickname)), centerOfMassEnergy = cms.int32(centerOfMassEnergy), puScenario = cms.string(datasetsHelper.getPuScenario(nickname, centerOfMassEnergy)), isData = cms.bool(data), ) ## ------------------------------------------------------------------------ # General configuration process.kappaTuple.active += cms.vstring('VertexSummary') ## save VertexSummary, process.kappaTuple.active += cms.vstring('BeamSpot') ## save Beamspot, process.kappaTuple.active += cms.vstring('TriggerObjects') if not isEmbedded: if data: process.kappaTuple.active+= cms.vstring('DataInfo') ## produce Metadata for data, else: process.kappaTuple.active+= cms.vstring('GenInfo') ## produce Metadata for MC, process.kappaTuple.active+= cms.vstring('GenParticles') ## save GenParticles, process.kappaTuple.active+= cms.vstring('GenTaus') ## save GenParticles, # prune GenParticles if not data: process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi") process.prunedGenParticles = cms.EDProducer("GenParticlePruner", src = cms.InputTag("genParticles", "", "SIM"), select = cms.vstring( "drop *", "keep status == 3", # all status 3 "keep++ abs(pdgId) == 23", # Z "keep++ abs(pdgId) == 24", # W "keep++ abs(pdgId) == 25", # H "keep abs(pdgId) == 11 || abs(pdgId) == 13", # charged leptons "keep++ abs(pdgId) == 15" # keep full tau decay chain ) ) process.kappaTuple.Info.hltWhitelist = cms.vstring( ## HLT selection # https://github.com/cms-analysis/HiggsAnalysis-KITHiggsToTauTau/blob/master/data/triggerTables-2011-2012.txt # https://twiki.cern.ch/twiki/bin/viewauth/CMS/HiggsToTauTauWorkingSummer2013 # can be tested at http://regexpal.com # e "^HLT_Ele[0-9]+_CaloIdVT(_CaloIsoT)?_TrkIdT(_TrkIsoT)?_v[0-9]+$", "^HLT_Ele[0-9]+_WP[0-9]+_v[0-9]+$", # m "^HLT_(Iso)?Mu[0-9]+(_eta2p1)?_v[0-9]+$", # ee "^HLT_Ele[0-9]+_CaloId(L|T)(_TrkIdVL)?_CaloIsoVL(_TrkIdVL)?(_TrkIsoVL)?" + "_Ele[0-9]+_CaloId(L|T)(_TrkIdVL)?_CaloIsoVL(_TrkIdVL)?(_TrkIsoVL)?_v[0-9]+$", "^HLT_Ele[0-9]+_Ele[0-9]+_CaloId(L|T)_CaloIsoVL(_TrkIdVL_TrkIsoVL)?_v[0-9]+$", # mm "^HLT_(Double)?Mu[0-9]+(_(Mu|Jet)[0-9]+)?_v[0-9]+$", # em "^HLT_Mu[0-9]+_(Ele|Photon)[0-9]+_CaloId(L|T|VT)(_CaloIsoVL|_IsoT)?(_TrkIdVL_TrkIsoVL)?_v[0-9]+$", # et "^HLT_Ele[0-9]+_CaloIdVT(_Calo(IsoRho|Iso)T)?_TrkIdT(_TrkIsoT)?_(Loose|Medium|Tight)IsoPFTau[0-9]+_v[0-9]+$", "^HLT_Ele[0-9]+_eta2p1_WP[0-9]+(Rho|NoIso)_LooseIsoPFTau[0-9]+_v[0-9]+$", # mt "^HLT_(Iso)?Mu[0-9]+(_eta2p1)?_(Loose|Medium|Tight)IsoPFTau[0-9]+(_Trk[0-9]_eta2p1)?_v[0-9]+$", # tt "^HLT_Double(Medium)?IsoPFTau[0-9]+_Trk(1|5)_eta2p1_(Jet[0-9]+|Prong[0-9])?_v[0-9]+$", "^HLT_Double(Medium)?IsoPFTau[0-9]+_Trk(1|5)(_eta2p1)?_v[0-9]+$", # specials (possible generalization: Mu15, L1ETM20, Photon20, Ele8) "^HLT_Ele[0-9]+_CaloId(L|T|VT)_CaloIso(VL|T|VT)(_TrkIdT)?(_TrkIsoVT)?_(SC|Ele)[0-9](_Mass[0-9]+)?_v[0-9]+$", "^HLT_Ele8_v[0-9]+$", "^HLT_IsoMu15(_eta2p1)?_L1ETM20_v[0-9]+$", "^HLT_Photon20_CaloIdVT_IsoT_Ele8_CaloIdL_CaloIsoVL_v[0-9]+$", # specials for tag and probe and em fakerate studies could be added if enough bits are ensured #"^HLT_Ele[0-9]+_CaloId(L|T|VT)_CaloIso(VL|T|VT)(_TrkIdT_TrkIso(T|VT))?_(SC|Ele)[0-9]+(_Mass[0-9]+)?_v[0-9]+$", #"^HLT_Mu[0-9]+_Photon[0-9]+_CaloIdVT_IsoT_v[0-9]+$", #"^HLT_Ele[0-9]+_CaloId(L|T)(_TrkIdVL)?_CaloIsoVL(_TrkIdVL_TrkIsoVL)?(_TrkIsoVL)?(_Jet[0-9]+|)?_v[0-9]+$", ) process.kappaTuple.Info.hltBlacklist = cms.vstring( "HLT_Mu13_Mu8", # v21 gives errors for the trigger objects ) ## ------------------------------------------------------------------------ # Configure PFCandidates and offline PV process.load("Kappa.Skimming.KPFCandidates_cff") #process.kappaTuple.active += cms.vstring('PFCandidates') ## save PFCandidates for deltaBeta corrected process.kappaTuple.PFCandidates.whitelist = cms.vstring( ## isolation used for electrons and muons. ## "pfNoPileUpChargedHadrons", ## switch to pfAllChargedParticles "pfAllChargedParticles", ## same as pfNoPileUpChargedHadrons +pf_electrons + pf_muons "pfNoPileUpNeutralHadrons", "pfNoPileUpPhotons", "pfPileUpChargedHadrons", ) process.p *= ( process.makePFBRECO * process.makePFCandidatesForDeltaBeta ) ## ------------------------------------------------------------------------ # Configure Muons process.load("Kappa.Skimming.KMuons_cff") process.kappaTuple.active += cms.vstring('Muons') ## produce/save KappaMuons process.kappaTuple.Muons.minPt = cms.double(8.0) process.p *= process.makeKappaMuons ## ------------------------------------------------------------------------ # Configure Electrons process.load("Kappa.Skimming.KElectrons_cff") process.kappaTuple.active += cms.vstring('Electrons') ## produce/save KappaElectrons, process.kappaTuple.Electrons.ids = cms.vstring("mvaTrigV0", "mvaTrigNoIPV0", "mvaNonTrigV0") process.kappaTuple.Electrons.minPt = cms.double(8.0) process.p *= process.makeKappaElectrons ## for electron/muon iso # https://github.com/ajgilbert/ICHiggsTauTau/blob/master/test/higgstautau_cfg.py#L418-L448 from CommonTools.ParticleFlow.Tools.pfIsolation import setupPFElectronIso, setupPFMuonIso process.eleIsoSequence = setupPFElectronIso(process, 'patElectrons') process.muIsoSequence = setupPFMuonIso(process, 'muons') process.eleIsoSequence.remove(process.elPFIsoValueCharged03NoPFIdPFIso) process.eleIsoSequence.remove(process.elPFIsoValueChargedAll03NoPFIdPFIso) process.eleIsoSequence.remove(process.elPFIsoValueGamma03NoPFIdPFIso) process.eleIsoSequence.remove(process.elPFIsoValueNeutral03NoPFIdPFIso) process.eleIsoSequence.remove(process.elPFIsoValuePU03NoPFIdPFIso) process.eleIsoSequence.remove(process.elPFIsoValueCharged04NoPFIdPFIso) process.eleIsoSequence.remove(process.elPFIsoValueChargedAll04NoPFIdPFIso) process.eleIsoSequence.remove(process.elPFIsoValueGamma04NoPFIdPFIso) process.eleIsoSequence.remove(process.elPFIsoValueNeutral04NoPFIdPFIso) process.eleIsoSequence.remove(process.elPFIsoValuePU04NoPFIdPFIso) process.elPFIsoValueGamma04PFIdPFIso.deposits[0].vetos = cms.vstring('EcalEndcaps:ConeVeto(0.08)','EcalBarrel:ConeVeto(0.08)') process.elPFIsoValueNeutral04PFIdPFIso.deposits[0].vetos = cms.vstring() process.elPFIsoValuePU04PFIdPFIso.deposits[0].vetos = cms.vstring() process.elPFIsoValueCharged04PFIdPFIso.deposits[0].vetos = cms.vstring('EcalEndcaps:ConeVeto(0.015)') process.elPFIsoValueChargedAll04PFIdPFIso.deposits[0].vetos = cms.vstring('EcalEndcaps:ConeVeto(0.015)','EcalBarrel:ConeVeto(0.01)') process.pfiso = cms.Sequence(process.pfParticleSelectionSequence + process.eleIsoSequence + process.muIsoSequence) # rho for electron iso from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJetsForIsolation = kt4PFJets.clone( rParam = 0.6, doRhoFastjet = True ) process.kt6PFJetsForIsolation.Rho_EtaMax = cms.double(2.5) process.p *= (process.pfiso * process.kt6PFJetsForIsolation) ## ------------------------------------------------------------------------ # Configure Taus process.load("Kappa.Skimming.KTaus_cff") process.kappaTuple.active += cms.vstring('Taus') ## produce/save KappaTaus process.kappaTuple.Taus.minPt = cms.double(8.0) process.p *= process.makeKappaTaus ## ------------------------------------------------------------------------ ## Kappa Jets process.load("Kappa.Skimming.KJets_cff") process.kappaTuple.active += cms.vstring('Jets', 'PileupDensity') process.kappaTuple.Jets = cms.PSet( process.kappaNoCut, process.kappaNoRegEx, taggers = cms.vstring( "QGlikelihood", "QGmlp", "TrackCountingHighEffBJetTags", "TrackCountingHighPurBJetTags", "JetProbabilityBJetTags", "JetBProbabilityBJetTags", "SoftElectronBJetTags", "SoftMuonBJetTags", "SoftMuonByIP3dBJetTags", "SoftMuonByPtBJetTags", "SimpleSecondaryVertexBJetTags", "CombinedSecondaryVertexBJetTags", "CombinedSecondaryVertexMVABJetTags", "puJetIDFullDiscriminant", "puJetIDFullLoose", "puJetIDFullMedium", "puJetIDFullTight", "puJetIDCutbasedDiscriminant", "puJetIDCutbasedLoose", "puJetIDCutbasedMedium", "puJetIDCutbasedTight" ), AK5PFTaggedJets = cms.PSet( src = cms.InputTag("ak5PFJets"), QGtagger = cms.InputTag("AK5PFJetsQGTagger"), Btagger = cms.InputTag("ak5PF"), PUJetID = cms.InputTag("ak5PFPuJetMva"), PUJetID_full = cms.InputTag("full"), ), AK5PFTaggedJetsCHS = cms.PSet( src = cms.InputTag("ak5PFJetsCHS"), QGtagger = cms.InputTag("AK5PFJetsCHSQGTagger"), Btagger = cms.InputTag("ak5PFCHS"), PUJetID = cms.InputTag("ak5PFCHSPuJetMva"), PUJetID_full = cms.InputTag("full"), ), ) process.kappaTuple.Jets.minPt = cms.double(10.0) ## ------------------------------------------------------------------------ # Special settings for embedded samples # https://twiki.cern.ch/twiki/bin/viewauth/CMS/MuonTauReplacementWithPFlow if isEmbedded: process.load('RecoBTag/Configuration/RecoBTag_cff') process.load('RecoJets/JetAssociationProducers/ak5JTA_cff') process.ak5PFJetNewTracksAssociatorAtVertex.tracks = "tmfTracks" process.ak5PFCHSNewJetTracksAssociatorAtVertex.tracks = "tmfTracks" process.p *= process.btagging # disable overrideHLTCheck for embedded samples, since it triggers an Kappa error process.kappaTuple.Info.overrideHLTCheck = cms.untracked.bool(True) process.kappaTuple.active+= cms.vstring('DataInfo') process.kappaTuple.active+= cms.vstring('GenParticles') ## save GenParticles, process.kappaTuple.active+= cms.vstring('GenTaus') ## save GenParticles, process.kappaTuple.GenParticles.genParticles.src = cms.InputTag("genParticles","","EmbeddedRECO") process.kappaTuple.Info.isEmbedded = cms.bool(True) # Let Jets run process.p *= ( process.makeKappaTaus * process.makePFJets * process.makePFJetsCHS * process.makeQGTagging * process.makeBTagging * process.makePUJetID ) ## ------------------------------------------------------------------------ ## MET process.load("Kappa.Skimming.KMET_cff") process.kappaTuple.active += cms.vstring('GenMET') ## produce/save KappaMET process.kappaTuple.active += cms.vstring('MET') ## produce/save KappaPFMET process.p *= process.makeKappaMET #""" if not data: process.load('PhysicsTools/JetMCAlgos/TauGenJets_cfi') process.load('PhysicsTools/JetMCAlgos/TauGenJetsDecayModeSelectorAllHadrons_cfi') process.p *= (process.tauGenJets+process.tauGenJetsSelectorAllHadrons) process.kappaTuple.GenJets.whitelist = cms.vstring("tauGenJets") process.kappaTuple.active += cms.vstring('GenJets') # add python config to TreeInfo process.kappaTuple.TreeInfo.parameters.config = cms.string(process.dumpPython()) # add repository revisions to TreeInfo for repo, rev in tools.get_repository_revisions().iteritems(): setattr(process.kappaTuple.TreeInfo.parameters, repo, cms.string(rev)) ## ------------------------------------------------------------------------ ## And let it run process.p *= ( process.kappaOut ) ## ------------------------------------------------------------------------ ## declare edm OutputModule (expects a path 'p'), uncommented if wanted #process.edmOut = cms.OutputModule( # "PoolOutputModule", # fileName = cms.untracked.string('dump.root'), ## name of output file # SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring('p') ), ## save only events passing the full path # outputCommands = cms.untracked.vstring('drop *', 'keep *_*_*_KAPPA') ## save each edm object that has been produced by process KAPPA # ) #process.ep = cms.EndPath(process.edmOut) return process
outputCommands = cms.untracked.vstring('drop *', *patEventContent ) ) # Configure PAT to use PF2PAT instead of AOD sources from PhysicsTools.PatAlgos.tools.pfTools import * # Compute the mean pt per unit area (rho) from the # various PFchs inputs # -> note: when using PFnoPileUp, rho must be computed from the kt6-pfjets # with charged pf-candidates not coming from the PV already subtracted! # since the kt6-pfjets come from the pfNoElectron collection (which # is different for each pf2pat branch) we run it three times... from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJetsPF2 = kt4PFJets.clone( rParam = cms.double(0.6), src = cms.InputTag('pfNoElectronPF2'), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True) ) process.kt6PFJetsPF3 = kt4PFJets.clone( rParam = cms.double(0.6), src = cms.InputTag('pfNoElectronPF3'), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True) ) process.kt6PFJetsPFAntiIso = kt4PFJets.clone( rParam = cms.double(0.6), src = cms.InputTag('pfNoElectronPFAntiIso'), doAreaFastjet = cms.bool(True), doRhoFastjet = cms.bool(True) )
import FWCore.ParameterSet.Config as cms # load jet energy correction parameters from JetMETCorrections.Configuration.JetCorrectionServices_cff import * #-------------------------------------------------------------------------------- # produce rho parameters needed for L1FastJet corrections from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets kt6PFNewJets = kt4PFJets.clone( src = cms.InputTag('particleFlow'), rParam = cms.double(0.6), doRhoFastjet = cms.bool(True), Rho_EtaMax = cms.double(2.5) ) # CV: need to rerun 'ak5PFJets' module with jet area computation enabled, # since it has not been enabled per default in CMSSW_4_2_x # (if the jet area of 'ak5PFJets' is zero, the L1FastjetCorrector::correction function always returns 1.0) from RecoJets.JetProducers.ak5PFJets_cfi import ak5PFJets ak5PFJets.doAreaFastjet = cms.bool(True) #-------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # select PFCandidates ("unclustered energy") not within jets # for Type 2 MET correction from CommonTools.ParticleFlow.TopProjectors.pfNoJet_cfi import pfNoJet pfCandsNotInJet = pfNoJet.clone( topCollection = cms.InputTag('ak5PFJets'), bottomCollection = cms.InputTag('particleFlow') ) #--------------------------------------------------------------------------------
def getBaseConfig(globaltag='START53_V15A::All', testfile=cms.untracked.vstring(""), maxevents=100, nickname='SM_VBFHToTauTau_M_90_powheg_pythia_8TeV', kappaTag='Kappa_1_0_0'): from Kappa.Skimming.KSkimming_template_cfg import process process.source.fileNames = testfile process.maxEvents.input = maxevents ## number of events to be processed (-1 = all in file) process.kappaTuple.outputFile = 'kappaTuple.root' ## name of output file process.kappaTuple.verbose = cms.int32(0) ## verbosity level process.kappaTuple.profile = cms.bool(True) if not globaltag.lower() == 'auto': process.GlobalTag.globaltag = globaltag print "GT (overwritten):", process.GlobalTag.globaltag data = datasetsHelper.isData(nickname) centerOfMassEnergy = datasetsHelper.getCenterOfMassEnergy(nickname) isEmbedded = datasetsHelper.getIsEmbedded(nickname) process.p = cms.Path() ## ------------------------------------------------------------------------ # Configure Metadata describing the file process.kappaTuple.active = cms.vstring('TreeInfo') process.kappaTuple.TreeInfo.parameters = cms.PSet( dataset=cms.string(datasetsHelper.getDatasetName(nickname)), generator=cms.string(datasetsHelper.getGenerator(nickname)), productionProcess=cms.string(datasetsHelper.getProcess(nickname)), globalTag=cms.string(globaltag), prodCampaignGlobalTag=cms.string( datasetsHelper.getProductionCampaignGlobalTag( nickname, centerOfMassEnergy)), runPeriod=cms.string(datasetsHelper.getRunPeriod(nickname)), kappaTag=cms.string(kappaTag), isEmbedded=cms.bool(isEmbedded), jetMultiplicity=cms.int32(datasetsHelper.getJetMultiplicity(nickname)), centerOfMassEnergy=cms.int32(centerOfMassEnergy), puScenario=cms.string( datasetsHelper.getPuScenario(nickname, centerOfMassEnergy)), isData=cms.bool(data), ) ## ------------------------------------------------------------------------ # General configuration process.kappaTuple.active += cms.vstring( 'VertexSummary') ## save VertexSummary, process.kappaTuple.active += cms.vstring('BeamSpot') ## save Beamspot, process.kappaTuple.active += cms.vstring('TriggerObjects') if not isEmbedded: if data: process.kappaTuple.active += cms.vstring( 'DataInfo') ## produce Metadata for data, else: process.kappaTuple.active += cms.vstring( 'GenInfo') ## produce Metadata for MC, process.kappaTuple.active += cms.vstring( 'GenParticles') ## save GenParticles, process.kappaTuple.active += cms.vstring( 'GenTaus') ## save GenParticles, # prune GenParticles if not data: process.load("SimGeneral.HepPDTESSource.pythiapdt_cfi") process.prunedGenParticles = cms.EDProducer( "GenParticlePruner", src=cms.InputTag("genParticles", "", "SIM"), select=cms.vstring( "drop *", "keep status == 3", # all status 3 "keep++ abs(pdgId) == 23", # Z "keep++ abs(pdgId) == 24", # W "keep++ abs(pdgId) == 25", # H "keep abs(pdgId) == 11 || abs(pdgId) == 13", # charged leptons "keep++ abs(pdgId) == 15" # keep full tau decay chain )) process.kappaTuple.Info.hltWhitelist = cms.vstring( ## HLT selection # https://github.com/cms-analysis/HiggsAnalysis-KITHiggsToTauTau/blob/master/data/triggerTables-2011-2012.txt # https://twiki.cern.ch/twiki/bin/viewauth/CMS/HiggsToTauTauWorkingSummer2013 # can be tested at http://regexpal.com # e "^HLT_Ele[0-9]+_CaloIdVT(_CaloIsoT)?_TrkIdT(_TrkIsoT)?_v[0-9]+$", "^HLT_Ele[0-9]+_WP[0-9]+_v[0-9]+$", # m "^HLT_(Iso)?Mu[0-9]+(_eta2p1)?_v[0-9]+$", # ee "^HLT_Ele[0-9]+_CaloId(L|T)(_TrkIdVL)?_CaloIsoVL(_TrkIdVL)?(_TrkIsoVL)?" + "_Ele[0-9]+_CaloId(L|T)(_TrkIdVL)?_CaloIsoVL(_TrkIdVL)?(_TrkIsoVL)?_v[0-9]+$", "^HLT_Ele[0-9]+_Ele[0-9]+_CaloId(L|T)_CaloIsoVL(_TrkIdVL_TrkIsoVL)?_v[0-9]+$", # mm "^HLT_(Double)?Mu[0-9]+(_(Mu|Jet)[0-9]+)?_v[0-9]+$", # em "^HLT_Mu[0-9]+_(Ele|Photon)[0-9]+_CaloId(L|T|VT)(_CaloIsoVL|_IsoT)?(_TrkIdVL_TrkIsoVL)?_v[0-9]+$", # et "^HLT_Ele[0-9]+_CaloIdVT(_Calo(IsoRho|Iso)T)?_TrkIdT(_TrkIsoT)?_(Loose|Medium|Tight)IsoPFTau[0-9]+_v[0-9]+$", "^HLT_Ele[0-9]+_eta2p1_WP[0-9]+(Rho|NoIso)_LooseIsoPFTau[0-9]+_v[0-9]+$", # mt "^HLT_(Iso)?Mu[0-9]+(_eta2p1)?_(Loose|Medium|Tight)IsoPFTau[0-9]+(_Trk[0-9]_eta2p1)?_v[0-9]+$", # tt "^HLT_Double(Medium)?IsoPFTau[0-9]+_Trk(1|5)_eta2p1_(Jet[0-9]+|Prong[0-9])?_v[0-9]+$", "^HLT_Double(Medium)?IsoPFTau[0-9]+_Trk(1|5)(_eta2p1)?_v[0-9]+$", # specials (possible generalization: Mu15, L1ETM20, Photon20, Ele8) "^HLT_Ele[0-9]+_CaloId(L|T|VT)_CaloIso(VL|T|VT)(_TrkIdT)?(_TrkIsoVT)?_(SC|Ele)[0-9](_Mass[0-9]+)?_v[0-9]+$", "^HLT_Ele8_v[0-9]+$", "^HLT_IsoMu15(_eta2p1)?_L1ETM20_v[0-9]+$", "^HLT_Photon20_CaloIdVT_IsoT_Ele8_CaloIdL_CaloIsoVL_v[0-9]+$", # specials for tag and probe and em fakerate studies could be added if enough bits are ensured #"^HLT_Ele[0-9]+_CaloId(L|T|VT)_CaloIso(VL|T|VT)(_TrkIdT_TrkIso(T|VT))?_(SC|Ele)[0-9]+(_Mass[0-9]+)?_v[0-9]+$", #"^HLT_Mu[0-9]+_Photon[0-9]+_CaloIdVT_IsoT_v[0-9]+$", #"^HLT_Ele[0-9]+_CaloId(L|T)(_TrkIdVL)?_CaloIsoVL(_TrkIdVL_TrkIsoVL)?(_TrkIsoVL)?(_Jet[0-9]+|)?_v[0-9]+$", ) process.kappaTuple.Info.hltBlacklist = cms.vstring( "HLT_Mu13_Mu8", # v21 gives errors for the trigger objects ) ## ------------------------------------------------------------------------ # Configure PFCandidates and offline PV process.load("Kappa.Skimming.KPFCandidates_cff") #process.kappaTuple.active += cms.vstring('PFCandidates') ## save PFCandidates for deltaBeta corrected process.kappaTuple.PFCandidates.whitelist = cms.vstring( ## isolation used for electrons and muons. ## "pfNoPileUpChargedHadrons", ## switch to pfAllChargedParticles "pfAllChargedParticles", ## same as pfNoPileUpChargedHadrons +pf_electrons + pf_muons "pfNoPileUpNeutralHadrons", "pfNoPileUpPhotons", "pfPileUpChargedHadrons", ) process.p *= (process.makePFBRECO * process.makePFCandidatesForDeltaBeta) ## ------------------------------------------------------------------------ # Configure Muons process.load("Kappa.Skimming.KMuons_cff") process.kappaTuple.active += cms.vstring( 'Muons') ## produce/save KappaMuons process.kappaTuple.Muons.minPt = cms.double(8.0) process.p *= process.makeKappaMuons ## ------------------------------------------------------------------------ # Configure Electrons process.load("Kappa.Skimming.KElectrons_cff") process.kappaTuple.active += cms.vstring( 'Electrons') ## produce/save KappaElectrons, process.kappaTuple.Electrons.ids = cms.vstring("mvaTrigV0", "mvaTrigNoIPV0", "mvaNonTrigV0") process.kappaTuple.Electrons.minPt = cms.double(8.0) process.p *= process.makeKappaElectrons ## for electron/muon iso # https://github.com/ajgilbert/ICHiggsTauTau/blob/master/test/higgstautau_cfg.py#L418-L448 from CommonTools.ParticleFlow.Tools.pfIsolation import setupPFElectronIso, setupPFMuonIso process.eleIsoSequence = setupPFElectronIso(process, 'patElectrons') process.muIsoSequence = setupPFMuonIso(process, 'muons') process.eleIsoSequence.remove(process.elPFIsoValueCharged03NoPFIdPFIso) process.eleIsoSequence.remove(process.elPFIsoValueChargedAll03NoPFIdPFIso) process.eleIsoSequence.remove(process.elPFIsoValueGamma03NoPFIdPFIso) process.eleIsoSequence.remove(process.elPFIsoValueNeutral03NoPFIdPFIso) process.eleIsoSequence.remove(process.elPFIsoValuePU03NoPFIdPFIso) process.eleIsoSequence.remove(process.elPFIsoValueCharged04NoPFIdPFIso) process.eleIsoSequence.remove(process.elPFIsoValueChargedAll04NoPFIdPFIso) process.eleIsoSequence.remove(process.elPFIsoValueGamma04NoPFIdPFIso) process.eleIsoSequence.remove(process.elPFIsoValueNeutral04NoPFIdPFIso) process.eleIsoSequence.remove(process.elPFIsoValuePU04NoPFIdPFIso) process.elPFIsoValueGamma04PFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.08)', 'EcalBarrel:ConeVeto(0.08)') process.elPFIsoValueNeutral04PFIdPFIso.deposits[0].vetos = cms.vstring() process.elPFIsoValuePU04PFIdPFIso.deposits[0].vetos = cms.vstring() process.elPFIsoValueCharged04PFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.015)') process.elPFIsoValueChargedAll04PFIdPFIso.deposits[0].vetos = cms.vstring( 'EcalEndcaps:ConeVeto(0.015)', 'EcalBarrel:ConeVeto(0.01)') process.pfiso = cms.Sequence(process.pfParticleSelectionSequence + process.eleIsoSequence + process.muIsoSequence) # rho for electron iso from RecoJets.JetProducers.kt4PFJets_cfi import kt4PFJets process.kt6PFJetsForIsolation = kt4PFJets.clone(rParam=0.6, doRhoFastjet=True) process.kt6PFJetsForIsolation.Rho_EtaMax = cms.double(2.5) process.p *= (process.pfiso * process.kt6PFJetsForIsolation) ## ------------------------------------------------------------------------ # Configure Taus process.load("Kappa.Skimming.KTaus_cff") process.kappaTuple.active += cms.vstring('Taus') ## produce/save KappaTaus process.kappaTuple.Taus.minPt = cms.double(8.0) process.p *= process.makeKappaTaus ## ------------------------------------------------------------------------ ## Kappa Jets process.load("Kappa.Skimming.KJets_cff") process.kappaTuple.active += cms.vstring('Jets', 'PileupDensity') process.kappaTuple.Jets = cms.PSet( process.kappaNoCut, process.kappaNoRegEx, taggers=cms.vstring( "QGlikelihood", "QGmlp", "TrackCountingHighEffBJetTags", "TrackCountingHighPurBJetTags", "JetProbabilityBJetTags", "JetBProbabilityBJetTags", "SoftElectronBJetTags", "SoftMuonBJetTags", "SoftMuonByIP3dBJetTags", "SoftMuonByPtBJetTags", "SimpleSecondaryVertexBJetTags", "CombinedSecondaryVertexBJetTags", "CombinedSecondaryVertexMVABJetTags", "puJetIDFullDiscriminant", "puJetIDFullLoose", "puJetIDFullMedium", "puJetIDFullTight", "puJetIDCutbasedDiscriminant", "puJetIDCutbasedLoose", "puJetIDCutbasedMedium", "puJetIDCutbasedTight"), AK5PFTaggedJets=cms.PSet( src=cms.InputTag("ak5PFJets"), QGtagger=cms.InputTag("AK5PFJetsQGTagger"), Btagger=cms.InputTag("ak5PF"), PUJetID=cms.InputTag("ak5PFPuJetMva"), PUJetID_full=cms.InputTag("full"), ), AK5PFTaggedJetsCHS=cms.PSet( src=cms.InputTag("ak5PFJetsCHS"), QGtagger=cms.InputTag("AK5PFJetsCHSQGTagger"), Btagger=cms.InputTag("ak5PFCHS"), PUJetID=cms.InputTag("ak5PFCHSPuJetMva"), PUJetID_full=cms.InputTag("full"), ), ) process.kappaTuple.Jets.minPt = cms.double(10.0) ## ------------------------------------------------------------------------ # Special settings for embedded samples # https://twiki.cern.ch/twiki/bin/viewauth/CMS/MuonTauReplacementWithPFlow if isEmbedded: process.load('RecoBTag/Configuration/RecoBTag_cff') process.load('RecoJets/JetAssociationProducers/ak5JTA_cff') process.ak5PFJetNewTracksAssociatorAtVertex.tracks = "tmfTracks" process.ak5PFCHSNewJetTracksAssociatorAtVertex.tracks = "tmfTracks" process.p *= process.btagging # disable overrideHLTCheck for embedded samples, since it triggers an Kappa error process.kappaTuple.Info.overrideHLTCheck = cms.untracked.bool(True) process.kappaTuple.active += cms.vstring('DataInfo') process.kappaTuple.active += cms.vstring( 'GenParticles') ## save GenParticles, process.kappaTuple.active += cms.vstring( 'GenTaus') ## save GenParticles, process.kappaTuple.GenParticles.genParticles.src = cms.InputTag( "genParticles", "", "EmbeddedRECO") process.kappaTuple.Info.isEmbedded = cms.bool(True) # Let Jets run process.p *= (process.makeKappaTaus * process.makePFJets * process.makePFJetsCHS * process.makeQGTagging * process.makeBTagging * process.makePUJetID) ## ------------------------------------------------------------------------ ## MET process.load("Kappa.Skimming.KMET_cff") process.kappaTuple.active += cms.vstring( 'GenMET') ## produce/save KappaMET process.kappaTuple.active += cms.vstring('MET') ## produce/save KappaPFMET process.p *= process.makeKappaMET #""" if not data: process.load('PhysicsTools/JetMCAlgos/TauGenJets_cfi') process.load( 'PhysicsTools/JetMCAlgos/TauGenJetsDecayModeSelectorAllHadrons_cfi' ) process.p *= (process.tauGenJets + process.tauGenJetsSelectorAllHadrons) process.kappaTuple.GenJets.whitelist = cms.vstring("tauGenJets") process.kappaTuple.active += cms.vstring('GenJets') # add python config to TreeInfo process.kappaTuple.TreeInfo.parameters.config = cms.string( process.dumpPython()) # add repository revisions to TreeInfo for repo, rev in tools.get_repository_revisions().iteritems(): setattr(process.kappaTuple.TreeInfo.parameters, repo, cms.string(rev)) ## ------------------------------------------------------------------------ ## And let it run process.p *= (process.kappaOut) ## ------------------------------------------------------------------------ ## declare edm OutputModule (expects a path 'p'), uncommented if wanted #process.edmOut = cms.OutputModule( # "PoolOutputModule", # fileName = cms.untracked.string('dump.root'), ## name of output file # SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring('p') ), ## save only events passing the full path # outputCommands = cms.untracked.vstring('drop *', 'keep *_*_*_KAPPA') ## save each edm object that has been produced by process KAPPA # ) #process.ep = cms.EndPath(process.edmOut) return process