Skimming/python/Skims_PDWG_cff.py

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_ReserveDMu_SD_cff import *
0160 ReserveDMuPath = cms.Path(ReserveDMu)
0161 SKIMStreamReserveDMu = cms.FilteredStream(
0162     responsible = 'PDWG',
0163     name = 'ReserveDMu',
0164     paths = (ReserveDMuPath),
0165     content = skimRawContent.outputCommands,
0166     selectEvents = cms.untracked.PSet(),
0167     dataTier = cms.untracked.string('RAW')
0168     )
0169
0170 #####################
0171
0172 from Configuration.Skimming.PDWG_DiPhoton_SD_cff import *
0173 CaloIdIsoPhotonPairsPath = cms.Path(CaloIdIsoPhotonPairsFilter)
0174 R9IdPhotonPairsPath = cms.Path(R9IdPhotonPairsFilter)
0175 MixedCaloR9IdPhotonPairsPath = cms.Path(MixedCaloR9IdPhotonPairsFilter)
0176 MixedR9CaloIdPhotonPairsPath = cms.Path(MixedR9CaloIdPhotonPairsFilter)
0177
0178 SKIMStreamDiPhoton = cms.FilteredStream(
0179     responsible = 'PDWG',
0180     name = 'DiPhoton',
0181     paths = (CaloIdIsoPhotonPairsPath,R9IdPhotonPairsPath,MixedCaloR9IdPhotonPairsPath,MixedR9CaloIdPhotonPairsPath),
0182     content = skimContent.outputCommands,
0183     selectEvents = cms.untracked.PSet(),
0184     dataTier = cms.untracked.string('RAW-RECO')
0185     )
0186
0187 ########## B-Parking #########
0188 from Configuration.Skimming.pwdgSkimBPark_cfi import *
0189 SkimBParkPath = cms.Path(SkimBPark)
0190 SKIMStreamSkimBPark = cms.FilteredStream(
0191     responsible = 'BPH PAG',
0192     name = 'SkimBPark',
0193     paths = ( SkimBParkPath ),
0194     content = skimContent.outputCommands,
0195     selectEvents = cms.untracked.PSet(),
0196     dataTier = cms.untracked.string('RAW-RECO')
0197 )
0198
0199 from Configuration.EventContent.EventContent_cff import AODEventContent
0200 skimAodContent = AODEventContent.clone()
0201 skimAodContent.outputCommands.append("drop *_MEtoEDMConverter_*_*")
0202 skimAodContent.outputCommands.append("drop *_*_*_SKIM")
0203
0204 #from Configuration.Skimming.PDWG_DoublePhotonSkim_cff import *
0205 #diphotonSkimPath = cms.Path(diphotonSkimSequence)
0206 #SKIMStreamDoublePhoton = cms.FilteredStream(
0207 #    responsible = 'PDWG',
0208 #    name = 'DoublePhoton',
0209 #    paths = (diphotonSkimPath),
0210 #    content = skimAodContent.outputCommands,
0211 #    selectEvents = cms.untracked.PSet(),
0212 #    dataTier = cms.untracked.string('AOD')
0213 #    )
0214
0215 from Configuration.Skimming.PDWG_HWWSkim_cff import *
0216 HWWmmPath = cms.Path(diMuonSequence)
0217 HWWeePath = cms.Path(diElectronSequence)
0218 HWWemPath = cms.Path(EleMuSequence)
0219 SKIMStreamHWW = cms.FilteredStream(
0220         responsible = 'PDWG',
0221         name = 'HWW',
0222         paths = (HWWmmPath,HWWeePath,HWWemPath),
0223         content = skimAodContent.outputCommands,
0224         selectEvents = cms.untracked.PSet(),
0225         dataTier = cms.untracked.string('AOD')
0226         )
0227
0228
0229 from Configuration.Skimming.PDWG_HZZSkim_cff import *
0230 HZZmmPath = cms.Path(zzdiMuonSequence)
0231 HZZeePath = cms.Path(zzdiElectronSequence)
0232 HZZemPath = cms.Path(zzeleMuSequence)
0233 SKIMStreamHZZ = cms.FilteredStream(
0234         responsible = 'PDWG',
0235         name = 'HZZ',
0236         paths = (HZZmmPath,HZZeePath,HZZemPath),
0237         content = skimAodContent.outputCommands,
0238         selectEvents = cms.untracked.PSet(),
0239         dataTier = cms.untracked.string('AOD')
0240         )
0241
0242
0243 from Configuration.Skimming.PDWG_EXOHPTE_cff import *
0244 exoHPTEPath = cms.Path(exoDiHPTESequence)
0245 SKIMStreamEXOHPTE = cms.FilteredStream(
0246     responsible = 'PDWG',
0247     name = 'EXOHPTE',
0248     paths = (exoHPTEPath),
0249     content = skimAodContent.outputCommands,
0250     selectEvents = cms.untracked.PSet(),
0251     dataTier = cms.untracked.string('AOD')
0252     )
0253
0254 from Configuration.Skimming.PDWG_EXOMONOPOLE_cff import *
0255 EXOMONOPOLEPath = cms.Path(EXOMonopoleSkimSequence)
0256 SKIMStreamEXOMONOPOLE = cms.FilteredStream(
0257         responsible = 'PDWG',
0258         name = 'EXOMONOPOLE',
0259         paths = (EXOMONOPOLEPath),
0260         content = EXOMonopoleSkimContent.outputCommands,
0261         selectEvents = cms.untracked.PSet(),
0262         dataTier = cms.untracked.string('USER')
0263         )
0264
0265 from Configuration.Skimming.PDWG_EXOHighMET_cff import *
0266 EXOHighMETPath = cms.Path(EXOHighMETSequence)
0267 SKIMStreamEXOHighMET = cms.FilteredStream(
0268     responsible = 'PDWG',
0269     name = 'EXOHighMET',
0270     paths = (EXOHighMETPath),
0271     content = skimContent.outputCommands,
0272     selectEvents = cms.untracked.PSet(),
0273     dataTier = cms.untracked.string('RAW-RECO')
0274     )
0275
0276 from Configuration.Skimming.PDWG_EXODisplacedJet_cff import *
0277 EXODisplacedJetPath = cms.Path(EXODisplacedJetSkimSequence)
0278 SKIMStreamEXODisplacedJet = cms.FilteredStream(
0279     responsible = 'PDWG',
0280     name = 'EXODisplacedJet',
0281     paths = (EXODisplacedJetPath),
0282     content = skimRawAODContent.outputCommands,
0283     selectEvents = cms.untracked.PSet(),
0284     dataTier = cms.untracked.string('USER')
0285     )
0286
0287 from Configuration.Skimming.PDWG_EXODelayedJet_cff import *
0288 EXODelayedJetPath = cms.Path(EXODelayedJetSkimSequence)
0289 SKIMStreamEXODelayedJet = cms.FilteredStream(
0290     responsible = 'PDWG',
0291     name = 'EXODelayedJet',
0292     paths = (EXODelayedJetPath),
0293     content = skimRawAODContent.outputCommands,
0294     selectEvents = cms.untracked.PSet(),
0295     dataTier = cms.untracked.string('AOD')
0296     )
0297
0298 from Configuration.Skimming.PDWG_EXODelayedJetMET_cff import *
0299 EXODelayedJetMETPath = cms.Path(EXODelayedJetMETSkimSequence)
0300 SKIMStreamEXODelayedJetMET = cms.FilteredStream(
0301     responsible = 'PDWG',
0302     name = 'EXODelayedJetMET',
0303     paths = (EXODelayedJetMETPath),
0304     content = skimRawAODContent.outputCommands,
0305     selectEvents = cms.untracked.PSet(),
0306     dataTier = cms.untracked.string('AOD')
0307     )
0308
0309 from Configuration.Skimming.PDWG_EXOLLPJetHCAL_cff import *
0310 EXOLLPJetHCALPath = cms.Path(EXOLLPJetHCALSkimSequence)
0311 SKIMStreamEXOLLPJetHCAL = cms.FilteredStream(
0312     responsible = 'PDWG',
0313     name = 'EXOLLPJetHCAL',
0314     paths = (EXOLLPJetHCALPath),
0315     content = skimRawAODContent.outputCommands+['keep *_hbhereco__*'],
0316     selectEvents = cms.untracked.PSet(),
0317     dataTier = cms.untracked.string('AOD')
0318     )
0319
0320 from Configuration.Skimming.PDWG_EXODTCluster_cff import *
0321 EXODTClusterPath = cms.Path(EXODTClusterSkimSequence)
0322 SKIMStreamEXODTCluster = cms.FilteredStream(
0323     responsible = 'PDWG',
0324     name = 'EXODTCluster',
0325     paths = (EXODTClusterPath),
0326     content = skimRawAODContent.outputCommands,
0327     selectEvents = cms.untracked.PSet(),
0328     dataTier = cms.untracked.string('AOD')
0329     )
0330
0331 from Configuration.Skimming.PDWG_EXOCSCCluster_cff import *
0332 EXOCSCClusterPath = cms.Path(EXOCSCClusterSkimSequence)
0333 SKIMStreamEXOCSCCluster = cms.FilteredStream(
0334     responsible = 'PDWG',
0335     name = 'EXOCSCCluster',
0336     paths = (EXOCSCClusterPath),
0337     content = skimRawAODContent.outputCommands+['keep *_csc2DRecHits_*_*','keep *_dt1DRecHits_*_*'],
0338     selectEvents = cms.untracked.PSet(),
0339     dataTier = cms.untracked.string('USER')
0340     )
0341
0342
0343 from Configuration.Skimming.PDWG_EXODisappTrk_cff import *
0344 EXODisappTrkPath = cms.Path(EXODisappTrkSkimSequence)
0345 SKIMStreamEXODisappTrk = cms.FilteredStream(
0346     responsible = 'PDWG',
0347     name = 'EXODisappTrk',
0348     paths = (EXODisappTrkPath),
0349     content = EXODisappTrkSkimContent.outputCommands,
0350     selectEvents = cms.untracked.PSet(),
0351     dataTier = cms.untracked.string('USER')
0352     )
0353
0354 from Configuration.Skimming.PDWG_EXODisappMuon_cff import *
0355 EXODisappMuonPath = cms.Path(EXODisappMuonSkimSequence)
0356 SKIMStreamEXODisappMuon = cms.FilteredStream(
0357     responsible = 'PDWG',
0358     name = 'EXODisappMuon',
0359     paths = (EXODisappMuonPath),
0360     content = EXODisappMuonSkimContent.outputCommands,
0361     selectEvents = cms.untracked.PSet(),
0362     dataTier = cms.untracked.string('USER')
0363     )
0364
0365 from Configuration.Skimming.PDWG_EXOSoftDisplacedVertices_cff import *
0366 EXOSoftDisplacedVerticesPath = cms.Path(EXOSoftDisplacedVerticesSkimSequence)
0367 SKIMStreamEXOSoftDisplacedVertices = cms.FilteredStream(
0368     responsible = 'PDWG',
0369     name = 'EXOSoftDisplacedVertices',
0370     paths = (EXOSoftDisplacedVerticesPath ),
0371     content = EXOSoftDisplacedVerticesSkimContent.outputCommands,
0372     selectEvents = cms.untracked.PSet(),
0373     dataTier = cms.untracked.string('AOD')
0374 )
0375
0376 #####################
0377 # For the Data on Data Mixing in TSG
0378 from HLTrigger.Configuration.HLT_Fake1_cff import fragment as _fragment
0379 if "hltGtDigis" in _fragment.__dict__:
0380     hltGtDigis = _fragment.hltGtDigis.clone()
0381     hltGtDigisPath = cms.Path(hltGtDigis)
0382 else:
0383     hltBoolEnd = _fragmet.hltBoolEnd.clone()
0384     hltGtDigisPath = cms.Path(hltBoolEnd)
0385
0386 # The events to be used as PileUp
0387 from Configuration.Skimming.PDWG_HLTZEROBIASPU_SD_cff import *
0388 HLTZEROBIASPUSDPath = cms.Path(HLTZEROBIASPUSD)
0389 SKIMStreamHLTZEROBIASPUSD = cms.FilteredStream(
0390     responsible = 'PDWG',
0391     name = 'HLTZEROBIASPUSD',
0392     paths = (HLTZEROBIASPUSDPath),
0393     content = skimRecoContent.outputCommands,
0394     selectEvents = cms.untracked.PSet(),
0395     dataTier = cms.untracked.string('RAW') # for the moment, it could be DIGI in the future
0396     )
0397
0398 #The events to be used as signal
0399 from Configuration.Skimming.PDWG_HLTZEROBIASSIG_SD_cff import *
0400 HLTZEROBIASSIGSDPath = cms.Path(HLTZEROBIASSIGSD)
0401 SKIMStreamHLTZEROBIASSIGSD = cms.FilteredStream(
0402     responsible = 'PDWG',
0403     name = 'HLTZEROBIASSIGSD',
0404     paths = (HLTZEROBIASSIGSDPath),
0405     content = skimRecoContent.outputCommands,
0406     selectEvents = cms.untracked.PSet(),
0407     dataTier = cms.untracked.string('RAW') # for the moment, it could be DIGI in the future
0408     )
0409
0410 from Configuration.Skimming.PDWG_EGMJME_SD_cff import *
0411 EGMJMEPath = cms.Path(EGMJME)
0412 SKIMStreamEGMJME = cms.FilteredStream(
0413     responsible = 'PDWG',
0414     name = 'EGMJME',
0415     paths = (EGMJMEPath),
0416     content = skimRawContent.outputCommands,
0417     selectEvents = cms.untracked.PSet(),
0418     dataTier = cms.untracked.string('RAW-RECO')
0419     )
0420
0421 from Configuration.Skimming.PDWG_MUOJME_SD_cff import *
0422 MUOJMEPath = cms.Path(MUOJME)
0423 SKIMStreamMUOJME = cms.FilteredStream(
0424     responsible = 'PDWG',
0425     name = 'MUOJME',
0426     paths = (MUOJMEPath),
0427     content = skimRawContent.outputCommands,
0428     selectEvents = cms.untracked.PSet(),
0429     dataTier = cms.untracked.string('RAW-RECO')
0430     )
0431
0432 ####################
0433
0434
0435
0436 ## exo skims
0437 """
0438 from SUSYBSMAnalysis.Skimming.EXOLLResSkim_cff import *
0439 exoLLResmmPath = cms.Path(exoLLResdiMuonSequence)
0440 exoLLReseePath = cms.Path(exoLLResdiElectronSequence)
0441 exoLLResemPath = cms.Path(exoLLResEleMuSequence)
0442 SKIMStreamEXOLLRes = cms.FilteredStream(
0443         responsible = 'EXO',
0444         name = 'EXOLLRes',
0445         paths = (exoLLResmmPath,exoLLReseePath,exoLLResemPath),
0446         content = skimAodContent.outputCommands,
0447         selectEvents = cms.untracked.PSet(),
0448         dataTier = cms.untracked.string('AOD')
0449         )
0450
0451 from SUSYBSMAnalysis.Skimming.EXOEle_cff import *
0452 exoElePath = cms.Path(exoEleLowetSeqReco)
0453 SKIMStreamEXOEle = cms.FilteredStream(
0454     responsible = 'EXO',
0455     name = 'EXOEle',
0456     paths = (exoElePath),
0457     content = skimAodContent.outputCommands,
0458     selectEvents = cms.untracked.PSet(),
0459     dataTier = cms.untracked.string('AOD')
0460     )
0461
0462 from SUSYBSMAnalysis.Skimming.EXOMu_cff import *
0463 exoMuPath = cms.Path(exoMuSequence)
0464 SKIMStreamEXOMu = cms.FilteredStream(
0465     responsible = 'EXO',
0466     name = "EXOMu",
0467     paths = (exoMuPath),
0468     content = skimAodContent.outputCommands,
0469     selectEvents = cms.untracked.PSet(),
0470     dataTier = cms.untracked.string('AOD')
0471     )
0472
0473 from SUSYBSMAnalysis.Skimming.EXOTriLepton_cff import *
0474 exoTriMuPath = cms.Path(exoTriMuonSequence)
0475 SKIMStreamEXOTriMu = cms.FilteredStream(
0476     responsible = 'EXO',
0477     name = 'EXOTriMu',
0478     paths = (exoTriMuPath),
0479     content = skimAodContent.outputCommands,
0480     selectEvents = cms.untracked.PSet(),
0481     dataTier = cms.untracked.string('AOD')
0482     )
0483 exoTriElePath = cms.Path(exoTriElectronSequence)
0484 SKIMStreamEXOTriEle = cms.FilteredStream(
0485     responsible = 'EXO',
0486     name = 'EXOTriEle',
0487     paths = (exoTriElePath),
0488     content = skimAodContent.outputCommands,
0489     selectEvents = cms.untracked.PSet(),
0490     dataTier = cms.untracked.string('AOD')
0491     )
0492 exo1E2MuPath = cms.Path(exo1E2MuSequence)
0493 SKIMStreamEXO1E2Mu = cms.FilteredStream(
0494     responsible = 'EXO',
0495     name = 'EXO1E2Mu',
0496     paths = (exo1E2MuPath),
0497     content = skimAodContent.outputCommands,
0498     selectEvents = cms.untracked.PSet(),
0499     dataTier = cms.untracked.string('AOD')
0500     )
0501
0502 from SUSYBSMAnalysis.Skimming.EXODiLepton_cff import *
0503 exoDiMuPath = cms.Path(exoDiMuSequence)
0504 exoDiElePath = cms.Path(exoDiMuSequence)
0505 exoEMuPath = cms.Path(exoEMuSequence)
0506 SKIMStreamEXODiMu = cms.FilteredStream(
0507     responsible = 'EXO',
0508     name = 'EXODiMu',
0509     paths = (exoDiMuPath),
0510     content = skimAodContent.outputCommands,
0511     selectEvents = cms.untracked.PSet(),
0512     dataTier = cms.untracked.string('AOD')
0513     )
0514 SKIMStreamEXODiEle = cms.FilteredStream(
0515     responsible = 'EXO',
0516     name = 'EXODiEle',
0517     paths = (exoDiElePath),
0518     content = skimAodContent.outputCommands,
0519     selectEvents = cms.untracked.PSet(),
0520     dataTier = cms.untracked.string('AOD')
0521     )
0522 SKIMStreamEXOEMu = cms.FilteredStream(
0523     responsible = 'EXO',
0524     name = 'EXOEMu',
0525     paths = (exoEMuPath),
0526     content = skimAodContent.outputCommands,
0527     selectEvents = cms.untracked.PSet(),
0528     dataTier = cms.untracked.string('AOD')
0529     )
0530 """
0531
0532 #####################
0533
0534 from Configuration.Skimming.PDWG_MuonPOGSkim_cff import *
0535 MuonPOGSkimTrackPath = cms.Path(MuonPOGSkimTrackSequence)
0536 MuonPOGSkimSTAPath   = cms.Path(MuonPOGSkimSTASequence)
0537 SKIMStreamMuonPOGSkim     = cms.FilteredStream(
0538     responsible = 'PDWG',
0539     name = 'MuonPOGSkim',
0540     paths = (MuonPOGSkimTrackPath,MuonPOGSkimSTAPath),
0541     content = MuonPOG_EventContent.outputCommands,
0542     selectEvents = cms.untracked.PSet(),
0543     dataTier = cms.untracked.string('USER')
0544     )
0545
0546
0547 MuonPOGJPsiSkimTrackPath = cms.Path(MuonPOGJPsiSkimTrackSequence)
0548 MuonPOGJPsiSkimSTAPath   = cms.Path(MuonPOGJPsiSkimSTASequence)
0549
0550 SKIMStreamMuonPOGJPsiSkim     = cms.FilteredStream(
0551     responsible = 'PDWG',
0552     name = 'MuonPOGJPsiSkim',
0553     paths = (MuonPOGJPsiSkimTrackPath,MuonPOGJPsiSkimSTAPath),
0554     content = MuonPOG_EventContent.outputCommands,
0555     selectEvents = cms.untracked.PSet(),
0556     dataTier = cms.untracked.string('USER')
0557     )
0558
0559
0560 #####################