Applications/test/ConfigBuilderTest.py

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 #    print(process.outputModules_())
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             # DQM sequences are unique
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             # Code in prepare_DQM() call assumes the 'sequenceList`
0076             # has at least as many elements as `postSequenceList`. We
0077             # can't fake 'postSequenceList' as it is also derived from
0078             # the prepare_DQM() argument, but duplicates are not
0079             # removed. The only handle we have (besides code changes,
0080             # that are beyond this bug fix), is to modify the autoDQM.
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             # seq4 is used only to have the expanded and uniquified
0088             # 'sequenceList' to have at least as many elements as
0089             # 'postSequenceList'
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             #RECO
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             #AOD
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             #MINIAOD
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             #MINIAOD w/ RNTuple
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             #MINIAOD1 [NOTE notiation not restricted to MINIAOD]
0144             #NOT SUPPORTED BY outputDefinition
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             #DQMIO
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             #DQMIO & rntuple (will not change)
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             #DQMIO&DQMIO
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             #DQMIO&DQMIO & rntuple (will not change)
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             #DQM, not DQMIO (decided by datatier)
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             #NANOAOD
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             #NANOEDMAOD
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             #NANOAOD & rntuple (no change)
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             #NANOEDMAOD & rntuple
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             #ALCARECO empty
0239             process = cms.Process("TEST")
0240             options.scenario = "TEST"
0241             options.datatier= "ALCARECO"
0242             options.eventcontent="ALCARECO"
0243             _test_addOutput(self, options, process, [])
0244             #ALCARECO present
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             #AOD+MINIAOD
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             #MINIAOD & generation_step
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             #MINIAOD & filtering_step
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             #LHE & generation_step
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             #RECO
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             #RECO & moduleLabel
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             #RECO & fileName
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             #RECO & eventContent
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             #RECO & selectEvents
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             #RECO & outputCommands
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             #AOD
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             #MINIAOD
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             #DQMIO&DQM
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             #NOTE: THE MODULE LABEL IS DIFFERENT FROM THE OTHER CASE
0378             #_test_addOutput(self, options, process, [OutStats('DQMIOoutput','DQMRootOutputModule','DQMIO','output.root',outputCommands_)])
0379             _test_addOutput(self, options, process, [OutStats('DQMDQMIOoutput','DQMRootOutputModule','DQMIO','output.root',outputCommands_)])
0380             #DQMIO&DQMIO
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             #DQM, not DQMIO (decided by datatier)
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             #NANOAOD
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             #NOTE: Does not use NanoAODOuputModule (this code path is not capable of making that type)
0404             #_test_addOutput(self, options, process, [OutStats('NANOAODoutput','NanoAODOutputModule','NANOAOD','output.root',outputCommands_)])
0405             _test_addOutput(self, options, process, [OutStats('NANOAODoutput','PoolOutputModule','NANOAOD','output.root',outputCommands_)])
0406             #NANOEDMAOD
0407             process = cms.Process("TEST")
0408             outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0409             #USES A DIFFERENT EVENT CONTENT (which we do not define)
0410             #process.NANOAODEventContent = cms.PSet( outputCommands = outputCommands_)
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             #GENERATES A DIFFERENT NAME
0416             #_test_addOutput(self, options, process, [OutStats('NANOEDMAODoutput', 'PoolOutputModule', 'NANOAOD', 'output.root', outputCommands_)])
0417             _test_addOutput(self, options, process, [OutStats('NANOEDMAODNANOAODoutput', 'PoolOutputModule', 'NANOAOD', 'output.root', outputCommands_)])
0418             #ALCARECO empty
0419             #THIS DOES NOT STOP THE ADDITION LIKE THE OTHER BRANCH
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             #OTHER BRANCH DOES NOT NEED THE FOLLOWING
0426             outputCommands_ = cms.untracked.vstring('drop *', 'keep foo')
0427             process.ALCARECOEventContent = cms.PSet( outputCommands = outputCommands_)
0428             #_test_addOutput(self, options, process, [])
0429             outs = _test_addOutput(self, options, process, [OutStats('ALCARECOoutput', 'PoolOutputModule', 'ALCARECO', 'output.root', outputCommands_)], lambda cb: setattr(cb, 'AlCaPaths',[]))
0430             #ALCARECO present
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             #AOD+MINIAOD
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             #MINIAOD & generation_step
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             #MINIAOD & filtering_step
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             #LHE & generation_step
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