Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2025-02-11 03:07:46

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 *_hltOfflinePrimaryVertices_*_*',
0694                             'keep *_hltHGCalRecHit_*_*'
0695                         ])
0696 
0697 phase2_common.toModify(FEVTDEBUGHLTEventContent,
0698                        outputCommands = FEVTDEBUGHLTEventContent.outputCommands+[
0699                            'keep *_hltEgammaGsfTracksL1Seeded_*_*',
0700                        ])
0701 
0702 phase2_muon.toModify(FEVTDEBUGHLTEventContent, 
0703     outputCommands = FEVTDEBUGHLTEventContent.outputCommands + [
0704         'keep recoMuons_muons1stStep_*_*',
0705         'keep *_hltL2MuonSeedsFromL1TkMuon_*_*',
0706         'keep *_hltL2MuonsFromL1TkMuon_*_*',
0707         'keep *_hltIter2Phase2L3FromL1TkMuonMerged_*_*',
0708         'keep *_hltPhase2L3OIMuonTrackSelectionHighPurity_*_*',
0709         'keep *_hltPhase2L3MuonMerged_*_*',
0710         'keep *_hltPhase2L3GlbMuon_*_*',
0711         'keep *_hltPhase2L3MuonsNoID_*_*',
0712         'keep *_hltPhase2L3Muons_*_*'])
0713 
0714 from Configuration.ProcessModifiers.phase2L2AndL3Muons_cff import phase2L2AndL3Muons
0715 (phase2_muon & ~phase2L2AndL3Muons).toModify(FEVTDEBUGHLTEventContent, 
0716     outputCommands = FEVTDEBUGHLTEventContent.outputCommands + [
0717         'keep *_hltL2OfflineMuonSeeds_*_*'
0718     ])
0719 
0720 (phase2_muon & phase2L2AndL3Muons).toModify(FEVTDEBUGHLTEventContent, 
0721     outputCommands = FEVTDEBUGHLTEventContent.outputCommands + [
0722         'keep *_hltPhase2L3MuonFilter_*_*'
0723     ])
0724 
0725 phase2_hgcal.toModify(FEVTDEBUGHLTEventContent,
0726     outputCommands = FEVTDEBUGHLTEventContent.outputCommands + TICL_FEVTHLT.outputCommands)
0727 
0728 ticl_v5.toModify(FEVTDEBUGHLTEventContent, outputCommands=FEVTDEBUGHLTEventContent.outputCommands+TICLv5_FEVTHLT.outputCommands)
0729 
0730 from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2
0731 
0732 (premix_stage2 & phase2_tracker).toModify(FEVTDEBUGHLTEventContent, 
0733     outputCommands = FEVTDEBUGHLTEventContent.outputCommands+[
0734         'keep *_*_Phase2OTDigiSimLink_*'])
0735 (premix_stage2 & phase2_muon).toModify(FEVTDEBUGHLTEventContent, 
0736     outputCommands = FEVTDEBUGHLTEventContent.outputCommands+[
0737         'keep *_*_GEMDigiSimLink_*',
0738         'keep *_*_GEMStripDigiSimLink_*',
0739         'keep *_*_ME0DigiSimLink_*',
0740         'keep *_*_ME0StripDigiSimLink_*'])
0741 #
0742 #
0743 # RECOSIMDEBUG Data Tier definition
0744 #
0745 #
0746 RECODEBUGEventContent = cms.PSet(
0747     outputCommands = cms.untracked.vstring('drop *'),
0748     splitLevel = cms.untracked.int32(0),
0749 )
0750 RECODEBUGEventContent.outputCommands.extend(RECOSIMEventContent.outputCommands)
0751 RECODEBUGEventContent.outputCommands.extend(SimGeneralFEVTDEBUG.outputCommands)
0752 RECODEBUGEventContent.outputCommands.extend(SimTrackerDEBUG.outputCommands)
0753 #
0754 ## HLTDEBUG tier definition
0755 #
0756 HLTDEBUGEventContent = cms.PSet(
0757     #outputCommands = cms.untracked.vstring('drop *',
0758     #        'keep *_hlt*_*_*')
0759     outputCommands = cms.untracked.vstring('drop *',
0760         'keep *_logErrorHarvester_*_*'),
0761     splitLevel = cms.untracked.int32(0),
0762 )
0763 HLTDEBUGEventContent.outputCommands.extend(HLTDebugFEVT.outputCommands)
0764 #
0765 #
0766 ## DQM event content
0767 #
0768 #
0769 DQMEventContent = cms.PSet(
0770     outputCommands = cms.untracked.vstring('drop *',
0771         'keep *_MEtoEDMConverter_*_*'),
0772     splitLevel = cms.untracked.int32(0)
0773 )
0774 
0775 #Special Event Content for MixingModule and DataMixer
0776 DATAMIXEREventContent = cms.PSet(
0777     outputCommands = cms.untracked.vstring('drop *',
0778         'keep CSCDetIdCSCALCTDigiMuonDigiCollection_muonCSCDigis_MuonCSCALCTDigi_*',
0779         'keep CSCDetIdCSCCLCTDigiMuonDigiCollection_muonCSCDigis_MuonCSCCLCTDigi_*',
0780         'keep CSCDetIdCSCComparatorDigiMuonDigiCollection_muonCSCDigis_MuonCSCComparatorDigi_*',
0781         'keep CSCDetIdCSCCorrelatedLCTDigiMuonDigiCollection_csctfDigis_*_*',
0782         'keep CSCDetIdCSCCorrelatedLCTDigiMuonDigiCollection_muonCSCDigis_MuonCSCCorrelatedLCTDigi_*',
0783         'keep CSCDetIdCSCRPCDigiMuonDigiCollection_muonCSCDigis_MuonCSCRPCDigi_*',
0784         'keep CSCDetIdCSCStripDigiMuonDigiCollection_muonCSCDigis_MuonCSCStripDigi_*',
0785         'keep CSCDetIdCSCWireDigiMuonDigiCollection_muonCSCDigis_MuonCSCWireDigi_*',
0786         'keep DTLayerIdDTDigiMuonDigiCollection_muonDTDigis_*_*',
0787         'keep PixelDigiedmDetSetVector_siPixelDigis_*_*',
0788         'keep SiStripDigiedmDetSetVector_siStripDigis_*_*',
0789         'keep RPCDetIdRPCDigiMuonDigiCollection_muonRPCDigis_*_*',
0790         'keep HBHEDataFramesSorted_hcalDigis_*_*',
0791         'keep HFDataFramesSorted_hcalDigis_*_*',
0792         'keep HODataFramesSorted_hcalDigis_*_*',
0793         'keep QIE10DataFrameHcalDataFrameContainer_hcalDigis_*_*',
0794         'keep QIE11DataFrameHcalDataFrameContainer_hcalDigis_*_*',
0795         'keep ZDCDataFramesSorted_hcalDigis_*_*',
0796         'keep CastorDataFramesSorted_castorDigis_*_*',
0797         'keep EBDigiCollection_ecalDigis_*_*',
0798         'keep EEDigiCollection_ecalDigis_*_*',
0799         'keep ESDigiCollection_ecalPreshowerDigis_*_*'),
0800     splitLevel = cms.untracked.int32(0),
0801 )
0802 
0803 PREMIXEventContent = cms.PSet(
0804     outputCommands = cms.untracked.vstring('drop *'),
0805     splitLevel = cms.untracked.int32(0),
0806 )
0807 PREMIXEventContent.outputCommands.extend(SimGeneralRAW.outputCommands)
0808 PREMIXEventContent.outputCommands.extend(IOMCRAW.outputCommands)
0809 PREMIXEventContent.outputCommands.extend(CommonEventContent.outputCommands)
0810 PREMIXEventContent.outputCommands.extend(SimTrackerPREMIX.outputCommands)
0811 PREMIXEventContent.outputCommands.extend(SimCalorimetryPREMIX.outputCommands)
0812 PREMIXEventContent.outputCommands.extend(SimFastTimingPREMIX.outputCommands)
0813 PREMIXEventContent.outputCommands.extend(SimMuonPREMIX.outputCommands)
0814 PREMIXEventContent.outputCommands.extend(SimGeneralPREMIX.outputCommands)
0815 fastSim.toModify(PREMIXEventContent,
0816     outputCommands = PREMIXEventContent.outputCommands+fastSimEC.extraPremixContent)
0817 
0818 MIXINGMODULEEventContent = cms.PSet(
0819     outputCommands = cms.untracked.vstring('drop *',
0820         'keep *_cfWriter_*_*'),
0821     splitLevel = cms.untracked.int32(0),
0822 )
0823 
0824 # PREMIXRAW Data Tier definition
0825 #
0826 #
0827 PREMIXRAWEventContent = cms.PSet(
0828     outputCommands = cms.untracked.vstring('drop *'),
0829     splitLevel = cms.untracked.int32(0),
0830 )
0831 PREMIXRAWEventContent.outputCommands.extend(RAWSIMEventContent.outputCommands)
0832 PREMIXRAWEventContent.outputCommands.append('keep CrossingFramePlaybackInfoNew_*_*_*')
0833 PREMIXRAWEventContent.outputCommands.append('drop CrossingFramePlaybackInfoNew_mix_*_*')
0834 PREMIXRAWEventContent.outputCommands.append('keep *_*_MergedTrackTruth_*')
0835 PREMIXRAWEventContent.outputCommands.append('keep *_*_StripDigiSimLink_*')
0836 PREMIXRAWEventContent.outputCommands.append('keep *_*_PixelDigiSimLink_*')
0837 PREMIXRAWEventContent.outputCommands.append('keep *_*_MuonCSCStripDigiSimLinks_*')
0838 PREMIXRAWEventContent.outputCommands.append('keep *_*_MuonCSCWireDigiSimLinks_*')
0839 PREMIXRAWEventContent.outputCommands.append('keep *_*_RPCDigiSimLink_*')
0840 PREMIXRAWEventContent.outputCommands.append('keep DTLayerIdDTDigiSimLinkMuonDigiCollection_*_*_*')
0841 #
0842 # Temporary eventcontent for Prod-Like Phase2 PREMIXRAW. 
0843 # They are until packer/unpackers are done.
0844 # 
0845 (premix_stage2 & phase2_common).toModify(PREMIXRAWEventContent, 
0846                                          outputCommands = PREMIXRAWEventContent.outputCommands + [
0847                                               'drop *_simSiPixelDigis_*_*',
0848                                               'keep *_mixData_Pixel_*',
0849                                               'keep *_mixData_Tracker_*',
0850                                               'keep *_*_Phase2OTDigiSimLink_*',
0851                                               'keep *_*_GEMDigiSimLink_*',
0852                                               'keep *_*_GEMStripDigiSimLink_*',
0853                                               'keep *_*_ME0DigiSimLink_*',
0854                                               'keep *_*_ME0StripDigiSimLink_*'
0855                                          ])
0856 
0857 #
0858 #
0859 ## RAW repacked event content definition
0860 #
0861 #
0862 REPACKRAWEventContent = cms.PSet(
0863     outputCommands = cms.untracked.vstring('drop *',
0864         'drop FEDRawDataCollection_*_*_*',
0865         'keep FEDRawDataCollection_rawDataRepacker_*_*',
0866         'keep FEDRawDataCollection_virginRawDataRepacker_*_*',
0867         'keep FEDRawDataCollection_rawDataReducedFormat_*_*'),
0868     splitLevel = cms.untracked.int32(0),
0869 )
0870 REPACKRAWEventContent.outputCommands.extend(L1TriggerRAW.outputCommands)
0871 REPACKRAWEventContent.outputCommands.extend(HLTriggerRAW.outputCommands)
0872 approxSiStripClusters.toModify(REPACKRAWEventContent,
0873                                outputCommands = REPACKRAWEventContent.outputCommands+[
0874                                    'keep *_hltSiStripClusters2ApproxClusters_*_*',
0875                                    'drop FEDRawDataCollection_rawDataRepacker_*_*',
0876                                    'keep FEDRawDataCollection_rawPrimeDataRepacker_*_*'
0877                                ])
0878 
0879 REPACKRAWSIMEventContent = cms.PSet(
0880     outputCommands = cms.untracked.vstring(),
0881     splitLevel = cms.untracked.int32(0),
0882 )
0883 REPACKRAWSIMEventContent.outputCommands.extend(REPACKRAWEventContent.outputCommands)
0884 REPACKRAWSIMEventContent.outputCommands.extend(SimG4CoreRAW.outputCommands)
0885 REPACKRAWSIMEventContent.outputCommands.extend(SimTrackerRAW.outputCommands)
0886 REPACKRAWSIMEventContent.outputCommands.extend(SimMuonRAW.outputCommands)
0887 REPACKRAWSIMEventContent.outputCommands.extend(SimCalorimetryRAW.outputCommands)
0888 REPACKRAWSIMEventContent.outputCommands.extend(SimFastTimingRAW.outputCommands)
0889 REPACKRAWSIMEventContent.outputCommands.extend(SimGeneralRAW.outputCommands)
0890 REPACKRAWSIMEventContent.outputCommands.extend(GeneratorInterfaceRAW.outputCommands)
0891 REPACKRAWSIMEventContent.outputCommands.extend(RecoGenJetsFEVT.outputCommands)
0892 REPACKRAWSIMEventContent.outputCommands.extend(RecoGenMETFEVT.outputCommands)
0893 REPACKRAWSIMEventContent.outputCommands.extend(DigiToRawFEVT.outputCommands)
0894 REPACKRAWSIMEventContent.outputCommands.extend(MEtoEDMConverterFEVT.outputCommands)
0895 REPACKRAWSIMEventContent.outputCommands.extend(IOMCRAW.outputCommands)
0896 REPACKRAWSIMEventContent.outputCommands.extend(CommonEventContent.outputCommands)
0897 REPACKRAWSIMEventContent.outputCommands.extend([
0898     'drop FEDRawDataCollection_source_*_*',
0899         'drop FEDRawDataCollection_rawDataCollector_*_*'])
0900 REPACKRAWEventContent.outputCommands.extend([
0901     'drop FEDRawDataCollection_source_*_*',
0902         'drop FEDRawDataCollection_rawDataCollector_*_*'])
0903 
0904 #from modules in Configuration.StandardSequence.Generator_cff fixGenInfo
0905 REGENEventContent = cms.PSet(
0906     inputCommands=cms.untracked.vstring(
0907         'keep *',
0908         'drop *_genParticles_*_*',
0909         'drop *_genParticlesForJets_*_*',
0910         'drop *_kt4GenJets_*_*',
0911         'drop *_kt6GenJets_*_*',
0912         'drop *_iterativeCone5GenJets_*_*',
0913         'drop *_ak4GenJets_*_*',
0914         'drop *_ak7GenJets_*_*',
0915         'drop *_ak8GenJets_*_*',
0916         'drop *_ak4GenJetsNoNu_*_*',
0917         'drop *_ak8GenJetsNoNu_*_*',
0918         'drop *_genCandidatesForMET_*_*',
0919         'drop *_genParticlesForMETAllVisible_*_*',
0920         'drop *_genMetCalo_*_*',
0921         'drop *_genMetCaloAndNonPrompt_*_*',
0922         'drop *_genMetTrue_*_*',
0923         'drop *_genMetIC5GenJs_*_*')
0924 )
0925 
0926 RESIMEventContent = cms.PSet(
0927     inputCommands=cms.untracked.vstring('drop *')
0928 )
0929 RESIMEventContent.inputCommands.extend(IOMCRAW.outputCommands)
0930 RESIMEventContent.inputCommands.extend(GeneratorInterfaceRAW.outputCommands)
0931 
0932 
0933 REDIGIEventContent = cms.PSet(
0934     inputCommands=cms.untracked.vstring('drop *')
0935 )
0936 REDIGIEventContent.inputCommands.extend(SimG4CoreRAW.outputCommands)
0937 REDIGIEventContent.inputCommands.extend(IOMCRAW.outputCommands)
0938 REDIGIEventContent.inputCommands.extend(GeneratorInterfaceRAW.outputCommands)
0939 REDIGIEventContent.inputCommands.append('drop *_randomEngineStateProducer_*_*')
0940 
0941 ########### and mini AOD
0942 #
0943 # MiniAOD is a bit special: the files tend to be so small that letting
0944 # ROOT automatically determine when to flush is a surprisingly big overhead.
0945 #
0946 from PhysicsTools.PatAlgos.slimming.slimming_cff import MicroEventContent,MicroEventContentMC,MicroEventContentGEN
0947 
0948 MINIAODEventContent= cms.PSet(
0949     outputCommands = cms.untracked.vstring('drop *'),
0950     eventAutoFlushCompressedSize=cms.untracked.int32(-900),
0951     compressionAlgorithm=cms.untracked.string("LZMA"),
0952     compressionLevel=cms.untracked.int32(4)
0953 )
0954 MINIAODEventContent.outputCommands.extend(MicroEventContent.outputCommands)
0955 MINIAODEventContent.outputCommands.extend(HLTriggerMINIAOD.outputCommands)
0956 
0957 MINIAODSIMEventContent= cms.PSet(
0958     outputCommands = cms.untracked.vstring('drop *'),
0959     eventAutoFlushCompressedSize=cms.untracked.int32(-900),
0960     compressionAlgorithm=cms.untracked.string("LZMA"),
0961     compressionLevel=cms.untracked.int32(4)
0962 )
0963 MINIAODSIMEventContent.outputCommands.extend(MicroEventContentMC.outputCommands)
0964 MINIAODSIMEventContent.outputCommands.extend(HLTriggerMINIAOD.outputCommands)
0965 
0966 MINIGENEventContent= cms.PSet(
0967     outputCommands = cms.untracked.vstring('drop *'),
0968     eventAutoFlushCompressedSize=cms.untracked.int32(15*1024*1024),
0969     compressionAlgorithm=cms.untracked.string("LZMA"),
0970     compressionLevel=cms.untracked.int32(4)
0971 )
0972 MINIGENEventContent.outputCommands.extend(MicroEventContentGEN.outputCommands)
0973 
0974 #### RAW+miniAOD
0975 
0976 RAWMINIAODEventContent= cms.PSet(
0977     outputCommands = cms.untracked.vstring('drop *'),
0978     eventAutoFlushCompressedSize=cms.untracked.int32(20*1024*1024),
0979     compressionAlgorithm=cms.untracked.string("LZMA"),
0980     compressionLevel=cms.untracked.int32(4)
0981 )
0982 RAWMINIAODEventContent.outputCommands.extend(MicroEventContent.outputCommands)
0983 RAWMINIAODEventContent.outputCommands.extend(L1TriggerRAW.outputCommands)
0984 RAWMINIAODEventContent.outputCommands.extend(HLTriggerRAW.outputCommands)
0985 RAWMINIAODEventContent.outputCommands.extend(cms.untracked.vstring(
0986     'keep FEDRawDataCollection_rawDataCollector_*_*',
0987     'keep FEDRawDataCollection_source_*_*'))
0988 
0989 RAWMINIAODSIMEventContent= cms.PSet(
0990     outputCommands = cms.untracked.vstring('drop *'),
0991     eventAutoFlushCompressedSize=cms.untracked.int32(20*1024*1024),
0992     compressionAlgorithm=cms.untracked.string("LZMA"),
0993     compressionLevel=cms.untracked.int32(4)
0994 )
0995 RAWMINIAODSIMEventContent.outputCommands.extend(RAWMINIAODEventContent.outputCommands)
0996 RAWMINIAODSIMEventContent.outputCommands.extend(MicroEventContentMC.outputCommands)
0997 RAWMINIAODSIMEventContent.outputCommands.extend(SimG4CoreHLTAODSIM.outputCommands)
0998 #
0999 #
1000 # RAWSIM Data Tier definition
1001 # Meant as means to temporarily hold the RAW + AODSIM information as to allow the
1002 # L1+HLT to be rerun at a later time.
1003 #
1004 RAWAODSIMEventContent = cms.PSet(
1005     outputCommands = cms.untracked.vstring('drop *'),
1006     eventAutoFlushCompressedSize=cms.untracked.int32(20*1024*1024),
1007     compressionAlgorithm=cms.untracked.string("LZMA"),
1008     compressionLevel=cms.untracked.int32(4)
1009 )
1010 RAWAODSIMEventContent.outputCommands.extend(AODSIMEventContent.outputCommands)
1011 RAWAODSIMEventContent.outputCommands.extend(L1TriggerRAW.outputCommands)
1012 RAWAODSIMEventContent.outputCommands.extend(HLTriggerRAW.outputCommands)
1013 RAWAODSIMEventContent.outputCommands.extend(SimG4CoreHLTAODSIM.outputCommands)
1014 
1015 # in fastsim, normal digis are edaliases of simdigis
1016 # drop the simdigis to avoid complaints from the outputmodule related to duplicated branches
1017 for _entry in [FEVTDEBUGHLTEventContent,FEVTDEBUGEventContent,RECOSIMEventContent,AODSIMEventContent,RAWAODSIMEventContent]:
1018     fastSim.toModify(_entry, outputCommands = _entry.outputCommands + fastSimEC.dropSimDigis)
1019 for _entry in [MINIAODEventContent, MINIAODSIMEventContent]:
1020     fastSim.toModify(_entry, outputCommands = _entry.outputCommands + fastSimEC.dropPatTrigger)
1021