EventContent/python/EventContent_cff.py

0001 import FWCore.ParameterSet.Config as cms
0002
0003 #
0004 # Event Content definition
0005 #
0006 # Data Tiers defined:
0007 #
0008 #  LHE:
0009 #    include pure LHE production
0010 #
0011 #  GEN:
0012 #    include GEN only information
0013 #
0014 #  RAW , RECO, AOD:
0015 #    include reconstruction content
0016 #
0017 #  RAWSIM, RECOSIM, AODSIM:
0018 #    include reconstruction and simulation
0019 #
0020 #  GENRAW
0021 #    slimmed-down version of RAWSIM for small transient disk size during MC production, contains Gen+Rawdata
0022 #
0023 #  PREMIX
0024 #    contains special Digi collection(s) for pre-mixing minbias events for pileup simulation
0025 #    Raw2Digi step is done on this file.
0026 #
0027 #  PREMIXRAW
0028 #    extension of RAWSIM for output of second stage of PreMixing using the DataMixer.
0029 #
0030 #  RAWDEBUG(RAWSIM+ALL_SIM_INFO), RAWDEBUGHLT(RAWDEBUG+HLTDEBUG)
0031 #
0032 #  RAWSIMHLT (RAWSIM + HLTDEBUG)
0033 #
0034 #  RAWRECOSIMHLT, RAWRECODEBUGHLT
0035 #
0036 #  FEVT (RAW+RECO), FEVTSIM (RAWSIM+RECOSIM), FEVTDEBUG (FEVTSIM+ALL_SIM_INFO), FEVTDEBUGHLT (FEVTDEBUG+HLTDEBUG)
0037 #
0038 #  $Id: EventContent_cff.py,v 1.54 2013/05/01 15:44:29 mikeh Exp $
0039 #
0040 #
0041 #
0042 #
0043 # Recontruction Systems
0044 #
0045 #
0046 from RecoLocalTracker.Configuration.RecoLocalTracker_EventContent_cff import *
0047 from RecoLocalMuon.Configuration.RecoLocalMuon_EventContent_cff import *
0048 from RecoLocalCalo.Configuration.RecoLocalCalo_EventContent_cff import *
0049 from RecoEcal.Configuration.RecoEcal_EventContent_cff import *
0050 from TrackingTools.Configuration.TrackingTools_EventContent_cff import *
0051 from RecoTracker.Configuration.RecoTracker_EventContent_cff import *
0052 from RecoJets.Configuration.RecoJets_EventContent_cff import *
0053 from RecoMET.Configuration.RecoMET_EventContent_cff import *
0054 from RecoMuon.Configuration.RecoMuon_EventContent_cff import *
0055 from RecoBTau.Configuration.RecoBTau_EventContent_cff import *
0056 from RecoBTag.Configuration.RecoBTag_EventContent_cff import *
0057 from RecoTauTag.Configuration.RecoTauTag_EventContent_cff import *
0058 from RecoVertex.Configuration.RecoVertex_EventContent_cff import *
0059 from RecoPixelVertexing.Configuration.RecoPixelVertexing_EventContent_cff import *
0060 from RecoEgamma.Configuration.RecoEgamma_EventContent_cff import *
0061 from RecoParticleFlow.Configuration.RecoParticleFlow_EventContent_cff import *
0062 from RecoVertex.BeamSpotProducer.BeamSpot_EventContent_cff import *
0063 from RecoPPS.Configuration.RecoCTPPS_EventContent_cff import *
0064 from RecoHGCal.Configuration.RecoHGCal_EventContent_cff import *
0065
0066 # raw2digi that are already the final RECO/AOD products
0067 from EventFilter.ScalersRawToDigi.Scalers_EventContent_cff import *
0068 from EventFilter.OnlineMetaDataRawToDigi.OnlineMetaData_EventContent_cff import *
0069 from EventFilter.OnlineMetaDataRawToDigi.Tcds_EventContent_cff import *
0070
0071 #DigiToRaw content
0072 from EventFilter.Configuration.DigiToRaw_EventContent_cff import *
0073 #
0074 #
0075 # Simulation Systems
0076 #
0077 #
0078 from GeneratorInterface.Configuration.GeneratorInterface_EventContent_cff import *
0079 from SimG4Core.Configuration.SimG4Core_EventContent_cff import *
0080 from SimTracker.Configuration.SimTracker_EventContent_cff import *
0081 from SimMuon.Configuration.SimMuon_EventContent_cff import *
0082 from SimCalorimetry.Configuration.SimCalorimetry_EventContent_cff import *
0083 from SimFastTiming.Configuration.SimFastTiming_EventContent_cff import *
0084 from SimGeneral.Configuration.SimGeneral_EventContent_cff import *
0085 from IOMC.RandomEngine.IOMC_EventContent_cff import *
0086 #
0087 #
0088 # L1
0089 #
0090 #
0091 from L1Trigger.Configuration.L1Trigger_EventContent_cff import *
0092 #
0093 #
0094 # HLT
0095 #
0096 #
0097 from HLTrigger.Configuration.HLTrigger_EventContent_cff import *
0098 #
0099 #
0100 # DQM
0101 #
0102 #
0103 from DQMOffline.Configuration.DQMOffline_EventContent_cff import *
0104 #
0105 #
0106 # NANOAOD
0107 #
0108 #
0109 from PhysicsTools.NanoAOD.NanoAODEDMEventContent_cff import *
0110 #
0111 #
0112 # FastSim
0113 #
0114 #
0115 from FastSimulation.Configuration.EventContent_cff import FASTPUEventContent
0116 import FastSimulation.Configuration.EventContent_cff as fastSimEC
0117 from Configuration.Eras.Modifier_fastSim_cff import fastSim
0118 fastSim.toModify(RecoLocalTrackerRECO, outputCommands = fastSimEC.RecoLocalTracker.outputCommands)
0119 fastSim.toModify(RecoLocalTrackerFEVT, outputCommands = fastSimEC.RecoLocalTracker.outputCommands)
0120 fastSim.toReplaceWith(SimG4CoreRAW, fastSimEC.SimRAW)
0121 fastSim.toReplaceWith(SimG4CoreRECO, fastSimEC.SimRECO)
0122
0123 def SwapKeepAndDrop(l):
0124     r=[]
0125     for item in l:
0126         if 'keep ' in item:
0127             r.append(item.replace('keep ','drop '))
0128         elif 'drop ' in item:
0129             r.append(item.replace('drop ','keep '))
0130     return r
0131
0132 #
0133 #
0134 # Top level additional keep statements
0135 #
0136 #
0137 CommonEventContent = cms.PSet(
0138     outputCommands = cms.untracked.vstring('keep *_logErrorHarvester_*_*')
0139 )
0140 #
0141 #
0142 # LHE Data Tier definition
0143 #
0144 #
0145 LHEEventContent = cms.PSet(
0146     outputCommands = cms.untracked.vstring('drop *'),
0147     splitLevel = cms.untracked.int32(0),
0148 )
0149 LHEEventContent.outputCommands.extend(GeneratorInterfaceLHE.outputCommands)
0150 #
0151 #
0152 # GEN Data Tier definition
0153 # include GeneratorInterfaceLHE in case of pLHEGEN campaign
0154 #
0155 GENEventContent = cms.PSet(
0156     outputCommands = cms.untracked.vstring('drop *'),
0157     splitLevel = cms.untracked.int32(0),
0158 )
0159 GENEventContent.outputCommands.extend(GeneratorInterfaceLHE.outputCommands)
0160 GENEventContent.outputCommands.extend(GeneratorInterfaceRAW.outputCommands)
0161 GENEventContent.outputCommands.extend(RecoGenJetsFEVT.outputCommands)
0162 GENEventContent.outputCommands.extend(RecoGenMETFEVT.outputCommands)
0163 GENEventContent.outputCommands.extend(IOMCRAW.outputCommands)
0164 #
0165 #
0166 # RAW Data Tier definition
0167 #
0168 #
0169 RAWEventContent = cms.PSet(
0170     outputCommands = cms.untracked.vstring('drop *',
0171         'keep  FEDRawDataCollection_rawDataCollector_*_*',
0172         'keep  FEDRawDataCollection_source_*_*'),
0173     splitLevel = cms.untracked.int32(0),
0174     compressionAlgorithm=cms.untracked.string("LZMA"),
0175     compressionLevel=cms.untracked.int32(4)
0176 )
0177 RAWEventContent.outputCommands.extend(L1TriggerRAW.outputCommands)
0178 RAWEventContent.outputCommands.extend(HLTriggerRAW.outputCommands)
0179 #
0180 #
0181 # HLTONLY Data Tier definition
0182 #
0183 #
0184 HLTONLYEventContent = cms.PSet(
0185     outputCommands = cms.untracked.vstring('drop *'),
0186     splitLevel = cms.untracked.int32(0)
0187 )
0188 HLTONLYEventContent.outputCommands.extend(L1TriggerRAW.outputCommands)
0189 HLTONLYEventContent.outputCommands.extend(HLTriggerRAW.outputCommands)
0190 HLTONLYEventContent.outputCommands.extend(['drop  FEDRawDataCollection_rawDataCollector_*_*',
0191                                            'drop  FEDRawDataCollection_source_*_*'])
0192 #
0193 #
0194 # RECO Data Tier definition
0195 #
0196 #
0197 RECOEventContent = cms.PSet(
0198     outputCommands = cms.untracked.vstring('drop *'),
0199     splitLevel = cms.untracked.int32(0),
0200 )
0201 RECOEventContent.outputCommands.extend(RecoLocalTrackerRECO.outputCommands)
0202 RECOEventContent.outputCommands.extend(RecoLocalMuonRECO.outputCommands)
0203 RECOEventContent.outputCommands.extend(RecoLocalCaloRECO.outputCommands)
0204 RECOEventContent.outputCommands.extend(RecoEcalRECO.outputCommands)
0205 RECOEventContent.outputCommands.extend(TrackingToolsRECO.outputCommands)
0206 RECOEventContent.outputCommands.extend(RecoTrackerRECO.outputCommands)
0207 RECOEventContent.outputCommands.extend(RecoJetsRECO.outputCommands)
0208 RECOEventContent.outputCommands.extend(RecoMETRECO.outputCommands)
0209 RECOEventContent.outputCommands.extend(RecoMuonRECO.outputCommands)
0210 RECOEventContent.outputCommands.extend(RecoBTauRECO.outputCommands)
0211 RECOEventContent.outputCommands.extend(RecoBTagRECO.outputCommands)
0212 RECOEventContent.outputCommands.extend(RecoTauTagRECO.outputCommands)
0213 RECOEventContent.outputCommands.extend(RecoVertexRECO.outputCommands)
0214 RECOEventContent.outputCommands.extend(RecoEgammaRECO.outputCommands)
0215 RECOEventContent.outputCommands.extend(RecoPixelVertexingRECO.outputCommands)
0216 RECOEventContent.outputCommands.extend(RecoParticleFlowRECO.outputCommands)
0217 RECOEventContent.outputCommands.extend(BeamSpotRECO.outputCommands)
0218 RECOEventContent.outputCommands.extend(L1TriggerRECO.outputCommands)
0219 RECOEventContent.outputCommands.extend(HLTriggerRECO.outputCommands)
0220 RECOEventContent.outputCommands.extend(MEtoEDMConverterRECO.outputCommands)
0221 RECOEventContent.outputCommands.extend(EvtScalersRECO.outputCommands)
0222 RECOEventContent.outputCommands.extend(OnlineMetaDataContent.outputCommands)
0223 RECOEventContent.outputCommands.extend(TcdsEventContent.outputCommands)
0224 RECOEventContent.outputCommands.extend(CommonEventContent.outputCommands)
0225
0226 from Configuration.Eras.Modifier_ctpps_cff import ctpps
0227 from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
0228 from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker
0229 from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
0230 from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
0231 from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017
0232 from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
0233 from Configuration.ProcessModifiers.pp_on_AA_cff import pp_on_AA
0234 from RecoLocalFastTime.Configuration.RecoLocalFastTime_EventContent_cff import *
0235 from RecoMTD.Configuration.RecoMTD_EventContent_cff import *
0236
0237 ctpps.toModify(RECOEventContent,
0238     outputCommands = RECOEventContent.outputCommands + RecoCTPPSRECO.outputCommands)
0239 phase2_hgcal.toModify(RECOEventContent,
0240     outputCommands = RECOEventContent.outputCommands + TICL_RECO.outputCommands)
0241 #
0242 #
0243 # RAWRECO Data Tier definition
0244 #
0245 #
0246 RAWRECOEventContent = cms.PSet(
0247     outputCommands = cms.untracked.vstring('drop *'),
0248     splitLevel = cms.untracked.int32(0),
0249 )
0250 RAWRECOEventContent.outputCommands.extend(RECOEventContent.outputCommands)
0251 RAWRECOEventContent.outputCommands.extend(cms.untracked.vstring(
0252     'keep FEDRawDataCollection_rawDataCollector_*_*',
0253     'keep FEDRawDataCollection_source_*_*')
0254 )
0255 #
0256 #
0257 # AOD Data Tier definition
0258 #
0259 #
0260 AODEventContent = cms.PSet(
0261     outputCommands = cms.untracked.vstring('drop *'),
0262     eventAutoFlushCompressedSize=cms.untracked.int32(30*1024*1024),
0263     compressionAlgorithm=cms.untracked.string("LZMA"),
0264     compressionLevel=cms.untracked.int32(4)
0265 )
0266 AODEventContent.outputCommands.extend(RecoLocalTrackerAOD.outputCommands)
0267 AODEventContent.outputCommands.extend(RecoLocalMuonAOD.outputCommands)
0268 AODEventContent.outputCommands.extend(RecoLocalCaloAOD.outputCommands)
0269 AODEventContent.outputCommands.extend(RecoEcalAOD.outputCommands)
0270 AODEventContent.outputCommands.extend(TrackingToolsAOD.outputCommands)
0271 AODEventContent.outputCommands.extend(RecoTrackerAOD.outputCommands)
0272 AODEventContent.outputCommands.extend(RecoJetsAOD.outputCommands)
0273 AODEventContent.outputCommands.extend(RecoMETAOD.outputCommands)
0274 AODEventContent.outputCommands.extend(RecoMuonAOD.outputCommands)
0275 AODEventContent.outputCommands.extend(RecoBTauAOD.outputCommands)
0276 AODEventContent.outputCommands.extend(RecoBTagAOD.outputCommands)
0277 AODEventContent.outputCommands.extend(RecoTauTagAOD.outputCommands)
0278 AODEventContent.outputCommands.extend(RecoVertexAOD.outputCommands)
0279 AODEventContent.outputCommands.extend(RecoEgammaAOD.outputCommands)
0280 AODEventContent.outputCommands.extend(RecoParticleFlowAOD.outputCommands)
0281 AODEventContent.outputCommands.extend(BeamSpotAOD.outputCommands)
0282 AODEventContent.outputCommands.extend(L1TriggerAOD.outputCommands)
0283 AODEventContent.outputCommands.extend(HLTriggerAOD.outputCommands)
0284 AODEventContent.outputCommands.extend(MEtoEDMConverterAOD.outputCommands)
0285 AODEventContent.outputCommands.extend(EvtScalersAOD.outputCommands)
0286 AODEventContent.outputCommands.extend(OnlineMetaDataContent.outputCommands)
0287 AODEventContent.outputCommands.extend(TcdsEventContent.outputCommands)
0288 AODEventContent.outputCommands.extend(CommonEventContent.outputCommands)
0289
0290 ctpps.toModify(AODEventContent,
0291     outputCommands = AODEventContent.outputCommands + RecoCTPPSAOD.outputCommands)
0292 phase2_hgcal.toModify(AODEventContent,
0293     outputCommands = AODEventContent.outputCommands + TICL_AOD.outputCommands)
0294 #
0295 #
0296 # RAWAOD Data Tier definition
0297 #
0298 #
0299 RAWAODEventContent = cms.PSet(
0300     outputCommands = cms.untracked.vstring('drop *'),
0301     eventAutoFlushCompressedSize=cms.untracked.int32(30*1024*1024),
0302     compressionAlgorithm=cms.untracked.string("LZMA"),
0303     compressionLevel=cms.untracked.int32(4)
0304 )
0305 RAWAODEventContent.outputCommands.extend(AODEventContent.outputCommands)
0306 RAWAODEventContent.outputCommands.extend(cms.untracked.vstring(
0307     'keep FEDRawDataCollection_rawDataCollector_*_*',
0308     'keep FEDRawDataCollection_source_*_*')
0309 )
0310 #
0311 #
0312 # RAWSIM Data Tier definition
0313 # ===========================
0314 #
0315 # Here, we sacrifice memory and CPU time to decrease the on-disk size as
0316 # much as possible.  Given the current per-event GEN-SIM and DIGI-RECO times,
0317 # the extra CPU time for LZMA compression works out to be ~1%.  The GEN-SIM
0318 # use case of reading a minbias event for `classic pileup` has a similar CPU
0319 # impact.
0320 # The memory increase appears to be closer to 50MB - but that should be
0321 # acceptable as the introduction of multithreaded processing has bought us some
0322 # breathing room.
0323 #
0324 RAWSIMEventContent = cms.PSet(
0325     outputCommands = cms.untracked.vstring('drop *'),
0326     splitLevel = cms.untracked.int32(0),
0327     eventAutoFlushCompressedSize=cms.untracked.int32(20*1024*1024),
0328     compressionAlgorithm=cms.untracked.string("LZMA"),
0329     compressionLevel=cms.untracked.int32(1)
0330 )
0331 RAWSIMEventContent.outputCommands.extend(RAWEventContent.outputCommands)
0332 RAWSIMEventContent.outputCommands.extend(SimG4CoreRAW.outputCommands)
0333 RAWSIMEventContent.outputCommands.extend(SimTrackerRAW.outputCommands)
0334 RAWSIMEventContent.outputCommands.extend(SimMuonRAW.outputCommands)
0335 RAWSIMEventContent.outputCommands.extend(SimCalorimetryRAW.outputCommands)
0336 RAWSIMEventContent.outputCommands.extend(SimFastTimingRAW.outputCommands)
0337 RAWSIMEventContent.outputCommands.extend(SimGeneralRAW.outputCommands)
0338 RAWSIMEventContent.outputCommands.extend(GeneratorInterfaceRAW.outputCommands)
0339 RAWSIMEventContent.outputCommands.extend(RecoGenJetsFEVT.outputCommands)
0340 RAWSIMEventContent.outputCommands.extend(RecoGenMETFEVT.outputCommands)
0341 RAWSIMEventContent.outputCommands.extend(DigiToRawFEVT.outputCommands)
0342 RAWSIMEventContent.outputCommands.extend(MEtoEDMConverterFEVT.outputCommands)
0343 RAWSIMEventContent.outputCommands.extend(IOMCRAW.outputCommands)
0344 RAWSIMEventContent.outputCommands.extend(CommonEventContent.outputCommands)
0345 #
0346 # Temporary collections needed for Phase-2 RECO using RAWSIM as input in Prod-like workflow
0347 # They are until packer/unpackers are done.
0348 #
0349 from Configuration.Eras.Modifier_phase2_common_cff import phase2_common
0350 phase2_common.toModify(RAWSIMEventContent,
0351     outputCommands = RAWSIMEventContent.outputCommands+[
0352         'keep *_sim*Digis_*_*',
0353         'keep *Phase2TrackerDigi*_*_*_*'])
0354 #
0355 #
0356 # RAWSIMHLT Data Tier definition
0357 #
0358 #
0359 RAWSIMHLTEventContent = cms.PSet(
0360     outputCommands = cms.untracked.vstring('drop *'),
0361     splitLevel = cms.untracked.int32(0),
0362 )
0363 RAWSIMHLTEventContent.outputCommands.extend(RAWSIMEventContent.outputCommands)
0364 RAWSIMHLTEventContent.outputCommands.extend(HLTDebugRAW.outputCommands)
0365 #
0366 #
0367 # RAWRECOSIMHLT Data Tier definition
0368 #
0369 #
0370 RAWRECOSIMHLTEventContent = cms.PSet(
0371     outputCommands = cms.untracked.vstring('drop *'),
0372     splitLevel = cms.untracked.int32(0),
0373 )
0374 RAWRECOSIMHLTEventContent.outputCommands.extend(RAWRECOEventContent.outputCommands)
0375 RAWRECOSIMHLTEventContent.outputCommands.extend(GeneratorInterfaceRECO.outputCommands)
0376 RAWRECOSIMHLTEventContent.outputCommands.extend(RecoGenMETRECO.outputCommands)
0377 RAWRECOSIMHLTEventContent.outputCommands.extend(RecoGenJetsRECO.outputCommands)
0378 RAWRECOSIMHLTEventContent.outputCommands.extend(SimG4CoreRECO.outputCommands)
0379 RAWRECOSIMHLTEventContent.outputCommands.extend(SimTrackerRECO.outputCommands)
0380 RAWRECOSIMHLTEventContent.outputCommands.extend(SimMuonRECO.outputCommands)
0381 RAWRECOSIMHLTEventContent.outputCommands.extend(SimCalorimetryRECO.outputCommands)
0382 RAWRECOSIMHLTEventContent.outputCommands.extend(SimFastTimingRECO.outputCommands)
0383 RAWRECOSIMHLTEventContent.outputCommands.extend(SimGeneralRECO.outputCommands)
0384 RAWRECOSIMHLTEventContent.outputCommands.extend(MEtoEDMConverterRECO.outputCommands)
0385 RAWRECOSIMHLTEventContent.outputCommands.extend(HLTDebugRAW.outputCommands)
0386 #
0387 #
0388 # RAWRECODEBUGHLT Data Tier definition
0389 #
0390 #
0391 RAWRECODEBUGHLTEventContent = cms.PSet(
0392     outputCommands = cms.untracked.vstring('drop *'),
0393     splitLevel = cms.untracked.int32(0),
0394 )
0395 RAWRECODEBUGHLTEventContent.outputCommands.extend(RAWRECOSIMHLTEventContent.outputCommands)
0396 RAWRECODEBUGHLTEventContent.outputCommands.extend(SimGeneralFEVTDEBUG.outputCommands)
0397 RAWRECODEBUGHLTEventContent.outputCommands.extend(SimTrackerDEBUG.outputCommands)
0398 #
0399 #
0400 # HLTONLYSIM Data Tier definition
0401 #
0402 #
0403 HLTONLYSIMEventContent = HLTONLYEventContent.clone()
0404 #
0405 #
0406 # RECOSIM Data Tier definition
0407 #
0408 #
0409 RECOSIMEventContent = cms.PSet(
0410     outputCommands = cms.untracked.vstring('drop *'),
0411     splitLevel = cms.untracked.int32(0),
0412 )
0413 RECOSIMEventContent.outputCommands.extend(RECOEventContent.outputCommands)
0414 RECOSIMEventContent.outputCommands.extend(GeneratorInterfaceRECO.outputCommands)
0415 RECOSIMEventContent.outputCommands.extend(RecoGenMETRECO.outputCommands)
0416 RECOSIMEventContent.outputCommands.extend(RecoGenJetsRECO.outputCommands)
0417 RECOSIMEventContent.outputCommands.extend(SimG4CoreRECO.outputCommands)
0418 RECOSIMEventContent.outputCommands.extend(SimTrackerRECO.outputCommands)
0419 RECOSIMEventContent.outputCommands.extend(SimMuonRECO.outputCommands)
0420 RECOSIMEventContent.outputCommands.extend(SimCalorimetryRECO.outputCommands)
0421 RECOSIMEventContent.outputCommands.extend(SimFastTimingRECO.outputCommands)
0422 RECOSIMEventContent.outputCommands.extend(SimGeneralRECO.outputCommands)
0423 RECOSIMEventContent.outputCommands.extend(MEtoEDMConverterRECO.outputCommands)
0424
0425 phase2_timing_layer.toModify(RECOSIMEventContent,
0426     outputCommands = RECOSIMEventContent.outputCommands + RecoLocalFastTimeRECO.outputCommands)
0427 phase2_timing_layer.toModify(RECOSIMEventContent,
0428     outputCommands = RECOSIMEventContent.outputCommands + RecoMTDRECO.outputCommands)
0429 #
0430 #
0431 # GENRAW Data Tier definition
0432 #
0433 #
0434 GENRAWEventContent = cms.PSet(
0435     outputCommands = cms.untracked.vstring('drop *'),
0436     splitLevel = cms.untracked.int32(0),
0437 )
0438 GENRAWEventContent.outputCommands.extend(RAWEventContent.outputCommands)
0439 GENRAWEventContent.outputCommands.extend(GeneratorInterfaceRECO.outputCommands)
0440 GENRAWEventContent.outputCommands.extend(SimG4CoreRECO.outputCommands)
0441 GENRAWEventContent.outputCommands.extend(SimTrackerRAW.outputCommands)
0442 GENRAWEventContent.outputCommands.extend(SimMuonRECO.outputCommands)
0443 GENRAWEventContent.outputCommands.extend(SimCalorimetryRECO.outputCommands)
0444 GENRAWEventContent.outputCommands.extend(SimFastTimingRECO.outputCommands)
0445 GENRAWEventContent.outputCommands.extend(SimGeneralRECO.outputCommands)
0446 GENRAWEventContent.outputCommands.extend(RecoGenMETFEVT.outputCommands)
0447 GENRAWEventContent.outputCommands.extend(RecoGenJetsFEVT.outputCommands)
0448 GENRAWEventContent.outputCommands.extend(MEtoEDMConverterFEVT.outputCommands)
0449 GENRAWEventContent.outputCommands.extend(IOMCRAW.outputCommands)
0450 GENRAWEventContent.outputCommands.extend(DigiToRawFEVT.outputCommands)
0451 GENRAWEventContent.outputCommands.extend(CommonEventContent.outputCommands)
0452 #
0453 #
0454 # AODSIM Data Tier definition
0455 #
0456 #
0457 AODSIMEventContent = cms.PSet(
0458     outputCommands = cms.untracked.vstring('drop *'),
0459     eventAutoFlushCompressedSize=cms.untracked.int32(30*1024*1024),
0460     compressionAlgorithm=cms.untracked.string("LZMA"),
0461     compressionLevel=cms.untracked.int32(4),
0462 )
0463 AODSIMEventContent.outputCommands.extend(AODEventContent.outputCommands)
0464 AODSIMEventContent.outputCommands.extend(GeneratorInterfaceAOD.outputCommands)
0465 AODSIMEventContent.outputCommands.extend(SimG4CoreAOD.outputCommands)
0466 AODSIMEventContent.outputCommands.extend(SimTrackerAOD.outputCommands)
0467 AODSIMEventContent.outputCommands.extend(SimMuonAOD.outputCommands)
0468 AODSIMEventContent.outputCommands.extend(SimCalorimetryAOD.outputCommands)
0469 AODSIMEventContent.outputCommands.extend(SimFastTimingAOD.outputCommands)
0470 AODSIMEventContent.outputCommands.extend(RecoGenJetsAOD.outputCommands)
0471 AODSIMEventContent.outputCommands.extend(RecoGenMETAOD.outputCommands)
0472 AODSIMEventContent.outputCommands.extend(SimGeneralAOD.outputCommands)
0473 AODSIMEventContent.outputCommands.extend(MEtoEDMConverterAOD.outputCommands)
0474
0475 phase2_timing_layer.toModify(AODSIMEventContent,
0476     outputCommands = AODSIMEventContent.outputCommands + RecoLocalFastTimeAOD.outputCommands)
0477 phase2_timing_layer.toModify(AODSIMEventContent,
0478     outputCommands = AODSIMEventContent.outputCommands + RecoMTDAOD.outputCommands)
0479 #
0480 #
0481 # FEVT Data Tier definition
0482 #
0483 #
0484 FEVTEventContent = cms.PSet(
0485     outputCommands = cms.untracked.vstring('drop *'),
0486     splitLevel = cms.untracked.int32(0),
0487 )
0488 FEVTEventContent.outputCommands.extend(RAWEventContent.outputCommands)
0489 FEVTEventContent.outputCommands.extend(RecoLocalTrackerRECO.outputCommands)
0490 FEVTEventContent.outputCommands.extend(RecoLocalMuonRECO.outputCommands)
0491 FEVTEventContent.outputCommands.extend(RecoLocalCaloRECO.outputCommands)
0492 FEVTEventContent.outputCommands.extend(RecoEcalRECO.outputCommands)
0493 FEVTEventContent.outputCommands.extend(TrackingToolsRECO.outputCommands)
0494 FEVTEventContent.outputCommands.extend(RecoTrackerRECO.outputCommands)
0495 FEVTEventContent.outputCommands.extend(RecoJetsRECO.outputCommands)
0496 FEVTEventContent.outputCommands.extend(RecoMETRECO.outputCommands)
0497 FEVTEventContent.outputCommands.extend(RecoMuonRECO.outputCommands)
0498 FEVTEventContent.outputCommands.extend(RecoBTauRECO.outputCommands)
0499 FEVTEventContent.outputCommands.extend(RecoBTagRECO.outputCommands)
0500 FEVTEventContent.outputCommands.extend(RecoTauTagRECO.outputCommands)
0501 FEVTEventContent.outputCommands.extend(RecoVertexRECO.outputCommands)
0502 FEVTEventContent.outputCommands.extend(RecoEgammaRECO.outputCommands)
0503 FEVTEventContent.outputCommands.extend(RecoPixelVertexingRECO.outputCommands)
0504 FEVTEventContent.outputCommands.extend(RecoParticleFlowRECO.outputCommands)
0505 FEVTEventContent.outputCommands.extend(BeamSpotRECO.outputCommands)
0506 FEVTEventContent.outputCommands.extend(L1TriggerRECO.outputCommands)
0507 FEVTEventContent.outputCommands.extend(HLTriggerRECO.outputCommands)
0508 FEVTEventContent.outputCommands.extend(MEtoEDMConverterRECO.outputCommands)
0509 FEVTEventContent.outputCommands.extend(EvtScalersRECO.outputCommands)
0510 FEVTEventContent.outputCommands.extend(OnlineMetaDataContent.outputCommands)
0511 FEVTEventContent.outputCommands.extend(TcdsEventContent.outputCommands)
0512 FEVTEventContent.outputCommands.extend(CommonEventContent.outputCommands)
0513
0514 ctpps.toModify(FEVTEventContent,
0515     outputCommands = FEVTEventContent.outputCommands + RecoCTPPSFEVT.outputCommands)
0516 phase2_hgcal.toModify(FEVTEventContent,
0517     outputCommands = FEVTEventContent.outputCommands + TICL_FEVT.outputCommands)
0518 phase2_tracker.toModify(FEVTEventContent,
0519     outputCommands = FEVTEventContent.outputCommands + [
0520         'keep Phase2TrackerDigiedmDetSetVector_mix_*_*',
0521         'keep *_TTClustersFromPhase2TrackerDigis_*_*',
0522         'keep *_TTStubsFromPhase2TrackerDigis_*_*',
0523         'keep *_TrackerDTC_*_*',
0524         'keep *_*_Level1TTTracks_*'])
0525 phase2_muon.toModify(FEVTEventContent,
0526     outputCommands = FEVTEventContent.outputCommands + ['keep *_muonGEMDigis_*_*'])
0527 run2_GEM_2017.toModify(FEVTEventContent,
0528     outputCommands = FEVTEventContent.outputCommands + ['keep *_muonGEMDigis_*_*'])
0529 run3_GEM.toModify(FEVTEventContent,
0530     outputCommands = FEVTEventContent.outputCommands + ['keep *_muonGEMDigis_*_*'])
0531 pp_on_AA.toModify(FEVTEventContent,
0532     outputCommands = FEVTEventContent.outputCommands + ['keep FEDRawDataCollection_rawDataRepacker_*_*'])
0533 phase2_timing_layer.toModify(FEVTEventContent,
0534     outputCommands = FEVTEventContent.outputCommands + RecoLocalFastTimeFEVT.outputCommands)
0535 phase2_timing_layer.toModify(FEVTEventContent,
0536     outputCommands = FEVTEventContent.outputCommands + RecoMTDFEVT.outputCommands)
0537
0538 FEVTHLTALLEventContent = cms.PSet(
0539     outputCommands = cms.untracked.vstring('drop *'),
0540     splitLevel = cms.untracked.int32(0),
0541 )
0542 FEVTHLTALLEventContent.outputCommands.extend(FEVTEventContent.outputCommands)
0543 FEVTHLTALLEventContent.outputCommands.append('keep *_*_*_HLT')
0544 #
0545 #
0546 # FEVTSIM Data Tier definition
0547 #
0548 #
0549 FEVTSIMEventContent = cms.PSet(
0550     outputCommands = cms.untracked.vstring('drop *'),
0551     splitLevel = cms.untracked.int32(0),
0552 )
0553 FEVTSIMEventContent.outputCommands.extend(FEVTEventContent.outputCommands)
0554 FEVTSIMEventContent.outputCommands.extend(SimG4CoreRAW.outputCommands)
0555 FEVTSIMEventContent.outputCommands.extend(SimTrackerRAW.outputCommands)
0556 FEVTSIMEventContent.outputCommands.extend(SimMuonRAW.outputCommands)
0557 FEVTSIMEventContent.outputCommands.extend(SimCalorimetryRAW.outputCommands)
0558 FEVTSIMEventContent.outputCommands.extend(SimFastTimingRAW.outputCommands)
0559 FEVTSIMEventContent.outputCommands.extend(SimGeneralRAW.outputCommands)
0560 FEVTSIMEventContent.outputCommands.extend(GeneratorInterfaceRAW.outputCommands)
0561 FEVTSIMEventContent.outputCommands.extend(RecoGenJetsFEVT.outputCommands)
0562 FEVTSIMEventContent.outputCommands.extend(RecoGenMETFEVT.outputCommands)
0563 FEVTSIMEventContent.outputCommands.extend(DigiToRawFEVT.outputCommands)
0564 FEVTSIMEventContent.outputCommands.extend(MEtoEDMConverterFEVT.outputCommands)
0565 FEVTSIMEventContent.outputCommands.extend(IOMCRAW.outputCommands)
0566 FEVTSIMEventContent.outputCommands.extend(GeneratorInterfaceRECO.outputCommands)
0567 FEVTSIMEventContent.outputCommands.extend(RecoGenMETRECO.outputCommands)
0568 FEVTSIMEventContent.outputCommands.extend(RecoGenJetsRECO.outputCommands)
0569 FEVTSIMEventContent.outputCommands.extend(SimG4CoreRECO.outputCommands)
0570 FEVTSIMEventContent.outputCommands.extend(SimTrackerRECO.outputCommands)
0571 FEVTSIMEventContent.outputCommands.extend(SimMuonRECO.outputCommands)
0572 FEVTSIMEventContent.outputCommands.extend(SimCalorimetryRECO.outputCommands)
0573 FEVTSIMEventContent.outputCommands.extend(SimFastTimingRECO.outputCommands)
0574 FEVTSIMEventContent.outputCommands.extend(SimGeneralRECO.outputCommands)
0575 #
0576 #
0577 # RAWDEBUG Data Tier definition
0578 #
0579 #
0580 RAWDEBUGEventContent = cms.PSet(
0581     outputCommands = cms.untracked.vstring('drop *'),
0582     splitLevel = cms.untracked.int32(0),
0583 )
0584 RAWDEBUGEventContent.outputCommands.extend(RAWSIMEventContent.outputCommands)
0585 RAWDEBUGEventContent.outputCommands.extend(SimTrackerDEBUG.outputCommands)
0586 RAWDEBUGEventContent.outputCommands.extend(SimGeneralFEVTDEBUG.outputCommands)
0587 RAWDEBUGEventContent.outputCommands.extend(L1TriggerRAWDEBUG.outputCommands)
0588 #
0589 #
0590 # RAWDEBUGHLT Data Tier definition
0591 #
0592 #
0593 RAWDEBUGHLTEventContent = cms.PSet(
0594     outputCommands = cms.untracked.vstring('drop *'),
0595     splitLevel = cms.untracked.int32(0),
0596 )
0597 RAWDEBUGHLTEventContent.outputCommands.extend(RAWDEBUGEventContent.outputCommands)
0598 RAWDEBUGHLTEventContent.outputCommands.extend(HLTDebugRAW.outputCommands)
0599 #
0600 #
0601 # FEVTDEBUG Data Tier definition
0602 #
0603 #
0604 FEVTDEBUGEventContent = cms.PSet(
0605     outputCommands = cms.untracked.vstring('drop *'),
0606     splitLevel = cms.untracked.int32(0),
0607 )
0608 FEVTDEBUGEventContent.outputCommands.extend(FEVTSIMEventContent.outputCommands)
0609 FEVTDEBUGEventContent.outputCommands.extend(L1TriggerFEVTDEBUG.outputCommands)
0610 FEVTDEBUGEventContent.outputCommands.extend(SimGeneralFEVTDEBUG.outputCommands)
0611 FEVTDEBUGEventContent.outputCommands.extend(SimTrackerFEVTDEBUG.outputCommands)
0612 FEVTDEBUGEventContent.outputCommands.extend(SimMuonFEVTDEBUG.outputCommands)
0613 FEVTDEBUGEventContent.outputCommands.extend(SimCalorimetryFEVTDEBUG.outputCommands)
0614 FEVTDEBUGEventContent.outputCommands.extend(SimFastTimingFEVTDEBUG.outputCommands)
0615 #
0616 #
0617 # FEVTDEBUGHLT Data Tier definition
0618 #
0619 #
0620 FEVTDEBUGHLTEventContent = cms.PSet(
0621     outputCommands = cms.untracked.vstring('drop *'),
0622     splitLevel = cms.untracked.int32(0),
0623 )
0624 FEVTDEBUGHLTEventContent.outputCommands.extend(FEVTDEBUGEventContent.outputCommands)
0625 FEVTDEBUGHLTEventContent.outputCommands.extend(HLTDebugFEVT.outputCommands)
0626 FEVTDEBUGHLTEventContent.outputCommands.append('keep *_*_MergedTrackTruth_*')
0627 FEVTDEBUGHLTEventContent.outputCommands.append('keep *_*_StripDigiSimLink_*')
0628 FEVTDEBUGHLTEventContent.outputCommands.append('keep *_*_PixelDigiSimLink_*')
0629
0630 from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2
0631
0632 (premix_stage2 & phase2_tracker).toModify(FEVTDEBUGHLTEventContent,
0633     outputCommands = FEVTDEBUGHLTEventContent.outputCommands+[
0634         'keep *_*_Phase2OTDigiSimLink_*'])
0635 (premix_stage2 & phase2_muon).toModify(FEVTDEBUGHLTEventContent,
0636     outputCommands = FEVTDEBUGHLTEventContent.outputCommands+[
0637         'keep *_*_GEMDigiSimLink_*',
0638         'keep *_*_GEMStripDigiSimLink_*',
0639         'keep *_*_ME0DigiSimLink_*',
0640         'keep *_*_ME0StripDigiSimLink_*'])
0641 #
0642 #
0643 # RECOSIMDEBUG Data Tier definition
0644 #
0645 #
0646 RECODEBUGEventContent = cms.PSet(
0647     outputCommands = cms.untracked.vstring('drop *'),
0648     splitLevel = cms.untracked.int32(0),
0649 )
0650 RECODEBUGEventContent.outputCommands.extend(RECOSIMEventContent.outputCommands)
0651 RECODEBUGEventContent.outputCommands.extend(SimGeneralFEVTDEBUG.outputCommands)
0652 RECODEBUGEventContent.outputCommands.extend(SimTrackerDEBUG.outputCommands)
0653 #
0654 ## HLTDEBUG tier definition
0655 #
0656 HLTDEBUGEventContent = cms.PSet(
0657     #outputCommands = cms.untracked.vstring('drop *',
0658     #        'keep *_hlt*_*_*')
0659     outputCommands = cms.untracked.vstring('drop *',
0660         'keep *_logErrorHarvester_*_*'),
0661     splitLevel = cms.untracked.int32(0),
0662 )
0663 HLTDEBUGEventContent.outputCommands.extend(HLTDebugFEVT.outputCommands)
0664 #
0665 #
0666 ## DQM event content
0667 #
0668 #
0669 DQMEventContent = cms.PSet(
0670     outputCommands = cms.untracked.vstring('drop *',
0671         'keep *_MEtoEDMConverter_*_*'),
0672     splitLevel = cms.untracked.int32(0)
0673 )
0674
0675 #Special Event Content for MixingModule and DataMixer
0676 DATAMIXEREventContent = cms.PSet(
0677     outputCommands = cms.untracked.vstring('drop *',
0678         'keep CSCDetIdCSCALCTDigiMuonDigiCollection_muonCSCDigis_MuonCSCALCTDigi_*',
0679         'keep CSCDetIdCSCCLCTDigiMuonDigiCollection_muonCSCDigis_MuonCSCCLCTDigi_*',
0680         'keep CSCDetIdCSCComparatorDigiMuonDigiCollection_muonCSCDigis_MuonCSCComparatorDigi_*',
0681         'keep CSCDetIdCSCCorrelatedLCTDigiMuonDigiCollection_csctfDigis_*_*',
0682         'keep CSCDetIdCSCCorrelatedLCTDigiMuonDigiCollection_muonCSCDigis_MuonCSCCorrelatedLCTDigi_*',
0683         'keep CSCDetIdCSCRPCDigiMuonDigiCollection_muonCSCDigis_MuonCSCRPCDigi_*',
0684         'keep CSCDetIdCSCStripDigiMuonDigiCollection_muonCSCDigis_MuonCSCStripDigi_*',
0685         'keep CSCDetIdCSCWireDigiMuonDigiCollection_muonCSCDigis_MuonCSCWireDigi_*',
0686         'keep DTLayerIdDTDigiMuonDigiCollection_muonDTDigis_*_*',
0687         'keep PixelDigiedmDetSetVector_siPixelDigis_*_*',
0688         'keep SiStripDigiedmDetSetVector_siStripDigis_*_*',
0689         'keep RPCDetIdRPCDigiMuonDigiCollection_muonRPCDigis_*_*',
0690         'keep HBHEDataFramesSorted_hcalDigis_*_*',
0691         'keep HFDataFramesSorted_hcalDigis_*_*',
0692         'keep HODataFramesSorted_hcalDigis_*_*',
0693         'keep QIE10DataFrameHcalDataFrameContainer_hcalDigis_*_*',
0694         'keep QIE11DataFrameHcalDataFrameContainer_hcalDigis_*_*',
0695         'keep ZDCDataFramesSorted_hcalDigis_*_*',
0696         'keep CastorDataFramesSorted_castorDigis_*_*',
0697         'keep EBDigiCollection_ecalDigis_*_*',
0698         'keep EEDigiCollection_ecalDigis_*_*',
0699         'keep ESDigiCollection_ecalPreshowerDigis_*_*'),
0700     splitLevel = cms.untracked.int32(0),
0701 )
0702
0703 PREMIXEventContent = cms.PSet(
0704     outputCommands = cms.untracked.vstring('drop *'),
0705     splitLevel = cms.untracked.int32(0),
0706 )
0707 PREMIXEventContent.outputCommands.extend(SimGeneralRAW.outputCommands)
0708 PREMIXEventContent.outputCommands.extend(IOMCRAW.outputCommands)
0709 PREMIXEventContent.outputCommands.extend(CommonEventContent.outputCommands)
0710 PREMIXEventContent.outputCommands.extend(SimTrackerPREMIX.outputCommands)
0711 PREMIXEventContent.outputCommands.extend(SimCalorimetryPREMIX.outputCommands)
0712 PREMIXEventContent.outputCommands.extend(SimFastTimingPREMIX.outputCommands)
0713 PREMIXEventContent.outputCommands.extend(SimMuonPREMIX.outputCommands)
0714 PREMIXEventContent.outputCommands.extend(SimGeneralPREMIX.outputCommands)
0715 fastSim.toModify(PREMIXEventContent,
0716     outputCommands = PREMIXEventContent.outputCommands+fastSimEC.extraPremixContent)
0717
0718 MIXINGMODULEEventContent = cms.PSet(
0719     outputCommands = cms.untracked.vstring('drop *',
0720         'keep *_cfWriter_*_*'),
0721     splitLevel = cms.untracked.int32(0),
0722 )
0723
0724 # PREMIXRAW Data Tier definition
0725 #
0726 #
0727 PREMIXRAWEventContent = cms.PSet(
0728     outputCommands = cms.untracked.vstring('drop *'),
0729     splitLevel = cms.untracked.int32(0),
0730 )
0731 PREMIXRAWEventContent.outputCommands.extend(RAWSIMEventContent.outputCommands)
0732 PREMIXRAWEventContent.outputCommands.append('keep CrossingFramePlaybackInfoNew_*_*_*')
0733 PREMIXRAWEventContent.outputCommands.append('drop CrossingFramePlaybackInfoNew_mix_*_*')
0734 PREMIXRAWEventContent.outputCommands.append('keep *_*_MergedTrackTruth_*')
0735 PREMIXRAWEventContent.outputCommands.append('keep *_*_StripDigiSimLink_*')
0736 PREMIXRAWEventContent.outputCommands.append('keep *_*_PixelDigiSimLink_*')
0737 PREMIXRAWEventContent.outputCommands.append('keep *_*_MuonCSCStripDigiSimLinks_*')
0738 PREMIXRAWEventContent.outputCommands.append('keep *_*_MuonCSCWireDigiSimLinks_*')
0739 PREMIXRAWEventContent.outputCommands.append('keep *_*_RPCDigiSimLink_*')
0740 PREMIXRAWEventContent.outputCommands.append('keep DTLayerIdDTDigiSimLinkMuonDigiCollection_*_*_*')
0741 #
0742 # Temporary eventcontent for Prod-Like Phase2 PREMIXRAW.
0743 # They are until packer/unpackers are done.
0744 #
0745 (premix_stage2 & phase2_common).toModify(PREMIXRAWEventContent,
0746                                          outputCommands = PREMIXRAWEventContent.outputCommands + [
0747                                               'drop *_simSiPixelDigis_*_*',
0748                                               'keep *_mixData_Pixel_*',
0749                                               'keep *_mixData_Tracker_*',
0750                                               'keep *_*_Phase2OTDigiSimLink_*',
0751                                               'keep *_*_GEMDigiSimLink_*',
0752                                               'keep *_*_GEMStripDigiSimLink_*',
0753                                               'keep *_*_ME0DigiSimLink_*',
0754                                               'keep *_*_ME0StripDigiSimLink_*'
0755                                          ])
0756
0757 #
0758 #
0759 ## RAW repacked event content definition
0760 #
0761 #
0762 REPACKRAWEventContent = cms.PSet(
0763     outputCommands = cms.untracked.vstring('drop *',
0764         'drop FEDRawDataCollection_*_*_*',
0765         'keep FEDRawDataCollection_rawDataRepacker_*_*',
0766         'keep FEDRawDataCollection_virginRawDataRepacker_*_*',
0767         'keep FEDRawDataCollection_rawDataReducedFormat_*_*'),
0768     splitLevel = cms.untracked.int32(0),
0769 )
0770 REPACKRAWEventContent.outputCommands.extend(L1TriggerRAW.outputCommands)
0771 REPACKRAWEventContent.outputCommands.extend(HLTriggerRAW.outputCommands)
0772
0773 REPACKRAWSIMEventContent = cms.PSet(
0774     outputCommands = cms.untracked.vstring(),
0775     splitLevel = cms.untracked.int32(0),
0776 )
0777 REPACKRAWSIMEventContent.outputCommands.extend(REPACKRAWEventContent.outputCommands)
0778 REPACKRAWSIMEventContent.outputCommands.extend(SimG4CoreRAW.outputCommands)
0779 REPACKRAWSIMEventContent.outputCommands.extend(SimTrackerRAW.outputCommands)
0780 REPACKRAWSIMEventContent.outputCommands.extend(SimMuonRAW.outputCommands)
0781 REPACKRAWSIMEventContent.outputCommands.extend(SimCalorimetryRAW.outputCommands)
0782 REPACKRAWSIMEventContent.outputCommands.extend(SimFastTimingRAW.outputCommands)
0783 REPACKRAWSIMEventContent.outputCommands.extend(SimGeneralRAW.outputCommands)
0784 REPACKRAWSIMEventContent.outputCommands.extend(GeneratorInterfaceRAW.outputCommands)
0785 REPACKRAWSIMEventContent.outputCommands.extend(RecoGenJetsFEVT.outputCommands)
0786 REPACKRAWSIMEventContent.outputCommands.extend(RecoGenMETFEVT.outputCommands)
0787 REPACKRAWSIMEventContent.outputCommands.extend(DigiToRawFEVT.outputCommands)
0788 REPACKRAWSIMEventContent.outputCommands.extend(MEtoEDMConverterFEVT.outputCommands)
0789 REPACKRAWSIMEventContent.outputCommands.extend(IOMCRAW.outputCommands)
0790 REPACKRAWSIMEventContent.outputCommands.extend(CommonEventContent.outputCommands)
0791 REPACKRAWSIMEventContent.outputCommands.extend([
0792     'drop FEDRawDataCollection_source_*_*',
0793         'drop FEDRawDataCollection_rawDataCollector_*_*'])
0794 REPACKRAWEventContent.outputCommands.extend([
0795     'drop FEDRawDataCollection_source_*_*',
0796         'drop FEDRawDataCollection_rawDataCollector_*_*'])
0797
0798 #from modules in Configuration.StandardSequence.Generator_cff fixGenInfo
0799 REGENEventContent = cms.PSet(
0800     inputCommands=cms.untracked.vstring(
0801         'keep *',
0802         'drop *_genParticles_*_*',
0803         'drop *_genParticlesForJets_*_*',
0804         'drop *_kt4GenJets_*_*',
0805         'drop *_kt6GenJets_*_*',
0806         'drop *_iterativeCone5GenJets_*_*',
0807         'drop *_ak4GenJets_*_*',
0808         'drop *_ak7GenJets_*_*',
0809         'drop *_ak8GenJets_*_*',
0810         'drop *_ak4GenJetsNoNu_*_*',
0811         'drop *_ak8GenJetsNoNu_*_*',
0812         'drop *_genCandidatesForMET_*_*',
0813         'drop *_genParticlesForMETAllVisible_*_*',
0814         'drop *_genMetCalo_*_*',
0815         'drop *_genMetCaloAndNonPrompt_*_*',
0816         'drop *_genMetTrue_*_*',
0817         'drop *_genMetIC5GenJs_*_*')
0818 )
0819
0820 RESIMEventContent = cms.PSet(
0821     inputCommands=cms.untracked.vstring('drop *')
0822 )
0823 RESIMEventContent.inputCommands.extend(IOMCRAW.outputCommands)
0824 RESIMEventContent.inputCommands.extend(GeneratorInterfaceRAW.outputCommands)
0825
0826
0827 REDIGIEventContent = cms.PSet(
0828     inputCommands=cms.untracked.vstring('drop *')
0829 )
0830 REDIGIEventContent.inputCommands.extend(SimG4CoreRAW.outputCommands)
0831 REDIGIEventContent.inputCommands.extend(IOMCRAW.outputCommands)
0832 REDIGIEventContent.inputCommands.extend(GeneratorInterfaceRAW.outputCommands)
0833 REDIGIEventContent.inputCommands.append('drop *_randomEngineStateProducer_*_*')
0834
0835 ########### and mini AOD
0836 #
0837 # MiniAOD is a bit special: the files tend to be so small that letting
0838 # ROOT automatically determine when to flush is a surprisingly big overhead.
0839 #
0840 from PhysicsTools.PatAlgos.slimming.slimming_cff import MicroEventContent,MicroEventContentMC,MicroEventContentGEN
0841
0842 MINIAODEventContent= cms.PSet(
0843     outputCommands = cms.untracked.vstring('drop *'),
0844     eventAutoFlushCompressedSize=cms.untracked.int32(-900),
0845     compressionAlgorithm=cms.untracked.string("LZMA"),
0846     compressionLevel=cms.untracked.int32(4)
0847 )
0848 MINIAODEventContent.outputCommands.extend(MicroEventContent.outputCommands)
0849
0850 MINIAODSIMEventContent= cms.PSet(
0851     outputCommands = cms.untracked.vstring('drop *'),
0852     eventAutoFlushCompressedSize=cms.untracked.int32(-900),
0853     compressionAlgorithm=cms.untracked.string("LZMA"),
0854     compressionLevel=cms.untracked.int32(4)
0855 )
0856 MINIAODSIMEventContent.outputCommands.extend(MicroEventContentMC.outputCommands)
0857
0858 MINIGENEventContent= cms.PSet(
0859     outputCommands = cms.untracked.vstring('drop *'),
0860     eventAutoFlushCompressedSize=cms.untracked.int32(15*1024*1024),
0861     compressionAlgorithm=cms.untracked.string("LZMA"),
0862     compressionLevel=cms.untracked.int32(4)
0863 )
0864 MINIGENEventContent.outputCommands.extend(MicroEventContentGEN.outputCommands)
0865
0866 #### RAW+miniAOD
0867
0868 RAWMINIAODEventContent= cms.PSet(
0869     outputCommands = cms.untracked.vstring('drop *'),
0870     eventAutoFlushCompressedSize=cms.untracked.int32(20*1024*1024),
0871     compressionAlgorithm=cms.untracked.string("LZMA"),
0872     compressionLevel=cms.untracked.int32(4)
0873 )
0874 RAWMINIAODEventContent.outputCommands.extend(MicroEventContent.outputCommands)
0875 RAWMINIAODEventContent.outputCommands.extend(L1TriggerRAW.outputCommands)
0876 RAWMINIAODEventContent.outputCommands.extend(HLTriggerRAW.outputCommands)
0877 RAWMINIAODEventContent.outputCommands.extend(cms.untracked.vstring(
0878     'keep FEDRawDataCollection_rawDataCollector_*_*',
0879     'keep FEDRawDataCollection_source_*_*'))
0880
0881 RAWMINIAODSIMEventContent= cms.PSet(
0882     outputCommands = cms.untracked.vstring('drop *'),
0883     eventAutoFlushCompressedSize=cms.untracked.int32(20*1024*1024),
0884     compressionAlgorithm=cms.untracked.string("LZMA"),
0885     compressionLevel=cms.untracked.int32(4)
0886 )
0887 RAWMINIAODSIMEventContent.outputCommands.extend(RAWMINIAODEventContent.outputCommands)
0888 RAWMINIAODSIMEventContent.outputCommands.extend(MicroEventContentMC.outputCommands)
0889 RAWMINIAODSIMEventContent.outputCommands.extend(SimG4CoreHLTAODSIM.outputCommands)
0890 #
0891 #
0892 # RAWSIM Data Tier definition
0893 # Meant as means to temporarily hold the RAW + AODSIM information as to allow the
0894 # L1+HLT to be rerun at a later time.
0895 #
0896 RAWAODSIMEventContent = cms.PSet(
0897     outputCommands = cms.untracked.vstring('drop *'),
0898     eventAutoFlushCompressedSize=cms.untracked.int32(20*1024*1024),
0899     compressionAlgorithm=cms.untracked.string("LZMA"),
0900     compressionLevel=cms.untracked.int32(4)
0901 )
0902 RAWAODSIMEventContent.outputCommands.extend(AODSIMEventContent.outputCommands)
0903 RAWAODSIMEventContent.outputCommands.extend(L1TriggerRAW.outputCommands)
0904 RAWAODSIMEventContent.outputCommands.extend(HLTriggerRAW.outputCommands)
0905 RAWAODSIMEventContent.outputCommands.extend(SimG4CoreHLTAODSIM.outputCommands)
0906
0907 # in fastsim, normal digis are edaliases of simdigis
0908 # drop the simdigis to avoid complaints from the outputmodule related to duplicated branches
0909 for _entry in [FEVTDEBUGHLTEventContent,FEVTDEBUGEventContent,RECOSIMEventContent,AODSIMEventContent,RAWAODSIMEventContent]:
0910     fastSim.toModify(_entry, outputCommands = _entry.outputCommands + fastSimEC.dropSimDigis)
0911 for _entry in [MINIAODEventContent, MINIAODSIMEventContent]:
0912     fastSim.toModify(_entry, outputCommands = _entry.outputCommands + fastSimEC.dropPatTrigger)