Beispiel #1
0
def catTool(process, runOnMC=True, useMiniAOD=True):
    if runOnMC:
        from CATTools.CatProducer.pileupWeight_cff import pileupWeightMap
        process.pileupWeight.pileupMC = pileupWeightMap[cat.pileupMCmap]
        process.pileupWeight.pileupRD = pileupWeightMap["%s"%cat.lumiJSON]
        process.pileupWeight.pileupUp = pileupWeightMap["%s_Up"%cat.lumiJSON]
        process.pileupWeight.pileupDn = pileupWeightMap["%s_Dn"%cat.lumiJSON]
    else:
        from FWCore.PythonUtilities.LumiList import LumiList
        process.lumiMask = cms.EDFilter("LumiMaskFilter",
            LumiSections = LumiList('%s/src/CATTools/CatProducer/data/LumiMask/%s.txt'%(os.environ['CMSSW_BASE'], cat.lumiJSON)).getVLuminosityBlockRange())

    useJECfile = True
    jecFiles = cat.JetEnergyCorrection
    if runOnMC:
        jecFile = jecFiles[1]
    else:
        jecFile = jecFiles[0]
    if useJECfile:
        from CondCore.CondDB.CondDB_cfi import CondDB
        if hasattr(CondDB, 'connect'): delattr(CondDB, 'connect')
        process.jec = cms.ESSource("PoolDBESSource",CondDB,
            connect = cms.string('sqlite_fip:CATTools/CatProducer/data/JEC/%s.db'%jecFile),            
            toGet = cms.VPSet(
                cms.PSet(
                    record = cms.string("JetCorrectionsRecord"),
                    tag = cms.string("JetCorrectorParametersCollection_%s_AK4PF"%jecFile),
                    label= cms.untracked.string("AK4PF")),
                cms.PSet(
                    record = cms.string("JetCorrectionsRecord"),
                    tag = cms.string("JetCorrectorParametersCollection_%s_AK4PFchs"%jecFile),
                    label= cms.untracked.string("AK4PFchs")),
            )
        )
        process.es_prefer_jec = cms.ESPrefer("PoolDBESSource","jec")
        print "JEC based on", process.jec.connect

        ## applying new jec on the fly
        from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
        updateJetCollection(
           process,
           jetSource = cms.InputTag('slimmedJets'),
           labelName = 'UpdatedJEC',
           jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute', 'L2L3Residual']), 'None')
        )
        process.p += process.patJetCorrFactorsUpdatedJEC
        process.p += process.updatedPatJetsUpdatedJEC
        process.catJets.src = cms.InputTag("updatedPatJetsUpdatedJEC","","CAT")

        #######################################################################
        # puppi https://twiki.cern.ch/twiki/bin/view/CMS/PUPPI
        # using default
        #######################################################################
        ### updating pile Jet.
#        process.load("RecoJets.JetProducers.PileupJetID_cfi")
#        process.pileupJetIdUpdated = process.pileupJetId.clone(
#          jets=cms.InputTag("slimmedJets"),
#          inputIsCorrected=True,
#          applyJec=True,
#          vertexes=cms.InputTag("offlineSlimmedPrimaryVertices")
#        )
        #process.patJetsUpdated.userData.userFloats.src +=['pileupJetIdUpdated:fullDiscriminant']


    ## #######################################################################
    ## # MET corrections from https://twiki.cern.ch/twiki/bin/view/CMS/MissingETUncertaintyPrescription
    if useMiniAOD:
      # Instructions for 9_4_X, X >=9 for 2017 data with EE noise mitigation
      from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncFromMiniAOD

      runMetCorAndUncFromMiniAOD (
              process,
              isData = not runOnMC,
              postfix = "ModifiedMET"
      )

      process.p += process.fullPatMetSequenceModifiedMET
      process.catMETs.src = cms.InputTag("slimmedMETsModifiedMET","","CAT")

      # Run ecalBadCalibFilter: https://twiki.cern.ch/twiki/bin/viewauth/CMS/MissingETOptionalFiltersRun2#How_to_run_ecal_BadCalibReducedM
      process.load('RecoMET.METFilters.ecalBadCalibFilter_cfi')
      baddetEcallist = cms.vuint32([872439604,872422825,872420274,872423218,
           872423215,872416066,872435036,872439336,872420273,872436907,872420147,872439731,
           872436657,872420397,872439732,872439339,872439603,872422436,872439861,872437051,
           872437052,872420649,872422436,872421950,872437185,872422564,872421566,872421695,
           872421955,872421567,872437184,872421951,872421694,872437056,872437057,872437313])
      process.ecalBadCalibReducedMINIAODFilter = cms.EDFilter(
          "EcalBadCalibFilter",
          EcalRecHitSource = cms.InputTag("reducedEgamma:reducedEERecHits"),
          ecalMinEt        = cms.double(50.),
          baddetEcal    = baddetEcallist,
          taggingMode = cms.bool(True),
          debug = cms.bool(False))
      process.p += process.ecalBadCalibReducedMINIAODFilter

      from EgammaUser.EgammaPostRecoTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
      setupEgammaPostRecoSeq(process,
                             runVID=False,
                             era='2018-Prompt')
      process.p += process.egammaPostRecoSeq
    postfix="ModifiedMET")

