Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2022-07-22 00:50:27

0001 import FWCore.ParameterSet.Config as cms
0002 
0003 from DPGAnalysis.Skims.Skims_DPG_cff import skimContent
0004 
0005 from Configuration.EventContent.EventContent_cff import RECOEventContent
0006 skimRecoContent = RECOEventContent.clone()
0007 skimRecoContent.outputCommands.append("drop *_MEtoEDMConverter_*_*")
0008 skimRecoContent.outputCommands.append("drop *_*_*_SKIM")
0009 
0010 from Configuration.EventContent.EventContent_cff import RAWEventContent
0011 skimRawContent = RAWEventContent.clone()
0012 skimRawContent.outputCommands.append("drop *_MEtoEDMConverter_*_*")
0013 skimRawContent.outputCommands.append("drop *_*_*_SKIM")
0014 
0015 from Configuration.EventContent.EventContent_cff import RAWAODEventContent
0016 skimRawAODContent = RAWAODEventContent.clone()
0017 skimRawAODContent.outputCommands.append("drop *_MEtoEDMConverter_*_*")
0018 skimRawAODContent.outputCommands.append("drop *_*_*_SKIM")
0019 
0020 #####################
0021 # event splitting special skims
0022 
0023 # select events 1, 5, 9, ...
0024 evtSplit_Prescaler_P1 = cms.EDFilter("Prescaler",
0025     prescaleFactor = cms.int32(4),
0026     prescaleOffset = cms.int32(1)
0027 )
0028 # select events 2, 6, 10, ...
0029 evtSplit_Prescaler_P2 = cms.EDFilter("Prescaler",
0030     prescaleFactor = cms.int32(4),
0031     prescaleOffset = cms.int32(2)
0032 )
0033 # select events 3, 7, 11, ...
0034 evtSplit_Prescaler_P3 = cms.EDFilter("Prescaler",
0035     prescaleFactor = cms.int32(4),
0036     prescaleOffset = cms.int32(3)
0037 )
0038 # select events 4, 8, 12, ...
0039 evtSplit_Prescaler_P4 = cms.EDFilter("Prescaler",
0040     prescaleFactor = cms.int32(4),
0041     prescaleOffset = cms.int32(0)
0042 )
0043 
0044 evtSplit_SkimPath_P1 = cms.Path(evtSplit_Prescaler_P1)
0045 evtSplit_SkimPath_P2 = cms.Path(evtSplit_Prescaler_P2)
0046 evtSplit_SkimPath_P3 = cms.Path(evtSplit_Prescaler_P3)
0047 evtSplit_SkimPath_P4 = cms.Path(evtSplit_Prescaler_P4)
0048 
0049 SKIMStreamevtSplitSkimP1 = cms.FilteredStream(
0050     responsible = 'PDWG',
0051     name = 'evtSplitSkimP1',
0052     paths = (evtSplit_SkimPath_P1),
0053     content = skimRawContent.outputCommands,
0054     selectEvents = cms.untracked.PSet(),
0055     dataTier = cms.untracked.string('RAW')
0056     )
0057 SKIMStreamevtSplitSkimP2 = cms.FilteredStream(
0058     responsible = 'PDWG',
0059     name = 'evtSplitSkimP2',
0060     paths = (evtSplit_SkimPath_P2),
0061     content = skimRawContent.outputCommands,
0062     selectEvents = cms.untracked.PSet(),
0063     dataTier = cms.untracked.string('RAW')
0064     )
0065 SKIMStreamevtSplitSkimP3 = cms.FilteredStream(
0066     responsible = 'PDWG',
0067     name = 'evtSplitSkimP3',
0068     paths = (evtSplit_SkimPath_P3),
0069     content = skimRawContent.outputCommands,
0070     selectEvents = cms.untracked.PSet(),
0071     dataTier = cms.untracked.string('RAW')
0072     )
0073 SKIMStreamevtSplitSkimP4 = cms.FilteredStream(
0074     responsible = 'PDWG',
0075     name = 'evtSplitSkimP4',
0076     paths = (evtSplit_SkimPath_P4),
0077     content = skimRawContent.outputCommands,
0078     selectEvents = cms.untracked.PSet(),
0079     dataTier = cms.untracked.string('RAW')
0080     )
0081 
0082 #####################
0083 
0084 from Configuration.Skimming.PDWG_BPHSkim_cff import *
0085 BPHSkimPath = cms.Path(BPHSkimSequence)
0086 SKIMStreamBPHSkim = cms.FilteredStream(
0087     responsible = 'PDWG',
0088     name = 'BPHSkim',
0089     paths = (BPHSkimPath),
0090     content = BPHSkim_EventContent.outputCommands,
0091     selectEvents = cms.untracked.PSet(),
0092     dataTier = cms.untracked.string('USER')
0093     )
0094 
0095 #####################
0096 
0097 from Configuration.Skimming.PDWG_EXONoBPTXSkim_cff import *
0098 EXONoBPTXSkimPath = cms.Path()
0099 SKIMStreamEXONoBPTXSkim = cms.FilteredStream(
0100     responsible = 'PDWG',
0101     name = 'EXONoBPTXSkim',
0102     paths = (EXONoBPTXSkimPath),
0103     content = EXONoBPTXSkim_EventContent.outputCommands,
0104     selectEvents = cms.untracked.PSet(),
0105     dataTier = cms.untracked.string('USER')
0106     )
0107 
0108 #####################
0109 
0110 from Configuration.Skimming.PDWG_DiJetAODSkim_cff import *
0111 diJetAveSkimPath = cms.Path(DiJetAveSkim_Trigger)
0112 SKIMStreamDiJet = cms.FilteredStream(
0113     responsible = 'PDWG',
0114     name = 'DiJet',
0115     paths = (diJetAveSkimPath),
0116     content = DiJetAveSkim_EventContent.outputCommands,
0117     selectEvents = cms.untracked.PSet(),
0118     dataTier = cms.untracked.string('USER')
0119     )
0120 
0121 #####################
0122 
0123 from Configuration.Skimming.PDWG_TauSkim_cff import *
0124 tauSkimBy1Path = cms.Path( tauSkim1Sequence )
0125 tauSkimBy2Path = cms.Path( tauSkim2Sequence )
0126 SKIMStreamTau = cms.FilteredStream(
0127     responsible = 'PDWG',
0128     name = 'Tau',
0129     paths = (tauSkimBy1Path),
0130     content = skimContent.outputCommands,
0131     selectEvents = cms.untracked.PSet(),
0132     dataTier = cms.untracked.string('RAW-RECO')
0133     )
0134 SKIMStreamDiTau = cms.FilteredStream(
0135     responsible = 'PDWG',
0136     name = 'Tau',
0137     paths = (tauSkimBy2Path),
0138     content = skimContent.outputCommands,
0139     selectEvents = cms.untracked.PSet(),
0140     dataTier = cms.untracked.string('RAW-RECO')
0141     )
0142 
0143 
0144 #####################
0145 
0146 from Configuration.Skimming.PDWG_HSCP_SD_cff import *
0147 HSCPSDPath = cms.Path(HSCPSD)
0148 SKIMStreamHSCPSD = cms.FilteredStream(
0149     responsible = 'PDWG',
0150     name = 'HSCPSD',
0151     paths = (HSCPSDPath),
0152     content = skimRecoContent.outputCommands,
0153     selectEvents = cms.untracked.PSet(),
0154     dataTier = cms.untracked.string('RECO')
0155     )
0156 
0157 #####################
0158 
0159 from Configuration.Skimming.PDWG_DiPhoton_SD_cff import *
0160 CaloIdIsoPhotonPairsPath = cms.Path(CaloIdIsoPhotonPairsFilter)
0161 R9IdPhotonPairsPath = cms.Path(R9IdPhotonPairsFilter)
0162 MixedCaloR9IdPhotonPairsPath = cms.Path(MixedCaloR9IdPhotonPairsFilter)
0163 MixedR9CaloIdPhotonPairsPath = cms.Path(MixedR9CaloIdPhotonPairsFilter)
0164 
0165 SKIMStreamDiPhoton = cms.FilteredStream(
0166     responsible = 'PDWG',
0167     name = 'DiPhoton',
0168     paths = (CaloIdIsoPhotonPairsPath,R9IdPhotonPairsPath,MixedCaloR9IdPhotonPairsPath,MixedR9CaloIdPhotonPairsPath),
0169     content = skimContent.outputCommands,
0170     selectEvents = cms.untracked.PSet(),
0171     dataTier = cms.untracked.string('RAW-RECO')
0172     )
0173 
0174 ########## B-Parking #########
0175 from Configuration.Skimming.pwdgSkimBPark_cfi import *
0176 SkimBParkPath = cms.Path(SkimBPark)
0177 SKIMStreamSkimBPark = cms.FilteredStream(
0178     responsible = 'BPH PAG',
0179     name = 'SkimBPark',
0180     paths = ( SkimBParkPath ),
0181     content = skimContent.outputCommands,
0182     selectEvents = cms.untracked.PSet(),
0183     dataTier = cms.untracked.string('RAW-RECO')
0184 )
0185 
0186 from Configuration.EventContent.EventContent_cff import AODEventContent
0187 skimAodContent = AODEventContent.clone()
0188 skimAodContent.outputCommands.append("drop *_MEtoEDMConverter_*_*")
0189 skimAodContent.outputCommands.append("drop *_*_*_SKIM")
0190 
0191 #from Configuration.Skimming.PDWG_DoublePhotonSkim_cff import *
0192 #diphotonSkimPath = cms.Path(diphotonSkimSequence)
0193 #SKIMStreamDoublePhoton = cms.FilteredStream(
0194 #    responsible = 'PDWG',
0195 #    name = 'DoublePhoton',
0196 #    paths = (diphotonSkimPath),
0197 #    content = skimAodContent.outputCommands,
0198 #    selectEvents = cms.untracked.PSet(),
0199 #    dataTier = cms.untracked.string('AOD')
0200 #    )
0201 
0202 from Configuration.Skimming.PDWG_HWWSkim_cff import *
0203 HWWmmPath = cms.Path(diMuonSequence)
0204 HWWeePath = cms.Path(diElectronSequence)
0205 HWWemPath = cms.Path(EleMuSequence)
0206 SKIMStreamHWW = cms.FilteredStream(
0207         responsible = 'PDWG',
0208         name = 'HWW',
0209         paths = (HWWmmPath,HWWeePath,HWWemPath),
0210         content = skimAodContent.outputCommands,
0211         selectEvents = cms.untracked.PSet(),
0212         dataTier = cms.untracked.string('AOD')
0213         )
0214 
0215 
0216 from Configuration.Skimming.PDWG_HZZSkim_cff import *
0217 HZZmmPath = cms.Path(zzdiMuonSequence)
0218 HZZeePath = cms.Path(zzdiElectronSequence)
0219 HZZemPath = cms.Path(zzeleMuSequence)
0220 SKIMStreamHZZ = cms.FilteredStream(
0221         responsible = 'PDWG',
0222         name = 'HZZ',
0223         paths = (HZZmmPath,HZZeePath,HZZemPath),
0224         content = skimAodContent.outputCommands,
0225         selectEvents = cms.untracked.PSet(),
0226         dataTier = cms.untracked.string('AOD')
0227         )
0228 
0229 
0230 from Configuration.Skimming.PDWG_EXOHPTE_cff import *
0231 exoHPTEPath = cms.Path(exoDiHPTESequence)
0232 SKIMStreamEXOHPTE = cms.FilteredStream(
0233     responsible = 'PDWG',
0234     name = 'EXOHPTE',
0235     paths = (exoHPTEPath),
0236     content = skimAodContent.outputCommands,
0237     selectEvents = cms.untracked.PSet(),
0238     dataTier = cms.untracked.string('AOD')
0239     )
0240 
0241 from Configuration.Skimming.PDWG_EXOMONOPOLE_cff import *
0242 EXOMONOPOLEPath = cms.Path(EXOMonopoleSkimSequence)
0243 SKIMStreamEXOMONOPOLE = cms.FilteredStream(
0244         responsible = 'PDWG',
0245         name = 'EXOMONOPOLE',
0246         paths = (EXOMONOPOLEPath),
0247         content = EXOMonopoleSkimContent.outputCommands,
0248         selectEvents = cms.untracked.PSet(),
0249         dataTier = cms.untracked.string('USER')
0250         )
0251 
0252 from Configuration.Skimming.PDWG_EXOHighMET_cff import *
0253 EXOHighMETPath = cms.Path(EXOHighMETSequence)
0254 SKIMStreamEXOHighMET = cms.FilteredStream(
0255     responsible = 'PDWG',
0256     name = 'EXOHighMET',
0257     paths = (EXOHighMETPath),
0258     content = skimContent.outputCommands,
0259     selectEvents = cms.untracked.PSet(),
0260     dataTier = cms.untracked.string('RAW-RECO')
0261     )
0262 
0263 from Configuration.Skimming.PDWG_EXODisplacedJet_cff import *
0264 EXODisplacedJetPath = cms.Path(EXODisplacedJetSkimSequence)
0265 SKIMStreamEXODisplacedJet = cms.FilteredStream(
0266     responsible = 'PDWG',
0267     name = 'EXODisplacedJet',
0268     paths = (EXODisplacedJetPath),
0269     content = skimRawAODContent.outputCommands,
0270     selectEvents = cms.untracked.PSet(),
0271     dataTier = cms.untracked.string('USER')
0272     )
0273 
0274 from Configuration.Skimming.PDWG_EXODelayedJet_cff import *
0275 EXODelayedJetPath = cms.Path(EXODelayedJetSkimSequence)
0276 SKIMStreamEXODelayedJet = cms.FilteredStream(
0277     responsible = 'PDWG',
0278     name = 'EXODelayedJet',
0279     paths = (EXODelayedJetPath),
0280     content = skimRawAODContent.outputCommands,
0281     selectEvents = cms.untracked.PSet(),
0282     dataTier = cms.untracked.string('AOD')
0283     )
0284 
0285 from Configuration.Skimming.PDWG_EXODelayedJetMET_cff import *
0286 EXODelayedJetMETPath = cms.Path(EXODelayedJetMETSkimSequence)
0287 SKIMStreamEXODelayedJetMET = cms.FilteredStream(
0288     responsible = 'PDWG',
0289     name = 'EXODelayedJetMET',
0290     paths = (EXODelayedJetMETPath),
0291     content = skimRawAODContent.outputCommands,
0292     selectEvents = cms.untracked.PSet(),
0293     dataTier = cms.untracked.string('AOD')
0294     )
0295 
0296 from Configuration.Skimming.PDWG_EXODTCluster_cff import *
0297 EXODTClusterPath = cms.Path(EXODTClusterSkimSequence)
0298 SKIMStreamEXODTCluster = cms.FilteredStream(
0299     responsible = 'PDWG',
0300     name = 'EXODTCluster',
0301     paths = (EXODTClusterPath),
0302     content = skimRawAODContent.outputCommands,
0303     selectEvents = cms.untracked.PSet(),
0304     dataTier = cms.untracked.string('AOD')
0305     )
0306 
0307 from Configuration.Skimming.PDWG_EXOCSCCluster_cff import *
0308 EXOCSCClusterPath = cms.Path(EXOCSCClusterSkimSequence)
0309 SKIMStreamEXOCSCCluster = cms.FilteredStream(
0310     responsible = 'PDWG',
0311     name = 'EXOCSCCluster',
0312     paths = (EXOCSCClusterPath),
0313     content = skimRawAODContent.outputCommands+['keep *_csc2DRecHits_*_*','keep *_dt1DRecHits_*_*'],
0314     selectEvents = cms.untracked.PSet(),
0315     dataTier = cms.untracked.string('USER')
0316     )
0317 
0318 
0319 from Configuration.Skimming.PDWG_EXODisappTrk_cff import *
0320 EXODisappTrkPath = cms.Path(EXODisappTrkSkimSequence)
0321 SKIMStreamEXODisappTrk = cms.FilteredStream(
0322     responsible = 'PDWG', 
0323     name = 'EXODisappTrk', 
0324     paths = (EXODisappTrkPath),
0325     content = EXODisappTrkSkimContent.outputCommands, 
0326     selectEvents = cms.untracked.PSet(), 
0327     dataTier = cms.untracked.string('AOD')
0328     )
0329 
0330 #####################
0331 # For the Data on Data Mixing in TSG
0332 from HLTrigger.Configuration.HLT_Fake1_cff import fragment as _fragment
0333 if "hltGtDigis" in _fragment.__dict__:
0334     hltGtDigis = _fragment.hltGtDigis.clone()
0335     hltGtDigisPath = cms.Path(hltGtDigis)
0336 else:
0337     hltBoolEnd = _fragmet.hltBoolEnd.clone()
0338     hltGtDigisPath = cms.Path(hltBoolEnd)
0339 
0340 # The events to be used as PileUp
0341 from Configuration.Skimming.PDWG_HLTZEROBIASPU_SD_cff import *
0342 HLTZEROBIASPUSDPath = cms.Path(HLTZEROBIASPUSD)
0343 SKIMStreamHLTZEROBIASPUSD = cms.FilteredStream(
0344     responsible = 'PDWG',
0345     name = 'HLTZEROBIASPUSD',
0346     paths = (HLTZEROBIASPUSDPath),
0347     content = skimRecoContent.outputCommands,
0348     selectEvents = cms.untracked.PSet(),
0349     dataTier = cms.untracked.string('RAW') # for the moment, it could be DIGI in the future
0350     )
0351 
0352 #The events to be used as signal
0353 from Configuration.Skimming.PDWG_HLTZEROBIASSIG_SD_cff import *
0354 HLTZEROBIASSIGSDPath = cms.Path(HLTZEROBIASSIGSD)
0355 SKIMStreamHLTZEROBIASSIGSD = cms.FilteredStream(
0356     responsible = 'PDWG',
0357     name = 'HLTZEROBIASSIGSD',
0358     paths = (HLTZEROBIASSIGSDPath),
0359     content = skimRecoContent.outputCommands,
0360     selectEvents = cms.untracked.PSet(),
0361     dataTier = cms.untracked.string('RAW') # for the moment, it could be DIGI in the future
0362     )
0363 
0364 ####################
0365    
0366 
0367 
0368 ## exo skims
0369 """
0370 from SUSYBSMAnalysis.Skimming.EXOLLResSkim_cff import *
0371 exoLLResmmPath = cms.Path(exoLLResdiMuonSequence)
0372 exoLLReseePath = cms.Path(exoLLResdiElectronSequence)
0373 exoLLResemPath = cms.Path(exoLLResEleMuSequence)
0374 SKIMStreamEXOLLRes = cms.FilteredStream(
0375         responsible = 'EXO',
0376         name = 'EXOLLRes',
0377         paths = (exoLLResmmPath,exoLLReseePath,exoLLResemPath),
0378         content = skimAodContent.outputCommands,
0379         selectEvents = cms.untracked.PSet(),
0380         dataTier = cms.untracked.string('AOD')
0381         )
0382 
0383 from SUSYBSMAnalysis.Skimming.EXOEle_cff import *
0384 exoElePath = cms.Path(exoEleLowetSeqReco)
0385 SKIMStreamEXOEle = cms.FilteredStream(
0386     responsible = 'EXO',
0387     name = 'EXOEle',
0388     paths = (exoElePath),
0389     content = skimAodContent.outputCommands,
0390     selectEvents = cms.untracked.PSet(),
0391     dataTier = cms.untracked.string('AOD')
0392     )
0393 
0394 from SUSYBSMAnalysis.Skimming.EXOMu_cff import *
0395 exoMuPath = cms.Path(exoMuSequence)
0396 SKIMStreamEXOMu = cms.FilteredStream(
0397     responsible = 'EXO',
0398     name = "EXOMu",
0399     paths = (exoMuPath),
0400     content = skimAodContent.outputCommands,
0401     selectEvents = cms.untracked.PSet(),
0402     dataTier = cms.untracked.string('AOD')
0403     )
0404 
0405 from SUSYBSMAnalysis.Skimming.EXOTriLepton_cff import *
0406 exoTriMuPath = cms.Path(exoTriMuonSequence)
0407 SKIMStreamEXOTriMu = cms.FilteredStream(
0408     responsible = 'EXO',
0409     name = 'EXOTriMu',
0410     paths = (exoTriMuPath),
0411     content = skimAodContent.outputCommands,
0412     selectEvents = cms.untracked.PSet(),
0413     dataTier = cms.untracked.string('AOD')
0414     )
0415 exoTriElePath = cms.Path(exoTriElectronSequence)
0416 SKIMStreamEXOTriEle = cms.FilteredStream(
0417     responsible = 'EXO',
0418     name = 'EXOTriEle',
0419     paths = (exoTriElePath),
0420     content = skimAodContent.outputCommands,
0421     selectEvents = cms.untracked.PSet(),
0422     dataTier = cms.untracked.string('AOD')
0423     )
0424 exo1E2MuPath = cms.Path(exo1E2MuSequence)
0425 SKIMStreamEXO1E2Mu = cms.FilteredStream(
0426     responsible = 'EXO',
0427     name = 'EXO1E2Mu',
0428     paths = (exo1E2MuPath),
0429     content = skimAodContent.outputCommands,
0430     selectEvents = cms.untracked.PSet(),
0431     dataTier = cms.untracked.string('AOD')
0432     )
0433 
0434 from SUSYBSMAnalysis.Skimming.EXODiLepton_cff import *
0435 exoDiMuPath = cms.Path(exoDiMuSequence)
0436 exoDiElePath = cms.Path(exoDiMuSequence)
0437 exoEMuPath = cms.Path(exoEMuSequence)
0438 SKIMStreamEXODiMu = cms.FilteredStream(
0439     responsible = 'EXO',
0440     name = 'EXODiMu',
0441     paths = (exoDiMuPath),
0442     content = skimAodContent.outputCommands,
0443     selectEvents = cms.untracked.PSet(),
0444     dataTier = cms.untracked.string('AOD')
0445     )
0446 SKIMStreamEXODiEle = cms.FilteredStream(
0447     responsible = 'EXO',
0448     name = 'EXODiEle',
0449     paths = (exoDiElePath),
0450     content = skimAodContent.outputCommands,
0451     selectEvents = cms.untracked.PSet(),
0452     dataTier = cms.untracked.string('AOD')
0453     )
0454 SKIMStreamEXOEMu = cms.FilteredStream(
0455     responsible = 'EXO',
0456     name = 'EXOEMu',
0457     paths = (exoEMuPath),
0458     content = skimAodContent.outputCommands,
0459     selectEvents = cms.untracked.PSet(),
0460     dataTier = cms.untracked.string('AOD')
0461     )
0462 """
0463 
0464 #####################
0465 
0466 from Configuration.Skimming.PDWG_MuonPOGSkim_cff import *
0467 MuonPOGSkimTrackPath = cms.Path(MuonPOGSkimTrackSequence)
0468 MuonPOGSkimSTAPath   = cms.Path(MuonPOGSkimSTASequence)
0469 SKIMStreamMuonPOGSkim     = cms.FilteredStream(
0470     responsible = 'PDWG',
0471     name = 'MuonPOGSkim',
0472     paths = (MuonPOGSkimTrackPath,MuonPOGSkimSTAPath),
0473     content = MuonPOG_EventContent.outputCommands,
0474     selectEvents = cms.untracked.PSet(),
0475     dataTier = cms.untracked.string('USER')
0476     )
0477 
0478 
0479 MuonPOGJPsiSkimTrackPath = cms.Path(MuonPOGJPsiSkimTrackSequence)
0480 MuonPOGJPsiSkimSTAPath   = cms.Path(MuonPOGJPsiSkimSTASequence)
0481 
0482 SKIMStreamMuonPOGJPsiSkim     = cms.FilteredStream(
0483     responsible = 'PDWG',
0484     name = 'MuonPOGJPsiSkim',
0485     paths = (MuonPOGJPsiSkimTrackPath,MuonPOGJPsiSkimSTAPath),
0486     content = MuonPOG_EventContent.outputCommands,
0487     selectEvents = cms.untracked.PSet(),
0488     dataTier = cms.untracked.string('USER')
0489     )
0490 
0491 
0492 #####################