Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2024-05-10 02:20:31

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 RecoTracker.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 
0572 FEVTHLTALLEventContent = cms.PSet(
0573     outputCommands = cms.untracked.vstring('drop *'),
0574     splitLevel = cms.untracked.int32(0),
0575 )
0576 FEVTHLTALLEventContent.outputCommands.extend(FEVTEventContent.outputCommands)
0577 FEVTHLTALLEventContent.outputCommands.append('keep *_*_*_HLT')
0578 #
0579 #
0580 # FEVTSIM Data Tier definition
0581 #
0582 #
0583 FEVTSIMEventContent = cms.PSet(
0584     outputCommands = cms.untracked.vstring('drop *'),
0585     splitLevel = cms.untracked.int32(0),
0586 )
0587 FEVTSIMEventContent.outputCommands.extend(FEVTEventContent.outputCommands)
0588 FEVTSIMEventContent.outputCommands.extend(SimG4CoreRAW.outputCommands)
0589 FEVTSIMEventContent.outputCommands.extend(SimTrackerRAW.outputCommands)
0590 FEVTSIMEventContent.outputCommands.extend(SimMuonRAW.outputCommands)
0591 FEVTSIMEventContent.outputCommands.extend(SimCalorimetryRAW.outputCommands)
0592 FEVTSIMEventContent.outputCommands.extend(SimFastTimingRAW.outputCommands)
0593 FEVTSIMEventContent.outputCommands.extend(SimGeneralRAW.outputCommands)
0594 FEVTSIMEventContent.outputCommands.extend(GeneratorInterfaceRAW.outputCommands)
0595 FEVTSIMEventContent.outputCommands.extend(RecoGenJetsFEVT.outputCommands)
0596 FEVTSIMEventContent.outputCommands.extend(RecoGenMETFEVT.outputCommands)
0597 FEVTSIMEventContent.outputCommands.extend(DigiToRawFEVT.outputCommands)
0598 FEVTSIMEventContent.outputCommands.extend(MEtoEDMConverterFEVT.outputCommands)
0599 FEVTSIMEventContent.outputCommands.extend(IOMCRAW.outputCommands) 
0600 FEVTSIMEventContent.outputCommands.extend(GeneratorInterfaceRECO.outputCommands)
0601 FEVTSIMEventContent.outputCommands.extend(RecoGenMETRECO.outputCommands)
0602 FEVTSIMEventContent.outputCommands.extend(RecoGenJetsRECO.outputCommands)
0603 FEVTSIMEventContent.outputCommands.extend(SimG4CoreRECO.outputCommands)
0604 FEVTSIMEventContent.outputCommands.extend(SimTrackerRECO.outputCommands)
0605 FEVTSIMEventContent.outputCommands.extend(SimMuonRECO.outputCommands)
0606 FEVTSIMEventContent.outputCommands.extend(SimCalorimetryRECO.outputCommands)
0607 FEVTSIMEventContent.outputCommands.extend(SimFastTimingRECO.outputCommands)
0608 FEVTSIMEventContent.outputCommands.extend(SimGeneralRECO.outputCommands)
0609 #
0610 #
0611 # RAWDEBUG Data Tier definition
0612 #
0613 #
0614 RAWDEBUGEventContent = cms.PSet(
0615     outputCommands = cms.untracked.vstring('drop *'),
0616     splitLevel = cms.untracked.int32(0),
0617 )
0618 RAWDEBUGEventContent.outputCommands.extend(RAWSIMEventContent.outputCommands)
0619 RAWDEBUGEventContent.outputCommands.extend(SimTrackerDEBUG.outputCommands)
0620 RAWDEBUGEventContent.outputCommands.extend(SimGeneralFEVTDEBUG.outputCommands)
0621 RAWDEBUGEventContent.outputCommands.extend(L1TriggerRAWDEBUG.outputCommands)
0622 #
0623 #
0624 # RAWDEBUGHLT Data Tier definition
0625 #
0626 #
0627 RAWDEBUGHLTEventContent = cms.PSet(
0628     outputCommands = cms.untracked.vstring('drop *'),
0629     splitLevel = cms.untracked.int32(0),
0630 )
0631 RAWDEBUGHLTEventContent.outputCommands.extend(RAWDEBUGEventContent.outputCommands)
0632 RAWDEBUGHLTEventContent.outputCommands.extend(HLTDebugRAW.outputCommands)
0633 #
0634 #
0635 # FEVTDEBUG Data Tier definition
0636 #
0637 #
0638 FEVTDEBUGEventContent = cms.PSet(
0639     outputCommands = cms.untracked.vstring('drop *'),
0640     splitLevel = cms.untracked.int32(0),
0641 )
0642 FEVTDEBUGEventContent.outputCommands.extend(FEVTSIMEventContent.outputCommands)
0643 FEVTDEBUGEventContent.outputCommands.extend(L1TriggerFEVTDEBUG.outputCommands)
0644 FEVTDEBUGEventContent.outputCommands.extend(SimGeneralFEVTDEBUG.outputCommands)
0645 FEVTDEBUGEventContent.outputCommands.extend(SimTrackerFEVTDEBUG.outputCommands)
0646 FEVTDEBUGEventContent.outputCommands.extend(SimMuonFEVTDEBUG.outputCommands)
0647 FEVTDEBUGEventContent.outputCommands.extend(SimCalorimetryFEVTDEBUG.outputCommands)
0648 FEVTDEBUGEventContent.outputCommands.extend(SimFastTimingFEVTDEBUG.outputCommands)
0649 approxSiStripClusters.toModify(FEVTDEBUGEventContent,
0650                               outputCommands = FEVTDEBUGEventContent.outputCommands+[
0651                                   'keep *_hltSiStripClusters2ApproxClusters_*_*',
0652                                   'keep DetIds_hltSiStripRawToDigi_*_*'
0653                               ])
0654 #
0655 #
0656 # FEVTDEBUGHLT Data Tier definition
0657 #
0658 #
0659 FEVTDEBUGHLTEventContent = cms.PSet(
0660     outputCommands = cms.untracked.vstring('drop *'),
0661     splitLevel = cms.untracked.int32(0),
0662 )
0663 FEVTDEBUGHLTEventContent.outputCommands.extend(FEVTDEBUGEventContent.outputCommands)
0664 FEVTDEBUGHLTEventContent.outputCommands.extend(HLTDebugFEVT.outputCommands)
0665 FEVTDEBUGHLTEventContent.outputCommands.append('keep *_*_MergedTrackTruth_*')
0666 FEVTDEBUGHLTEventContent.outputCommands.append('keep *_*_StripDigiSimLink_*')
0667 FEVTDEBUGHLTEventContent.outputCommands.append('keep *_*_PixelDigiSimLink_*')
0668 
0669 approxSiStripClusters.toModify(FEVTDEBUGHLTEventContent,
0670                               outputCommands = FEVTDEBUGHLTEventContent.outputCommands+[
0671                                   'keep *_hltSiStripClusters2ApproxClusters_*_*',
0672                                   'keep DetIds_hltSiStripRawToDigi_*_*'
0673                               ])
0674 phase2_tracker.toModify(FEVTDEBUGHLTEventContent,
0675                         outputCommands = FEVTDEBUGHLTEventContent.outputCommands+[
0676                             'keep *_hltPhase2PixelTracks_*_*',
0677                             'keep *_hltPhase2PixelVertices_*_*'
0678                         ])
0679 
0680 phase2_common.toModify(FEVTDEBUGHLTEventContent,
0681                        outputCommands = FEVTDEBUGHLTEventContent.outputCommands+[
0682                            'keep *_hltEgammaGsfTracksL1Seeded_*_*',
0683                        ])
0684 
0685 phase2_muon.toModify(FEVTDEBUGHLTEventContent, 
0686     outputCommands = FEVTDEBUGHLTEventContent.outputCommands + ['keep recoMuons_muons1stStep_*_*'])
0687 
0688 from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2
0689 
0690 (premix_stage2 & phase2_tracker).toModify(FEVTDEBUGHLTEventContent, 
0691     outputCommands = FEVTDEBUGHLTEventContent.outputCommands+[
0692         'keep *_*_Phase2OTDigiSimLink_*'])
0693 (premix_stage2 & phase2_muon).toModify(FEVTDEBUGHLTEventContent, 
0694     outputCommands = FEVTDEBUGHLTEventContent.outputCommands+[
0695         'keep *_*_GEMDigiSimLink_*',
0696         'keep *_*_GEMStripDigiSimLink_*',
0697         'keep *_*_ME0DigiSimLink_*',
0698         'keep *_*_ME0StripDigiSimLink_*'])
0699 #
0700 #
0701 # RECOSIMDEBUG Data Tier definition
0702 #
0703 #
0704 RECODEBUGEventContent = cms.PSet(
0705     outputCommands = cms.untracked.vstring('drop *'),
0706     splitLevel = cms.untracked.int32(0),
0707 )
0708 RECODEBUGEventContent.outputCommands.extend(RECOSIMEventContent.outputCommands)
0709 RECODEBUGEventContent.outputCommands.extend(SimGeneralFEVTDEBUG.outputCommands)
0710 RECODEBUGEventContent.outputCommands.extend(SimTrackerDEBUG.outputCommands)
0711 #
0712 ## HLTDEBUG tier definition
0713 #
0714 HLTDEBUGEventContent = cms.PSet(
0715     #outputCommands = cms.untracked.vstring('drop *',
0716     #        'keep *_hlt*_*_*')
0717     outputCommands = cms.untracked.vstring('drop *',
0718         'keep *_logErrorHarvester_*_*'),
0719     splitLevel = cms.untracked.int32(0),
0720 )
0721 HLTDEBUGEventContent.outputCommands.extend(HLTDebugFEVT.outputCommands)
0722 #
0723 #
0724 ## DQM event content
0725 #
0726 #
0727 DQMEventContent = cms.PSet(
0728     outputCommands = cms.untracked.vstring('drop *',
0729         'keep *_MEtoEDMConverter_*_*'),
0730     splitLevel = cms.untracked.int32(0)
0731 )
0732 
0733 #Special Event Content for MixingModule and DataMixer
0734 DATAMIXEREventContent = cms.PSet(
0735     outputCommands = cms.untracked.vstring('drop *',
0736         'keep CSCDetIdCSCALCTDigiMuonDigiCollection_muonCSCDigis_MuonCSCALCTDigi_*',
0737         'keep CSCDetIdCSCCLCTDigiMuonDigiCollection_muonCSCDigis_MuonCSCCLCTDigi_*',
0738         'keep CSCDetIdCSCComparatorDigiMuonDigiCollection_muonCSCDigis_MuonCSCComparatorDigi_*',
0739         'keep CSCDetIdCSCCorrelatedLCTDigiMuonDigiCollection_csctfDigis_*_*',
0740         'keep CSCDetIdCSCCorrelatedLCTDigiMuonDigiCollection_muonCSCDigis_MuonCSCCorrelatedLCTDigi_*',
0741         'keep CSCDetIdCSCRPCDigiMuonDigiCollection_muonCSCDigis_MuonCSCRPCDigi_*',
0742         'keep CSCDetIdCSCStripDigiMuonDigiCollection_muonCSCDigis_MuonCSCStripDigi_*',
0743         'keep CSCDetIdCSCWireDigiMuonDigiCollection_muonCSCDigis_MuonCSCWireDigi_*',
0744         'keep DTLayerIdDTDigiMuonDigiCollection_muonDTDigis_*_*',
0745         'keep PixelDigiedmDetSetVector_siPixelDigis_*_*',
0746         'keep SiStripDigiedmDetSetVector_siStripDigis_*_*',
0747         'keep RPCDetIdRPCDigiMuonDigiCollection_muonRPCDigis_*_*',
0748         'keep HBHEDataFramesSorted_hcalDigis_*_*',
0749         'keep HFDataFramesSorted_hcalDigis_*_*',
0750         'keep HODataFramesSorted_hcalDigis_*_*',
0751         'keep QIE10DataFrameHcalDataFrameContainer_hcalDigis_*_*',
0752         'keep QIE11DataFrameHcalDataFrameContainer_hcalDigis_*_*',
0753         'keep ZDCDataFramesSorted_hcalDigis_*_*',
0754         'keep CastorDataFramesSorted_castorDigis_*_*',
0755         'keep EBDigiCollection_ecalDigis_*_*',
0756         'keep EEDigiCollection_ecalDigis_*_*',
0757         'keep ESDigiCollection_ecalPreshowerDigis_*_*'),
0758     splitLevel = cms.untracked.int32(0),
0759 )
0760 
0761 PREMIXEventContent = cms.PSet(
0762     outputCommands = cms.untracked.vstring('drop *'),
0763     splitLevel = cms.untracked.int32(0),
0764 )
0765 PREMIXEventContent.outputCommands.extend(SimGeneralRAW.outputCommands)
0766 PREMIXEventContent.outputCommands.extend(IOMCRAW.outputCommands)
0767 PREMIXEventContent.outputCommands.extend(CommonEventContent.outputCommands)
0768 PREMIXEventContent.outputCommands.extend(SimTrackerPREMIX.outputCommands)
0769 PREMIXEventContent.outputCommands.extend(SimCalorimetryPREMIX.outputCommands)
0770 PREMIXEventContent.outputCommands.extend(SimFastTimingPREMIX.outputCommands)
0771 PREMIXEventContent.outputCommands.extend(SimMuonPREMIX.outputCommands)
0772 PREMIXEventContent.outputCommands.extend(SimGeneralPREMIX.outputCommands)
0773 fastSim.toModify(PREMIXEventContent,
0774     outputCommands = PREMIXEventContent.outputCommands+fastSimEC.extraPremixContent)
0775 
0776 MIXINGMODULEEventContent = cms.PSet(
0777     outputCommands = cms.untracked.vstring('drop *',
0778         'keep *_cfWriter_*_*'),
0779     splitLevel = cms.untracked.int32(0),
0780 )
0781 
0782 # PREMIXRAW Data Tier definition
0783 #
0784 #
0785 PREMIXRAWEventContent = cms.PSet(
0786     outputCommands = cms.untracked.vstring('drop *'),
0787     splitLevel = cms.untracked.int32(0),
0788 )
0789 PREMIXRAWEventContent.outputCommands.extend(RAWSIMEventContent.outputCommands)
0790 PREMIXRAWEventContent.outputCommands.append('keep CrossingFramePlaybackInfoNew_*_*_*')
0791 PREMIXRAWEventContent.outputCommands.append('drop CrossingFramePlaybackInfoNew_mix_*_*')
0792 PREMIXRAWEventContent.outputCommands.append('keep *_*_MergedTrackTruth_*')
0793 PREMIXRAWEventContent.outputCommands.append('keep *_*_StripDigiSimLink_*')
0794 PREMIXRAWEventContent.outputCommands.append('keep *_*_PixelDigiSimLink_*')
0795 PREMIXRAWEventContent.outputCommands.append('keep *_*_MuonCSCStripDigiSimLinks_*')
0796 PREMIXRAWEventContent.outputCommands.append('keep *_*_MuonCSCWireDigiSimLinks_*')
0797 PREMIXRAWEventContent.outputCommands.append('keep *_*_RPCDigiSimLink_*')
0798 PREMIXRAWEventContent.outputCommands.append('keep DTLayerIdDTDigiSimLinkMuonDigiCollection_*_*_*')
0799 #
0800 # Temporary eventcontent for Prod-Like Phase2 PREMIXRAW. 
0801 # They are until packer/unpackers are done.
0802 # 
0803 (premix_stage2 & phase2_common).toModify(PREMIXRAWEventContent, 
0804                                          outputCommands = PREMIXRAWEventContent.outputCommands + [
0805                                               'drop *_simSiPixelDigis_*_*',
0806                                               'keep *_mixData_Pixel_*',
0807                                               'keep *_mixData_Tracker_*',
0808                                               'keep *_*_Phase2OTDigiSimLink_*',
0809                                               'keep *_*_GEMDigiSimLink_*',
0810                                               'keep *_*_GEMStripDigiSimLink_*',
0811                                               'keep *_*_ME0DigiSimLink_*',
0812                                               'keep *_*_ME0StripDigiSimLink_*'
0813                                          ])
0814 
0815 #
0816 #
0817 ## RAW repacked event content definition
0818 #
0819 #
0820 REPACKRAWEventContent = cms.PSet(
0821     outputCommands = cms.untracked.vstring('drop *',
0822         'drop FEDRawDataCollection_*_*_*',
0823         'keep FEDRawDataCollection_rawDataRepacker_*_*',
0824         'keep FEDRawDataCollection_virginRawDataRepacker_*_*',
0825         'keep FEDRawDataCollection_rawDataReducedFormat_*_*'),
0826     splitLevel = cms.untracked.int32(0),
0827 )
0828 REPACKRAWEventContent.outputCommands.extend(L1TriggerRAW.outputCommands)
0829 REPACKRAWEventContent.outputCommands.extend(HLTriggerRAW.outputCommands)
0830 approxSiStripClusters.toModify(REPACKRAWEventContent,
0831                                outputCommands = REPACKRAWEventContent.outputCommands+[
0832                                    'keep *_hltSiStripClusters2ApproxClusters_*_*',
0833                                    'drop FEDRawDataCollection_rawDataRepacker_*_*',
0834                                    'keep FEDRawDataCollection_rawPrimeDataRepacker_*_*'
0835                                ])
0836 
0837 REPACKRAWSIMEventContent = cms.PSet(
0838     outputCommands = cms.untracked.vstring(),
0839     splitLevel = cms.untracked.int32(0),
0840 )
0841 REPACKRAWSIMEventContent.outputCommands.extend(REPACKRAWEventContent.outputCommands)
0842 REPACKRAWSIMEventContent.outputCommands.extend(SimG4CoreRAW.outputCommands)
0843 REPACKRAWSIMEventContent.outputCommands.extend(SimTrackerRAW.outputCommands)
0844 REPACKRAWSIMEventContent.outputCommands.extend(SimMuonRAW.outputCommands)
0845 REPACKRAWSIMEventContent.outputCommands.extend(SimCalorimetryRAW.outputCommands)
0846 REPACKRAWSIMEventContent.outputCommands.extend(SimFastTimingRAW.outputCommands)
0847 REPACKRAWSIMEventContent.outputCommands.extend(SimGeneralRAW.outputCommands)
0848 REPACKRAWSIMEventContent.outputCommands.extend(GeneratorInterfaceRAW.outputCommands)
0849 REPACKRAWSIMEventContent.outputCommands.extend(RecoGenJetsFEVT.outputCommands)
0850 REPACKRAWSIMEventContent.outputCommands.extend(RecoGenMETFEVT.outputCommands)
0851 REPACKRAWSIMEventContent.outputCommands.extend(DigiToRawFEVT.outputCommands)
0852 REPACKRAWSIMEventContent.outputCommands.extend(MEtoEDMConverterFEVT.outputCommands)
0853 REPACKRAWSIMEventContent.outputCommands.extend(IOMCRAW.outputCommands)
0854 REPACKRAWSIMEventContent.outputCommands.extend(CommonEventContent.outputCommands)
0855 REPACKRAWSIMEventContent.outputCommands.extend([
0856     'drop FEDRawDataCollection_source_*_*',
0857         'drop FEDRawDataCollection_rawDataCollector_*_*'])
0858 REPACKRAWEventContent.outputCommands.extend([
0859     'drop FEDRawDataCollection_source_*_*',
0860         'drop FEDRawDataCollection_rawDataCollector_*_*'])
0861 
0862 #from modules in Configuration.StandardSequence.Generator_cff fixGenInfo
0863 REGENEventContent = cms.PSet(
0864     inputCommands=cms.untracked.vstring(
0865         'keep *',
0866         'drop *_genParticles_*_*',
0867         'drop *_genParticlesForJets_*_*',
0868         'drop *_kt4GenJets_*_*',
0869         'drop *_kt6GenJets_*_*',
0870         'drop *_iterativeCone5GenJets_*_*',
0871         'drop *_ak4GenJets_*_*',
0872         'drop *_ak7GenJets_*_*',
0873         'drop *_ak8GenJets_*_*',
0874         'drop *_ak4GenJetsNoNu_*_*',
0875         'drop *_ak8GenJetsNoNu_*_*',
0876         'drop *_genCandidatesForMET_*_*',
0877         'drop *_genParticlesForMETAllVisible_*_*',
0878         'drop *_genMetCalo_*_*',
0879         'drop *_genMetCaloAndNonPrompt_*_*',
0880         'drop *_genMetTrue_*_*',
0881         'drop *_genMetIC5GenJs_*_*')
0882 )
0883 
0884 RESIMEventContent = cms.PSet(
0885     inputCommands=cms.untracked.vstring('drop *')
0886 )
0887 RESIMEventContent.inputCommands.extend(IOMCRAW.outputCommands)
0888 RESIMEventContent.inputCommands.extend(GeneratorInterfaceRAW.outputCommands)
0889 
0890 
0891 REDIGIEventContent = cms.PSet(
0892     inputCommands=cms.untracked.vstring('drop *')
0893 )
0894 REDIGIEventContent.inputCommands.extend(SimG4CoreRAW.outputCommands)
0895 REDIGIEventContent.inputCommands.extend(IOMCRAW.outputCommands)
0896 REDIGIEventContent.inputCommands.extend(GeneratorInterfaceRAW.outputCommands)
0897 REDIGIEventContent.inputCommands.append('drop *_randomEngineStateProducer_*_*')
0898 
0899 ########### and mini AOD
0900 #
0901 # MiniAOD is a bit special: the files tend to be so small that letting
0902 # ROOT automatically determine when to flush is a surprisingly big overhead.
0903 #
0904 from PhysicsTools.PatAlgos.slimming.slimming_cff import MicroEventContent,MicroEventContentMC,MicroEventContentGEN
0905 
0906 MINIAODEventContent= cms.PSet(
0907     outputCommands = cms.untracked.vstring('drop *'),
0908     eventAutoFlushCompressedSize=cms.untracked.int32(-900),
0909     compressionAlgorithm=cms.untracked.string("LZMA"),
0910     compressionLevel=cms.untracked.int32(4)
0911 )
0912 MINIAODEventContent.outputCommands.extend(MicroEventContent.outputCommands)
0913 MINIAODEventContent.outputCommands.extend(HLTriggerMINIAOD.outputCommands)
0914 
0915 MINIAODSIMEventContent= cms.PSet(
0916     outputCommands = cms.untracked.vstring('drop *'),
0917     eventAutoFlushCompressedSize=cms.untracked.int32(-900),
0918     compressionAlgorithm=cms.untracked.string("LZMA"),
0919     compressionLevel=cms.untracked.int32(4)
0920 )
0921 MINIAODSIMEventContent.outputCommands.extend(MicroEventContentMC.outputCommands)
0922 MINIAODSIMEventContent.outputCommands.extend(HLTriggerMINIAOD.outputCommands)
0923 
0924 MINIGENEventContent= cms.PSet(
0925     outputCommands = cms.untracked.vstring('drop *'),
0926     eventAutoFlushCompressedSize=cms.untracked.int32(15*1024*1024),
0927     compressionAlgorithm=cms.untracked.string("LZMA"),
0928     compressionLevel=cms.untracked.int32(4)
0929 )
0930 MINIGENEventContent.outputCommands.extend(MicroEventContentGEN.outputCommands)
0931 
0932 #### RAW+miniAOD
0933 
0934 RAWMINIAODEventContent= cms.PSet(
0935     outputCommands = cms.untracked.vstring('drop *'),
0936     eventAutoFlushCompressedSize=cms.untracked.int32(20*1024*1024),
0937     compressionAlgorithm=cms.untracked.string("LZMA"),
0938     compressionLevel=cms.untracked.int32(4)
0939 )
0940 RAWMINIAODEventContent.outputCommands.extend(MicroEventContent.outputCommands)
0941 RAWMINIAODEventContent.outputCommands.extend(L1TriggerRAW.outputCommands)
0942 RAWMINIAODEventContent.outputCommands.extend(HLTriggerRAW.outputCommands)
0943 RAWMINIAODEventContent.outputCommands.extend(cms.untracked.vstring(
0944     'keep FEDRawDataCollection_rawDataCollector_*_*',
0945     'keep FEDRawDataCollection_source_*_*'))
0946 
0947 RAWMINIAODSIMEventContent= cms.PSet(
0948     outputCommands = cms.untracked.vstring('drop *'),
0949     eventAutoFlushCompressedSize=cms.untracked.int32(20*1024*1024),
0950     compressionAlgorithm=cms.untracked.string("LZMA"),
0951     compressionLevel=cms.untracked.int32(4)
0952 )
0953 RAWMINIAODSIMEventContent.outputCommands.extend(RAWMINIAODEventContent.outputCommands)
0954 RAWMINIAODSIMEventContent.outputCommands.extend(MicroEventContentMC.outputCommands)
0955 RAWMINIAODSIMEventContent.outputCommands.extend(SimG4CoreHLTAODSIM.outputCommands)
0956 #
0957 #
0958 # RAWSIM Data Tier definition
0959 # Meant as means to temporarily hold the RAW + AODSIM information as to allow the
0960 # L1+HLT to be rerun at a later time.
0961 #
0962 RAWAODSIMEventContent = cms.PSet(
0963     outputCommands = cms.untracked.vstring('drop *'),
0964     eventAutoFlushCompressedSize=cms.untracked.int32(20*1024*1024),
0965     compressionAlgorithm=cms.untracked.string("LZMA"),
0966     compressionLevel=cms.untracked.int32(4)
0967 )
0968 RAWAODSIMEventContent.outputCommands.extend(AODSIMEventContent.outputCommands)
0969 RAWAODSIMEventContent.outputCommands.extend(L1TriggerRAW.outputCommands)
0970 RAWAODSIMEventContent.outputCommands.extend(HLTriggerRAW.outputCommands)
0971 RAWAODSIMEventContent.outputCommands.extend(SimG4CoreHLTAODSIM.outputCommands)
0972 
0973 # in fastsim, normal digis are edaliases of simdigis
0974 # drop the simdigis to avoid complaints from the outputmodule related to duplicated branches
0975 for _entry in [FEVTDEBUGHLTEventContent,FEVTDEBUGEventContent,RECOSIMEventContent,AODSIMEventContent,RAWAODSIMEventContent]:
0976     fastSim.toModify(_entry, outputCommands = _entry.outputCommands + fastSimEC.dropSimDigis)
0977 for _entry in [MINIAODEventContent, MINIAODSIMEventContent]:
0978     fastSim.toModify(_entry, outputCommands = _entry.outputCommands + fastSimEC.dropPatTrigger)
0979