EventContent/python/EventContent_cff.py

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