Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2022-11-02 03:49:58

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