## L1 Prefirring
## https://twiki.cern.ch/twiki/bin/viewauth/CMS/L1ECALPrefiringWeightRecipe
from PhysicsTools.PatUtils.l1ECALPrefiringWeightProducer_cfi import l1ECALPrefiringWeightProducer
process.prefiringweight = l1ECALPrefiringWeightProducer.clone(
    DataEra=cms.string("2017BtoF"),
    UseJetEMPt=cms.bool(False),
    PrefiringRateSystematicUncty=cms.double(0.2),
    SkipWarnings=False)

## https://twiki.cern.ch/twiki/bin/view/CMS/EgammaPostRecoRecipes#Running_on_2017_MiniAOD_V2
from EgammaUser.EgammaPostRecoTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
setupEgammaPostRecoSeq(
    process,
    runVID=
    True,  #saves CPU time by not needlessly re-running VID, if you want the Fall17V2 IDs, set this to True or remove (default is True)
    era='2017-Nov17ReReco')

## Apply JEC in AK4
## https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#CorrPatJets
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
    process,
    jetSource=cms.InputTag('slimmedJets'),
    pvSource=cms.InputTag('offlineSlimmedPrimaryVertices'),
    svSource=cms.InputTag('slimmedSecondaryVertices'),
    jetCorrections=(
        'AK4PFchs',
        cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute',
                     'L2L3Residual']), 'None'
Beispiel #3
0
    "TFileService",
    fileName=cms.string('Zjpsi_elel_v7.root'),
)
#process.SimpleMemoryCheck = cms.Service('SimpleMemoryCheck',
#                                        ignoreTotal=cms.untracked.int32(0),
#                                        oncePerEventMode = cms.untracked.bool(False)
#                                        )
#
#process.Timing = cms.Service("Timing")

#from RecoEgamma.EgammaTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
from EgammaUser.EgammaPostRecoTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
setupEgammaPostRecoSeq(
    process,
    runVID=True,
    runEnergyCorrections=
    False,  #no point in re-running them, they are already fine
    era='2016-Legacy'
)  #era is new to select between 2016 / 2017,  it defaults to 2017

