File indexing completed on 2025-03-27 03:36:29
0001 import FWCore.ParameterSet.Config as cms
0002 from Configuration.Applications.ConfigBuilder import ConfigBuilder, defaultOptions
0003
0004 import copy
0005
0006 def prepareDQMSequenceOrder():
0007 options = copy.deepcopy(defaultOptions)
0008 options.scenario = "Test"
0009
0010 process = cms.Process("Test")
0011 process.a1 = cms.EDAnalyzer("A1")
0012 process.a2 = cms.EDAnalyzer("A2")
0013 process.a3 = cms.EDAnalyzer("A3")
0014 process.a4 = cms.EDAnalyzer("A4")
0015 process.seq1 = cms.Sequence(process.a1)
0016 process.seq2 = cms.Sequence(process.a2)
0017 process.seq3 = cms.Sequence(process.a3)
0018 process.seq4 = cms.Sequence(process.a4)
0019 process.ps1 = cms.Sequence()
0020 process.ps2 = cms.Sequence()
0021 process.ps3 = cms.Sequence()
0022 process.ps3 = cms.Sequence()
0023 process.ps4 = cms.Sequence()
0024 return (options, process)
0025
0026 class OutStats(object):
0027 def __init__(self, name, type_, tier, fileName, commands):
0028 self.name = name
0029 self.type_ = type_
0030 self.tier = tier
0031 self.fileName = fileName
0032 self.commands = commands
0033 def _test_addOutput(tester, options, process, outStats, modifier = None):
0034 cb = ConfigBuilder(options, process)
0035 if modifier:
0036 modifier(cb)
0037 cb.addOutput()
0038 tester.assertEqual(len(process.outputModules_()), len(outStats))
0039 outs = []
0040
0041 for stat in outStats:
0042 tester.assertTrue( stat.name in process.outputModules_() )
0043 r = process.outputModules_()[stat.name]
0044 tester.assertEqual(r.type_(), stat.type_)
0045 tester.assertEqual(r.dataset.dataTier.value(), stat.tier)
0046 tester.assertEqual(r.fileName.value(), stat.fileName)
0047 tester.assertEqual(r.outputCommands, stat.commands)
0048 outs.append(r)
0049 return outs
0050
0051 if __name__=="__main__":
0052 import unittest
0053
0054 class TestModuleCommand(unittest.TestCase):
0055 def setUp(self):
0056 """Nothing to do """
0057 None
0058
0059 def testDQMSequenceOrder(self):
0060 def extract(process, count):
0061 if count == 0:
0062 return []
0063 ret = list(process.dqmoffline_step.moduleNames())
0064 for i in range(1, count):
0065 ret.extend(list(getattr(process, f"dqmoffline_{i}_step").moduleNames()))
0066 return ret
0067
0068
0069 (options, process) = prepareDQMSequenceOrder()
0070 order = [3, 1, 2]
0071 cb = ConfigBuilder(options, process)
0072 cb.prepare_DQM("+".join(f"seq{o}" for o in order))
0073 self.assertEqual([f"a{o}" for o in order], extract(process, len(order)))
0074
0075
0076
0077
0078
0079
0080
0081 from DQMOffline.Configuration.autoDQM import autoDQM
0082 autoDQM_orig = copy.deepcopy(autoDQM)
0083 autoDQM.clear()
0084 autoDQM["alias1"] = ["seq1", "ps1", "not needed"]
0085 autoDQM["alias2"] = ["seq2", "ps2", "not needed"]
0086 autoDQM["alias3"] = ["seq3", "ps3", "not needed"]
0087
0088
0089
0090 autoDQM["alias4"] = ["seq2+seq4", "ps4", "not needed"]
0091
0092 order = [2, 1, 3]
0093 cb = ConfigBuilder(options, process)
0094 cb.prepare_DQM("+".join(f"@alias{o}" for o in order))
0095 self.assertEqual([f"a{o}" for o in order], extract(process, len(order)))
0096
0097 cb = ConfigBuilder(options, process)
0098 order = [2, 1, 4, 3]
0099 cb.prepare_DQM("+".join(f"@alias{o}" for o in order))
0100 self.assertEqual([f"a{o}" for o in order], extract(process, len(order)))
0101
0102 autoDQM.clear()
0103 autoDQM.update(autoDQM_orig)
0104
0105 def testOutputFormatWithEventContent(self):
0106
0107 process = cms.Process("TEST")
0108 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0109 process.RECOEventContent = cms.PSet( outputCommands = outputCommands_)
0110 options = copy.deepcopy(defaultOptions)
0111 options.scenario = "TEST"
0112 options.datatier= "RECO"
0113 options.eventcontent="RECO"
0114 _test_addOutput(self, options, process, [OutStats('RECOoutput','PoolOutputModule','RECO','output.root',outputCommands_)])
0115
0116 process = cms.Process("TEST")
0117 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0118 process.AODEventContent = cms.PSet( outputCommands = outputCommands_)
0119 options = copy.deepcopy(defaultOptions)
0120 options.scenario = "TEST"
0121 options.datatier= "AOD"
0122 options.eventcontent="AOD"
0123 _test_addOutput(self, options, process, [OutStats('AODoutput','PoolOutputModule','AOD','output.root',outputCommands_)])
0124
0125 process = cms.Process("TEST")
0126 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0127 process.MINIAODEventContent = cms.PSet( outputCommands = outputCommands_)
0128 options = copy.deepcopy(defaultOptions)
0129 options.scenario = "TEST"
0130 options.datatier= "MINIAOD"
0131 options.eventcontent="MINIAOD"
0132 _test_addOutput(self, options, process, [OutStats('MINIAODoutput','PoolOutputModule','MINIAOD','output.root',outputCommands_)])
0133
0134 process = cms.Process("TEST")
0135 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0136 process.MINIAODEventContent = cms.PSet( outputCommands = outputCommands_)
0137 options = copy.deepcopy(defaultOptions)
0138 options.scenario = "TEST"
0139 options.datatier= "MINIAOD"
0140 options.eventcontent="MINIAOD"
0141 options.rntuple_out = True
0142 _test_addOutput(self, options, process, [OutStats('MINIAODoutput','RNTupleOutputModule','MINIAOD','output.rntpl',outputCommands_)])
0143
0144
0145 process = cms.Process("TEST")
0146 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0147 process.MINIAODEventContent = cms.PSet( outputCommands = outputCommands_)
0148 options = copy.deepcopy(defaultOptions)
0149 options.scenario = "TEST"
0150 options.datatier= "MINIAOD"
0151 options.eventcontent="MINIAOD1"
0152 _test_addOutput(self, options, process, [OutStats('MINIAOD1output','PoolOutputModule','MINIAOD','output.root',outputCommands_)])
0153
0154 process = cms.Process("TEST")
0155 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0156 process.DQMEventContent = cms.PSet( outputCommands = outputCommands_)
0157 options = copy.deepcopy(defaultOptions)
0158 options.scenario = "TEST"
0159 options.datatier= "DQMIO"
0160 options.eventcontent="DQM"
0161 _test_addOutput(self, options, process, [OutStats('DQMoutput','DQMRootOutputModule','DQMIO','output.root',outputCommands_)])
0162
0163 process = cms.Process("TEST")
0164 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0165 process.DQMEventContent = cms.PSet( outputCommands = outputCommands_)
0166 options = copy.deepcopy(defaultOptions)
0167 options.scenario = "TEST"
0168 options.datatier= "DQMIO"
0169 options.eventcontent="DQM"
0170 options.rntuple_out = True
0171 _test_addOutput(self, options, process, [OutStats('DQMoutput','DQMRootOutputModule','DQMIO','output.root',outputCommands_)])
0172
0173 process = cms.Process("TEST")
0174 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0175 process.DQMEventContent = cms.PSet( outputCommands = outputCommands_)
0176 options = copy.deepcopy(defaultOptions)
0177 options.scenario = "TEST"
0178 options.datatier= "DQMIO"
0179 options.eventcontent="DQMIO"
0180 _test_addOutput(self, options, process, [OutStats('DQMoutput','DQMRootOutputModule','DQMIO','output.root',outputCommands_)])
0181
0182 process = cms.Process("TEST")
0183 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0184 process.DQMEventContent = cms.PSet( outputCommands = outputCommands_)
0185 options = copy.deepcopy(defaultOptions)
0186 options.scenario = "TEST"
0187 options.datatier= "DQMIO"
0188 options.eventcontent="DQMIO"
0189 options.rntuple_out = True
0190 _test_addOutput(self, options, process, [OutStats('DQMoutput','DQMRootOutputModule','DQMIO','output.root',outputCommands_)])
0191
0192 process = cms.Process("TEST")
0193 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0194 process.DQMEventContent = cms.PSet( outputCommands = outputCommands_)
0195 options = copy.deepcopy(defaultOptions)
0196 options.scenario = "TEST"
0197 options.datatier= "DQM"
0198 options.eventcontent="DQM"
0199 _test_addOutput(self, options, process, [OutStats('DQMoutput','PoolOutputModule','DQM','output.root',outputCommands_)])
0200
0201 process = cms.Process("TEST")
0202 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0203 process.NANOAODEventContent = cms.PSet( outputCommands = outputCommands_)
0204 options = copy.deepcopy(defaultOptions)
0205 options.scenario = "TEST"
0206 options.datatier= "NANOAOD"
0207 options.eventcontent="NANOAOD"
0208 _test_addOutput(self, options, process, [OutStats('NANOAODoutput','NanoAODOutputModule','NANOAOD','output.root',outputCommands_)])
0209
0210 process = cms.Process("TEST")
0211 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0212 process.NANOAODEventContent = cms.PSet( outputCommands = outputCommands_)
0213 options = copy.deepcopy(defaultOptions)
0214 options.scenario = "TEST"
0215 options.datatier= "NANOAOD"
0216 options.eventcontent="NANOEDMAOD"
0217 _test_addOutput(self, options, process, [OutStats('NANOEDMAODoutput', 'PoolOutputModule', 'NANOAOD', 'output.root', outputCommands_)])
0218
0219 process = cms.Process("TEST")
0220 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0221 process.NANOAODEventContent = cms.PSet( outputCommands = outputCommands_)
0222 options = copy.deepcopy(defaultOptions)
0223 options.scenario = "TEST"
0224 options.datatier= "NANOAOD"
0225 options.eventcontent="NANOAOD"
0226 options.rntuple_out = True
0227 _test_addOutput(self, options, process, [OutStats('NANOAODoutput','NanoAODOutputModule','NANOAOD','output.root',outputCommands_)])
0228
0229 process = cms.Process("TEST")
0230 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0231 process.NANOAODEventContent = cms.PSet( outputCommands = outputCommands_)
0232 options = copy.deepcopy(defaultOptions)
0233 options.scenario = "TEST"
0234 options.datatier= "NANOAOD"
0235 options.eventcontent="NANOEDMAOD"
0236 options.rntuple_out = True
0237 _test_addOutput(self, options, process, [OutStats('NANOEDMAODoutput', 'RNTupleOutputModule', 'NANOAOD', 'output.rntpl', outputCommands_)])
0238
0239 process = cms.Process("TEST")
0240 options.scenario = "TEST"
0241 options.datatier= "ALCARECO"
0242 options.eventcontent="ALCARECO"
0243 _test_addOutput(self, options, process, [])
0244
0245 process = cms.Process("TEST")
0246 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0247 process.ALCARECOEventContent = cms.PSet( outputCommands = outputCommands_)
0248 options = copy.deepcopy(defaultOptions)
0249 options.scenario = "TEST"
0250 options.datatier= "ALCARECO"
0251 options.eventcontent="ALCARECO"
0252 options.step = 'ALCAPRODUCER'
0253 outs = _test_addOutput(self, options, process, [OutStats('ALCARECOoutput', 'PoolOutputModule', 'ALCARECO', 'output.root', outputCommands_)])
0254 self.assertEqual(outs[0].dataset.filterName, cms.untracked.string('StreamALCACombined'))
0255
0256 process = cms.Process("TEST")
0257 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0258 process.AODEventContent = cms.PSet( outputCommands = outputCommands_)
0259 process.MINIAODEventContent = cms.PSet( outputCommands = outputCommands_)
0260 options = copy.deepcopy(defaultOptions)
0261 options.fileout = 'stepN.root'
0262 options.scenario = "TEST"
0263 options.datatier= "AOD,MINIAOD"
0264 options.eventcontent="AOD,MINIAOD"
0265 _test_addOutput(self, options, process, [OutStats('AODoutput','PoolOutputModule','AOD','stepN.root',outputCommands_), OutStats('MINIAODoutput','PoolOutputModule','MINIAOD','stepN_inMINIAOD.root',outputCommands_)])
0266
0267 process = cms.Process("TEST")
0268 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0269 process.MINIAODEventContent = cms.PSet( outputCommands = outputCommands_)
0270 process.generation_step = cms.Path()
0271 options = copy.deepcopy(defaultOptions)
0272 options.fileout = 'stepN.root'
0273 options.scenario = "TEST"
0274 options.datatier= "MINIAOD"
0275 options.eventcontent="MINIAOD"
0276 out = _test_addOutput(self, options, process, [OutStats('MINIAODoutput','PoolOutputModule','MINIAOD','stepN.root',outputCommands_)])
0277 self.assertEqual(out[0].SelectEvents.SelectEvents, cms.vstring('generation_step'))
0278
0279 process = cms.Process("TEST")
0280 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0281 process.MINIAODEventContent = cms.PSet( outputCommands = outputCommands_)
0282 process.filtering_step = cms.Path()
0283 options = copy.deepcopy(defaultOptions)
0284 options.fileout = 'stepN.root'
0285 options.scenario = "TEST"
0286 options.datatier= "MINIAOD"
0287 options.eventcontent="MINIAOD"
0288 out = _test_addOutput(self, options, process, [OutStats('MINIAODoutput','PoolOutputModule','MINIAOD','stepN.root',outputCommands_)])
0289 self.assertEqual(out[0].SelectEvents.SelectEvents, cms.vstring('filtering_step'))
0290
0291 process = cms.Process("TEST")
0292 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0293 process.LHEEventContent = cms.PSet( outputCommands = outputCommands_)
0294 process.generation_step = cms.Path()
0295 options = copy.deepcopy(defaultOptions)
0296 options.fileout = 'stepN.root'
0297 options.scenario = "TEST"
0298 options.datatier= "LHE"
0299 options.eventcontent="LHE"
0300 out = _test_addOutput(self, options, process, [OutStats('LHEoutput','PoolOutputModule','LHE','stepN.root',outputCommands_)])
0301 self.assertFalse(hasattr(out[0],"SelectEvents"))
0302
0303 def testOutputFormatWith_outputDefinition(self):
0304
0305 process = cms.Process("TEST")
0306 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0307 process.RECOEventContent = cms.PSet( outputCommands = outputCommands_)
0308 options = copy.deepcopy(defaultOptions)
0309 options.scenario = "TEST"
0310 options.outputDefinition = str([dict(tier='RECO'),])
0311 _test_addOutput(self, options, process, [OutStats('RECOoutput','PoolOutputModule','RECO','output.root',outputCommands_)])
0312
0313 process = cms.Process("TEST")
0314 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0315 process.RECOEventContent = cms.PSet( outputCommands = outputCommands_)
0316 options = copy.deepcopy(defaultOptions)
0317 options.scenario = "TEST"
0318 options.outputDefinition = str([dict(tier='RECO',moduleLabel='RECOoutputOther'),])
0319 _test_addOutput(self, options, process, [OutStats('RECOoutputOther','PoolOutputModule','RECO','output.root',outputCommands_)])
0320
0321 process = cms.Process("TEST")
0322 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0323 process.RECOEventContent = cms.PSet( outputCommands = outputCommands_)
0324 options = copy.deepcopy(defaultOptions)
0325 options.scenario = "TEST"
0326 options.outputDefinition = str([dict(tier='RECO',fileName='other.root'),])
0327 _test_addOutput(self, options, process, [OutStats('RECOoutput','PoolOutputModule','RECO','other.root',outputCommands_)])
0328
0329 process = cms.Process("TEST")
0330 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0331 process.RECOSIMEventContent = cms.PSet( outputCommands = outputCommands_)
0332 options = copy.deepcopy(defaultOptions)
0333 options.scenario = "TEST"
0334 options.outputDefinition = str([dict(tier='RECO',eventContent='RECOSIM'),])
0335 _test_addOutput(self, options, process, [OutStats('SIMRECOoutput','PoolOutputModule','RECO','output.root',outputCommands_)])
0336
0337 process = cms.Process("TEST")
0338 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0339 process.RECOEventContent = cms.PSet( outputCommands = outputCommands_)
0340 options = copy.deepcopy(defaultOptions)
0341 options.scenario = "TEST"
0342 options.outputDefinition = str([dict(tier='RECO',selectEvents='select'),])
0343 out = _test_addOutput(self, options, process, [OutStats('RECOoutput','PoolOutputModule','RECO','output.root',outputCommands_)])
0344 self.assertEqual(out[0].SelectEvents.SelectEvents, cms.vstring('select'))
0345
0346 process = cms.Process("TEST")
0347 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0348 process.RECOEventContent = cms.PSet( outputCommands = outputCommands_)
0349 options = copy.deepcopy(defaultOptions)
0350 options.scenario = "TEST"
0351 options.outputDefinition = str([dict(tier='RECO',outputCommands=cms.untracked.vstring('keep bar')),])
0352 fullOutputCommands = cms.untracked.vstring('drop *', 'keep foo', 'keep bar')
0353 _test_addOutput(self, options, process, [OutStats('RECOoutput','PoolOutputModule','RECO','output.root',fullOutputCommands)])
0354
0355 process = cms.Process("TEST")
0356 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0357 process.AODEventContent = cms.PSet( outputCommands = outputCommands_)
0358 options = copy.deepcopy(defaultOptions)
0359 options.scenario = "TEST"
0360 options.outputDefinition = str([dict(tier='AOD'),])
0361 _test_addOutput(self, options, process, [OutStats('AODoutput','PoolOutputModule','AOD','output.root',outputCommands_)])
0362
0363 process = cms.Process("TEST")
0364 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0365 process.MINIAODEventContent = cms.PSet( outputCommands = outputCommands_)
0366 options = copy.deepcopy(defaultOptions)
0367 options.scenario = "TEST"
0368 options.outputDefinition = str([dict(tier='MINIAOD'),])
0369 _test_addOutput(self, options, process, [OutStats('MINIAODoutput','PoolOutputModule','MINIAOD','output.root',outputCommands_)])
0370
0371 process = cms.Process("TEST")
0372 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0373 process.DQMEventContent = cms.PSet( outputCommands = outputCommands_)
0374 options = copy.deepcopy(defaultOptions)
0375 options.scenario = "TEST"
0376 options.outputDefinition = str([dict(tier='DQMIO', eventContent='DQM'),])
0377
0378
0379 _test_addOutput(self, options, process, [OutStats('DQMDQMIOoutput','DQMRootOutputModule','DQMIO','output.root',outputCommands_)])
0380
0381 process = cms.Process("TEST")
0382 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0383 process.DQMEventContent = cms.PSet( outputCommands = outputCommands_)
0384 options = copy.deepcopy(defaultOptions)
0385 options.scenario = "TEST"
0386 options.outputDefinition = str([dict(tier='DQMIO', eventContent='DQMIO'),])
0387 _test_addOutput(self, options, process, [OutStats('DQMIOoutput','DQMRootOutputModule','DQMIO','output.root',outputCommands_)])
0388
0389 process = cms.Process("TEST")
0390 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0391 process.DQMEventContent = cms.PSet( outputCommands = outputCommands_)
0392 options = copy.deepcopy(defaultOptions)
0393 options.scenario = "TEST"
0394 options.outputDefinition = str([dict(tier='DQM', eventContent='DQM'),])
0395 _test_addOutput(self, options, process, [OutStats('DQMoutput','PoolOutputModule','DQM','output.root',outputCommands_)])
0396
0397 process = cms.Process("TEST")
0398 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0399 process.NANOAODEventContent = cms.PSet( outputCommands = outputCommands_)
0400 options = copy.deepcopy(defaultOptions)
0401 options.scenario = "TEST"
0402 options.outputDefinition = str([dict(tier='NANOAOD', eventContent='NANOAOD'),])
0403
0404
0405 _test_addOutput(self, options, process, [OutStats('NANOAODoutput','PoolOutputModule','NANOAOD','output.root',outputCommands_)])
0406
0407 process = cms.Process("TEST")
0408 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0409
0410
0411 process.NANOEDMAODEventContent = cms.PSet( outputCommands = outputCommands_)
0412 options = copy.deepcopy(defaultOptions)
0413 options.scenario = "TEST"
0414 options.outputDefinition = str([dict(tier='NANOAOD', eventContent='NANOEDMAOD'),])
0415
0416
0417 _test_addOutput(self, options, process, [OutStats('NANOEDMAODNANOAODoutput', 'PoolOutputModule', 'NANOAOD', 'output.root', outputCommands_)])
0418
0419
0420 process = cms.Process("TEST")
0421 options.scenario = "TEST"
0422 options.datatier= "ALCARECO"
0423 options.eventcontent="ALCARECO"
0424 options.outputDefinition = str([dict(tier='ALCARECO', eventContent='ALCARECO'),])
0425
0426 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0427 process.ALCARECOEventContent = cms.PSet( outputCommands = outputCommands_)
0428
0429 outs = _test_addOutput(self, options, process, [OutStats('ALCARECOoutput', 'PoolOutputModule', 'ALCARECO', 'output.root', outputCommands_)], lambda cb: setattr(cb, 'AlCaPaths',[]))
0430
0431 process = cms.Process("TEST")
0432 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0433 process.ALCARECOEventContent = cms.PSet( outputCommands = outputCommands_)
0434 options = copy.deepcopy(defaultOptions)
0435 options.scenario = "TEST"
0436 options.outputDefinition = str([dict(tier='ALCARECO', eventContent='ALCARECO'),])
0437 options.step = 'ALCAPRODUCER'
0438 outs = _test_addOutput(self, options, process, [OutStats('ALCARECOoutput', 'PoolOutputModule', 'ALCARECO', 'output.root', outputCommands_)], lambda cb: setattr(cb, 'AlCaPaths', []))
0439 self.assertEqual(outs[0].dataset.filterName, cms.untracked.string('StreamALCACombined'))
0440
0441 process = cms.Process("TEST")
0442 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0443 process.AODEventContent = cms.PSet( outputCommands = outputCommands_)
0444 process.MINIAODEventContent = cms.PSet( outputCommands = outputCommands_)
0445 options = copy.deepcopy(defaultOptions)
0446 options.fileout = 'stepN.root'
0447 options.scenario = "TEST"
0448 options.outputDefinition = str([dict(tier='AOD'),dict(tier='MINIAOD')])
0449 _test_addOutput(self, options, process, [OutStats('AODoutput','PoolOutputModule','AOD','stepN.root',outputCommands_), OutStats('MINIAODoutput','PoolOutputModule','MINIAOD','stepN_inMINIAOD.root',outputCommands_)])
0450
0451 process = cms.Process("TEST")
0452 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0453 process.MINIAODEventContent = cms.PSet( outputCommands = outputCommands_)
0454 process.generation_step = cms.Path()
0455 options = copy.deepcopy(defaultOptions)
0456 options.fileout = 'stepN.root'
0457 options.scenario = "TEST"
0458 options.outputDefinition = str([dict(tier='MINIAOD'),])
0459 out = _test_addOutput(self, options, process, [OutStats('MINIAODoutput','PoolOutputModule','MINIAOD','stepN.root',outputCommands_)])
0460 self.assertEqual(out[0].SelectEvents.SelectEvents, cms.vstring('generation_step'))
0461
0462 process = cms.Process("TEST")
0463 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0464 process.MINIAODEventContent = cms.PSet( outputCommands = outputCommands_)
0465 process.filtering_step = cms.Path()
0466 options = copy.deepcopy(defaultOptions)
0467 options.fileout = 'stepN.root'
0468 options.scenario = "TEST"
0469 options.outputDefinition = str([dict(tier='MINIAOD'),])
0470 out = _test_addOutput(self, options, process, [OutStats('MINIAODoutput','PoolOutputModule','MINIAOD','stepN.root',outputCommands_)])
0471 self.assertEqual(out[0].SelectEvents.SelectEvents, cms.vstring('filtering_step'))
0472
0473 process = cms.Process("TEST")
0474 outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0475 process.LHEEventContent = cms.PSet( outputCommands = outputCommands_)
0476 process.generation_step = cms.Path()
0477 options = copy.deepcopy(defaultOptions)
0478 options.fileout = 'stepN.root'
0479 options.scenario = "TEST"
0480 options.outputDefinition = str([dict(tier='LHE'),])
0481 out = _test_addOutput(self, options, process, [OutStats('LHEoutput','PoolOutputModule','LHE','stepN.root',outputCommands_)])
0482 self.assertFalse(hasattr(out[0],"SelectEvents"))
0483
0484 unittest.main()
0485