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 RecoVertex.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 from Configuration.ProcessModifiers.approxSiStripClusters_cff import approxSiStripClusters
0181 approxSiStripClusters.toModify(RAWEventContent,
0182                               outputCommands = RAWEventContent.outputCommands+[
0183                                   'keep *_hltSiStripClusters2ApproxClusters_*_*',
0184                                   'keep DetIds_hltSiStripRawToDigi_*_*'
0185                               ])
0186
0187 #
0188 # HLTSCOUT Data Tier definition
0189 #
0190 #
0191 HLTSCOUTEventContent = cms.PSet(
0192     outputCommands = cms.untracked.vstring('drop *'),
0193     splitLevel = cms.untracked.int32(0),
0194     compressionAlgorithm=cms.untracked.string("LZMA"),
0195     compressionLevel=cms.untracked.int32(4)
0196 )
0197 HLTSCOUTEventContent.outputCommands.extend(HLTriggerRAW.outputCommands)
0198
0199 #
0200 # L1SCOUT Data Tier definition
0201 #
0202 #
0203 L1SCOUTEventContent = cms.PSet(
0204     outputCommands = cms.untracked.vstring('drop *'),
0205     splitLevel = cms.untracked.int32(0),
0206     compressionAlgorithm=cms.untracked.string("LZMA"),
0207     compressionLevel=cms.untracked.int32(4)
0208 )
0209 L1SCOUTEventContent.outputCommands.extend(L1TriggerRAW.outputCommands)
0210
0211 #
0212 #
0213 # HLTONLY Data Tier definition
0214 #
0215 #
0216 HLTONLYEventContent = cms.PSet(
0217     outputCommands = cms.untracked.vstring('drop *'),
0218     splitLevel = cms.untracked.int32(0)
0219 )
0220 HLTONLYEventContent.outputCommands.extend(L1TriggerRAW.outputCommands)
0221 HLTONLYEventContent.outputCommands.extend(HLTriggerRAW.outputCommands)
0222 HLTONLYEventContent.outputCommands.extend(['drop  FEDRawDataCollection_rawDataCollector_*_*',
0223                                            'drop  FEDRawDataCollection_source_*_*'])
0224 #
0225 #
0226 # RECO Data Tier definition
0227 #
0228 #
0229 RECOEventContent = cms.PSet(
0230     outputCommands = cms.untracked.vstring('drop *'),
0231     splitLevel = cms.untracked.int32(0),
0232 )
0233 RECOEventContent.outputCommands.extend(RecoLocalTrackerRECO.outputCommands)
0234 RECOEventContent.outputCommands.extend(RecoLocalMuonRECO.outputCommands)
0235 RECOEventContent.outputCommands.extend(RecoLocalCaloRECO.outputCommands)
0236 RECOEventContent.outputCommands.extend(RecoEcalRECO.outputCommands)
0237 RECOEventContent.outputCommands.extend(TrackingToolsRECO.outputCommands)
0238 RECOEventContent.outputCommands.extend(RecoTrackerRECO.outputCommands)
0239 RECOEventContent.outputCommands.extend(RecoJetsRECO.outputCommands)
0240 RECOEventContent.outputCommands.extend(RecoMETRECO.outputCommands)
0241 RECOEventContent.outputCommands.extend(RecoMuonRECO.outputCommands)
0242 RECOEventContent.outputCommands.extend(RecoBTauRECO.outputCommands)
0243 RECOEventContent.outputCommands.extend(RecoBTagRECO.outputCommands)
0244 RECOEventContent.outputCommands.extend(RecoTauTagRECO.outputCommands)
0245 RECOEventContent.outputCommands.extend(RecoVertexRECO.outputCommands)
0246 RECOEventContent.outputCommands.extend(RecoEgammaRECO.outputCommands)
0247 RECOEventContent.outputCommands.extend(RecoPixelVertexingRECO.outputCommands)
0248 RECOEventContent.outputCommands.extend(RecoParticleFlowRECO.outputCommands)
0249 RECOEventContent.outputCommands.extend(BeamSpotRECO.outputCommands)
0250 RECOEventContent.outputCommands.extend(L1TriggerRECO.outputCommands)
0251 RECOEventContent.outputCommands.extend(HLTriggerRECO.outputCommands)
0252 RECOEventContent.outputCommands.extend(MEtoEDMConverterRECO.outputCommands)
0253 RECOEventContent.outputCommands.extend(EvtScalersRECO.outputCommands)
0254 RECOEventContent.outputCommands.extend(OnlineMetaDataContent.outputCommands)
0255 RECOEventContent.outputCommands.extend(TcdsEventContent.outputCommands)
0256 RECOEventContent.outputCommands.extend(CommonEventContent.outputCommands)
0257
0258 from Configuration.Eras.Modifier_ctpps_cff import ctpps
0259 from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
0260 from Configuration.Eras.Modifier_phase2_common_cff import phase2_common
0261 from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker
0262 from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
0263 from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer
0264 from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017
0265 from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM
0266 from Configuration.ProcessModifiers.pp_on_AA_cff import pp_on_AA
0267 from RecoLocalFastTime.Configuration.RecoLocalFastTime_EventContent_cff import *
0268 from RecoMTD.Configuration.RecoMTD_EventContent_cff import *
0269
0270 ctpps.toModify(RECOEventContent,
0271     outputCommands = RECOEventContent.outputCommands + RecoCTPPSRECO.outputCommands)
0272 phase2_hgcal.toModify(RECOEventContent,
0273     outputCommands = RECOEventContent.outputCommands + TICL_RECO.outputCommands)
0274 #
0275 #
0276 # RAWRECO Data Tier definition
0277 #
0278 #
0279 RAWRECOEventContent = cms.PSet(
0280     outputCommands = cms.untracked.vstring('drop *'),
0281     splitLevel = cms.untracked.int32(0),
0282 )
0283 RAWRECOEventContent.outputCommands.extend(RECOEventContent.outputCommands)
0284 RAWRECOEventContent.outputCommands.extend(cms.untracked.vstring(
0285     'keep FEDRawDataCollection_rawDataCollector_*_*',
0286     'keep FEDRawDataCollection_source_*_*')
0287 )
0288 #
0289 #
0290 # AOD Data Tier definition
0291 #
0292 #
0293 AODEventContent = cms.PSet(
0294     outputCommands = cms.untracked.vstring('drop *'),
0295     eventAutoFlushCompressedSize=cms.untracked.int32(30*1024*1024),
0296     compressionAlgorithm=cms.untracked.string("LZMA"),
0297     compressionLevel=cms.untracked.int32(4)
0298 )
0299 AODEventContent.outputCommands.extend(RecoLocalTrackerAOD.outputCommands)
0300 AODEventContent.outputCommands.extend(RecoLocalMuonAOD.outputCommands)
0301 AODEventContent.outputCommands.extend(RecoLocalCaloAOD.outputCommands)
0302 AODEventContent.outputCommands.extend(RecoEcalAOD.outputCommands)
0303 AODEventContent.outputCommands.extend(TrackingToolsAOD.outputCommands)
0304 AODEventContent.outputCommands.extend(RecoTrackerAOD.outputCommands)
0305 AODEventContent.outputCommands.extend(RecoJetsAOD.outputCommands)
0306 AODEventContent.outputCommands.extend(RecoMETAOD.outputCommands)
0307 AODEventContent.outputCommands.extend(RecoMuonAOD.outputCommands)
0308 AODEventContent.outputCommands.extend(RecoBTauAOD.outputCommands)
0309 AODEventContent.outputCommands.extend(RecoBTagAOD.outputCommands)
0310 AODEventContent.outputCommands.extend(RecoTauTagAOD.outputCommands)
0311 AODEventContent.outputCommands.extend(RecoVertexAOD.outputCommands)
0312 AODEventContent.outputCommands.extend(RecoEgammaAOD.outputCommands)
0313 AODEventContent.outputCommands.extend(RecoParticleFlowAOD.outputCommands)
0314 AODEventContent.outputCommands.extend(BeamSpotAOD.outputCommands)
0315 AODEventContent.outputCommands.extend(L1TriggerAOD.outputCommands)
0316 AODEventContent.outputCommands.extend(HLTriggerAOD.outputCommands)
0317 AODEventContent.outputCommands.extend(MEtoEDMConverterAOD.outputCommands)
0318 AODEventContent.outputCommands.extend(EvtScalersAOD.outputCommands)
0319 AODEventContent.outputCommands.extend(OnlineMetaDataContent.outputCommands)
0320 AODEventContent.outputCommands.extend(TcdsEventContent.outputCommands)
0321 AODEventContent.outputCommands.extend(CommonEventContent.outputCommands)
0322
0323 ctpps.toModify(AODEventContent,
0324     outputCommands = AODEventContent.outputCommands + RecoCTPPSAOD.outputCommands)
0325 phase2_hgcal.toModify(AODEventContent,
0326     outputCommands = AODEventContent.outputCommands + TICL_AOD.outputCommands)
0327 #
0328 #
0329 # RAWAOD Data Tier definition
0330 #
0331 #
0332 RAWAODEventContent = cms.PSet(
0333     outputCommands = cms.untracked.vstring('drop *'),
0334     eventAutoFlushCompressedSize=cms.untracked.int32(30*1024*1024),
0335     compressionAlgorithm=cms.untracked.string("LZMA"),
0336     compressionLevel=cms.untracked.int32(4)
0337 )
0338 RAWAODEventContent.outputCommands.extend(AODEventContent.outputCommands)
0339 RAWAODEventContent.outputCommands.extend(cms.untracked.vstring(
0340     'keep FEDRawDataCollection_rawDataCollector_*_*',
0341     'keep FEDRawDataCollection_source_*_*')
0342 )
0343 #
0344 #
0345 # RAWSIM Data Tier definition
0346 # ===========================
0347 #
0348 # Here, we sacrifice memory and CPU time to decrease the on-disk size as
0349 # much as possible.  Given the current per-event GEN-SIM and DIGI-RECO times,
0350 # the extra CPU time for LZMA compression works out to be ~1%.  The GEN-SIM
0351 # use case of reading a minbias event for `classic pileup` has a similar CPU
0352 # impact.
0353 # The memory increase appears to be closer to 50MB - but that should be
0354 # acceptable as the introduction of multithreaded processing has bought us some
0355 # breathing room.
0356 #
0357 RAWSIMEventContent = cms.PSet(
0358     outputCommands = cms.untracked.vstring('drop *'),
0359     splitLevel = cms.untracked.int32(0),
0360     eventAutoFlushCompressedSize=cms.untracked.int32(20*1024*1024),
0361     compressionAlgorithm=cms.untracked.string("LZMA"),
0362     compressionLevel=cms.untracked.int32(1)
0363 )
0364 RAWSIMEventContent.outputCommands.extend(RAWEventContent.outputCommands)
0365 RAWSIMEventContent.outputCommands.extend(SimG4CoreRAW.outputCommands)
0366 RAWSIMEventContent.outputCommands.extend(SimTrackerRAW.outputCommands)
0367 RAWSIMEventContent.outputCommands.extend(SimMuonRAW.outputCommands)
0368 RAWSIMEventContent.outputCommands.extend(SimCalorimetryRAW.outputCommands)
0369 RAWSIMEventContent.outputCommands.extend(SimFastTimingRAW.outputCommands)
0370 RAWSIMEventContent.outputCommands.extend(SimGeneralRAW.outputCommands)
0371 RAWSIMEventContent.outputCommands.extend(GeneratorInterfaceRAW.outputCommands)
0372 RAWSIMEventContent.outputCommands.extend(RecoGenJetsFEVT.outputCommands)
0373 RAWSIMEventContent.outputCommands.extend(RecoGenMETFEVT.outputCommands)
0374 RAWSIMEventContent.outputCommands.extend(DigiToRawFEVT.outputCommands)
0375 RAWSIMEventContent.outputCommands.extend(MEtoEDMConverterFEVT.outputCommands)
0376 RAWSIMEventContent.outputCommands.extend(IOMCRAW.outputCommands)
0377 RAWSIMEventContent.outputCommands.extend(CommonEventContent.outputCommands)
0378 #
0379 # Temporary collections needed for Phase-2 RECO using RAWSIM as input in Prod-like workflow
0380 # They are until packer/unpackers are done.
0381 #
0382 from Configuration.Eras.Modifier_phase2_common_cff import phase2_common
0383 phase2_common.toModify(RAWSIMEventContent,
0384     outputCommands = RAWSIMEventContent.outputCommands+[
0385         'keep *_sim*Digis_*_*',
0386         'keep *Phase2TrackerDigi*_*_*_*'])
0387 #
0388 #
0389 # RAWSIMHLT Data Tier definition
0390 #
0391 #
0392 RAWSIMHLTEventContent = cms.PSet(
0393     outputCommands = cms.untracked.vstring('drop *'),
0394     splitLevel = cms.untracked.int32(0),
0395 )
0396 RAWSIMHLTEventContent.outputCommands.extend(RAWSIMEventContent.outputCommands)
0397 RAWSIMHLTEventContent.outputCommands.extend(HLTDebugRAW.outputCommands)
0398 #
0399 #
0400 # RAWRECOSIMHLT Data Tier definition
0401 #
0402 #
0403 RAWRECOSIMHLTEventContent = cms.PSet(
0404     outputCommands = cms.untracked.vstring('drop *'),
0405     splitLevel = cms.untracked.int32(0),
0406 )
0407 RAWRECOSIMHLTEventContent.outputCommands.extend(RAWRECOEventContent.outputCommands)
0408 RAWRECOSIMHLTEventContent.outputCommands.extend(GeneratorInterfaceRECO.outputCommands)
0409 RAWRECOSIMHLTEventContent.outputCommands.extend(RecoGenMETRECO.outputCommands)
0410 RAWRECOSIMHLTEventContent.outputCommands.extend(RecoGenJetsRECO.outputCommands)
0411 RAWRECOSIMHLTEventContent.outputCommands.extend(SimG4CoreRECO.outputCommands)
0412 RAWRECOSIMHLTEventContent.outputCommands.extend(SimTrackerRECO.outputCommands)
0413 RAWRECOSIMHLTEventContent.outputCommands.extend(SimMuonRECO.outputCommands)
0414 RAWRECOSIMHLTEventContent.outputCommands.extend(SimCalorimetryRECO.outputCommands)
0415 RAWRECOSIMHLTEventContent.outputCommands.extend(SimFastTimingRECO.outputCommands)
0416 RAWRECOSIMHLTEventContent.outputCommands.extend(SimGeneralRECO.outputCommands)
0417 RAWRECOSIMHLTEventContent.outputCommands.extend(MEtoEDMConverterRECO.outputCommands)
0418 RAWRECOSIMHLTEventContent.outputCommands.extend(HLTDebugRAW.outputCommands)
0419 #
0420 #
0421 # RAWRECODEBUGHLT Data Tier definition
0422 #
0423 #
0424 RAWRECODEBUGHLTEventContent = cms.PSet(
0425     outputCommands = cms.untracked.vstring('drop *'),
0426     splitLevel = cms.untracked.int32(0),
0427 )
0428 RAWRECODEBUGHLTEventContent.outputCommands.extend(RAWRECOSIMHLTEventContent.outputCommands)
0429 RAWRECODEBUGHLTEventContent.outputCommands.extend(SimGeneralFEVTDEBUG.outputCommands)
0430 RAWRECODEBUGHLTEventContent.outputCommands.extend(SimTrackerDEBUG.outputCommands)
0431 #
0432 #
0433 # HLTONLYSIM Data Tier definition
0434 #
0435 #
0436 HLTONLYSIMEventContent = HLTONLYEventContent.clone()
0437 #
0438 #
0439 # RECOSIM Data Tier definition
0440 #
0441 #
0442 RECOSIMEventContent = cms.PSet(
0443     outputCommands = cms.untracked.vstring('drop *'),
0444     splitLevel = cms.untracked.int32(0),
0445 )
0446 RECOSIMEventContent.outputCommands.extend(RECOEventContent.outputCommands)
0447 RECOSIMEventContent.outputCommands.extend(GeneratorInterfaceRECO.outputCommands)
0448 RECOSIMEventContent.outputCommands.extend(RecoGenMETRECO.outputCommands)
0449 RECOSIMEventContent.outputCommands.extend(RecoGenJetsRECO.outputCommands)
0450 RECOSIMEventContent.outputCommands.extend(SimG4CoreRECO.outputCommands)
0451 RECOSIMEventContent.outputCommands.extend(SimTrackerRECO.outputCommands)
0452 RECOSIMEventContent.outputCommands.extend(SimMuonRECO.outputCommands)
0453 RECOSIMEventContent.outputCommands.extend(SimCalorimetryRECO.outputCommands)
0454 RECOSIMEventContent.outputCommands.extend(SimFastTimingRECO.outputCommands)
0455 RECOSIMEventContent.outputCommands.extend(SimGeneralRECO.outputCommands)
0456 RECOSIMEventContent.outputCommands.extend(MEtoEDMConverterRECO.outputCommands)
0457
0458 phase2_timing_layer.toModify(RECOSIMEventContent,
0459     outputCommands = RECOSIMEventContent.outputCommands + RecoLocalFastTimeRECO.outputCommands)
0460 phase2_timing_layer.toModify(RECOSIMEventContent,
0461     outputCommands = RECOSIMEventContent.outputCommands + RecoMTDRECO.outputCommands)
0462 #
0463 #
0464 # GENRAW Data Tier definition
0465 #
0466 #
0467 GENRAWEventContent = cms.PSet(
0468     outputCommands = cms.untracked.vstring('drop *'),
0469     splitLevel = cms.untracked.int32(0),
0470 )
0471 GENRAWEventContent.outputCommands.extend(RAWEventContent.outputCommands)
0472 GENRAWEventContent.outputCommands.extend(GeneratorInterfaceRECO.outputCommands)
0473 GENRAWEventContent.outputCommands.extend(SimG4CoreRECO.outputCommands)
0474 GENRAWEventContent.outputCommands.extend(SimTrackerRAW.outputCommands)
0475 GENRAWEventContent.outputCommands.extend(SimMuonRECO.outputCommands)
0476 GENRAWEventContent.outputCommands.extend(SimCalorimetryRECO.outputCommands)
0477 GENRAWEventContent.outputCommands.extend(SimFastTimingRECO.outputCommands)
0478 GENRAWEventContent.outputCommands.extend(SimGeneralRECO.outputCommands)
0479 GENRAWEventContent.outputCommands.extend(RecoGenMETFEVT.outputCommands)
0480 GENRAWEventContent.outputCommands.extend(RecoGenJetsFEVT.outputCommands)
0481 GENRAWEventContent.outputCommands.extend(MEtoEDMConverterFEVT.outputCommands)
0482 GENRAWEventContent.outputCommands.extend(IOMCRAW.outputCommands)
0483 GENRAWEventContent.outputCommands.extend(DigiToRawFEVT.outputCommands)
0484 GENRAWEventContent.outputCommands.extend(CommonEventContent.outputCommands)
0485 #
0486 #
0487 # AODSIM Data Tier definition
0488 #
0489 #
0490 AODSIMEventContent = cms.PSet(
0491     outputCommands = cms.untracked.vstring('drop *'),
0492     eventAutoFlushCompressedSize=cms.untracked.int32(30*1024*1024),
0493     compressionAlgorithm=cms.untracked.string("LZMA"),
0494     compressionLevel=cms.untracked.int32(4),
0495     overrideInputFileSplitLevels=cms.untracked.bool(True)
0496 )
0497 AODSIMEventContent.outputCommands.extend(AODEventContent.outputCommands)
0498 AODSIMEventContent.outputCommands.extend(GeneratorInterfaceAOD.outputCommands)
0499 AODSIMEventContent.outputCommands.extend(SimG4CoreAOD.outputCommands)
0500 AODSIMEventContent.outputCommands.extend(SimTrackerAOD.outputCommands)
0501 AODSIMEventContent.outputCommands.extend(SimMuonAOD.outputCommands)
0502 AODSIMEventContent.outputCommands.extend(SimCalorimetryAOD.outputCommands)
0503 AODSIMEventContent.outputCommands.extend(SimFastTimingAOD.outputCommands)
0504 AODSIMEventContent.outputCommands.extend(RecoGenJetsAOD.outputCommands)
0505 AODSIMEventContent.outputCommands.extend(RecoGenMETAOD.outputCommands)
0506 AODSIMEventContent.outputCommands.extend(SimGeneralAOD.outputCommands)
0507 AODSIMEventContent.outputCommands.extend(MEtoEDMConverterAOD.outputCommands)
0508
0509 phase2_timing_layer.toModify(AODSIMEventContent,
0510     outputCommands = AODSIMEventContent.outputCommands + RecoLocalFastTimeAOD.outputCommands)
0511 phase2_timing_layer.toModify(AODSIMEventContent,
0512     outputCommands = AODSIMEventContent.outputCommands + RecoMTDAOD.outputCommands)
0513 #
0514 #
0515 # FEVT Data Tier definition
0516 #
0517 #
0518 FEVTEventContent = cms.PSet(
0519     outputCommands = cms.untracked.vstring('drop *'),
0520     splitLevel = cms.untracked.int32(0),
0521 )
0522 FEVTEventContent.outputCommands.extend(RAWEventContent.outputCommands)
0523 FEVTEventContent.outputCommands.extend(RecoLocalTrackerRECO.outputCommands)
0524 FEVTEventContent.outputCommands.extend(RecoLocalMuonRECO.outputCommands)
0525 FEVTEventContent.outputCommands.extend(RecoLocalCaloRECO.outputCommands)
0526 FEVTEventContent.outputCommands.extend(RecoEcalRECO.outputCommands)
0527 FEVTEventContent.outputCommands.extend(TrackingToolsRECO.outputCommands)
0528 FEVTEventContent.outputCommands.extend(RecoTrackerRECO.outputCommands)
0529 FEVTEventContent.outputCommands.extend(RecoJetsRECO.outputCommands)
0530 FEVTEventContent.outputCommands.extend(RecoMETRECO.outputCommands)
0531 FEVTEventContent.outputCommands.extend(RecoMuonRECO.outputCommands)
0532 FEVTEventContent.outputCommands.extend(RecoBTauRECO.outputCommands)
0533 FEVTEventContent.outputCommands.extend(RecoBTagRECO.outputCommands)
0534 FEVTEventContent.outputCommands.extend(RecoTauTagRECO.outputCommands)
0535 FEVTEventContent.outputCommands.extend(RecoVertexRECO.outputCommands)
0536 FEVTEventContent.outputCommands.extend(RecoEgammaRECO.outputCommands)
0537 FEVTEventContent.outputCommands.extend(RecoPixelVertexingRECO.outputCommands)
0538 FEVTEventContent.outputCommands.extend(RecoParticleFlowRECO.outputCommands)
0539 FEVTEventContent.outputCommands.extend(BeamSpotRECO.outputCommands)
0540 FEVTEventContent.outputCommands.extend(L1TriggerRECO.outputCommands)
0541 FEVTEventContent.outputCommands.extend(HLTriggerRECO.outputCommands)
0542 FEVTEventContent.outputCommands.extend(MEtoEDMConverterRECO.outputCommands)
0543 FEVTEventContent.outputCommands.extend(EvtScalersRECO.outputCommands)
0544 FEVTEventContent.outputCommands.extend(OnlineMetaDataContent.outputCommands)
0545 FEVTEventContent.outputCommands.extend(TcdsEventContent.outputCommands)
0546 FEVTEventContent.outputCommands.extend(CommonEventContent.outputCommands)
0547
0548 ctpps.toModify(FEVTEventContent,
0549     outputCommands = FEVTEventContent.outputCommands + RecoCTPPSFEVT.outputCommands)
0550 phase2_hgcal.toModify(FEVTEventContent,
0551     outputCommands = FEVTEventContent.outputCommands + TICL_FEVT.outputCommands)
0552 phase2_tracker.toModify(FEVTEventContent,
0553     outputCommands = FEVTEventContent.outputCommands + [
0554         'keep Phase2TrackerDigiedmDetSetVector_mix_*_*',
0555         'keep *_TTClustersFromPhase2TrackerDigis_*_*',
0556         'keep *_TTStubsFromPhase2TrackerDigis_*_*',
0557         'keep *_TrackerDTC_*_*',
0558         'keep *_*_Level1TTTracks_*'])
0559 phase2_muon.toModify(FEVTEventContent,
0560     outputCommands = FEVTEventContent.outputCommands + ['keep *_muonGEMDigis_*_*'])
0561 run2_GEM_2017.toModify(FEVTEventContent,
0562     outputCommands = FEVTEventContent.outputCommands + ['keep *_muonGEMDigis_*_*'])
0563 run3_GEM.toModify(FEVTEventContent,
0564     outputCommands = FEVTEventContent.outputCommands + ['keep *_muonGEMDigis_*_*'])
0565 pp_on_AA.toModify(FEVTEventContent,
0566     outputCommands = FEVTEventContent.outputCommands + ['keep FEDRawDataCollection_rawDataRepacker_*_*'])
0567 phase2_timing_layer.toModify(FEVTEventContent,
0568     outputCommands = FEVTEventContent.outputCommands + RecoLocalFastTimeFEVT.outputCommands)
0569 phase2_timing_layer.toModify(FEVTEventContent,
0570     outputCommands = FEVTEventContent.outputCommands + RecoMTDFEVT.outputCommands)
0571 from Configuration.ProcessModifiers.ticl_v5_cff import ticl_v5
0572 ticl_v5.toModify(FEVTEventContent, outputCommands=FEVTEventContent.outputCommands+TICLv5_FEVT.outputCommands)
0573
0574 FEVTHLTALLEventContent = cms.PSet(
0575     outputCommands = cms.untracked.vstring('drop *'),
0576     splitLevel = cms.untracked.int32(0),
0577 )
0578 FEVTHLTALLEventContent.outputCommands.extend(FEVTEventContent.outputCommands)
0579 FEVTHLTALLEventContent.outputCommands.append('keep *_*_*_HLT')
0580 #
0581 #
0582 # FEVTSIM Data Tier definition
0583 #
0584 #
0585 FEVTSIMEventContent = cms.PSet(
0586     outputCommands = cms.untracked.vstring('drop *'),
0587     splitLevel = cms.untracked.int32(0),
0588 )
0589 FEVTSIMEventContent.outputCommands.extend(FEVTEventContent.outputCommands)
0590 FEVTSIMEventContent.outputCommands.extend(SimG4CoreRAW.outputCommands)
0591 FEVTSIMEventContent.outputCommands.extend(SimTrackerRAW.outputCommands)
0592 FEVTSIMEventContent.outputCommands.extend(SimMuonRAW.outputCommands)
0593 FEVTSIMEventContent.outputCommands.extend(SimCalorimetryRAW.outputCommands)
0594 FEVTSIMEventContent.outputCommands.extend(SimFastTimingRAW.outputCommands)
0595 FEVTSIMEventContent.outputCommands.extend(SimGeneralRAW.outputCommands)
0596 FEVTSIMEventContent.outputCommands.extend(GeneratorInterfaceRAW.outputCommands)
0597 FEVTSIMEventContent.outputCommands.extend(RecoGenJetsFEVT.outputCommands)
0598 FEVTSIMEventContent.outputCommands.extend(RecoGenMETFEVT.outputCommands)
0599 FEVTSIMEventContent.outputCommands.extend(DigiToRawFEVT.outputCommands)
0600 FEVTSIMEventContent.outputCommands.extend(MEtoEDMConverterFEVT.outputCommands)
0601 FEVTSIMEventContent.outputCommands.extend(IOMCRAW.outputCommands)
0602 FEVTSIMEventContent.outputCommands.extend(GeneratorInterfaceRECO.outputCommands)
0603 FEVTSIMEventContent.outputCommands.extend(RecoGenMETRECO.outputCommands)
0604 FEVTSIMEventContent.outputCommands.extend(RecoGenJetsRECO.outputCommands)
0605 FEVTSIMEventContent.outputCommands.extend(SimG4CoreRECO.outputCommands)
0606 FEVTSIMEventContent.outputCommands.extend(SimTrackerRECO.outputCommands)
0607 FEVTSIMEventContent.outputCommands.extend(SimMuonRECO.outputCommands)
0608 FEVTSIMEventContent.outputCommands.extend(SimCalorimetryRECO.outputCommands)
0609 FEVTSIMEventContent.outputCommands.extend(SimFastTimingRECO.outputCommands)
0610 FEVTSIMEventContent.outputCommands.extend(SimGeneralRECO.outputCommands)
0611 #
0612 #
0613 # RAWDEBUG Data Tier definition
0614 #
0615 #
0616 RAWDEBUGEventContent = cms.PSet(
0617     outputCommands = cms.untracked.vstring('drop *'),
0618     splitLevel = cms.untracked.int32(0),
0619 )
0620 RAWDEBUGEventContent.outputCommands.extend(RAWSIMEventContent.outputCommands)
0621 RAWDEBUGEventContent.outputCommands.extend(SimTrackerDEBUG.outputCommands)
0622 RAWDEBUGEventContent.outputCommands.extend(SimGeneralFEVTDEBUG.outputCommands)
0623 RAWDEBUGEventContent.outputCommands.extend(L1TriggerRAWDEBUG.outputCommands)
0624 #
0625 #
0626 # RAWDEBUGHLT Data Tier definition
0627 #
0628 #
0629 RAWDEBUGHLTEventContent = cms.PSet(
0630     outputCommands = cms.untracked.vstring('drop *'),
0631     splitLevel = cms.untracked.int32(0),
0632 )
0633 RAWDEBUGHLTEventContent.outputCommands.extend(RAWDEBUGEventContent.outputCommands)
0634 RAWDEBUGHLTEventContent.outputCommands.extend(HLTDebugRAW.outputCommands)
0635 #
0636 #
0637 # FEVTDEBUG Data Tier definition
0638 #
0639 #
0640 FEVTDEBUGEventContent = cms.PSet(
0641     outputCommands = cms.untracked.vstring('drop *'),
0642     splitLevel = cms.untracked.int32(0),
0643 )
0644 FEVTDEBUGEventContent.outputCommands.extend(FEVTSIMEventContent.outputCommands)
0645 FEVTDEBUGEventContent.outputCommands.extend(L1TriggerFEVTDEBUG.outputCommands)
0646 FEVTDEBUGEventContent.outputCommands.extend(SimGeneralFEVTDEBUG.outputCommands)
0647 FEVTDEBUGEventContent.outputCommands.extend(SimTrackerFEVTDEBUG.outputCommands)
0648 FEVTDEBUGEventContent.outputCommands.extend(SimMuonFEVTDEBUG.outputCommands)
0649 FEVTDEBUGEventContent.outputCommands.extend(SimCalorimetryFEVTDEBUG.outputCommands)
0650 FEVTDEBUGEventContent.outputCommands.extend(SimFastTimingFEVTDEBUG.outputCommands)
0651 approxSiStripClusters.toModify(FEVTDEBUGEventContent,
0652                               outputCommands = FEVTDEBUGEventContent.outputCommands+[
0653                                   'keep *_hltSiStripClusters2ApproxClusters_*_*',
0654                                   'keep DetIds_hltSiStripRawToDigi_*_*'
0655                               ])
0656
0657 ticl_v5.toModify(FEVTDEBUGEventContent, outputCommands=FEVTDEBUGEventContent.outputCommands+TICLv5_FEVT.outputCommands)
0658 #
0659 #
0660 # FEVTDEBUGHLT Data Tier definition
0661 #
0662 #
0663 FEVTDEBUGHLTEventContent = cms.PSet(
0664     outputCommands = cms.untracked.vstring('drop *'),
0665     splitLevel = cms.untracked.int32(0),
0666 )
0667 FEVTDEBUGHLTEventContent.outputCommands.extend(FEVTDEBUGEventContent.outputCommands)
0668 FEVTDEBUGHLTEventContent.outputCommands.extend(HLTDebugFEVT.outputCommands)
0669 FEVTDEBUGHLTEventContent.outputCommands.append('keep *_*_MergedTrackTruth_*')
0670 FEVTDEBUGHLTEventContent.outputCommands.append('keep *_*_StripDigiSimLink_*')
0671 FEVTDEBUGHLTEventContent.outputCommands.append('keep *_*_PixelDigiSimLink_*')
0672
0673 from Configuration.ProcessModifiers.hltClusterSplitting_cff import hltClusterSplitting
0674 hltClusterSplitting.toModify(FEVTDEBUGHLTEventContent,
0675                               outputCommands = FEVTDEBUGHLTEventContent.outputCommands+[
0676                                   'keep *_hltPixelVertices_*_*'
0677                               ])
0678
0679 approxSiStripClusters.toModify(FEVTDEBUGHLTEventContent,
0680                               outputCommands = FEVTDEBUGHLTEventContent.outputCommands+[
0681                                   'keep *_hltSiStripClusters2ApproxClusters_*_*',
0682                                   'keep DetIds_hltSiStripRawToDigi_*_*'
0683                               ])
0684 phase2_tracker.toModify(FEVTDEBUGHLTEventContent,
0685                         outputCommands = FEVTDEBUGHLTEventContent.outputCommands+[
0686                             'keep *_hltSiPixelClusters_*_*',
0687                             'keep *_hltSiPhase2Clusters_*_*',
0688                             'keep *_hltPhase2PixelTracks_*_*',
0689                             'keep *_hltPhase2PixelVertices_*_*',
0690                             'keep *_hltGeneralTracks_*_*',
0691                             'keep *_hltInitialStepTrackSelectionHighPurity_*_*',
0692                             'keep *_hltHighPtTripletStepTrackSelectionHighPurity_*_*',
0693                             'keep *_hltInitialStepTrackSelectionHighPuritypTTCLST_*_*',
0694                             'keep *_hltInitialStepTrackSelectionHighPuritypLSTCLST_*_*',
0695                             'keep *_hltInitialStepTracksT5TCLST_*_*',
0696                             'keep *_hltHighPtTripletStepTrackSelectionHighPuritypLSTCLST_*_*',
0697                             'keep *_hltOfflinePrimaryVertices_*_*',
0698                         ])
0699
0700 phase2_common.toModify(FEVTDEBUGHLTEventContent,
0701                        outputCommands = FEVTDEBUGHLTEventContent.outputCommands+[
0702                            'keep *_hltHGCalRecHit_*_*',
0703                            'keep *_hltMergeLayerClusters_*_*',
0704                            'keep *_hltParticleFlowRecHit*_*_*',
0705                            'keep *_hltEgammaGsfTracksL1Seeded_*_*',
0706                        ])
0707
0708 phase2_muon.toModify(FEVTDEBUGHLTEventContent,
0709     outputCommands = FEVTDEBUGHLTEventContent.outputCommands + [
0710         'keep recoMuons_muons1stStep_*_*',
0711         'keep *_hltL2MuonSeedsFromL1TkMuon_*_*',
0712         'keep *_hltL2MuonsFromL1TkMuon_*_*',
0713         'keep *_hltIter2Phase2L3FromL1TkMuonMerged_*_*',
0714         'keep *_hltPhase2L3OIMuonTrackSelectionHighPurity_*_*',
0715         'keep *_hltPhase2L3MuonFilter_*_*',
0716         'keep *_hltPhase2L3MuonMerged_*_*',
0717         'keep *_hltPhase2L3GlbMuon_*_*',
0718         'keep *_hltPhase2L3MuonsNoID_*_*',
0719         'keep *_hltPhase2L3Muons_*_*'])
0720
0721 phase2_hgcal.toModify(FEVTDEBUGHLTEventContent,
0722     outputCommands = FEVTDEBUGHLTEventContent.outputCommands + TICL_FEVTHLT.outputCommands)
0723
0724 ticl_v5.toModify(FEVTDEBUGHLTEventContent, outputCommands=FEVTDEBUGHLTEventContent.outputCommands+TICLv5_FEVTHLT.outputCommands)
0725
0726 from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2
0727
0728 (premix_stage2 & phase2_tracker).toModify(FEVTDEBUGHLTEventContent,
0729     outputCommands = FEVTDEBUGHLTEventContent.outputCommands+[
0730         'keep *_*_Phase2OTDigiSimLink_*'])
0731 (premix_stage2 & phase2_muon).toModify(FEVTDEBUGHLTEventContent,
0732     outputCommands = FEVTDEBUGHLTEventContent.outputCommands+[
0733         'keep *_*_GEMDigiSimLink_*',
0734         'keep *_*_GEMStripDigiSimLink_*',
0735         'keep *_*_ME0DigiSimLink_*',
0736         'keep *_*_ME0StripDigiSimLink_*'])
0737 #
0738 #
0739 # RECOSIMDEBUG Data Tier definition
0740 #
0741 #
0742 RECODEBUGEventContent = cms.PSet(
0743     outputCommands = cms.untracked.vstring('drop *'),
0744     splitLevel = cms.untracked.int32(0),
0745 )
0746 RECODEBUGEventContent.outputCommands.extend(RECOSIMEventContent.outputCommands)
0747 RECODEBUGEventContent.outputCommands.extend(SimGeneralFEVTDEBUG.outputCommands)
0748 RECODEBUGEventContent.outputCommands.extend(SimTrackerDEBUG.outputCommands)
0749 #
0750 ## HLTDEBUG tier definition
0751 #
0752 HLTDEBUGEventContent = cms.PSet(
0753     #outputCommands = cms.untracked.vstring('drop *',
0754     #        'keep *_hlt*_*_*')
0755     outputCommands = cms.untracked.vstring('drop *',
0756         'keep *_logErrorHarvester_*_*'),
0757     splitLevel = cms.untracked.int32(0),
0758 )
0759 HLTDEBUGEventContent.outputCommands.extend(HLTDebugFEVT.outputCommands)
0760 #
0761 #
0762 ## DQM event content
0763 #
0764 #
0765 DQMEventContent = cms.PSet(
0766     outputCommands = cms.untracked.vstring('drop *',
0767         'keep *_MEtoEDMConverter_*_*'),
0768     splitLevel = cms.untracked.int32(0)
0769 )
0770
0771 #Special Event Content for MixingModule and DataMixer
0772 DATAMIXEREventContent = cms.PSet(
0773     outputCommands = cms.untracked.vstring('drop *',
0774         'keep CSCDetIdCSCALCTDigiMuonDigiCollection_muonCSCDigis_MuonCSCALCTDigi_*',
0775         'keep CSCDetIdCSCCLCTDigiMuonDigiCollection_muonCSCDigis_MuonCSCCLCTDigi_*',
0776         'keep CSCDetIdCSCComparatorDigiMuonDigiCollection_muonCSCDigis_MuonCSCComparatorDigi_*',
0777         'keep CSCDetIdCSCCorrelatedLCTDigiMuonDigiCollection_csctfDigis_*_*',
0778         'keep CSCDetIdCSCCorrelatedLCTDigiMuonDigiCollection_muonCSCDigis_MuonCSCCorrelatedLCTDigi_*',
0779         'keep CSCDetIdCSCRPCDigiMuonDigiCollection_muonCSCDigis_MuonCSCRPCDigi_*',
0780         'keep CSCDetIdCSCStripDigiMuonDigiCollection_muonCSCDigis_MuonCSCStripDigi_*',
0781         'keep CSCDetIdCSCWireDigiMuonDigiCollection_muonCSCDigis_MuonCSCWireDigi_*',
0782         'keep DTLayerIdDTDigiMuonDigiCollection_muonDTDigis_*_*',
0783         'keep PixelDigiedmDetSetVector_siPixelDigis_*_*',
0784         'keep SiStripDigiedmDetSetVector_siStripDigis_*_*',
0785         'keep RPCDetIdRPCDigiMuonDigiCollection_muonRPCDigis_*_*',
0786         'keep HBHEDataFramesSorted_hcalDigis_*_*',
0787         'keep HFDataFramesSorted_hcalDigis_*_*',
0788         'keep HODataFramesSorted_hcalDigis_*_*',
0789         'keep QIE10DataFrameHcalDataFrameContainer_hcalDigis_*_*',
0790         'keep QIE11DataFrameHcalDataFrameContainer_hcalDigis_*_*',
0791         'keep ZDCDataFramesSorted_hcalDigis_*_*',
0792         'keep CastorDataFramesSorted_castorDigis_*_*',
0793         'keep EBDigiCollection_ecalDigis_*_*',
0794         'keep EEDigiCollection_ecalDigis_*_*',
0795         'keep ESDigiCollection_ecalPreshowerDigis_*_*'),
0796     splitLevel = cms.untracked.int32(0),
0797 )
0798
0799 PREMIXEventContent = cms.PSet(
0800     outputCommands = cms.untracked.vstring('drop *'),
0801     splitLevel = cms.untracked.int32(0),
0802 )
0803 PREMIXEventContent.outputCommands.extend(SimGeneralRAW.outputCommands)
0804 PREMIXEventContent.outputCommands.extend(IOMCRAW.outputCommands)
0805 PREMIXEventContent.outputCommands.extend(CommonEventContent.outputCommands)
0806 PREMIXEventContent.outputCommands.extend(SimTrackerPREMIX.outputCommands)
0807 PREMIXEventContent.outputCommands.extend(SimCalorimetryPREMIX.outputCommands)
0808 PREMIXEventContent.outputCommands.extend(SimFastTimingPREMIX.outputCommands)
0809 PREMIXEventContent.outputCommands.extend(SimMuonPREMIX.outputCommands)
0810 PREMIXEventContent.outputCommands.extend(SimGeneralPREMIX.outputCommands)
0811 fastSim.toModify(PREMIXEventContent,
0812     outputCommands = PREMIXEventContent.outputCommands+fastSimEC.extraPremixContent)
0813
0814 MIXINGMODULEEventContent = cms.PSet(
0815     outputCommands = cms.untracked.vstring('drop *',
0816         'keep *_cfWriter_*_*'),
0817     splitLevel = cms.untracked.int32(0),
0818 )
0819
0820 # PREMIXRAW Data Tier definition
0821 #
0822 #
0823 PREMIXRAWEventContent = cms.PSet(
0824     outputCommands = cms.untracked.vstring('drop *'),
0825     splitLevel = cms.untracked.int32(0),
0826 )
0827 PREMIXRAWEventContent.outputCommands.extend(RAWSIMEventContent.outputCommands)
0828 PREMIXRAWEventContent.outputCommands.append('keep CrossingFramePlaybackInfoNew_*_*_*')
0829 PREMIXRAWEventContent.outputCommands.append('drop CrossingFramePlaybackInfoNew_mix_*_*')
0830 PREMIXRAWEventContent.outputCommands.append('keep *_*_MergedTrackTruth_*')
0831 PREMIXRAWEventContent.outputCommands.append('keep *_*_StripDigiSimLink_*')
0832 PREMIXRAWEventContent.outputCommands.append('keep *_*_PixelDigiSimLink_*')
0833 PREMIXRAWEventContent.outputCommands.append('keep *_*_MuonCSCStripDigiSimLinks_*')
0834 PREMIXRAWEventContent.outputCommands.append('keep *_*_MuonCSCWireDigiSimLinks_*')
0835 PREMIXRAWEventContent.outputCommands.append('keep *_*_RPCDigiSimLink_*')
0836 PREMIXRAWEventContent.outputCommands.append('keep DTLayerIdDTDigiSimLinkMuonDigiCollection_*_*_*')
0837 #
0838 # Temporary eventcontent for Prod-Like Phase2 PREMIXRAW.
0839 # They are until packer/unpackers are done.
0840 #
0841 (premix_stage2 & phase2_common).toModify(PREMIXRAWEventContent,
0842                                          outputCommands = PREMIXRAWEventContent.outputCommands + [
0843                                               'drop *_simSiPixelDigis_*_*',
0844                                               'keep *_mixData_Pixel_*',
0845                                               'keep *_mixData_Tracker_*',
0846                                               'keep *_*_Phase2OTDigiSimLink_*',
0847                                               'keep *_*_GEMDigiSimLink_*',
0848                                               'keep *_*_GEMStripDigiSimLink_*',
0849                                               'keep *_*_ME0DigiSimLink_*',
0850                                               'keep *_*_ME0StripDigiSimLink_*'
0851                                          ])
0852
0853 #
0854 #
0855 ## RAW repacked event content definition
0856 #
0857 #
0858 REPACKRAWEventContent = cms.PSet(
0859     outputCommands = cms.untracked.vstring('drop *',
0860         'drop FEDRawDataCollection_*_*_*',
0861         'keep FEDRawDataCollection_rawDataRepacker_*_*',
0862         'keep FEDRawDataCollection_virginRawDataRepacker_*_*',
0863         'keep FEDRawDataCollection_rawDataReducedFormat_*_*'),
0864     splitLevel = cms.untracked.int32(0),
0865 )
0866 REPACKRAWEventContent.outputCommands.extend(L1TriggerRAW.outputCommands)
0867 REPACKRAWEventContent.outputCommands.extend(HLTriggerRAW.outputCommands)
0868 approxSiStripClusters.toModify(REPACKRAWEventContent,
0869                                outputCommands = REPACKRAWEventContent.outputCommands+[
0870                                    'keep *_hltSiStripClusters2ApproxClusters_*_*',
0871                                    'drop FEDRawDataCollection_rawDataRepacker_*_*',
0872                                    'keep FEDRawDataCollection_rawPrimeDataRepacker_*_*'
0873                                ])
0874
0875 REPACKRAWSIMEventContent = cms.PSet(
0876     outputCommands = cms.untracked.vstring(),
0877     splitLevel = cms.untracked.int32(0),
0878 )
0879 REPACKRAWSIMEventContent.outputCommands.extend(REPACKRAWEventContent.outputCommands)
0880 REPACKRAWSIMEventContent.outputCommands.extend(SimG4CoreRAW.outputCommands)
0881 REPACKRAWSIMEventContent.outputCommands.extend(SimTrackerRAW.outputCommands)
0882 REPACKRAWSIMEventContent.outputCommands.extend(SimMuonRAW.outputCommands)
0883 REPACKRAWSIMEventContent.outputCommands.extend(SimCalorimetryRAW.outputCommands)
0884 REPACKRAWSIMEventContent.outputCommands.extend(SimFastTimingRAW.outputCommands)
0885 REPACKRAWSIMEventContent.outputCommands.extend(SimGeneralRAW.outputCommands)
0886 REPACKRAWSIMEventContent.outputCommands.extend(GeneratorInterfaceRAW.outputCommands)
0887 REPACKRAWSIMEventContent.outputCommands.extend(RecoGenJetsFEVT.outputCommands)
0888 REPACKRAWSIMEventContent.outputCommands.extend(RecoGenMETFEVT.outputCommands)
0889 REPACKRAWSIMEventContent.outputCommands.extend(DigiToRawFEVT.outputCommands)
0890 REPACKRAWSIMEventContent.outputCommands.extend(MEtoEDMConverterFEVT.outputCommands)
0891 REPACKRAWSIMEventContent.outputCommands.extend(IOMCRAW.outputCommands)
0892 REPACKRAWSIMEventContent.outputCommands.extend(CommonEventContent.outputCommands)
0893 REPACKRAWSIMEventContent.outputCommands.extend([
0894     'drop FEDRawDataCollection_source_*_*',
0895         'drop FEDRawDataCollection_rawDataCollector_*_*'])
0896 REPACKRAWEventContent.outputCommands.extend([
0897     'drop FEDRawDataCollection_source_*_*',
0898         'drop FEDRawDataCollection_rawDataCollector_*_*'])
0899
0900 #from modules in Configuration.StandardSequence.Generator_cff fixGenInfo
0901 REGENEventContent = cms.PSet(
0902     inputCommands=cms.untracked.vstring(
0903         'keep *',
0904         'drop *_genParticles_*_*',
0905         'drop *_genParticlesForJets_*_*',
0906         'drop *_kt4GenJets_*_*',
0907         'drop *_kt6GenJets_*_*',
0908         'drop *_iterativeCone5GenJets_*_*',
0909         'drop *_ak4GenJets_*_*',
0910         'drop *_ak7GenJets_*_*',
0911         'drop *_ak8GenJets_*_*',
0912         'drop *_ak4GenJetsNoNu_*_*',
0913         'drop *_ak8GenJetsNoNu_*_*',
0914         'drop *_genCandidatesForMET_*_*',
0915         'drop *_genParticlesForMETAllVisible_*_*',
0916         'drop *_genMetCalo_*_*',
0917         'drop *_genMetCaloAndNonPrompt_*_*',
0918         'drop *_genMetTrue_*_*',
0919         'drop *_genMetIC5GenJs_*_*')
0920 )
0921
0922 RESIMEventContent = cms.PSet(
0923     inputCommands=cms.untracked.vstring('drop *')
0924 )
0925 RESIMEventContent.inputCommands.extend(IOMCRAW.outputCommands)
0926 RESIMEventContent.inputCommands.extend(GeneratorInterfaceRAW.outputCommands)
0927
0928
0929 REDIGIEventContent = cms.PSet(
0930     inputCommands=cms.untracked.vstring('drop *')
0931 )
0932 REDIGIEventContent.inputCommands.extend(SimG4CoreRAW.outputCommands)
0933 REDIGIEventContent.inputCommands.extend(IOMCRAW.outputCommands)
0934 REDIGIEventContent.inputCommands.extend(GeneratorInterfaceRAW.outputCommands)
0935 REDIGIEventContent.inputCommands.append('drop *_randomEngineStateProducer_*_*')
0936
0937 ########### and mini AOD
0938 #
0939 # MiniAOD is a bit special: the files tend to be so small that letting
0940 # ROOT automatically determine when to flush is a surprisingly big overhead.
0941 #
0942 from PhysicsTools.PatAlgos.slimming.slimming_cff import MicroEventContent,MicroEventContentMC,MicroEventContentGEN
0943
0944 MINIAODEventContent= cms.PSet(
0945     outputCommands = cms.untracked.vstring('drop *'),
0946     eventAutoFlushCompressedSize=cms.untracked.int32(-900),
0947     compressionAlgorithm=cms.untracked.string("LZMA"),
0948     compressionLevel=cms.untracked.int32(4)
0949 )
0950 MINIAODEventContent.outputCommands.extend(MicroEventContent.outputCommands)
0951 MINIAODEventContent.outputCommands.extend(HLTriggerMINIAOD.outputCommands)
0952
0953 MINIAODSIMEventContent= cms.PSet(
0954     outputCommands = cms.untracked.vstring('drop *'),
0955     eventAutoFlushCompressedSize=cms.untracked.int32(-900),
0956     compressionAlgorithm=cms.untracked.string("LZMA"),
0957     compressionLevel=cms.untracked.int32(4)
0958 )
0959 MINIAODSIMEventContent.outputCommands.extend(MicroEventContentMC.outputCommands)
0960 MINIAODSIMEventContent.outputCommands.extend(HLTriggerMINIAOD.outputCommands)
0961
0962 MINIGENEventContent= cms.PSet(
0963     outputCommands = cms.untracked.vstring('drop *'),
0964     eventAutoFlushCompressedSize=cms.untracked.int32(15*1024*1024),
0965     compressionAlgorithm=cms.untracked.string("LZMA"),
0966     compressionLevel=cms.untracked.int32(4)
0967 )
0968 MINIGENEventContent.outputCommands.extend(MicroEventContentGEN.outputCommands)
0969
0970 #### RAW+miniAOD
0971
0972 RAWMINIAODEventContent= cms.PSet(
0973     outputCommands = cms.untracked.vstring('drop *'),
0974     eventAutoFlushCompressedSize=cms.untracked.int32(20*1024*1024),
0975     compressionAlgorithm=cms.untracked.string("LZMA"),
0976     compressionLevel=cms.untracked.int32(4)
0977 )
0978 RAWMINIAODEventContent.outputCommands.extend(MicroEventContent.outputCommands)
0979 RAWMINIAODEventContent.outputCommands.extend(L1TriggerRAW.outputCommands)
0980 RAWMINIAODEventContent.outputCommands.extend(HLTriggerRAW.outputCommands)
0981 RAWMINIAODEventContent.outputCommands.extend(cms.untracked.vstring(
0982     'keep FEDRawDataCollection_rawDataCollector_*_*',
0983     'keep FEDRawDataCollection_source_*_*'))
0984
0985 RAWMINIAODSIMEventContent= cms.PSet(
0986     outputCommands = cms.untracked.vstring('drop *'),
0987     eventAutoFlushCompressedSize=cms.untracked.int32(20*1024*1024),
0988     compressionAlgorithm=cms.untracked.string("LZMA"),
0989     compressionLevel=cms.untracked.int32(4)
0990 )
0991 RAWMINIAODSIMEventContent.outputCommands.extend(RAWMINIAODEventContent.outputCommands)
0992 RAWMINIAODSIMEventContent.outputCommands.extend(MicroEventContentMC.outputCommands)
0993 RAWMINIAODSIMEventContent.outputCommands.extend(SimG4CoreHLTAODSIM.outputCommands)
0994 #
0995 #
0996 # RAWSIM Data Tier definition
0997 # Meant as means to temporarily hold the RAW + AODSIM information as to allow the
0998 # L1+HLT to be rerun at a later time.
0999 #
1000 RAWAODSIMEventContent = cms.PSet(
1001     outputCommands = cms.untracked.vstring('drop *'),
1002     eventAutoFlushCompressedSize=cms.untracked.int32(20*1024*1024),
1003     compressionAlgorithm=cms.untracked.string("LZMA"),
1004     compressionLevel=cms.untracked.int32(4)
1005 )
1006 RAWAODSIMEventContent.outputCommands.extend(AODSIMEventContent.outputCommands)
1007 RAWAODSIMEventContent.outputCommands.extend(L1TriggerRAW.outputCommands)
1008 RAWAODSIMEventContent.outputCommands.extend(HLTriggerRAW.outputCommands)
1009 RAWAODSIMEventContent.outputCommands.extend(SimG4CoreHLTAODSIM.outputCommands)
1010
1011 # in fastsim, normal digis are edaliases of simdigis
1012 # drop the simdigis to avoid complaints from the outputmodule related to duplicated branches
1013 for _entry in [FEVTDEBUGHLTEventContent,FEVTDEBUGEventContent,RECOSIMEventContent,AODSIMEventContent,RAWAODSIMEventContent]:
1014     fastSim.toModify(_entry, outputCommands = _entry.outputCommands + fastSimEC.dropSimDigis)
1015 for _entry in [MINIAODEventContent, MINIAODSIMEventContent]:
1016     fastSim.toModify(_entry, outputCommands = _entry.outputCommands + fastSimEC.dropPatTrigger)
1017