#update for v7
####this apply de BF cuts to dimuon & dilepton 1, 3, 4 & 7
####For electros use PATElectronSelector
process.muonFilter = cms.EDFilter(
    'PATMuonSelector',
    src=cms.InputTag('slimmedMuons'),
    cut=cms.string(
        '(pfIsolationR03().sumChargedHadronPt + max(0., pfIsolationR03().sumNeutralHadronEt + pfIsolationR03().sumPhotonEt-0.5*pfIsolationR03().sumPUPt))/pt() < 1.6'
        #' && innerTrack.hitPattern.trackerLayersWithMeasurement > 4'
        #' && innerTrack.hitPattern.pixelLayersWithMeasurement > 0'
        #' && innerTrack.quality(\"highPurity\") '
Beispiel #4
0
process.source = cms.Source("PoolSource",
    fileNames = cms.untracked.vstring(
        #'/store/mc/RunIIAutumn18MiniAOD/ZZTo4L_TuneCP5_DoubleScattering_13TeV-pythia8/MINIAODSIM/102X_upgrade2018_realistic_v15-v5/00000/56984832-8D15-3A4D-8C03-F145A5DD2627.root' ### 2018MC
        '/store/mc/RunIIAutumn18MiniAOD/ZZTo4L_TuneCP5_13TeV_powheg_pythia8/MINIAODSIM/102X_upgrade2018_realistic_v15_ext1-v2/10000/4E82A14A-00E7-2A48-A9A7-C2DE26FE6F7A.root'
   )
)

#new sample Dataset for 4l: /ZZTo4L_TuneCP5_DoubleScattering_13TeV-pythia8/RunIIAutumn18MiniAOD-102X_upgrade2018_realistic_v15-v5/MINIAODSIM
process.TFileService = cms.Service("TFileService",
        fileName = cms.string('Z4l_ee_MC18.root'),
)

#from RecoEgamma.EgammaTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
from EgammaUser.EgammaPostRecoTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
setupEgammaPostRecoSeq(process,
runEnergyCorrections=False, #corrections by default are fine so no need to re-run
era='2018-Prompt')

process.load("HeavyFlavorAnalysis.Onia2MuMu.onia2MuMuPAT_cfi")
process.onia2MuMuPAT.muons=cms.InputTag('slimmedMuons')
process.onia2MuMuPAT.primaryVertexTag=cms.InputTag('offlineSlimmedPrimaryVertices')
process.onia2MuMuPAT.beamSpotTag=cms.InputTag('offlineBeamSpot')
process.onia2MuMuPAT.higherPuritySelection=cms.string("isGlobalMuon")
process.onia2MuMuPAT.lowerPuritySelection=cms.string("isGlobalMuon")
#process.onia2MuMuPAT.dimuonSelection=cms.string("2.55 < mass && mass < 3.65") ## linea 149
process.onia2MuMuPAT.dimuonSelection=cms.string("0.01 < mass && mass < 20.0") ## linea 149
process.onia2MuMuPAT.addMCTruth = cms.bool(False)

###Lepton filter
process.dileptonFilter = cms.EDProducer('LeptonMcFilterElectron',
    electronsMiniAOD        = cms.InputTag("slimmedElectrons"),
Beispiel #5
0
        jecL2RelativeFile = "Fall17_17Nov2017_V32_MC_L2Relative_AK4PFchs.txt"
        jecL3AbsoluteFile = "Fall17_17Nov2017_V32_MC_L3Absolute_AK4PFchs.txt"
        jecL2L3ResidualFile = "Fall17_17Nov2017_V32_MC_L2L3Residual_AK4PFchs.txt"
    else:
        jecUncertaintyFile = 'Summer16_07Aug2017_V11_MC_Uncertainty_AK4PFchs.txt'
        jecUncertaintySourcesFile = 'Summer16_07Aug2017_V11_MC_UncertaintySources_AK4PFchs.txt'
        jecUncertaintyRegroupedFile = 'RegroupedV2_Summer16_07Aug2017_V11_MC_UncertaintySources_AK4PFchs.txt'
        jecL1FastJetFile = "Summer16_07Aug2017_V11_MC_L1FastJet_AK4PFchs.txt"
        jecL2RelativeFile = "Summer16_07Aug2017_V11_MC_L2Relative_AK4PFchs.txt"
        jecL3AbsoluteFile = "Summer16_07Aug2017_V11_MC_L3Absolute_AK4PFchs.txt"
        jecL2L3ResidualFile = "Summer16_07Aug2017_V11_MC_L2L3Residual_AK4PFchs.txt"

from EgammaUser.EgammaPostRecoTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
if is2018:
    setupEgammaPostRecoSeq(process,
                           runEnergyCorrections=True,
                           era='2018-Prompt')  # Updated scale and smearings
elif is2017:
    setupEgammaPostRecoSeq(
        process, runEnergyCorrections=True,
        era='2017-Nov17ReReco')  # Rerun scale and smearings for shiftscale bug
else:
    setupEgammaPostRecoSeq(
        process, runEnergyCorrections=False,
        era='2016-Legacy')  # Default scale and smearings are ok

#
# L1 prefiring (only needed for 2016/2017, use empty sequence for 2018)
#
from PhysicsTools.PatUtils.l1ECALPrefiringWeightProducer_cfi import l1ECALPrefiringWeightProducer
if not is2018:
if Is2016:

    print "################"
    print "Running 2016"
    print "################"

    ###########################
    #### Rerun EGammaPostReco
    ###########################

    from EgammaUser.EgammaPostRecoTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
    setupEgammaPostRecoSeq(
        process,
        runVID=True,
        era='2016-Legacy',
        eleIDModules=myEleID,
        phoIDModules=myPhoID,
        #runEnergyCorrections=False ## when False, VID not reran.. I dunno why..
    )

    #################
    ### Reapply JEC
    ### https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#CorrPatJets
    #################

    from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection

    #### AK4

    updateJetCollection(
        process,
    reportEvery = cms.untracked.int32(5000),
    limit = cms.untracked.int32(10000000)
)
process.maxEvents = cms.untracked.PSet(
    input = cms.untracked.int32(options.maxEvents)
)

process.options = cms.untracked.PSet(
    numberOfStreams = cms.untracked.uint32(options.nrThreads),
    numberOfThreads = cms.untracked.uint32(options.nrThreads),
    wantSummary = cms.untracked.bool(True)
)

from EgammaUser.EgammaPostRecoTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
setupEgammaPostRecoSeq(process,
                       runVID=False, 
                       era='2017-UL')    

process.path = cms.Path(process.egammaPostRecoSeq)

process.output = cms.OutputModule("PoolOutputModule",
                                  splitLevel = cms.untracked.int32(0),
                                  outputCommands = cms.untracked.vstring(
                                      "keep *",
                                      #we drop all the intermediate products we produce
                                      #keeping just resulting slimmedElectrons and slimmedPhotons
                                      "drop *_*_*_EGUSER",
                                      "keep *_slimmedElectrons_*_*",
                                      "keep *_slimmedPhotons_*_*"
                                  )
                                  fileName = cms.untracked.string(options.outputFile),
Beispiel #8
0
process.TFileService = cms.Service(
    "TFileService",
    fileName=cms.string('Zjpsi_elel_v7.root'),
)
#process.SimpleMemoryCheck = cms.Service('SimpleMemoryCheck',
#                                        ignoreTotal=cms.untracked.int32(0),
#                                        oncePerEventMode = cms.untracked.bool(False)
#                                        )
#
#process.Timing = cms.Service("Timing")

#from RecoEgamma.EgammaTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
from EgammaUser.EgammaPostRecoTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
setupEgammaPostRecoSeq(
    process,
    runVID=
    True,  #if you want the Fall17V2 IDs, set this to True or remove (default is True)
    era='2017-Nov17ReReco'
)  #era is new to select between 2016 / 2017,  it defaults to 2017

#update for v7
####this apply de BF cuts to dimuon & dilepton 1, 3, 4 & 7
####For electros use PATElectronSelector
process.muonFilter = cms.EDFilter(
    'PATMuonSelector',
    src=cms.InputTag('slimmedMuons'),
    cut=cms.string(
        '(pfIsolationR03().sumChargedHadronPt + max(0., pfIsolationR03().sumNeutralHadronEt + pfIsolationR03().sumPhotonEt-0.5*pfIsolationR03().sumPUPt))/pt() < 1.6'
        #' && innerTrack.hitPattern.trackerLayersWithMeasurement > 4'
        #' && innerTrack.hitPattern.pixelLayersWithMeasurement > 0'
        #' && innerTrack.quality(\"highPurity\") '
        ' && abs(eta) <= 2.5 && pt >= 1'),
Beispiel #9
0
process.load("Geometry.CaloEventSetup.CaloTowerConstituents_cfi")
process.load("Configuration.StandardSequences.Services_cff")
process.load(
    'Configuration.StandardSequences.FrontierConditions_GlobalTag_condDBv2_cff'
)
from Configuration.AlCa.GlobalTag import GlobalTag
process.GlobalTag = GlobalTag(
    process.GlobalTag, getGlobalTagName(isMC=options.isMC, era=options.era),
    '')

from EgammaUser.EgammaPostRecoTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
setupEgammaPostRecoSeq(
    process,
    applyEnergyCorrections=options.applyEnergyCorrections,
    applyVIDOnCorrectedEgamma=options.applyVIDOnCorrectedEgamma,
    isMiniAOD=options.isMiniAOD,
    era=options.era,
    runVID=options.runVID,
    runEnergyCorrections=options.runEnergyCorrections,
    applyEPCombBug=options.applyEPCombBug)

process.p = cms.Path(process.egammaPostRecoSeq)

process.egammaOutput = cms.OutputModule(
    "PoolOutputModule",
    compressionAlgorithm=cms.untracked.string('LZMA'),
    compressionLevel=cms.untracked.int32(4),
    dataset=cms.untracked.PSet(dataTier=cms.untracked.string('AODSIM'),
                               filterName=cms.untracked.string('')),
    eventAutoFlushCompressedSize=cms.untracked.int32(15728640),
    fileName=cms.untracked.string(
Beispiel #10
0
                                  debugOn=cms.untracked.bool(False),
                                  numtrack=cms.untracked.uint32(10),
                                  thresh=cms.untracked.double(0.25))

from PhysicsTools.PatUtils.l1ECALPrefiringWeightProducer_cfi import l1ECALPrefiringWeightProducer
process.prefiringweight = l1ECALPrefiringWeightProducer.clone(
    TheJets=cms.InputTag(
        "slimmedJets"
    ),  #this should be the slimmedJets collection with up to date JECs !
    DataEra=cms.string("2016BtoH"),  #Use 2016BtoH for 2016
    UseJetEMPt=cms.bool(False),
    PrefiringRateSystematicUncty=cms.double(0.2),
    SkipWarnings=False)

from EgammaUser.EgammaPostRecoTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
setupEgammaPostRecoSeq(process, era='2016-Legacy')

newTask = cms.Task()
process.egammaPostRecoSeq.associate(newTask)

process.load("RecoLocalCalo.EcalRecAlgos.EcalSeverityLevelESProducer_cfi")
process.load("ZprimeTo4l.ModifiedHEEP.ModifiedHEEPIdVarValueMapProducer_cfi")
process.load("ZprimeTo4l.ModifiedHEEP.ModifiedEcalRecHitIsolationScone_cfi")
newTask.add(process.ModifiedHEEPIDVarValueMaps)
newTask.add(process.ModifiedEcalRecHitIsolationScone)

process.tree = cms.EDAnalyzer(
    "Minituplizer",
    isMC=cms.untracked.bool(True),
    TriggerResults=cms.InputTag("TriggerResults", "", "HLT"),
    TriggerSummary=cms.InputTag("hltTriggerSummaryAOD"),
Beispiel #11
0
def userElectrons(process, era):
    ###
    ### setupEgammaPostRecoSeq: EGamma-POG routine to apply IDs + Energy-Scale/Smearing Corrections
    ###
    ###  - https://twiki.cern.ch/twiki/bin/view/CMS/EgammaMiniAODV2
    ###  - https://twiki.cern.ch/twiki/bin/view/CMS/EgammaPostRecoRecipes
    ###  - https://hypernews.cern.ch/HyperNews/CMS/get/egamma/2204/1/1.html (because of PUPPI MET, added 'phoIDModules=[]')
    ###
    if era == '2016':
        setupEgammaPostRecoSeq(process,
                               runVID=True,
                               phoIDModules=[],
                               runEnergyCorrections=True,
                               applyEnergyCorrections=False,
                               era='2016-Legacy')
    elif era == '2017':
        setupEgammaPostRecoSeq(process,
                               runVID=True,
                               phoIDModules=[],
                               runEnergyCorrections=True,
                               applyEnergyCorrections=False,
                               era='2017-Nov17ReReco')
    elif era == '2018':
        setupEgammaPostRecoSeq(process,
                               runVID=True,
                               phoIDModules=[],
                               runEnergyCorrections=True,
                               applyEnergyCorrections=False,
                               era='2018-Prompt')
    else:
        raise RuntimeError('userElectrons(process, era="' + str(era) +
                           '") -- invalid value for argument "era"')

    process.userPreselectedElectrons = selectedPatElectrons.clone(
        src='slimmedElectrons',
        cut=
        '(pt > 10.) && (abs(superCluster.eta) < 2.5) && !((1.4442 < abs(superCluster.eta)) && (abs(superCluster.eta) < 1.5660))',
    )

    _elecID_dxydzCuts = '((abs(superCluster.eta) < 1.4442) && (abs(userFloat("dxyPV")) < 0.05) && (abs(userFloat("dzPV")) < 0.10))'
    _elecID_dxydzCuts += ' || ((abs(superCluster.eta) > 1.5660) && (abs(userFloat("dxyPV")) < 0.10) && (abs(userFloat("dzPV")) < 0.20))'

    process.userElectronsWithUserData = cms.EDProducer(
        'ElectronPATUserData',
        src=cms.InputTag('userPreselectedElectrons'),
        primaryVertices=cms.InputTag('offlineSlimmedPrimaryVertices'),
        effAreas_file=cms.FileInPath(
            'RecoEgamma/ElectronIdentification/data/Fall17/effAreaElectrons_cone03_pfNeuHadronsAndPhotons_94X.txt'
        ),
        rho=cms.InputTag('fixedGridRhoFastjetAll'),
        userFloat_copycat=cms.PSet(
            mva_Iso=cms.string('ElectronMVAEstimatorRun2Fall17' +
                               'IsoV2Values'),
            mva_NoIso=cms.string('ElectronMVAEstimatorRun2Fall17' +
                                 'NoIsoV2Values'),
        ),
        userInt_stringSelectors=cms.PSet(
            IDCutBasedVeto=cms.string(
                '(' + _elecID_dxydzCuts +
                ') && (electronID("cutBasedElectronID-Fall17-94X-V2-veto") > 0.5)'
            ),
            IDCutBasedLoose=cms.string(
                '(' + _elecID_dxydzCuts +
                ') && (electronID("cutBasedElectronID-Fall17-94X-V2-loose") > 0.5)'
            ),
            IDCutBasedMedium=cms.string(
                '(' + _elecID_dxydzCuts +
                ') && (electronID("cutBasedElectronID-Fall17-94X-V2-medium") > 0.5)'
            ),
            IDCutBasedTight=cms.string(
                '(' + _elecID_dxydzCuts +
                ') && (electronID("cutBasedElectronID-Fall17-94X-V2-tight") > 0.5)'
            ),
            IDMVAIsoWP80=cms.string(
                '(electronID("mvaEleID-Fall17-iso-V2-wp80") > 0.5)'),
            IDMVAIsoWP90=cms.string(
                '(electronID("mvaEleID-Fall17-iso-V2-wp90") > 0.5)'),
        ),
    )

    if era == '2016':
        process.userElectronsWithUserData.effAreas_file = 'RecoEgamma/ElectronIdentification/data/Summer16/effAreaElectrons_cone03_pfNeuHadronsAndPhotons_80X.txt'

    process.userIsolatedElectrons = selectedPatElectrons.clone(
        src='userElectronsWithUserData',
        cut='userInt("IDCutBasedLoose") > 0',
    )

    process.userElectronsTask = cms.Task(
        process.userPreselectedElectrons,
        process.userElectronsWithUserData,
        process.userIsolatedElectrons,
    )

    process.userElectronsSeq = cms.Sequence(process.egammaPostRecoSeq,
                                            process.userElectronsTask)

    return process, 'userIsolatedElectrons'
    'root://cms-xrd-global.cern.ch//store/data/Run2017F/SingleMuon/MINIAOD/31Mar2018-v1/100000/70F7C6A6-A739-E811-A1B8-0CC47A4D7674.root'
)

process.output.fileName = cms.untracked.string('output_2017_data.root')

##########################################################################################
## RERUN EGAMMA ID Fall17V2
##########################################################################################
# https://twiki.cern.ch/twiki/bin/view/CMS/EgammaMiniAODV2
# https://twiki.cern.ch/twiki/bin/view/CMS/EgammaPostRecoRecipes#106X
# https://github.com/cms-egamma/EgammaPostRecoTools/blob/master/test/runEgammaPostRecoTools.py#L71-L79
from EgammaUser.EgammaPostRecoTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
setupEgammaPostRecoSeq(
    process,
    runVID=
    True,  #saves CPU time by not needlessly re-running VID, if you want the Fall17V2 IDs, set this to True or remove (default is True)
    phoIDModules=[],  # do not fiddle with photons, we don't use them
    era='2017-Nov17ReReco',
)

# for data, use skims
process.lowPtSkimSequence = cms.Sequence(process.goodLowPtEles +
                                         process.goodLowPtMuons +
                                         process.goodLeptons)
process.p.insert(0, process.lowPtSkimSequence)

process.highPtSkimSequence = cms.Sequence(process.goodHighPtEles +
                                          process.goodHighPtMuons +
                                          process.goodHighPtLeptons)
process.p.insert(1, process.highPtSkimSequence)
process.source.fileNames = cms.untracked.vstring(
    'root://cms-xrd-global.cern.ch//store/data/Run2018D/SingleMuon/MINIAOD/22Jan2019-v2/110000/B1E7101A-30C6-1F4D-BAAA-AB13484DD057.root',
)

process.output.fileName = cms.untracked.string('output_2018D_data.root')

##########################################################################################
## RERUN EGAMMA ID Fall17V2
##########################################################################################
# https://twiki.cern.ch/twiki/bin/view/CMS/EgammaMiniAODV2
# https://twiki.cern.ch/twiki/bin/view/CMS/EgammaPostRecoRecipes#106X
# https://github.com/cms-egamma/EgammaPostRecoTools/blob/master/test/runEgammaPostRecoTools.py#L71-L79
from EgammaUser.EgammaPostRecoTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
setupEgammaPostRecoSeq(
    process,
    era='2018-Prompt',
    phoIDModules=[],  # do not fiddle with photons, we don't use them
)

# for data, use skims
process.lowPtSkimSequence = cms.Sequence(process.goodLowPtEles +
                                         process.goodLowPtMuons +
                                         process.goodLeptons)
process.p.insert(0, process.lowPtSkimSequence)

process.highPtSkimSequence = cms.Sequence(process.goodHighPtEles +
                                          process.goodHighPtMuons +
                                          process.goodHighPtLeptons)
process.p.insert(1, process.highPtSkimSequence)

# find where the new IDs are needed first
Beispiel #14
0
        label=cms.untracked.string("gsfElectron_ee_ecalTrk_05To50_mean"),
        tag=cms.string("gsfElectron_ee_ecalTrk_05To50_mean_2018V1"),
        connect=cms.string("sqlite_file:lowPtEleReg_2018_02062020_nv.db")),
    cms.PSet(
        record=cms.string("GBRDWrapperRcd"),
        label=cms.untracked.string("gsfElectron_eb_ecalTrk_05To50_sigma"),
        tag=cms.string("gsfElectron_eb_ecalTrk_05To50_sigma_2018V1"),
        connect=cms.string("sqlite_file:lowPtEleReg_2018_02062020_nv.db")),
    cms.PSet(
        record=cms.string("GBRDWrapperRcd"),
        label=cms.untracked.string("gsfElectron_ee_ecalTrk_05To50_sigma"),
        tag=cms.string("gsfElectron_ee_ecalTrk_05To50_sigma_2018V1"),
        connect=cms.string("sqlite_file:lowPtEleReg_2018_02062020_nv.db")))

from EgammaUser.EgammaPostRecoTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
process = setupEgammaPostRecoSeq(process, era='2018-Prompt', runVID=False)
#a sequence egammaPostRecoSeq has now been created and should be added to your path, eg process.p=cms.Path(process.egammaPostRecoSeq)
from PhysicsTools.BParkingNano.nanoBPark_cff import *
process = nanoAOD_customizeMuonTriggerBPark(process)
process = nanoAOD_customizeElectronFilteredBPark(process)
process = nanoAOD_customizeTrackFilteredBPark(process)
#process = nanoAOD_customizeLeptonPair(process)
process = nanoAOD_customizeBToKLL(process)
#process = nanoAOD_customizeBToKstarEE(process)
#process = nanoAOD_customizeBToKstarMuMu(process)
#process = nanoAOD_customizeTriggerBitsBPark(process)

# Path and EndPath definitions
#process.nanoAOD_KMuMu_step = cms.Path(process.nanoSequence + process.nanoBKMuMuSequence + CountBToKmumu )
process.nanoAOD_Kee_step = cms.Path(process.egammaPostRecoSeq +
                                    process.nanoSequence +
Beispiel #15
0
    "EcalBadCalibFilter",
    EcalRecHitSource=cms.InputTag("reducedEgamma:reducedEERecHits"),
    ecalMinEt=cms.double(50.),
    baddetEcal=baddetEcallist,
    taggingMode=cms.bool(True),
    debug=cms.bool(False))

##MET Corrections: Type-1
from PhysicsTools.PatAlgos.tools.coreTools import *
runOnData(process,
          names=['Photons', 'Electrons', 'Muons', 'Taus', 'Jets'],
          outputModules=[])

## https://twiki.cern.ch/twiki/bin/view/CMS/EgammaPostRecoRecipes#Running_on_2017_MiniAOD_V2
from EgammaUser.EgammaPostRecoTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
setupEgammaPostRecoSeq(process, era='2018-Prompt')

## Apply JEC in AK4
## https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookJetEnergyCorrections#CorrPatJets
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
updateJetCollection(
    process,
    jetSource=cms.InputTag('slimmedJets'),
    pvSource=cms.InputTag('offlineSlimmedPrimaryVertices'),
    svSource=cms.InputTag('slimmedSecondaryVertices'),
    jetCorrections=(
        'AK4PFchs',
        cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute',
                     'L2L3Residual']), 'None'
    ),  # Update: Safe to always add 'L2L3Residual' as MC contains dummy L2L3Residual corrections (always set to 1)
    postfix='UpdatedJECAK4',
    #L1(PU), L2L3(MCTruth)
    correctors  = cms.VInputTag('ak4CaloL1FastL2L3Corrector')
    )

# pat for trigger
process.load( 'PhysicsTools.PatAlgos.triggerLayer1.triggerProducer_cff' )

# pat for muons
process.load('PhysicsTools.PatAlgos.patSequences_cff')

#from RecoEgamma.EgammaTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
from EgammaUser.EgammaPostRecoTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
setupEgammaPostRecoSeq(process,
                       runVID=True,
                       era='2018-Prompt',
		       isMiniAOD=False,
		       eleIDModules=['RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V2_cff'],
		       phoIDModules=['RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V2_cff']
#		       phoIDModules=[]
)

# For AOD Track variables
process.MaterialPropagator = cms.ESProducer('PropagatorWithMaterialESProducer',
    ComponentName = cms.string('PropagatorWithMaterial'),
    Mass = cms.double(0.105),
    MaxDPhi = cms.double(1.6),
    PropagationDirection = cms.string('alongMomentum'),
    SimpleMagneticField = cms.string(''),
    ptMin = cms.double(-1.0),
    useRungeKutta = cms.bool(False)
)
process.source.fileNames = cms.untracked.vstring(
    'root://cms-xrd-global.cern.ch//store/mc/RunIISummer16MiniAODv3/TTJets_TuneCUETP8M2T4_13TeV-amcatnloFXFX-pythia8/MINIAODSIM/PUMoriond17_94X_mcRun2_asymptotic_v3-v2/40000/E0277B98-6F16-E911-8C5F-B083FED42B3A.root',
)

process.output.fileName = cms.untracked.string('output_2016_mc.root')

##########################################################################################
## RERUN EGAMMA ID Fall17V2
##########################################################################################
# https://twiki.cern.ch/twiki/bin/view/CMS/EgammaMiniAODV2
# https://twiki.cern.ch/twiki/bin/view/CMS/EgammaPostRecoRecipes#106X
# https://github.com/cms-egamma/EgammaPostRecoTools/blob/master/test/runEgammaPostRecoTools.py#L71-L79
from EgammaUser.EgammaPostRecoTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
setupEgammaPostRecoSeq(
    process,
    runVID=True,
    phoIDModules=[], # do not fiddle with photons, we don't use them
    runEnergyCorrections=False, # no point in re-running them, they are already fine
    era='2016-Legacy',
)  # era is new to select between 2016 / 2017,  it defaults to 2017

# SKIM TEMPORARILY DISABLED
# find where the new IDs are needed first
# and then insert this rerun EGamma sequence just before that
process.p.insert(0, process.egammaPostRecoSeq)

# do not filter!
process.p.remove(process.goodLeptons)
process.p.remove(process.goodHighPtLeptons)
Beispiel #18
0
#process.GlobalTag = GlobalTag(process.GlobalTag, '106X_mcRun3_2023_realistic_v3', '')     # 2023 MC
#process.GlobalTag = GlobalTag(process.GlobalTag, '106X_mcRun3_2021_realistic_v3', '')     # 2021 MC
#process.GlobalTag = GlobalTag(process.GlobalTag, '102X_upgrade2018_realistic_v15', '')     # 2018 MC
#process.GlobalTag = GlobalTag(process.GlobalTag, '102X_dataRun2_Sep2018Rereco_v1', '')     # 2018 data
process.GlobalTag = GlobalTag(process.GlobalTag, '94X_dataRun2_ReReco_EOY17_v6', '')     # 2017 data 

#process.SimpleMemoryCheck = cms.Service("SimpleMemoryCheck",
#    ignoreTotal = cms.untracked.int32(1),
#    moduleMemorySummary = cms.untracked.bool(True),
#)

process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(-1) )

setupEgammaPostRecoSeq(process,
#                       era='2017-UL',
                       era='2018-Prompt',
                       phoIDModules=['RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V2_cff']
)  

process.source = cms.Source("PoolSource",
                            fileNames = cms.untracked.vstring(
#                                '/store/mc/Run3Summer19MiniAOD/GJet_Pt-40toInf_DoubleEMEnriched_MGG-80toInf_TuneCP5_14TeV_Pythia8/MINIAODSIM/2021Scenario_106X_mcRun3_2021_realistic_v3-v2/130000/00DF0005-F507-2C4B-BF8B-C46342D7194E.root'
#                                '/store/mc/RunIIAutumn18MiniAOD/DYJetsToLL_M-50_TuneCP5_13TeV-madgraphMLM-pythia8/MINIAODSIM/102X_upgrade2018_realistic_v15-v1/80000/E7AE77A2-59DD-6C4B-AF91-8263DA41EFD8.root'
#                                '/store/mc/Run3Summer19MiniAOD/DYToEE_M-50_NNPDF31_TuneCP5_14TeV-powheg-pythia8/MINIAODSIM/2023Scenario_106X_mcRun3_2023_realistic_v3-v2/260000/FE3A7D24-F46E-8744-B92B-F6115FD395A0.root'
#                                '/store/mc/Run3Winter20DRMiniAOD/DoubleElectron_FlatPt-1To300/MINIAODSIM/FlatPU0to80_110X_mcRun3_2021_realistic_v6-v3/10000/07184556-FFC3-A94A-8124-9CBD85FCD2C9.root',
#                                '/store/mc/Run3Winter20DRMiniAOD/DoubleElectron_FlatPt-1To300/MINIAODSIM/FlatPU0to80_110X_mcRun3_2021_realistic_v6-v3/50000/F5215AC7-4F83-3C42-A188-46198D345570.root',
#                                '/store/mc/Run3Winter20DRMiniAOD/DoubleElectron_FlatPt-1To300/MINIAODSIM/FlatPU0to80_110X_mcRun3_2021_realistic_v6-v3/50000/EDBE4672-2F34-154A-9A46-30E4146A7851.root',
#                                '/store/mc/Run3Winter20DRMiniAOD/DoubleElectron_FlatPt-1To300/MINIAODSIM/FlatPU0to80_110X_mcRun3_2021_realistic_v6-v3/50000/EDA7C170-3345-9D4B-917E-16EA730D6C2B.root',
#                                '/store/mc/Run3Winter20DRMiniAOD/DoubleElectron_FlatPt-1To300/MINIAODSIM/FlatPU0to80_110X_mcRun3_2021_realistic_v6-v3/50000/E9BF7ABB-46DF-9849-938F-6A1C9B5A1E8E.root',
#                                '/store/mc/Run3Winter20DRMiniAOD/DoubleElectron_FlatPt-1To300/MINIAODSIM/FlatPU0to80_110X_mcRun3_2021_realistic_v6-v3/50000/E8108FFB-A1F2-7A47-92E6-2667EA6582A3.root',
#                                '/store/mc/Run3Winter20DRMiniAOD/DoubleElectron_FlatPt-1To300/MINIAODSIM/FlatPU0to80_110X_mcRun3_2021_realistic_v6-v3/50000/E50D3AA3-B57B-BB4E-83FC-E2D4D5C0457D.root',