def configureZllRecoilCorrection(process, diTauProducerModuleName, ZllRecoilCorrectionType, shiftByUncertainty=0., label=""): #print("<configureZllRecoilCorrection>:") process.load("TauAnalysis.RecoTools.recoZllRecoilCorrection_cfi") retVal = {} patPFMETsZllRecoilCorrectionModule = cms.EDProducer( ZllRecoilCorrectionType, process.recoZllRecoilCorrectionParameter, src=cms.InputTag(diTauProducerModuleName)) patPFMETsZllRecoilCorrectionModule.shiftByUncertainty = cms.double( shiftByUncertainty) retVal[ 'patPFMETsZllRecoilCorrectionModule'] = patPFMETsZllRecoilCorrectionModule patPFMETsZllRecoilCorrectionModuleName = composeModuleName( ["patPFMETsZllRecoilCorrected", diTauProducerModuleName, label]) setattr(process, patPFMETsZllRecoilCorrectionModuleName, patPFMETsZllRecoilCorrectionModule) retVal[ 'patPFMETsZllRecoilCorrectionModuleName'] = patPFMETsZllRecoilCorrectionModuleName diTauProducerModule = getattr(process, diTauProducerModuleName) diTauProducerModuleZllRecoilCorrected = diTauProducerModule.clone() diTauProducerModuleZllRecoilCorrected.srcMET = \ cms.InputTag(patPFMETsZllRecoilCorrectionModuleName, 'met') diTauProducerModuleZllRecoilCorrected.srcReRecoDiTauObjects = \ cms.InputTag(diTauProducerModuleName) diTauProducerModuleZllRecoilCorrected.srcReRecoDiTauToMEtAssociations = \ cms.InputTag(patPFMETsZllRecoilCorrectionModuleName, 'diTauToMEtAssociations') retVal[ 'diTauProducerModuleZllRecoilCorrected'] = diTauProducerModuleZllRecoilCorrected diTauProducerModuleZllRecoilCorrectedName = composeModuleName( [diTauProducerModuleName, "ZllRecoilCorrected", label]) setattr(process, diTauProducerModuleZllRecoilCorrectedName, diTauProducerModuleZllRecoilCorrected) retVal[ 'diTauProducerModuleZllRecoilCorrectedName'] = diTauProducerModuleZllRecoilCorrectedName patPFMETsZllRecoilCorrectionSequence = cms.Sequence( patPFMETsZllRecoilCorrectionModule * diTauProducerModuleZllRecoilCorrected) retVal[ 'patPFMETsZllRecoilCorrectionSequence'] = patPFMETsZllRecoilCorrectionSequence patPFMETsZllRecoilCorrectionSequenceName = \ composeModuleName([ "patPFMETsZllRecoilCorrectionSequence", diTauProducerModuleName, label ]) setattr(process, patPFMETsZllRecoilCorrectionSequenceName, patPFMETsZllRecoilCorrectionSequence) retVal[ 'patPFMETsZllRecoilCorrectionSequenceName'] = patPFMETsZllRecoilCorrectionSequenceName return retVal
def configureZllRecoilCorrection( process, diTauProducerModuleName, ZllRecoilCorrectionType, shiftByUncertainty=0.0, label="" ): # print("<configureZllRecoilCorrection>:") process.load("TauAnalysis.RecoTools.recoZllRecoilCorrection_cfi") retVal = {} patPFMETsZllRecoilCorrectionModule = cms.EDProducer( ZllRecoilCorrectionType, process.recoZllRecoilCorrectionParameter, src=cms.InputTag(diTauProducerModuleName) ) patPFMETsZllRecoilCorrectionModule.shiftByUncertainty = cms.double(shiftByUncertainty) retVal["patPFMETsZllRecoilCorrectionModule"] = patPFMETsZllRecoilCorrectionModule patPFMETsZllRecoilCorrectionModuleName = composeModuleName( ["patPFMETsZllRecoilCorrected", diTauProducerModuleName, label] ) setattr(process, patPFMETsZllRecoilCorrectionModuleName, patPFMETsZllRecoilCorrectionModule) retVal["patPFMETsZllRecoilCorrectionModuleName"] = patPFMETsZllRecoilCorrectionModuleName diTauProducerModule = getattr(process, diTauProducerModuleName) diTauProducerModuleZllRecoilCorrected = diTauProducerModule.clone() diTauProducerModuleZllRecoilCorrected.srcMET = cms.InputTag(patPFMETsZllRecoilCorrectionModuleName, "met") diTauProducerModuleZllRecoilCorrected.srcReRecoDiTauObjects = cms.InputTag(diTauProducerModuleName) diTauProducerModuleZllRecoilCorrected.srcReRecoDiTauToMEtAssociations = cms.InputTag( patPFMETsZllRecoilCorrectionModuleName, "diTauToMEtAssociations" ) retVal["diTauProducerModuleZllRecoilCorrected"] = diTauProducerModuleZllRecoilCorrected diTauProducerModuleZllRecoilCorrectedName = composeModuleName( [diTauProducerModuleName, "ZllRecoilCorrected", label] ) setattr(process, diTauProducerModuleZllRecoilCorrectedName, diTauProducerModuleZllRecoilCorrected) retVal["diTauProducerModuleZllRecoilCorrectedName"] = diTauProducerModuleZllRecoilCorrectedName patPFMETsZllRecoilCorrectionSequence = cms.Sequence( patPFMETsZllRecoilCorrectionModule * diTauProducerModuleZllRecoilCorrected ) retVal["patPFMETsZllRecoilCorrectionSequence"] = patPFMETsZllRecoilCorrectionSequence patPFMETsZllRecoilCorrectionSequenceName = composeModuleName( ["patPFMETsZllRecoilCorrectionSequence", diTauProducerModuleName, label] ) setattr(process, patPFMETsZllRecoilCorrectionSequenceName, patPFMETsZllRecoilCorrectionSequence) retVal["patPFMETsZllRecoilCorrectionSequenceName"] = patPFMETsZllRecoilCorrectionSequenceName return retVal
def _addModule(self, objProdItem, sysName, sysAttributes, pyNameSpace = None, process = None): # create module moduleType = objProdItem.type_() module = cms.EDProducer(moduleType) # set module attributes # to default values for objProdAttrName in dir(objProdItem): objProdAttr = getattr(objProdItem, objProdAttrName) if isinstance(objProdAttr, cms._ParameterTypeBase) and not objProdAttrName in [ "pluginName", "pluginType" ]: if isinstance(objProdAttr, cms.PSet): # CV: need to clone configuration parameters of type cms.PSet,... # in order to avoid that recursiveSetAttr function # overwrites objProd "template" object passed to objProdConfigurator constructor !! setattr(module, objProdAttrName, objProdAttr.clone()) else: setattr(module, objProdAttrName, objProdAttr) # set names of source collections # to objects shifted in energy/transverse momentum, theta, phi... for sysAttrName, sysAttrValue in sysAttributes.items(): recursiveSetAttr(module, sysAttrName, sysAttrValue) moduleName = composeModuleName([ getInstanceName(objProdItem, pyNameSpace, process), sysName ]) module.setLabel(moduleName) # if process object exists, attach module to process object; # else register module in global python name-space if process is not None: setattr(process, moduleName, module) else: pyModule = sys.modules[self.pyModuleName[0]] if pyModule is None: raise ValueError("'pyModuleName' Parameter invalid !!") setattr(pyModule, moduleName, module) # add module to sequence if self.sequence == None: self.sequence = module else: self.sequence *= module
def _addModule(self, objProdItem, sysName, sysAttributes, pyNameSpace = None, process = None): # create module moduleType = objProdItem.type_() module = cms.EDProducer(moduleType) # set module attributes # to default values for objProdAttrName in dir(objProdItem): objProdAttr = getattr(objProdItem, objProdAttrName) if isinstance(objProdAttr, cms._ParameterTypeBase) and not objProdAttrName in [ "pluginName", "pluginType" ]: if isinstance(objProdAttr, cms.PSet): # CV: need to clone configuration parameters of type cms.PSet,... # in order to avoid that recursiveSetAttr function # overwrites objProd "template" object passed to objProdConfigurator constructor !! setattr(module, objProdAttrName, objProdAttr.clone()) else: setattr(module, objProdAttrName, objProdAttr) # set names of source collections # to objects shifted in energy/transverse momentum, theta, phi... for sysAttrName, sysAttrValue in sysAttributes.items(): recursiveSetAttr(module, sysAttrName, sysAttrValue) moduleName = composeModuleName([ getInstanceName(objProdItem, pyNameSpace, process), sysName ]) #print "moduleName = %s" % moduleName module.setLabel(moduleName) # if process object exists, attach module to process object; # else register module in global python name-space if process is not None: setattr(process, moduleName, module) else: pyModule = sys.modules[self.pyModuleName[0]] if pyModule is None: raise ValueError("'pyModuleName' Parameter invalid !!") setattr(pyModule, moduleName, module) # add module to sequence self.sequence += module
def configurePatTupleProductionTauIdEffMeasSpecific( process, patSequenceBuilder=buildGenericTauSequence, hltProcess="HLT", isMC=False, isEmbedded=False, runSVfit=False): # check that patSequenceBuilder and patTauCleanerPrototype are defined and non-null if patSequenceBuilder is None: raise ValueError("Undefined 'patSequenceBuilder' Parameter !!") #-------------------------------------------------------------------------------- # produce "basic" PAT objects #-------------------------------------------------------------------------------- process.load("PhysicsTools.PatAlgos.cleaningLayer1.tauCleaner_cfi") patCaloTauCleanerPrototype = process.cleanPatTaus.clone( preselection=cms.string(''), checkOverlaps=cms.PSet(), finalCut=cms.string( 'caloTauTagInfoRef().jetRef().pt() > 5 & abs(caloTauTagInfoRef().jetRef().eta()) < 2.5' )) patPFTauCleanerPrototype = process.cleanPatTaus.clone( preselection=cms.string(''), checkOverlaps=cms.PSet(), finalCut=cms.string( 'pfJetRef().pt() > 5 & abs(pfJetRef().eta()) < 2.5')) patTupleConfig = configurePatTupleProduction(process, patSequenceBuilder, patPFTauCleanerPrototype, patCaloTauCleanerPrototype, True, hltProcess, isMC, False) if isMC: addJetCollection( process, cms.InputTag('smearedAK5PFJets'), 'SmearedAK5', 'PF', doJTA=False, doBTagging=True, jetCorrLabel= None, # CV: jet corrections already applied on reco::PFJet input doType1MET=False, genJetCollection=cms.InputTag("ak5GenJets"), doJetID=True, jetIdLabel="ak5", outputModules=[]) else: addJetCollection( process, cms.InputTag('calibratedAK5PFJets'), 'CalibratedAK5', 'PF', doJTA=False, doBTagging=True, jetCorrLabel= None, # CV: jet corrections already applied on reco::PFJet input doType1MET=False, doJetID=True, jetIdLabel="ak5", outputModules=[]) # add "raw" (uncorrected) CaloMET, # needed to parametrize efficiency turn-on of HLT_IsoMu15_L1ETM20 cross-trigger process.patCaloMet = process.patMETs.clone( metSource=cms.InputTag('met'), addMuonCorrections=cms.bool(False)) process.patCaloMetNoHF = process.patMETs.clone( metSource=cms.InputTag('metNoHF'), addMuonCorrections=cms.bool(False)) process.producePatTupleTauIdEffMeasSpecific = cms.Sequence( process.patTupleProductionSequence + process.caloTauSequence # store TaNC inputs as discriminators #+ process.produceTancMVAInputDiscriminators #+ process.pfTauSequenceFixedCone #+ process.pfTauSequenceShrinkingCone + process.pfTauSequenceHPS + process.pfTauSequenceHPSpTaNC + process.patCaloMet + process.patCaloMetNoHF) #-------------------------------------------------------------------------------- # select "the" primary event Vertex #-------------------------------------------------------------------------------- process.load("TauAnalysis.RecoTools.recoVertexSelection_cff") process.producePatTupleTauIdEffMeasSpecific += process.selectPrimaryVertex #-------------------------------------------------------------------------------- # produce collections of "global" and "stand-alone" Muons for di-Muon veto #-------------------------------------------------------------------------------- process.selectedPatMuonsLoose = cms.EDFilter( "PATMuonSelector", src=cms.InputTag('patMuons'), cut=cms.string( '(isGlobalMuon() | isStandAloneMuon() | isTrackerMuon()) & pt > 5.0' ), filter=cms.bool(False)) process.producePatTupleTauIdEffMeasSpecific += process.selectedPatMuonsLoose #-------------------------------------------------------------------------------- # define Muon momentum scale corrections #-------------------------------------------------------------------------------- process.load("TauAnalysis.RecoTools.patMuonMomentumCorrection_cfi") if isMC: process.poolDBESSourceMuScleFitCentralValue.toGet[0].tag = cms.string( 'MuScleFit_Scale_Z_MC_Startup_innerTrack') else: process.poolDBESSourceMuScleFitCentralValue.toGet[0].tag = cms.string( 'MuScleFit_Scale_Z_36_invPb_innerTrack_Dec22_v1') process.patMuonsMuScleFitCorrectedMomentum.MuonLabel = cms.InputTag( 'selectedPatMuonsVBTFid') # CV: MuScleFit muon momentum corrections do not work in CMSSW_5_2_x (May 4th 2012) ##process.producePatTupleTauIdEffMeasSpecific += process.patMuonsMuScleFitCorrectedMomentum ##process.load("TauAnalysis.RecoTools.patLeptonSystematics_cff") ##process.patMuonsMuScleFitCorrectedMomentumShiftUp.MuonLabel = process.patMuonsMuScleFitCorrectedMomentum.MuonLabel ##process.patMuonsMuScleFitCorrectedMomentumShiftDown.MuonLabel = process.patMuonsMuScleFitCorrectedMomentum.MuonLabel ##process.producePatTupleTauIdEffMeasSpecific += process.patMuonsMuScleFitCorrectedMomentumShiftUp ##process.producePatTupleTauIdEffMeasSpecific += process.patMuonsMuScleFitCorrectedMomentumShiftDown #-------------------------------------------------------------------------------- # define Muon selection #-------------------------------------------------------------------------------- process.selectedPatMuonsForTauIdEffPFRelIso = cms.EDFilter("PATMuonSelector", cut = cms.string( '(userIsolation("pat::User1Iso")' + \ ' + max(0., userIsolation("pat::PfNeutralHadronIso") + userIsolation("pat::PfGammaIso")' + \ ' - 0.5*userIsolation("pat::User2Iso"))) < 0.50*pt' ), filter = cms.bool(False) ) patMuonSelConfiguratorForTauIdEff = objSelConfigurator( [process.selectedPatMuonsForTauIdEffPFRelIso], # CV: MuScleFit muon momentum corrections do not work in CMSSW_5_2_x (May 4th 2012) #src = "patMuonsMuScleFitCorrectedMomentum", src="selectedPatMuonsVBTFid", pyModuleName=__name__, doSelIndividual=False) setattr(patMuonSelConfiguratorForTauIdEff, "systematics", muonSystematics) process.selectPatMuonsForTauIdEff = patMuonSelConfiguratorForTauIdEff.configure( process=process) process.producePatTupleTauIdEffMeasSpecific += process.selectPatMuonsForTauIdEff #-------------------------------------------------------------------------------- # define Muon selection for di-Muon veto #-------------------------------------------------------------------------------- process.selectedPatMuonsForTauIdEffZmumuHypotheses = cms.EDFilter( "PATMuonSelector", src=cms.InputTag("patMuons"), cut=cms.string( 'isGlobalMuon() | isTrackerMuon() | isStandAloneMuon()'), filter=cms.bool(False)) process.allDiMuPairForTauIdEffZmumuHypotheses = cms.EDProducer( "PATDiMuPairProducer", useLeadingTausOnly=cms.bool(False), srcLeg1=cms.InputTag( composeModuleName( ['selectedPatMuonsForTauIdEffPFRelIso', "cumulative"])), srcLeg2=cms.InputTag('selectedPatMuonsForTauIdEffZmumuHypotheses'), dRmin12=cms.double(0.01), srcMET=cms.InputTag(''), recoMode=cms.string(""), verbosity=cms.untracked.int32(0)) process.selectedDiMuPairForTauIdEffZmumuHypotheses = cms.EDFilter( "PATDiMuPairSelector", src=cms.InputTag("allDiMuPairForTauIdEffZmumuHypotheses"), cut=cms.string('charge = 0'), filter=cms.bool(False)) process.produceDiMuPairsForTauIdEff = cms.Sequence( process.selectedPatMuonsForTauIdEffZmumuHypotheses * process.allDiMuPairForTauIdEffZmumuHypotheses * process.selectedDiMuPairForTauIdEffZmumuHypotheses) process.producePatTupleTauIdEffMeasSpecific += process.produceDiMuPairsForTauIdEff #-------------------------------------------------------------------------------- # define Electron selection (needed for pat::Jet overlap removal) #-------------------------------------------------------------------------------- process.load("TauAnalysis/RecoTools/patLeptonSelection_cff") process.producePatTupleTauIdEffMeasSpecific += process.selectPatElectrons #-------------------------------------------------------------------------------- # define Jet energy scale corrections #-------------------------------------------------------------------------------- process.load("TauAnalysis.RecoTools.patJetSystematics_cff") # CV: shift jet energy by 3 standard-deviations, # so that template morphing remains an interpolation and no extrapolation is needed setattr(process.patJetsJECshiftUp, "varyByNsigmas", cms.double(3.0)) setattr(process.patJetsJECshiftDown, "varyByNsigmas", cms.double(3.0)) process.producePatTupleTauIdEffMeasSpecific += process.prodSmearedJets #-------------------------------------------------------------------------------- # produce collections of Tau-Jets and of Muon + Tau-jet candidate pairs #-------------------------------------------------------------------------------- # CV: do not run SVFit and PFMetSignificance algorithms, # as they use a significant amount of time (2011/05/27) #retVal_pfTauFixedCone = \ # buildSequenceTauIdEffMeasSpecific(process, # 'selectedPatMuonsForTauIdEffPFRelIso', # [ "PFTau", "FixedCone" ], patTupleConfig["pfTauCollectionFixedCone"], False, # None, # 'patType1CorrectedPFMet', # isMC = isMC, isEmbedded = isEmbedded, # runSVfit = False) #process.producePatTupleTauIdEffMeasSpecific += retVal_pfTauFixedCone["sequence"] #retVal_pfTauShrinkingCone = \ # buildSequenceTauIdEffMeasSpecific(process, # 'selectedPatMuonsForTauIdEffPFRelIso', # [ "PFTau", "ShrinkingCone" ], patTupleConfig["pfTauCollectionShrinkingCone"], False, # None, # 'patType1CorrectedPFMet', # isMC = isMC, isEmbedded = isEmbedded, # runSVfit = False) #process.producePatTupleTauIdEffMeasSpecific += retVal_pfTauShrinkingCone["sequence"] # CV: save HPS taus passing the following tau id. discriminators # for measurement of tau charge misidentification rate savePFTauHPS = \ "pt > 15.0 & abs(eta) < 2.5 & " \ + "tauID('decayModeFinding') > 0.5 & " \ + "(tauID('byLooseIsolation') > 0.5 |" \ + " tauID('byLooseIsolationDeltaBetaCorr') > 0.5 |" \ + " tauID('byLooseCombinedIsolationDeltaBetaCorr') > 0.5) & " \ + "tauID('againstElectronLoose') > 0.5 & " \ + "tauID('againstMuonTight') > 0.5" retVal_pfTauHPS = \ buildSequenceTauIdEffMeasSpecific(process, 'selectedPatMuonsForTauIdEffPFRelIso', [ "PFTau", "HPS" ], patTupleConfig["pfTauCollectionHPS"], True, savePFTauHPS, 'patType1CorrectedPFMet', isMC = isMC, isEmbedded = isEmbedded, runSVfit = runSVfit) process.producePatTupleTauIdEffMeasSpecific += retVal_pfTauHPS["sequence"] # CV: save HPS+TaNC taus passing the following tau id. discriminators # for measurement of tau charge misidentification rate #savePFTauHPSpTaNC = \ # "pt > 15.0 & abs(eta) < 2.5 & " \ # + "tauID('leadingTrackFinding') > 0.5 & " \ # + "tauID('byTaNCloose') > 0.5 & " \ # + "tauID('againstElectronLoose') > 0.5 & " \ # + "tauID('againstMuonTight') > 0.5" #retVal_pfTauHPSpTaNC = \ # buildSequenceTauIdEffMeasSpecific(process, # 'selectedPatMuonsForTauIdEffPFRelIso', # [ "PFTau", "HPSpTaNC" ], patTupleConfig["pfTauCollectionHPSpTaNC"], True, # savePFTauHPSpTaNC, # 'patType1CorrectedPFMet', # isMC = isMC, isEmbedded = isEmbedded, # runSVfit = runSVfit) #process.producePatTupleTauIdEffMeasSpecific += retVal_pfTauHPSpTaNC["sequence"] retVal = {} #retVal["pfTauFixedCone"] = retVal_pfTauFixedCone #retVal["pfTauShrinkingCone"] = retVal_pfTauShrinkingCone retVal["pfTauHPS"] = retVal_pfTauHPS #retVal["pfTauHPSpTaNC"] = retVal_pfTauHPSpTaNC retVal["algorithms"] = [ #"pfTauFixedCone", #"pfTauShrinkingCone", "pfTauHPS", #"pfTauHPSpTaNC" ] return retVal
def produceTauIdEffMeasPATTuple(process, isMC, isEmbedded, HLTprocessName, pfCandidateCollection, runSVfit): # produce PAT objects common between PAT-tuple and Ntuple production produceTauIdEffMeasPATTuple_base(process, isMC, isEmbedded, HLTprocessName, pfCandidateCollection, runSVfit) #-------------------------------------------------------------------------------- # # CV: add (new) SVfit algorithm; # for speed reasons, run SVfit in 'fit' mode only # (using combination of PS + MET likelihoods + logM regularization term # to reconstruct mass of tau lepton pair, as described in CMS AN-11-165) # muTauPairProducers = [ #"allMuPFTauHPSpairsForTauIdEff", #"allMuPFTauHPSpairsForTauIdEffSysJetEnUp", #"allMuPFTauHPSpairsForTauIdEffSysJetEnDown", #"allMuPFTauHPSpairsForTauIdEffSysTauJetEnUp", #"allMuPFTauHPSpairsForTauIdEffSysTauJetEnDown", #"allMuPFTauHPSpTaNCpairsForTauIdEff", #"allMuPFTauHPSpTaNCpairsForTauIdEffSysJetEnUp", #"allMuPFTauHPSpTaNCpairsForTauIdEffSysJetEnDown", #"allMuPFTauHPSpTaNCpairsForTauIdEffSysTauJetEnUp", #"allMuPFTauHPSpTaNCpairsForTauIdEffSysTauJetEnDown" ] for muTauPairProducer in muTauPairProducers: muTauPairProducerModule = getattr(process, muTauPairProducer) muTauPairProducerModule.doSVreco = cms.bool(True) muTauPairProducerModule.nSVfit = cms.PSet() muTauPairProducerModule.nSVfit.psKine_MEt_logM_fit = cms.PSet() muTauPairProducerModule.nSVfit.psKine_MEt_logM_fit.config = copy.deepcopy(process.nSVfitConfig_template) muTauPairProducerModule.nSVfit.psKine_MEt_logM_fit.config.event.resonances.A.daughters.leg1 = cms.PSet( src = muTauPairProducerModule.srcLeg1, likelihoodFunctions = cms.VPSet(process.nSVfitMuonLikelihoodPhaseSpace), builder = process.nSVfitTauToMuBuilder ) muTauPairProducerModule.nSVfit.psKine_MEt_logM_fit.config.event.resonances.A.daughters.leg2 = cms.PSet( src = muTauPairProducerModule.srcLeg2, likelihoodFunctions = cms.VPSet(process.nSVfitTauLikelihoodPhaseSpace), builder = process.nSVfitTauToHadBuilder ) muTauPairProducerModule.nSVfit.psKine_MEt_logM_fit.algorithm = cms.PSet( pluginName = cms.string("nSVfitAlgorithmByLikelihoodMaximization"), pluginType = cms.string("NSVfitAlgorithmByLikelihoodMaximization"), minimizer = cms.vstring("Minuit2", "Migrad"), maxObjFunctionCalls = cms.uint32(5000), verbosity = cms.int32(0) ) muTauPairProducerModule.doPFMEtSign = cms.bool(True) pfJetCollection = 'selectedPatJetsAK5PFAntiOverlapWithMuonsVeto' if isMC: pfJetCollection = 'selectedPatJetsAK5PFsmearedAntiOverlapWithMuonsVeto' muTauPairProducerModule.pfMEtSign = cms.PSet( srcPFJets = cms.InputTag(pfJetCollection), srcPFCandidates = cms.InputTag('particleFlow'), resolution = process.METSignificance_params, dRoverlapPFJet = cms.double(0.3), dRoverlapPFCandidate = cms.double(0.1) ) #-------------------------------------------------------------------------------- #------------------------------------------------------------------------------------------------------------------------- # # add Data to Monte-Carlo correction factors # (simple doubles) # if isMC: # add Data/MC correction factor for muon trigger efficiency process.muonTriggerEfficiencyCorrection = cms.EDProducer("PATMuonEfficiencyCorrectionProducer", inputFileName = cms.FileInPath("TauAnalysis/TauIdEfficiency/data/singleMuHLTeff.root"), lutName = cms.string('hEff'), parametrization = cms.PSet( src = cms.VInputTag(composeModuleName(['selectedPatMuonsForTauIdEffPFRelIso', "cumulative"])), x = cms.string("eta()"), y = cms.string("pt()"), z = cms.string("0.") ), noObjectSubstituteValue = cms.double(0.) # weight returned in case all 'src' collections do not contain any entries ) process.producePatTupleTauIdEffMeasSpecific += process.muonTriggerEfficiencyCorrection # add reweighting factors (rho-Neutral correction) # to correct for Data/MC differences in modeling out-out-time pile-up process.load("TauAnalysis.RecoTools.vertexMultiplicityVsRhoPFNeutralReweight_cfi") process.producePatTupleTauIdEffMeasSpecific += process.produceVertexMultiplicityVsRhoPFNeutralReweights #------------------------------------------------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # add event counter for Mauro's "self baby-sitting" technology process.processedEventsPATtupleProduction = cms.EDProducer("EventCountProducer") process.eventCounterPath = cms.Path(process.processedEventsPATtupleProduction) #-------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # # save PAT-tuple # process.patTupleOutputModule = cms.OutputModule("PoolOutputModule", cms.PSet( outputCommands = cms.untracked.vstring( 'drop *', 'keep EventAux_*_*_*', 'keep LumiSummary_*_*_*', 'keep edmMergeableCounter_*_*_*', 'keep *_gtDigis_*_*', 'keep *_hltL1GtObjectMap_*_*', 'keep *_TriggerResults_*_*', 'keep *_selectedPatMuonsForTauIdEffPFRelIsoCumulative_*_*', 'keep *_selectedPatMuonsForTauIdEffZmumuHypotheses_*_*', 'keep *_selectedDiMuPairForTauIdEffZmumuHypotheses_*_*', 'keep *_patJetsSmearedAK5PF_*_*', 'keep *_patJetsCalibratedAK5PF_*_*', #'keep *_selectedPatPFTausFixedConeForTauIdEff*_*_*', #'keep *_selectedPatPFTausShrinkingConeForTauIdEff*_*_*', 'keep *_selectedPatPFTausHPSforTauIdEff*_*_*', #'keep *_selectedPatPFTausHPSpTaNCforTauIdEff*_*_*', #'keep *_selectedMuPFTauFixedConePairsDzForTauIdEff*_*_*', #'keep *_selectedMuPFTauShrinkingConePairsDzForTauIdEff*_*_*', 'keep *_selectedMuPFTauHPSpairsDzForTauIdEff*_*_*', #'keep *_selectedMuPFTauHPSpTaNCpairsDzForTauIdEff*_*_*', 'keep *_offlinePrimaryVertices_*_*', 'keep *_offlinePrimaryVerticesWithBS_*_*', 'keep *_selectedPrimaryVertexHighestPtTrackSum_*_*', # keep CaloMEt objects 'keep *_patCaloMet*_*_*', # keep PFMEt objects 'keep *_patPFMet*_*_*', 'keep *_patType1CorrectedPFMet*_*_*', # CV: additional collections needed to run nSVfit algorithm #'keep recoTracks_generalTracks_*_*', #'keep *_ak5PFJets_*_*', #'keep *_particleFlow_*_*' ) ), process.tauIdEffSampleEventSelection, fileName = cms.untracked.string("tauIdEffMeasPATtuple.root") ) process.patTupleOutputModule.outputCommands.extend(patTriggerEventContent) if isMC: process.patTupleOutputModule.outputCommands.extend( cms.untracked.vstring( 'keep *_smearedPatJetsAK5PF*_*_*', 'keep *_muonTriggerEfficiencyCorrection_*_*', 'keep *_vertexMultiplicityReweight*_*_*', 'keep *_vertexMultiplicityReweight*_*_*', 'keep *_vertexMultiplicityVsRhoPFNeutralReweight_*_*', 'keep *_addPileupInfo_*_*', 'keep *_genParticles_*_*', 'keep *_tauGenJets_*_*', 'keep *_tauGenJetsSelectorAllHadrons_*_*', 'keep *_genMetTrue_*_*', # CV: additional collections needed to run nSVfit algorithm #'keep *_smearedAK5PFJets_*_*' ) ) #-------------------------------------------------------------------------------- process.printEventContent = cms.EDAnalyzer("EventContentAnalyzer") process.p = cms.Path( process.prePatProductionSequence + process.producePatTupleTauIdEffMeasSpecific ##+ process.printEventContent ) process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(True) ) process.o = cms.EndPath(process.patTupleOutputModule) #-------------------------------------------------------------------------------- # # CV: keep Z --> tau+ tau- --> muon + tau-jet events # passing Pt and eta cuts on generator level # (for studying preselection efficiencies) # if isMC: process.load('PhysicsTools.JetMCAlgos.TauGenJets_cfi') process.load('TauAnalysis.GenSimTools.gen_decaysFromZs_cfi') process.genMuonWithinAccFilter = cms.EDFilter("PATCandViewCountFilter", src = cms.InputTag('genMuonsFromZtautauDecaysWithinAcceptance'), minNumber = cms.uint32(1), maxNumber = cms.uint32(1000) ) process.genHadTauWithinAccFilter = cms.EDFilter("PATCandViewCountFilter", src = cms.InputTag('genHadronsFromZtautauDecaysWithinAcceptance'), minNumber = cms.uint32(1), maxNumber = cms.uint32(1000) ) process.genZtoMuTauWithinAccSkimPath = cms.Path( process.tauGenJets + process.produceGenDecayProductsFromZs + process.genMuonWithinAccFilter + process.genHadTauWithinAccFilter ) extSkimPaths = process.patTupleOutputModule.SelectEvents.SelectEvents.value() extSkimPaths.append('genZtoMuTauWithinAccSkimPath') process.patTupleOutputModule.SelectEvents.SelectEvents = cms.vstring(extSkimPaths) #-------------------------------------------------------------------------------- # define order in which different paths are run if isMC: process.schedule = cms.Schedule( process.p, #process.muonPFTauFixedConeSkimPath, #process.muonPFTauShrinkingConeSkimPath, process.muonPFTauHPSskimPath, #process.muonPFTauHPSpTaNCskimPath, process.genZtoMuTauWithinAccSkimPath, process.o ) else: process.schedule = cms.Schedule( process.p, #process.muonPFTauFixedConeSkimPath, #process.muonPFTauShrinkingConeSkimPath, process.muonPFTauHPSskimPath, #process.muonPFTauHPSpTaNCskimPath, process.o )
def buildConfigFile_FWLiteTauIdEffAnalyzer(sampleToAnalyze, jobId, inputFilePath, fwliteInput_firstRun, fwliteInput_lastRun, tauIds, binning, sysUncertainties, outputFilePath, recoSampleDefinitions, regions, intLumiData, hltPaths, srcWeights, tauChargeMode, disableTauCandPreselCuts, muonPtMin, tauLeadTrackPtMin, tauAbsIsoMax, caloMEtPtMin, pfMEtPtMin, plot_hltPaths, fillControlPlots, requireUniqueMuTauPair=False): """Build cfg.py file to run FWLiteTauIdEffAnalyzer macro to run on PAT-tuples, apply event selections and fill histograms for A/B/C/D regions""" print "<buildConfigFile_FWLiteTauIdEffAnalyzer>:" print " processing sample %s" % sampleToAnalyze # CV: check that tauChargeMode parameter matches either of the modes # define in TauAnalysis/TauIdEfficiency/src/TauIdEffEventSelector.cc if not (tauChargeMode == "tauLeadTrackCharge" or tauChargeMode == "tauSignalChargedHadronSum"): raise ValueError( "Invalid configuration parameter 'tauChargeMode' = %s !!" % tauChargeMode) disableTauCandPreselCuts_string = getStringRep_bool( disableTauCandPreselCuts) inputFileNames = os.listdir(inputFilePath) #print(inputFileNames) # check if inputFile is PAT-tuple and # matches sampleToAnalyze, jobId inputFile_regex = \ r"tauIdEffMeasPATTuple_%s_%s_(?P<hash>[a-zA-Z0-9]*).root" % (sampleToAnalyze, jobId) inputFileNames_sample = [] fwliteInput_fileNames = "" for inputFileName in inputFileNames: inputFile_matcher = re.compile(inputFile_regex) if inputFile_matcher.match(inputFileName): inputFileNames_sample.append( os.path.join(inputFilePath, inputFileName)) fwliteInput_fileNames += "process.fwliteInput.fileNames.append('%s')\n" % os.path.join( inputFilePath, inputFileName) print " found %i input files." % len(inputFileNames_sample) if len(inputFileNames_sample) == 0: print("Sample %s has no input files --> skipping !!" % sampleToAnalyze) return # find name of associated "process" process_matched = None processes = recoSampleDefinitions['MERGE_SAMPLES'].keys() for process in processes: process_samples = [] if 'samples' in recoSampleDefinitions['MERGE_SAMPLES'][process].keys(): process_samples = recoSampleDefinitions['MERGE_SAMPLES'][process][ 'samples'] else: process_samples.append(process) for sample in process_samples: if sample == sampleToAnalyze: process_matched = process if process_matched and process_matched.startswith('Data'): process_matched = 'Data' print("sample = %s: process_matched = %s" % (sampleToAnalyze, process_matched)) if not process_matched: print("No process associated to sample %s --> skipping !!" % sampleToAnalyze) return print(" building config file...") processType = recoSampleDefinitions['RECO_SAMPLES'][sampleToAnalyze][ 'type'] regions_string = make_inputFileNames_vstring(regions) sysUncertainties_expanded = ["CENTRAL_VALUE"] if processType != 'Data': for sysUncertainty in sysUncertainties: sysUncertainties_expanded.append(sysUncertainty + "Up") sysUncertainties_expanded.append(sysUncertainty + "Down") print " sysUncertainties = %s" % sysUncertainties_expanded tauIds_string = make_tauIds_string(tauIds) binning_string = make_binning_string(binning) hltPaths_string = make_inputFileNames_vstring(hltPaths[processType]) plot_hltPaths_string = make_inputFileNames_vstring(plot_hltPaths) weights_string = make_inputFileNames_vstring(srcWeights[processType]) srcGenParticles = '' fillGenMatchHistograms = False if processType != 'Data' and \ (process_matched.find('Ztautau') != -1 or process_matched.find('Zmumu') != -1 or process_matched.find('ZplusJets') != -1 or process_matched.find('WplusJets') != -1): srcGenParticles = 'genParticles' fillGenMatchHistograms = True configFileNames = [] outputFileNames = [] logFileNames = [] for sysUncertainty in sysUncertainties_expanded: outputFileName = None if sysUncertainty != "CENTRAL_VALUE": outputFileName = 'analyzeTauIdEffHistograms_%s_%s_%s.root' % ( sampleToAnalyze, sysUncertainty, jobId) else: outputFileName = 'analyzeTauIdEffHistograms_%s_%s.root' % ( sampleToAnalyze, jobId) outputFileName_full = os.path.join(outputFilePath, outputFileName) srcMuTauPairs = 'selectedMuPFTauHPSpairsDzForTauIdEff' if sysUncertainty not in [ "CENTRAL_VALUE", "CaloMEtResponseUp", "CaloMEtResponseDown" ]: srcMuTauPairs = composeModuleName( [srcMuTauPairs, sysUncertainty, "cumulative"]) else: srcMuTauPairs = composeModuleName([srcMuTauPairs, "cumulative"]) srcJets = None if not processType == 'Data': srcJets = 'patJetsSmearedAK5PF' else: srcJets = 'patJetsCalibratedAK5PF' allEvents_DBS = -1 xSection = 0.0 if not processType == 'Data': allEvents_DBS = recoSampleDefinitions['RECO_SAMPLES'][ sampleToAnalyze]['events_processed'] xSection = recoSampleDefinitions['RECO_SAMPLES'][sampleToAnalyze][ 'x_sec'] config = \ """ import FWCore.ParameterSet.Config as cms process = cms.PSet() process.fwliteInput = cms.PSet( fileNames = cms.vstring(), firstRun = cms.int32(%i), lastRun = cms.int32(%i), maxEvents = cms.int32(-1), outputEvery = cms.uint32(1000) ) %s process.fwliteOutput = cms.PSet( fileName = cms.string('%s') ) process.tauIdEffAnalyzer = cms.PSet( process = cms.string('%s'), type = cms.string('%s'), regions = cms.vstring( %s ), tauIds = cms.VPSet( %s ), binning = cms.PSet( %s ), sysShift = cms.string('%s'), srcHLTresults = cms.InputTag('TriggerResults::HLT'), hltPaths = cms.vstring(%s), srcGoodMuons = cms.InputTag('selectedPatMuonsForTauIdEffPFRelIsoCumulative'), srcMuTauPairs = cms.InputTag('%s'), requireUniqueMuTauPair = cms.bool(%s), srcCaloMEt = cms.InputTag('patCaloMetNoHF'), srcJets = cms.InputTag('%s'), #svFitMassHypothesis = cms.string('psKine_MEt_logM_fit'), svFitMassHypothesis = cms.string('psKine_MEt_int'), tauChargeMode = cms.string('%s'), disableTauCandPreselCuts = cms.bool(%s), eventSelCuts = cms.PSet( muonPtMin = cms.double(%f), tauLeadTrackPtMin = cms.double(%f), tauAbsIsoMax = cms.double(%f), caloMEtPtMin = cms.double(%f), pfMEtPtMin = cms.double(%f) ), srcVertices = cms.InputTag('offlinePrimaryVertices'), srcGenParticles = cms.InputTag('%s'), fillGenMatchHistograms = cms.bool(%s), skipPdgIdsGenParticleMatch = cms.vint32(12, 14, 16), plot_hltPaths = cms.vstring(%s), weights = cms.VInputTag(%s), # CV: restrict event weights to avoid problem with too low Monte Carlo event statistics # and large pile-up reweighting factors in Spring'12 MC production minWeight = cms.double(0.), maxWeight = cms.double(3.), muonIsoProbExtractor = cms.PSet( inputFileName = cms.FileInPath('TauAnalysis/TauIdEfficiency/data_nocrab/train_kNNmuonIsolation_kNN.weights.xml'), parametrization = cms.VPSet( cms.PSet( name = cms.string('logMuonPt'), expression = cms.string('log(pt)') ), cms.PSet( name = cms.string('absMuonEta'), expression = cms.string('abs(eta)') ) ), selection = cms.string( '(userIsolation("pat::User1Iso")' + \ ' + max(0., userIsolation("pat::PfNeutralHadronIso") + userIsolation("pat::PfGammaIso")' + \ ' - 0.5*userIsolation("pat::User2Iso"))) > 0.20*pt' ) ), #applyMuonIsoWeights = cms.bool(False), applyMuonIsoWeights = cms.bool(True), # CV: only book histograms needed to run tau id. efficiency fit; # drop all control plots fillControlPlots = cms.bool(%s), # CV: 'srcEventCounter' is defined in TauAnalysis/Skimming/test/skimTauIdEffSample_cfg.py srcEventCounter = cms.InputTag('processedEventsSkimming'), allEvents_DBS = cms.int32(%i), xSection = cms.double(%f), intLumiData = cms.double(%f), srcLumiProducer = cms.InputTag('lumiProducer') ) """ % (fwliteInput_firstRun, fwliteInput_lastRun, fwliteInput_fileNames, outputFileName_full, process_matched, processType, regions_string, tauIds_string, binning_string, sysUncertainty, hltPaths_string, srcMuTauPairs, getStringRep_bool(requireUniqueMuTauPair), srcJets, tauChargeMode, disableTauCandPreselCuts_string, muonPtMin, tauLeadTrackPtMin, tauAbsIsoMax, caloMEtPtMin, pfMEtPtMin, srcGenParticles, getStringRep_bool(fillGenMatchHistograms), plot_hltPaths_string, weights_string, getStringRep_bool(fillControlPlots), allEvents_DBS, xSection, intLumiData) outputFileNames.append(outputFileName_full) configFileName = None if sysUncertainty != "CENTRAL_VALUE": configFileName = "analyzeTauIdEffPATtuple_%s_%s_%s_cfg.py" % ( sampleToAnalyze, sysUncertainty, jobId) else: configFileName = "analyzeTauIdEffPATtuple_%s_%s_cfg.py" % ( sampleToAnalyze, jobId) configFileName_full = os.path.join(outputFilePath, configFileName) configFile = open(configFileName_full, "w") configFile.write(config) configFile.close() configFileNames.append(configFileName_full) logFileName = configFileName.replace('_cfg.py', '.log') logFileName_full = os.path.join(outputFilePath, logFileName) logFileNames.append(logFileName_full) retVal = {} retVal['configFileNames'] = configFileNames retVal['outputFileNames'] = outputFileNames retVal['logFileNames'] = logFileNames return retVal
#nSVfitProducer_template = process.nSVfitProducerByIntegration nSVfitProducer_template = process.nSVfitProducerByLikelihoodMaximization for optRESnSVfitName, optRESnSVfit in nSVfitRESoptions.items(): # adjust MET likelihood to "toy" Monte Carlo resolution nSVfitEventLikelihoodMEt_customized = cms.PSet( pluginName=cms.string("nSVfitEventLikelihoodMEt"), pluginType=cms.string("NSVfitEventLikelihoodMEt"), resolution=cms.PSet(parSigma=optRESnSVfit['metResolutionX'], parBias=cms.string("0."), perpSigma=optRESnSVfit['metResolutionY'], perpBias=cms.string("0."))) setattr( process, composeModuleName( ["nSVfitEventLikelihoodMEt_customized", optRESnSVfitName]), nSVfitEventLikelihoodMEt_customized) for optLLnSVfitName, optLLnSVfit in nSVfitLLoptions.items(): nSVfitElecMuPairHypotheses = copy.deepcopy(nSVfitProducer_template) nSVfitElecMuPairHypotheses.config.event.resonances.A.daughters.leg1 = \ process.nSVfitConfig_template.event.resonances.A.daughters.leg1.clone( src = optRESnSVfit['srcElectrons'], likelihoodFunctions = cms.VPSet(process.nSVfitElectronLikelihoodPhaseSpace), builder = process.nSVfitTauToElecBuilder ) nSVfitElecMuPairHypotheses.config.event.resonances.A.daughters.leg2 = \ process.nSVfitConfig_template.event.resonances.A.daughters.leg2.clone( src = optRESnSVfit['srcMuons'], likelihoodFunctions = cms.VPSet(process.nSVfitMuonLikelihoodPhaseSpace),
def get_moduleName(name, sysName = None): moduleName_base = name if sysName is not None: moduleName_base = composeModuleName([ name, sysName ]) return composeModuleName([ moduleName_base, "Individual" ])
def get_moduleName(name, sysName=None): moduleName_base = name if sysName is not None: moduleName_base = composeModuleName([name, sysName]) return composeModuleName([moduleName_base, "Cumulative"])
def produceTauIdEffMeasPATTuple(process, isMC, isEmbedded, HLTprocessName, pfCandidateCollection, runSVfit): # produce PAT objects common between PAT-tuple and Ntuple production produceTauIdEffMeasPATTuple_base(process, isMC, isEmbedded, HLTprocessName, pfCandidateCollection, runSVfit) #-------------------------------------------------------------------------------- # # CV: add (new) SVfit algorithm; # for speed reasons, run SVfit in 'fit' mode only # (using combination of PS + MET likelihoods + logM regularization term # to reconstruct mass of tau lepton pair, as described in CMS AN-11-165) # muTauPairProducers = [ #"allMuPFTauHPSpairsForTauIdEff", #"allMuPFTauHPSpairsForTauIdEffSysJetEnUp", #"allMuPFTauHPSpairsForTauIdEffSysJetEnDown", #"allMuPFTauHPSpairsForTauIdEffSysTauJetEnUp", #"allMuPFTauHPSpairsForTauIdEffSysTauJetEnDown", #"allMuPFTauHPSpTaNCpairsForTauIdEff", #"allMuPFTauHPSpTaNCpairsForTauIdEffSysJetEnUp", #"allMuPFTauHPSpTaNCpairsForTauIdEffSysJetEnDown", #"allMuPFTauHPSpTaNCpairsForTauIdEffSysTauJetEnUp", #"allMuPFTauHPSpTaNCpairsForTauIdEffSysTauJetEnDown" ] for muTauPairProducer in muTauPairProducers: muTauPairProducerModule = getattr(process, muTauPairProducer) muTauPairProducerModule.doSVreco = cms.bool(True) muTauPairProducerModule.nSVfit = cms.PSet() muTauPairProducerModule.nSVfit.psKine_MEt_logM_fit = cms.PSet() muTauPairProducerModule.nSVfit.psKine_MEt_logM_fit.config = copy.deepcopy( process.nSVfitConfig_template) muTauPairProducerModule.nSVfit.psKine_MEt_logM_fit.config.event.resonances.A.daughters.leg1 = cms.PSet( src=muTauPairProducerModule.srcLeg1, likelihoodFunctions=cms.VPSet( process.nSVfitMuonLikelihoodPhaseSpace), builder=process.nSVfitTauToMuBuilder) muTauPairProducerModule.nSVfit.psKine_MEt_logM_fit.config.event.resonances.A.daughters.leg2 = cms.PSet( src=muTauPairProducerModule.srcLeg2, likelihoodFunctions=cms.VPSet( process.nSVfitTauLikelihoodPhaseSpace), builder=process.nSVfitTauToHadBuilder) muTauPairProducerModule.nSVfit.psKine_MEt_logM_fit.algorithm = cms.PSet( pluginName=cms.string("nSVfitAlgorithmByLikelihoodMaximization"), pluginType=cms.string("NSVfitAlgorithmByLikelihoodMaximization"), minimizer=cms.vstring("Minuit2", "Migrad"), maxObjFunctionCalls=cms.uint32(5000), verbosity=cms.int32(0)) muTauPairProducerModule.doPFMEtSign = cms.bool(True) pfJetCollection = 'selectedPatJetsAK5PFAntiOverlapWithMuonsVeto' if isMC: pfJetCollection = 'selectedPatJetsAK5PFsmearedAntiOverlapWithMuonsVeto' muTauPairProducerModule.pfMEtSign = cms.PSet( srcPFJets=cms.InputTag(pfJetCollection), srcPFCandidates=cms.InputTag('particleFlow'), resolution=process.METSignificance_params, dRoverlapPFJet=cms.double(0.3), dRoverlapPFCandidate=cms.double(0.1)) #-------------------------------------------------------------------------------- #------------------------------------------------------------------------------------------------------------------------- # # add Data to Monte-Carlo correction factors # (simple doubles) # if isMC: # add Data/MC correction factor for muon trigger efficiency process.muonTriggerEfficiencyCorrection = cms.EDProducer( "PATMuonEfficiencyCorrectionProducer", inputFileName=cms.FileInPath( "TauAnalysis/TauIdEfficiency/data/singleMuHLTeff.root"), lutName=cms.string('hEff'), parametrization=cms.PSet(src=cms.VInputTag( composeModuleName( ['selectedPatMuonsForTauIdEffPFRelIso', "cumulative"])), x=cms.string("eta()"), y=cms.string("pt()"), z=cms.string("0.")), noObjectSubstituteValue=cms.double( 0. ) # weight returned in case all 'src' collections do not contain any entries ) process.producePatTupleTauIdEffMeasSpecific += process.muonTriggerEfficiencyCorrection # add reweighting factors (rho-Neutral correction) # to correct for Data/MC differences in modeling out-out-time pile-up process.load( "TauAnalysis.RecoTools.vertexMultiplicityVsRhoPFNeutralReweight_cfi" ) process.producePatTupleTauIdEffMeasSpecific += process.produceVertexMultiplicityVsRhoPFNeutralReweights #------------------------------------------------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # add event counter for Mauro's "self baby-sitting" technology process.processedEventsPATtupleProduction = cms.EDProducer( "EventCountProducer") process.eventCounterPath = cms.Path( process.processedEventsPATtupleProduction) #-------------------------------------------------------------------------------- #-------------------------------------------------------------------------------- # # save PAT-tuple # process.patTupleOutputModule = cms.OutputModule( "PoolOutputModule", cms.PSet(outputCommands=cms.untracked.vstring( 'drop *', 'keep EventAux_*_*_*', 'keep LumiSummary_*_*_*', 'keep edmMergeableCounter_*_*_*', 'keep *_gtDigis_*_*', 'keep *_hltL1GtObjectMap_*_*', 'keep *_TriggerResults_*_*', 'keep *_selectedPatMuonsForTauIdEffPFRelIsoCumulative_*_*', 'keep *_selectedPatMuonsForTauIdEffZmumuHypotheses_*_*', 'keep *_selectedDiMuPairForTauIdEffZmumuHypotheses_*_*', 'keep *_patJetsSmearedAK5PF_*_*', 'keep *_patJetsCalibratedAK5PF_*_*', #'keep *_selectedPatPFTausFixedConeForTauIdEff*_*_*', #'keep *_selectedPatPFTausShrinkingConeForTauIdEff*_*_*', 'keep *_selectedPatPFTausHPSforTauIdEff*_*_*', #'keep *_selectedPatPFTausHPSpTaNCforTauIdEff*_*_*', #'keep *_selectedMuPFTauFixedConePairsDzForTauIdEff*_*_*', #'keep *_selectedMuPFTauShrinkingConePairsDzForTauIdEff*_*_*', 'keep *_selectedMuPFTauHPSpairsDzForTauIdEff*_*_*', #'keep *_selectedMuPFTauHPSpTaNCpairsDzForTauIdEff*_*_*', 'keep *_offlinePrimaryVertices_*_*', 'keep *_offlinePrimaryVerticesWithBS_*_*', 'keep *_selectedPrimaryVertexHighestPtTrackSum_*_*', # keep CaloMEt objects 'keep *_patCaloMet*_*_*', # keep PFMEt objects 'keep *_patPFMet*_*_*', 'keep *_patType1CorrectedPFMet*_*_*', # CV: additional collections needed to run nSVfit algorithm #'keep recoTracks_generalTracks_*_*', #'keep *_ak5PFJets_*_*', #'keep *_particleFlow_*_*' )), process.tauIdEffSampleEventSelection, fileName=cms.untracked.string("tauIdEffMeasPATtuple.root")) process.patTupleOutputModule.outputCommands.extend(patTriggerEventContent) if isMC: process.patTupleOutputModule.outputCommands.extend( cms.untracked.vstring( 'keep *_smearedPatJetsAK5PF*_*_*', 'keep *_muonTriggerEfficiencyCorrection_*_*', 'keep *_vertexMultiplicityReweight*_*_*', 'keep *_vertexMultiplicityReweight*_*_*', 'keep *_vertexMultiplicityVsRhoPFNeutralReweight_*_*', 'keep *_addPileupInfo_*_*', 'keep *_genParticles_*_*', 'keep *_tauGenJets_*_*', 'keep *_tauGenJetsSelectorAllHadrons_*_*', 'keep *_genMetTrue_*_*', # CV: additional collections needed to run nSVfit algorithm #'keep *_smearedAK5PFJets_*_*' )) #-------------------------------------------------------------------------------- process.printEventContent = cms.EDAnalyzer("EventContentAnalyzer") process.p = cms.Path(process.prePatProductionSequence + process.producePatTupleTauIdEffMeasSpecific ##+ process.printEventContent ) process.options = cms.untracked.PSet(wantSummary=cms.untracked.bool(True)) process.o = cms.EndPath(process.patTupleOutputModule) #-------------------------------------------------------------------------------- # # CV: keep Z --> tau+ tau- --> muon + tau-jet events # passing Pt and eta cuts on generator level # (for studying preselection efficiencies) # if isMC: process.load('PhysicsTools.JetMCAlgos.TauGenJets_cfi') process.load('TauAnalysis.GenSimTools.gen_decaysFromZs_cfi') process.genMuonWithinAccFilter = cms.EDFilter( "PATCandViewCountFilter", src=cms.InputTag('genMuonsFromZtautauDecaysWithinAcceptance'), minNumber=cms.uint32(1), maxNumber=cms.uint32(1000)) process.genHadTauWithinAccFilter = cms.EDFilter( "PATCandViewCountFilter", src=cms.InputTag('genHadronsFromZtautauDecaysWithinAcceptance'), minNumber=cms.uint32(1), maxNumber=cms.uint32(1000)) process.genZtoMuTauWithinAccSkimPath = cms.Path( process.tauGenJets + process.produceGenDecayProductsFromZs + process.genMuonWithinAccFilter + process.genHadTauWithinAccFilter) extSkimPaths = process.patTupleOutputModule.SelectEvents.SelectEvents.value( ) extSkimPaths.append('genZtoMuTauWithinAccSkimPath') process.patTupleOutputModule.SelectEvents.SelectEvents = cms.vstring( extSkimPaths) #-------------------------------------------------------------------------------- # define order in which different paths are run if isMC: process.schedule = cms.Schedule( process.p, #process.muonPFTauFixedConeSkimPath, #process.muonPFTauShrinkingConeSkimPath, process.muonPFTauHPSskimPath, #process.muonPFTauHPSpTaNCskimPath, process.genZtoMuTauWithinAccSkimPath, process.o) else: process.schedule = cms.Schedule( process.p, #process.muonPFTauFixedConeSkimPath, #process.muonPFTauShrinkingConeSkimPath, process.muonPFTauHPSskimPath, #process.muonPFTauHPSpTaNCskimPath, process.o)
def _addModule(self, objSelItem, srcParam, sysName = None, process = None): # create module module = cms.EDProducer(self.boolEventSelFlagProducer) # set module attributes moduleName = None if sysName is None: moduleName = objSelItem.pluginName.value() else: moduleName = composeModuleName([ objSelItem.pluginName.value(), sysName ]) module.setLabel(moduleName) selectors = [] for src_i in srcParam: assert len(src_i) == 2, "'src_i' Parameter must have exactly 2 elements !!" exclAttributeNames = [ "src", "src_cumulative", "src_individual", "systematics" ] selector = cms.PSet() for objSelAttrName in dir(objSelItem): objSelAttr = getattr(objSelItem, objSelAttrName) if isinstance(objSelAttr, cms._ParameterTypeBase) and not objSelAttrName in exclAttributeNames: setattr(selector, objSelAttrName, objSelAttr) selector_i = copy.deepcopy(selector) if sysName is None: setattr(selector_i, "src", src_i[0]) else: src_extensions = [ "Cumulative", "cumulative", "Individual", "individual" ] for src_extension in src_extensions: if src_i[0].value().endswith(src_extension): src_iBase = src_i[0].value()[:src_i[0].value().rindex(src_extension)] src_iExt = src_extension setattr(selector_i, "src", cms.InputTag(composeModuleName([ src_iBase, sysName, src_iExt ]))) if not hasattr(selector_i, "src"): setattr(selector_i, "src", cms.InputTag(composeModuleName([ src_i[0].value(), sysName ]))) if src_i[1] is not None: setattr(selector_i, "instanceName", cms.string(src_i[1])) selectors.append(selector_i) setattr(module, "selectors", cms.VPSet(*selectors)) # if process object exists, attach module to process object; # else register module in global python name-space if process is not None: setattr(process, moduleName, module) else: pyModule = sys.modules[self.pyModuleName] if pyModule is None: raise ValueError("'pyModuleName' Parameter invalid !!") setattr(pyModule, moduleName, module) # add module to sequence if self.sequence == None: self.sequence = module else: self.sequence *= module
def _addModule(self, objSelItem, srcParam, sysName=None, process=None): # create module module = cms.EDProducer(self.boolEventSelFlagProducer) # set module attributes moduleName = None if sysName is None: moduleName = objSelItem.pluginName.value() else: moduleName = composeModuleName( [objSelItem.pluginName.value(), sysName]) module.setLabel(moduleName) selectors = [] for src_i in srcParam: assert len( src_i ) == 2, "'src_i' Parameter must have exactly 2 elements !!" exclAttributeNames = [ "src", "src_cumulative", "src_individual", "systematics" ] selector = cms.PSet() for objSelAttrName in dir(objSelItem): objSelAttr = getattr(objSelItem, objSelAttrName) if isinstance(objSelAttr, cms._ParameterTypeBase ) and not objSelAttrName in exclAttributeNames: setattr(selector, objSelAttrName, objSelAttr) selector_i = copy.deepcopy(selector) if sysName is None: setattr(selector_i, "src", src_i[0]) else: src_extensions = [ "Cumulative", "cumulative", "Individual", "individual" ] for src_extension in src_extensions: if src_i[0].value().endswith(src_extension): src_iBase = src_i[0].value()[:src_i[0].value(). rindex(src_extension)] src_iExt = src_extension setattr( selector_i, "src", cms.InputTag( composeModuleName( [src_iBase, sysName, src_iExt]))) if not hasattr(selector_i, "src"): setattr( selector_i, "src", cms.InputTag( composeModuleName([src_i[0].value(), sysName]))) if src_i[1] is not None: setattr(selector_i, "instanceName", cms.string(src_i[1])) selectors.append(selector_i) setattr(module, "selectors", cms.VPSet(*selectors)) # if process object exists, attach module to process object; # else register module in global python name-space if process is not None: setattr(process, moduleName, module) else: pyModule = sys.modules[self.pyModuleName] if pyModule is None: raise ValueError("'pyModuleName' Parameter invalid !!") setattr(pyModule, moduleName, module) # add module to sequence if self.sequence == None: self.sequence = module else: self.sequence *= module
def get_moduleName(name, sysName=None): moduleName_base = name if sysName is not None: moduleName_base = composeModuleName([name, sysName]) return composeModuleName([moduleName_base, "Individual"])
nSVfitProducer_template = process.nSVfitProducerByLikelihoodMaximization for optRESnSVfitName, optRESnSVfit in nSVfitRESoptions.items(): # adjust MET likelihood to "toy" Monte Carlo resolution nSVfitEventLikelihoodMEt_customized = cms.PSet( pluginName = cms.string("nSVfitEventLikelihoodMEt"), pluginType = cms.string("NSVfitEventLikelihoodMEt"), resolution = cms.PSet( parSigma = optRESnSVfit['metResolutionX'], parBias = cms.string("0."), perpSigma = optRESnSVfit['metResolutionY'], perpBias = cms.string("0.") ) ) setattr(process, composeModuleName(["nSVfitEventLikelihoodMEt_customized", optRESnSVfitName]), nSVfitEventLikelihoodMEt_customized) for optLLnSVfitName, optLLnSVfit in nSVfitLLoptions.items(): nSVfitElecMuPairHypotheses = copy.deepcopy(nSVfitProducer_template) nSVfitElecMuPairHypotheses.config.event.resonances.A.daughters.leg1 = \ process.nSVfitConfig_template.event.resonances.A.daughters.leg1.clone( src = optRESnSVfit['srcElectrons'], likelihoodFunctions = cms.VPSet(process.nSVfitElectronLikelihoodPhaseSpace), builder = process.nSVfitTauToElecBuilder ) nSVfitElecMuPairHypotheses.config.event.resonances.A.daughters.leg2 = \ process.nSVfitConfig_template.event.resonances.A.daughters.leg2.clone( src = optRESnSVfit['srcMuons'], likelihoodFunctions = cms.VPSet(process.nSVfitMuonLikelihoodPhaseSpace), builder = process.nSVfitTauToMuBuilder
def buildSequenceTauIdEffMeasSpecific(process, patMuonCollectionName = "selectedPatMuonsForTauIdEffPFRelIsoCumulative", tauIdAlgorithmName = None, patTauCollectionName = "patTaus", applyTauJEC = False, savePatTaus = None, patMEtCollectionName = "patType1CorrectedPFMet", isMC = False, isEmbedded = False, runSVfit = False): #print("<buildSequenceTauIdEffMeasSpecific>:") #print(" patTauCollectionName = %s" % patTauCollectionName) #print(" isMC = %s" % isMC) # check that tauIdAlgorithmName is defined, non-null and composed of two parts if tauIdAlgorithmName is None or len(tauIdAlgorithmName) != 2: raise ValueError("Undefined of invalid 'tauIdAlgorithmName' Parameter !!") patTauProducerName = "".join(patTauCollectionName) sequenceName = composeModuleName(["sequenceTauIdEffMeasSpecific", "".join(tauIdAlgorithmName)]) sequence = cms.Sequence() setattr(process, sequenceName, sequence) #-------------------------------------------------------------------------------- # define loose Tau-jet candidate selection #-------------------------------------------------------------------------------- patTauSelectionModules = [] process.load("TauAnalysis.RecoTools.patLeptonSelection_cff") selectedPatTausAntiOverlapWithMuonsVetoName = \ "selectedPat%ss%sAntiOverlapWithMuonsVeto" % (tauIdAlgorithmName[0], tauIdAlgorithmName[1]) selectedPatTausAntiOverlapWithMuonsVeto = process.selectedPatTausForMuTauAntiOverlapWithMuonsVeto.clone( dRmin = cms.double(0.5), srcNotToBeFiltered = cms.VInputTag(composeModuleName([patMuonCollectionName, "cumulative"])) ) setattr(process, selectedPatTausAntiOverlapWithMuonsVetoName, selectedPatTausAntiOverlapWithMuonsVeto) patTauSelectionModules.append(selectedPatTausAntiOverlapWithMuonsVeto) process.load("RecoTauTag.RecoTau.PFRecoTauQualityCuts_cfi") selectedPatPFTausForTauIdEffName = \ composeModuleName(["selectedPat%ss%s" % (tauIdAlgorithmName[0], tauIdAlgorithmName[1]), "ForTauIdEff"]) selectedPatPFTausForTauIdEff = cms.EDFilter("PATPFTauSelectorForTauIdEff", minJetPt = cms.double(15.0), maxJetEta = cms.double(2.3), trackQualityCuts = process.PFTauQualityCuts.signalQualityCuts, minLeadTrackPt = cms.double(5.0), maxDzLeadTrack = cms.double(0.2), maxLeadTrackPFElectronMVA = cms.double(0.6), #applyECALcrackVeto = cms.bool(True), applyECALcrackVeto = cms.bool(False), minDeltaRtoNearestMuon = cms.double(0.5), muonSelection = cms.string("isGlobalMuon() | isTrackerMuon() | isStandAloneMuon()"), srcMuon = cms.InputTag('patMuons'), pfIsolation = cms.PSet( chargedParticleIso = cms.PSet( ptMin = cms.double(1.0), dRvetoCone = cms.double(0.15), dRisoCone = cms.double(0.6) ), neutralHadronIso = cms.PSet( ptMin = cms.double(1000.), dRvetoCone = cms.double(0.15), dRisoCone = cms.double(0.) ), photonIso = cms.PSet( ptMin = cms.double(1.5), dPhiVeto = cms.double(-1.), # asymmetric Eta x Phi veto region dEtaVeto = cms.double(-1.), # to account for photon conversions in electron isolation case dRvetoCone = cms.double(0.15), dRisoCone = cms.double(0.6) ), pileUpCorr = cms.PSet( method = cms.string("deltaBeta"), chargedToNeutralFactor = cms.double(0.50) ) ), maxPFIsoPt = cms.double(5.0), srcPFIsoCandidates = cms.InputTag('particleFlow'), srcPFNoPileUpCandidates = cms.InputTag('pfNoPileUp'), srcBeamSpot = cms.InputTag('offlineBeamSpot'), srcVertex = cms.InputTag('offlinePrimaryVertices'), filter = cms.bool(False) ) # CV: comment-out for now, in order to make sure there is no bias # on the tau id. efficiency measurement #if savePatTaus is not None: # setattr(selectedPatPFTausForTauIdEff, "save", cms.string(savePatTaus)) setattr(process, selectedPatPFTausForTauIdEffName, selectedPatPFTausForTauIdEff) patTauSelectionModules.append(selectedPatPFTausForTauIdEff) # for MC apply L1FastJet + L2 + L3 jet-energy corrections, # for Data apply L1FastJet + L2 + L3 + L2/L3 residual corrections # # CV: Ztautau samples produced via MCEmbedding technique are technically "Data', # L2/L3 residual jet energy corrections **must not** be applied, however, # since the tau-jet response is taken from the Monte Carlo simulation # if isMC or isEmbedded: setattr(selectedPatPFTausForTauIdEff, "jetEnergyCorrection", cms.string('ak5PFL1FastL2L3')) else: setattr(selectedPatPFTausForTauIdEff, "jetEnergyCorrection", cms.string('ak5PFL1FastL2L3Residual')) patTauSelConfigurator = objSelConfigurator( patTauSelectionModules, src = patTauCollectionName, pyModuleName = __name__, doSelIndividual = False ) patTauSelectionSequenceName = "selectPat%ss%sForTauIdEff" % (tauIdAlgorithmName[0], tauIdAlgorithmName[1]) patTauSelectionSequence = patTauSelConfigurator.configure(process = process) setattr(process, patTauSelectionSequenceName, patTauSelectionSequence) sequence += patTauSelectionSequence selTauCollectionName = selectedPatPFTausForTauIdEffName patTauCollections = [] for patTauSelectionModule in patTauSelectionModules: patTauCollections.append(composeModuleName([patTauSelectionModule.label(), "cumulative"])) patTauForTauIdEffCounter = cms.EDAnalyzer("PATCandViewCountAnalyzer", src = cms.VInputTag(patTauCollections), minNumEntries = cms.int32(1), maxNumEntries = cms.int32(1000) ) patTauForTauIdEffCounterName = "pat%s%sForTauIdEffCounter" % (tauIdAlgorithmName[0], tauIdAlgorithmName[1]) setattr(process, patTauForTauIdEffCounterName, patTauForTauIdEffCounter) sequence += patTauForTauIdEffCounter #-------------------------------------------------------------------------------- # produce collections of Tau-jet candidates shifted Up/Down in energy # # NOTE: Tau-jet energy shifts/smearing needs to be applied # **after** PATPFTauSelectorForTauIdEff module is run, # as the PATPFTauSelectorForTauIdEff module sets Tau-jet momentum to PFJet momentum, # regardless of any shifts/smearing applied to Tau-jet momentum # #-------------------------------------------------------------------------------- tauSystematics = None if isMC: # CV: shift Tau-jet energy by 3 standard-deviations, # so that template morphing remains an interpolation and no extrapolation is needed patTausJECshiftUpModuleName = composeModuleName([patTauSelectionModule.label(), "TauJetEnUp", "cumulative"]) patTausJECshiftUpModule = cms.EDProducer("ShiftedPATTauJetProducer", src = cms.InputTag(composeModuleName([selTauCollectionName, "cumulative"])), jetCorrPayloadName = cms.string('AK5PF'), jetCorrUncertaintyTag = cms.string('Uncertainty'), addResidualJES = cms.bool(False), shiftBy = cms.double(+3.) ) setattr(process, patTausJECshiftUpModuleName, patTausJECshiftUpModule) sequence += patTausJECshiftUpModule patTausJECshiftDownModuleName = composeModuleName([patTauSelectionModule.label(), "TauJetEnDown", "cumulative"]) patTausJECshiftDownModule = patTausJECshiftUpModule.clone( shiftBy = cms.double(-3.) ) setattr(process, patTausJECshiftDownModuleName, patTausJECshiftDownModule) sequence += patTausJECshiftDownModule process.load("RecoMET.METProducers.METSigParams_cfi") patTausJERshiftUpModuleName = composeModuleName([patTauSelectionModule.label(), "TauJetResUp", "cumulative"]) patTausJERshiftUpModule = cms.EDProducer("SmearedPATTauJetProducer", src = cms.InputTag(composeModuleName([selTauCollectionName, "cumulative"])), inputFileName = cms.FileInPath('PhysicsTools/PatUtils/data/pfJetResolutionMCtoDataCorrLUT.root'), lutName = cms.string('pfJetResolutionMCtoDataCorrLUT'), jetResolutions = process.METSignificance_params, srcGenJets = cms.InputTag('ak5GenJetsNoNu'), dRmaxGenJetMatch = cms.string('TMath::Min(0.5, 0.1 + 0.3*TMath::Exp(-0.05*(genJetPt - 10.)))'), sigmaMaxGenJetMatch = cms.double(5.), smearBy = cms.double(0.), shiftBy = cms.double(+3.) ) setattr(process, patTausJERshiftUpModuleName, patTausJERshiftUpModule) sequence += patTausJERshiftUpModule patTausJERshiftDownModuleName = composeModuleName([patTauSelectionModule.label(), "TauJetResDown", "cumulative"]) patTausJERshiftDownModule = patTausJERshiftUpModule.clone( shiftBy = cms.double(-3.) ) setattr(process, patTausJERshiftDownModuleName, patTausJERshiftDownModule) sequence += patTausJERshiftDownModule #-------------------------------------------------------------------------------- # define selection of Muon + Tau-jet candidate pairs #-------------------------------------------------------------------------------- process.load("TauAnalysis.CandidateTools.muTauPairProduction_cff") allMuTauPairsModuleName = composeModuleName(["allMu", "".join(tauIdAlgorithmName), "PairsForTauIdEff"]) allMuTauPairsModule = process.allMuTauPairs.clone( srcLeg1 = cms.InputTag(composeModuleName([patMuonCollectionName, "cumulative"])), srcLeg2 = cms.InputTag(composeModuleName([selTauCollectionName, "cumulative"])), dRmin12 = cms.double(0.5), srcMET = cms.InputTag(patMEtCollectionName), doSVreco = cms.bool(runSVfit), doPFMEtSign = cms.bool(runSVfit), doMtautauMin = cms.bool(runSVfit) ) if not runSVfit: if hasattr(allMuTauPairsModule, "nSVfit"): delattr(allMuTauPairsModule, "nSVfit") if hasattr(allMuTauPairsModule, "pfMEtSign"): delattr(allMuTauPairsModule, "pfMEtSign") else: # CV: for speed reasons, run NSVfit algorithm in "fit" mode only, not in "integration" mode if hasattr(allMuTauPairsModule, "nSVfit") and hasattr(allMuTauPairsModule.nSVfit, "psKine_MEt_logM_int"): delattr(allMuTauPairsModule.nSVfit, "psKine_MEt_logM_int") if isMC: setattr(allMuTauPairsModule, "srcGenParticles", cms.InputTag('genParticles')) else: setattr(allMuTauPairsModule, "srcGenParticles", cms.InputTag('')) setattr(process, allMuTauPairsModuleName, allMuTauPairsModule) sequence += allMuTauPairsModule muTauPairProdConfigurator_systematics = None if isMC: muTauPairProdConfigurator_systematics = { "TauJetEnUp" : { "srcLeg2" : cms.InputTag(patTausJECshiftUpModuleName), "srcMET" : cms.InputTag(composeModuleName([patMEtCollectionName, "JetEnUp"])) }, "TauJetEnDown" : { "srcLeg2" : cms.InputTag(patTausJECshiftDownModuleName), "srcMET" : cms.InputTag(composeModuleName([patMEtCollectionName, "JetEnDown"])) }, "TauJetResUp" : { "srcLeg2" : cms.InputTag(patTausJERshiftUpModuleName), "srcMET" : cms.InputTag(composeModuleName([patMEtCollectionName, "JetResUp"])) }, "TauJetResDown" : { "srcLeg2" : cms.InputTag(patTausJERshiftDownModuleName), "srcMET" : cms.InputTag(composeModuleName([patMEtCollectionName, "JetResDown"])) }, "JetEnUp" : { "srcMET" : cms.InputTag(composeModuleName([patMEtCollectionName, "JetEnUp"])) }, "JetEnDown" : { "srcMET" : cms.InputTag(composeModuleName([patMEtCollectionName, "JetEnDown"])) }, "UnclusteredEnUp" : { "srcMET" : cms.InputTag(composeModuleName([patMEtCollectionName, "UnclusteredEnUp"])) }, "UnclusteredEnDown" : { "srcMET" : cms.InputTag(composeModuleName([patMEtCollectionName, "UnclusteredEnDown"])) } } muTauPairProdConfigurator = objProdConfigurator( allMuTauPairsModule, pyModuleName = __name__ ) if isMC: setattr(muTauPairProdConfigurator, "systematics", muTauPairProdConfigurator_systematics) prodMuTauPairSequenceName = composeModuleName(["prodMu", "".join(tauIdAlgorithmName), "PairsForTauIdEff"]) prodMuTauPairSequence = muTauPairProdConfigurator.configure(process = process) setattr(process, prodMuTauPairSequenceName, prodMuTauPairSequence) sequence += prodMuTauPairSequence muTauPairSystematicsForTauIdEff = { "TauJetEnUp" : cms.InputTag(composeModuleName([allMuTauPairsModuleName, "TauJetEnUp"])), "TauJetEnDown" : cms.InputTag(composeModuleName([allMuTauPairsModuleName, "TauJetEnDown"])), "TauJetResUp" : cms.InputTag(composeModuleName([allMuTauPairsModuleName, "TauJetResUp"])), "TauJetResDown" : cms.InputTag(composeModuleName([allMuTauPairsModuleName, "TauJetResDown"])), "JetEnUp" : cms.InputTag(composeModuleName([allMuTauPairsModuleName, "JetEnUp"])), "JetEnDown" : cms.InputTag(composeModuleName([allMuTauPairsModuleName, "JetEnDown"])), "UnclusteredEnUp" : cms.InputTag(composeModuleName([allMuTauPairsModuleName, "UnclusteredEnUp"])), "UnclusteredEnDown" : cms.InputTag(composeModuleName([allMuTauPairsModuleName, "UnclusteredEnDown"])) } #print("muTauPairSystematicsForTauIdEff:", muTauPairSystematicsForTauIdEff) process.load("TauAnalysis.CandidateTools.muTauPairSelection_cfi") selectedMuTauPairsAntiOverlapVetoModuleName = \ composeModuleName(["selectedMu", "".join(tauIdAlgorithmName), "PairsAntiOverlapVetoForTauIdEff"]) selectedMuTauPairsAntiOverlapVetoModule = process.selectedMuTauPairsAntiOverlapVeto.clone( cut = cms.string('dR12 > 0.5') ) setattr(process, selectedMuTauPairsAntiOverlapVetoModuleName, selectedMuTauPairsAntiOverlapVetoModule) selectedMuTauPairsDzModuleName = \ composeModuleName(["selectedMu", "".join(tauIdAlgorithmName), "PairsDzForTauIdEff"]) selectedMuTauPairsDzModule = selectedMuTauPairsAntiOverlapVetoModule.clone( #cut = cms.string('abs(leg1().vertex().z() - leg2().vertex().z()) < 0.2') cut = cms.string('abs(leg1().vertex().z() - leg2().vertex().z()) < 1.e+3') ) setattr(process, selectedMuTauPairsDzModuleName, selectedMuTauPairsDzModule) muTauPairSelConfigurator = objSelConfigurator( [ selectedMuTauPairsAntiOverlapVetoModule, selectedMuTauPairsDzModule ], src = allMuTauPairsModuleName, pyModuleName = __name__, doSelIndividual = False ) if isMC: setattr(muTauPairSelConfigurator, "systematics", muTauPairSystematicsForTauIdEff) muTauPairSelectionSequenceName = composeModuleName(["selectMu", "".join(tauIdAlgorithmName), "PairsForTauIdEff"]) #print "muTauPairSelectionSequenceName = %s" % muTauPairSelectionSequenceName muTauPairSelectionSequence = muTauPairSelConfigurator.configure(process = process) setattr(process, muTauPairSelectionSequenceName, muTauPairSelectionSequence) sequence += muTauPairSelectionSequence muTauPairForTauIdEffCounter = cms.EDAnalyzer("PATCandViewCountAnalyzer", src = cms.VInputTag( allMuTauPairsModuleName, composeModuleName([selectedMuTauPairsAntiOverlapVetoModuleName, "cumulative"]), composeModuleName([selectedMuTauPairsDzModuleName, "cumulative"]) ), minNumEntries = cms.int32(1), maxNumEntries = cms.int32(1000) ) muTauPairForTauIdEffCounterName = composeModuleName(["mu", "".join(tauIdAlgorithmName), "PairForTauIdEffCounter"]) setattr(process, muTauPairForTauIdEffCounterName, muTauPairForTauIdEffCounter) sequence += muTauPairForTauIdEffCounter retVal = {} retVal["sequence"] = sequence retVal["patTauCollections"] = [ composeModuleName([selTauCollectionName, "cumulative"]) ] retVal["muTauPairCollections"] = [ composeModuleName([selectedMuTauPairsDzModuleName, "cumulative"]) ] if isMC: retVal["patTauCollections"].extend([ composeModuleName([selTauCollectionName, "TauJetEnUp", "cumulative"]), composeModuleName([selTauCollectionName, "TauJetEnDown", "cumulative"]), composeModuleName([selTauCollectionName, "TauJetResUp", "cumulative"]), composeModuleName([selTauCollectionName, "TauJetResDown", "cumulative"]) ]) retVal["muTauPairCollections"].extend([ composeModuleName([selectedMuTauPairsDzModuleName, "TauJetEnUp", "cumulative"]), composeModuleName([selectedMuTauPairsDzModuleName, "TauJetEnDown", "cumulative"]), composeModuleName([selectedMuTauPairsDzModuleName, "TauJetResUp", "cumulative"]), composeModuleName([selectedMuTauPairsDzModuleName, "TauJetResDown", "cumulative"]), composeModuleName([selectedMuTauPairsDzModuleName, "JetEnUp", "cumulative"]), composeModuleName([selectedMuTauPairsDzModuleName, "JetEnDown", "cumulative"]), composeModuleName([selectedMuTauPairsDzModuleName, "UnclusteredEnUp", "cumulative"]), composeModuleName([selectedMuTauPairsDzModuleName, "UnclusteredEnDown", "cumulative"]) ]) return retVal
def get_moduleName(name, sysName = None): moduleName_base = name if sysName is not None: moduleName_base = composeModuleName([ name, sysName ]) return composeModuleName([ moduleName_base, "Cumulative" ])