diff --git a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/CMakeLists.txt b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/CMakeLists.txt
index fd6061475a3bf9753ff4bea525f8908096f16bdd..e6b3cc2f6dfe8fe27b00dab250cb51d7f1aaab25 100644
--- a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/CMakeLists.txt
+++ b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/CMakeLists.txt
@@ -13,28 +13,28 @@ if( XAOD_STANDALONE )
atlas_install_scripts( share/*_eljob.py )
atlas_add_test( testJobData
- SCRIPT FullCPAlgorithmsTest_eljob.py --data-type data --unit-test
+ SCRIPT FullCPAlgorithmsTest_eljob.py --data-type data --unit-test --direct-driver
POST_EXEC_SCRIPT nopost.sh
PROPERTIES TIMEOUT 600 )
atlas_add_test( testJobFullSim
- SCRIPT FullCPAlgorithmsTest_eljob.py --data-type mc --unit-test
+ SCRIPT FullCPAlgorithmsTest_eljob.py --data-type mc --unit-test --direct-driver
POST_EXEC_SCRIPT nopost.sh
PROPERTIES TIMEOUT 600 )
atlas_add_test( testJobFastSim
- SCRIPT FullCPAlgorithmsTest_eljob.py --data-type afii --unit-test
+ SCRIPT FullCPAlgorithmsTest_eljob.py --data-type afii --unit-test --direct-driver
POST_EXEC_SCRIPT nopost.sh
PROPERTIES TIMEOUT 600 )
atlas_add_test( testJobDataConfig
- SCRIPT FullCPAlgorithmsTest_eljob.py --data-type data --unit-test --block-config
+ SCRIPT FullCPAlgorithmsTest_eljob.py --data-type data --unit-test --direct-driver --block-config
POST_EXEC_SCRIPT nopost.sh
PROPERTIES TIMEOUT 600 )
atlas_add_test( testJobFullSimConfig
- SCRIPT FullCPAlgorithmsTest_eljob.py --data-type mc --unit-test --block-config
+ SCRIPT FullCPAlgorithmsTest_eljob.py --data-type mc --unit-test --direct-driver --block-config
POST_EXEC_SCRIPT nopost.sh
PROPERTIES TIMEOUT 600 )
atlas_add_test( testJobFastSimConfig
- SCRIPT FullCPAlgorithmsTest_eljob.py --data-type afii --unit-test --block-config
+ SCRIPT FullCPAlgorithmsTest_eljob.py --data-type afii --unit-test --direct-driver --block-config
POST_EXEC_SCRIPT nopost.sh
PROPERTIES TIMEOUT 600 )
diff --git a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/python/FullCPAlgorithmsTest.py b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/python/FullCPAlgorithmsTest.py
index 74a24b211cb6456a5da1d444b71256a931af194e..568eefb28b2da9dc3a62666d8e501dbc2189a667 100644
--- a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/python/FullCPAlgorithmsTest.py
+++ b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/python/FullCPAlgorithmsTest.py
@@ -8,7 +8,53 @@ from AsgAnalysisAlgorithms.AsgAnalysisAlgorithmsTest import pileupConfigFiles
from AnalysisAlgorithmsConfig.ConfigSequence import ConfigSequence
from AnalysisAlgorithmsConfig.ConfigAccumulator import ConfigAccumulator
-def makeSequenceOld (dataType, algSeq) :
+# Config:
+triggerChains = [
+ 'HLT_2mu14',
+ 'HLT_mu20_mu8noL1',
+ 'HLT_2e17_lhvloose_nod0'
+]
+
+
+def makeSequenceOld (dataType, algSeq, forCompare) :
+
+ # Include, and then set up the pileup analysis sequence:
+ prwfiles, lumicalcfiles = pileupConfigFiles(dataType)
+
+ from AsgAnalysisAlgorithms.PileupAnalysisSequence import \
+ makePileupAnalysisSequence
+ pileupSequence = makePileupAnalysisSequence(
+ dataType,
+ userPileupConfigs=prwfiles,
+ userLumicalcFiles=lumicalcfiles,
+ )
+ pileupSequence.configure( inputName = {}, outputName = {} )
+
+ # Add the pileup sequence to the job:
+ algSeq += pileupSequence
+
+
+ # Include, and then set up the jet analysis algorithm sequence:
+ from JetAnalysisAlgorithms.JetAnalysisSequence import makeJetAnalysisSequence
+ jetContainer = 'AntiKt4EMPFlowJets'
+ jetSequence = makeJetAnalysisSequence( dataType, jetContainer, enableCutflow=True, enableKinematicHistograms=True )
+
+ from FTagAnalysisAlgorithms.FTagAnalysisSequence import makeFTagAnalysisSequence
+ makeFTagAnalysisSequence( jetSequence, dataType, jetContainer, noEfficiency = True, legacyRecommendations = True,
+ enableCutflow=True )
+
+ jetSequence.configure( inputName = jetContainer, outputName = 'AnaJetsBase_%SYS%' )
+
+ # Include, and then set up the jet analysis algorithm sequence:
+ from JetAnalysisAlgorithms.JetJvtAnalysisSequence import makeJetJvtAnalysisSequence
+ jvtSequence = makeJetJvtAnalysisSequence( dataType, jetContainer, enableCutflow=True )
+ jvtSequence.configure( inputName = { 'jets' : 'AnaJetsBase_%SYS%' },
+ outputName = { 'jets' : 'AnaJets_%SYS%' } )
+
+ # Add the sequences to the job:
+ algSeq += jetSequence
+ algSeq += jvtSequence
+
# Include, and then set up the muon analysis algorithm sequence:
from MuonAnalysisAlgorithms.MuonAnalysisSequence import makeMuonAnalysisSequence
@@ -16,7 +62,7 @@ def makeSequenceOld (dataType, algSeq) :
workingPoint = 'Medium.Iso', postfix = 'medium',
enableCutflow=True, enableKinematicHistograms=True )
muonSequenceMedium.configure( inputName = 'Muons',
- outputName = 'AnalysisMuonsMedium_%SYS%' )
+ outputName = 'AnaMuonsMedium_%SYS%' )
# Add the sequence to the job:
algSeq += muonSequenceMedium
@@ -25,37 +71,138 @@ def makeSequenceOld (dataType, algSeq) :
workingPoint = 'Tight.Iso', postfix = 'tight',
enableCutflow=True, enableKinematicHistograms=True )
muonSequenceTight.removeStage ("calibration")
- muonSequenceTight.configure( inputName = 'AnalysisMuonsMedium_%SYS%',
- outputName = 'AnalysisMuons_%SYS%')
+ muonSequenceTight.configure( inputName = 'AnaMuonsMedium_%SYS%',
+ outputName = 'AnaMuons_%SYS%')
# Add the sequence to the job:
algSeq += muonSequenceTight
+ # Include, and then set up the electron analysis sequence:
+ from EgammaAnalysisAlgorithms.ElectronAnalysisSequence import \
+ makeElectronAnalysisSequence
+ likelihood = True
+ recomputeLikelihood=False
+ if likelihood:
+ workingpoint = 'LooseLHElectron.Loose_VarRad'
+ else:
+ workingpoint = 'LooseDNNElectron.Loose_VarRad'
+ electronSequence = makeElectronAnalysisSequence( dataType, workingpoint, postfix = 'loose',
+ recomputeLikelihood=recomputeLikelihood, enableCutflow=True, enableKinematicHistograms=True )
+ electronSequence.configure( inputName = 'Electrons',
+ outputName = 'AnaElectrons_%SYS%' )
+ algSeq += electronSequence
-def makeSequenceBlocks (dataType, algSeq) :
- # Include, and then set up the muon analysis algorithm sequence:
- from MuonAnalysisAlgorithms.MuonAnalysisConfig import makeMuonCalibrationConfig, makeMuonWorkingPointConfig
+ # Include, and then set up the photon analysis sequence:
+ from EgammaAnalysisAlgorithms.PhotonAnalysisSequence import \
+ makePhotonAnalysisSequence
+ photonSequence = makePhotonAnalysisSequence( dataType, 'Tight.FixedCutTight', postfix = 'tight',
+ recomputeIsEM=False, enableCutflow=True, enableKinematicHistograms=True )
+ photonSequence.configure( inputName = 'Photons',
+ outputName = 'AnaPhotons_%SYS%' )
+ algSeq += photonSequence
- configSeq = ConfigSequence ()
- makeMuonCalibrationConfig (configSeq, 'AnalysisMuons')
- makeMuonWorkingPointConfig (configSeq, 'AnalysisMuons', workingPoint='Medium.Iso', postfix='medium')
- makeMuonWorkingPointConfig (configSeq, 'AnalysisMuons', workingPoint='Tight.Iso', postfix='tight')
+ # Include, and then set up the tau analysis algorithm sequence:
+ from TauAnalysisAlgorithms.TauAnalysisSequence import makeTauAnalysisSequence
+ tauSequence = makeTauAnalysisSequence( dataType, 'Tight', postfix = 'tight',
+ enableCutflow=True, enableKinematicHistograms=True )
+ tauSequence.configure( inputName = 'TauJets', outputName = 'AnaTauJets_%SYS%' )
- configAccumulator = ConfigAccumulator (dataType, algSeq)
- configSeq.fullConfigure (configAccumulator)
+ # Add the sequence to the job:
+ algSeq += tauSequence
+ # temporarily disabled until di-taus are supported in R22
+ # # Include, and then set up the tau analysis algorithm sequence:
+ # from TauAnalysisAlgorithms.DiTauAnalysisSequence import makeDiTauAnalysisSequence
+ # diTauSequence = makeDiTauAnalysisSequence( dataType, 'Tight', postfix = 'tight' )
+ # diTauSequence.configure( inputName = 'DiTauJets', outputName = 'AnaDiTauJets_%SYS%' )
+ # Add the sequence to the job:
+ # disabling this, the standard test files don't have DiTauJets
+ # algSeq += diTauSequence
-def makeSequence (dataType, useBlocks) :
- algSeq = AlgSequence()
+ from AnaAlgorithm.DualUseConfig import addPrivateTool, createAlgorithm
+ # Set up a selection alg for demonstration purposes
+ # Also to avoid warnings from building MET with very soft electrons
- # Set up the systematics loader/handler service:
- sysService = createService( 'CP::SystematicsSvc', 'SystematicsSvc', sequence = algSeq )
- sysService.sigmaRecommended = 1
+ selalg = createAlgorithm( 'CP::AsgSelectionAlg', 'METEleSelAlg' )
+ addPrivateTool( selalg, 'selectionTool', 'CP::AsgPtEtaSelectionTool' )
+ selalg.selectionTool.minPt = 10e3
+ selalg.selectionTool.maxEta = 2.47
+ selalg.selectionDecoration = 'selectPtEta'
+ selalg.particles = 'AnaElectrons_%SYS%'
+ algSeq += selalg
+
+ # Now make a view container holding only the electrons for the MET calculation
+ viewalg = createAlgorithm( 'CP::AsgViewFromSelectionAlg','METEleViewAlg' )
+ viewalg.selection = [ 'selectPtEta' ]
+ viewalg.input = 'AnaElectrons_%SYS%'
+ viewalg.output = 'METElectrons_%SYS%'
+ algSeq += viewalg
+
+ # Include, and then set up the met analysis algorithm sequence:
+ from MetAnalysisAlgorithms.MetAnalysisSequence import makeMetAnalysisSequence
+ metSequence = makeMetAnalysisSequence( dataType, metSuffix = jetContainer[:-4] )
+ metSequence.configure( inputName = { 'jets' : 'AnaJets_%SYS%',
+ 'muons' : 'AnaMuons_%SYS%',
+ 'electrons' : 'METElectrons_%SYS%' },
+ outputName = 'AnaMET_%SYS%' )
+
+ # Add the sequence to the job:
+ algSeq += metSequence
+
+
+ # Include, and then set up the overlap analysis algorithm sequence:
+ from AsgAnalysisAlgorithms.OverlapAnalysisSequence import \
+ makeOverlapAnalysisSequence
+ overlapSequence = makeOverlapAnalysisSequence( dataType, doMuPFJetOR=True, doTaus=False, enableCutflow=True )
+ overlapSequence.configure(
+ inputName = {
+ 'electrons' : 'AnaElectrons_%SYS%',
+ 'photons' : 'AnaPhotons_%SYS%',
+ 'muons' : 'AnaMuons_%SYS%',
+ 'jets' : 'AnaJets_%SYS%',
+ # 'taus' : 'AnaTauJets_%SYS%'
+ },
+ outputName = {
+ 'electrons' : 'AnaElectronsOR_%SYS%',
+ 'photons' : 'AnaPhotonsOR_%SYS%',
+ 'muons' : 'AnaMuonsOR_%SYS%',
+ 'jets' : 'AnaJetsOR_%SYS%',
+ # 'taus' : 'AnaTauJetsOR_%SYS%'
+ } )
+
+ # FIX ME: temporarily disabling this for data, as there are some
+ # errors with missing primary vertices
+ if dataType != 'data' :
+ algSeq += overlapSequence
+
+
+ if dataType != 'data' :
+ # Include, and then set up the generator analysis sequence:
+ from AsgAnalysisAlgorithms.GeneratorAnalysisSequence import \
+ makeGeneratorAnalysisSequence
+ generatorSequence = makeGeneratorAnalysisSequence( dataType, saveCutBookkeepers=True, runNumber=284500, cutBookkeepersSystematics=True )
+ algSeq += generatorSequence
+
+
+ # Include, and then set up the trigger analysis sequence:
+ from TriggerAnalysisAlgorithms.TriggerAnalysisSequence import \
+ makeTriggerAnalysisSequence
+ triggerSequence = makeTriggerAnalysisSequence( dataType, triggerChains=triggerChains )
+ # FIXME: temporarily disabling this for comparisons, as there is no
+ # corresponding configuration block. also, maybe it should be possible
+ # to disable filtering in the algorithm, i.e. just store the trigger
+ # decision without throwing away events.
+ if not forCompare :
+ algSeq += triggerSequence
+
+
+
+def makeSequenceBlocks (dataType, algSeq, forCompare) :
# Include, and then set up the pileup analysis sequence:
prwfiles, lumicalcfiles = pileupConfigFiles(dataType)
@@ -72,10 +219,33 @@ def makeSequence (dataType, useBlocks) :
# Add the pileup sequence to the job:
algSeq += pileupSequence
+
+ # Include, and then set up the muon analysis algorithm sequence:
+ from MuonAnalysisAlgorithms.MuonAnalysisConfig import makeMuonCalibrationConfig, makeMuonWorkingPointConfig
+
+ configSeq = ConfigSequence ()
+
+ makeMuonCalibrationConfig (configSeq, 'AnaMuons')
+ makeMuonWorkingPointConfig (configSeq, 'AnaMuons', workingPoint='Medium.Iso', postfix='medium')
+ makeMuonWorkingPointConfig (configSeq, 'AnaMuons', workingPoint='Tight.Iso', postfix='tight')
+
+ configAccumulator = ConfigAccumulator (dataType, algSeq)
+ configSeq.fullConfigure (configAccumulator)
+
+
+
+def makeSequence (dataType, useBlocks, forCompare) :
+
+ algSeq = AlgSequence()
+
+ # Set up the systematics loader/handler service:
+ sysService = createService( 'CP::SystematicsSvc', 'SystematicsSvc', sequence = algSeq )
+ sysService.sigmaRecommended = 1
+
if not useBlocks :
- makeSequenceOld (dataType, algSeq)
+ makeSequenceOld (dataType, algSeq, forCompare=forCompare)
else :
- makeSequenceBlocks (dataType, algSeq)
+ makeSequenceBlocks (dataType, algSeq, forCompare=forCompare)
# Add an ntuple dumper algorithm:
@@ -89,17 +259,54 @@ def makeSequence (dataType, useBlocks) :
algSeq += ntupleMaker
ntupleMaker = createAlgorithm( 'CP::AsgxAODNTupleMakerAlg', 'NTupleMakerMuons' )
ntupleMaker.TreeName = 'analysis'
- ntupleMaker.Branches = [ 'AnalysisMuons_NOSYS.eta -> mu_eta',
- 'AnalysisMuons_NOSYS.phi -> mu_phi',
- 'AnalysisMuons_%SYS%.pt -> mu_pt_%SYS%', ]
- # These branches are temporarily excluded as they make the test
- # fail. The differences between sequence and block configuration
- # need to be addressed and then these need to be reenabled.
- # ntupleMaker.Branches = [ 'AnalysisMuons_%SYS%.baselineSelection_medium -> mu_select_medium_%SYS%',
- # 'AnalysisMuons_%SYS%.baselineSelection_tight -> mu_select_tight_%SYS%', ]
- # if dataType != 'data':
- # ntupleMaker.Branches += [ 'AnalysisMuons_%SYS%.muon_effSF_medium_%SYS% -> mu_effSF_medium_%SYS%' ]
- # ntupleMaker.Branches += [ 'AnalysisMuons_%SYS%.muon_effSF_tight_%SYS% -> mu_effSF_tight_%SYS%' ]
+ ntupleMaker.Branches = [ 'EventInfo.runNumber -> runNumber',
+ 'EventInfo.eventNumber -> eventNumber',
+ 'AnaMuons_NOSYS.eta -> muon_eta',
+ 'AnaMuons_NOSYS.phi -> muon_phi',
+ 'AnaMuons_%SYS%.pt -> muon_pt_%SYS%', ]
+
+ # These branches are temporarily excluded for the comparison
+ # between sequences and blocks as they are either not yet
+ # implemented or make the test fail. The differences between
+ # sequence and block configuration need to be addressed and then
+ # these need to be reenabled.
+ if not forCompare and not useBlocks :
+ ntupleMaker.Branches += [
+ 'AnaJets_%SYS%.pt -> jet_%SYS%_pt',
+ 'AnaJets_NOSYS.phi -> jet_phi',
+ 'AnaJets_NOSYS.eta -> jet_eta',
+ 'AnaMuons_%SYS%.baselineSelection_medium -> muon_select_medium_%SYS%',
+ 'AnaMuons_%SYS%.baselineSelection_tight -> muon_select_tight_%SYS%',
+ 'AnaElectrons_%SYS%.pt -> electron_%SYS%_pt',
+ 'AnaElectrons_NOSYS.phi -> electron_phi',
+ 'AnaElectrons_NOSYS.eta -> electron_eta',
+ 'AnaElectrons_%SYS%.baselineSelection_loose -> electron_select_loose_%SYS%',
+ 'AnaPhotons_%SYS%.pt -> photon_%SYS%_pt',
+ 'AnaPhotons_NOSYS.phi -> photon_phi',
+ 'AnaPhotons_NOSYS.eta -> photon_eta',
+ 'AnaPhotons_%SYS%.baselineSelection_tight -> photon_select_tight_%SYS%',
+ 'AnaTauJets_%SYS%.pt -> tau_jet_%SYS%_pt',
+ 'AnaTauJets_NOSYS.phi -> tau_jet_phi',
+ 'AnaTauJets_NOSYS.eta -> tau_jet_eta',
+ 'AnaTauJets_%SYS%.baselineSelection_tight -> tau_select_tight_%SYS%',
+ ]
+ if dataType != 'data':
+ ntupleMaker.Branches += [
+ # 'EventInfo.jvt_effSF_%SYS% -> jvtSF_%SYS%',
+ # 'EventInfo.fjvt_effSF_%SYS% -> fjvtSF_%SYS%',
+ 'AnaJets_%SYS%.jvt_effSF_%SYS% -> jet_%SYS%_jvtEfficiency',
+ # 'AnaJets_%SYS%.fjvt_effSF_NOSYS -> jet_%SYS%_fjvtEfficiency',
+ 'AnaMET_%SYS%.mpx -> met_%SYS%_mpx',
+ 'AnaMET_%SYS%.mpy -> met_%SYS%_mpy',
+ 'AnaMET_%SYS%.sumet -> met_%SYS%_sumet',
+ 'AnaMET_%SYS%.name -> met_%SYS%_name',
+ ]
+
+ ntupleMaker.Branches += ['EventInfo.trigPassed_' + t + ' -> trigPassed_' + t for t in triggerChains]
+ if dataType != 'data':
+ ntupleMaker.Branches += [ 'EventInfo.generatorWeight_%SYS% -> generatorWeight_%SYS%', ]
+ ntupleMaker.Branches += [ 'AnaMuons_%SYS%.muon_effSF_medium_%SYS% -> muon_effSF_medium_%SYS%' ]
+ ntupleMaker.Branches += [ 'AnaMuons_%SYS%.muon_effSF_tight_%SYS% -> muon_effSF_tight_%SYS%' ]
# ntupleMaker.OutputLevel = 2 # For output validation
algSeq += ntupleMaker
treeFiller = createAlgorithm( 'CP::TreeFillerAlg', 'TreeFiller' )
diff --git a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/BlockConfigurationAthenaTest.sh b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/BlockConfigurationAthenaTest.sh
index 22f6a7b075a7899275972dcbe37db02add72663d..4ce807978229e4a72a216728c159bc3d3242ea98 100755
--- a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/BlockConfigurationAthenaTest.sh
+++ b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/BlockConfigurationAthenaTest.sh
@@ -9,8 +9,8 @@ set -e
set -u
dataType=$1
-athena.py AnalysisAlgorithmsConfig/FullCPAlgorithmsTest_jobOptions.py --evtMax=500 - --data-type $dataType
-athena.py AnalysisAlgorithmsConfig/FullCPAlgorithmsTest_jobOptions.py --evtMax=500 - --data-type $dataType --block-config
+athena.py AnalysisAlgorithmsConfig/FullCPAlgorithmsTest_jobOptions.py --evtMax=500 - --data-type $dataType --for-compare
+athena.py AnalysisAlgorithmsConfig/FullCPAlgorithmsTest_jobOptions.py --evtMax=500 - --data-type $dataType --for-compare --block-config
acmd.py diff-root --enforce-leaves -t analysis FullCPAlgorithmsTest.$dataType.hist.root FullCPAlgorithmsConfigTest.$dataType.hist.root
diff --git a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/FullCPAlgorithmsTest_eljob.py b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/FullCPAlgorithmsTest_eljob.py
index 4db8e621c2fa418da4c9b2be426cb2d08de5d51e..7fb3acc3ae27bf3f5df558430c9170cc6f764e1b 100755
--- a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/FullCPAlgorithmsTest_eljob.py
+++ b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/FullCPAlgorithmsTest_eljob.py
@@ -18,9 +18,18 @@ parser.add_option( '-s', '--submission-dir', dest = 'submission_dir',
parser.add_option( '-u', '--unit-test', dest='unit_test',
action = 'store_true', default = False,
help = 'Run the job in "unit test mode"' )
+parser.add_option( '--direct-driver', dest='direct_driver',
+ action = 'store_true', default = False,
+ help = 'Run the job with the direct driver' )
+parser.add_option( '--algorithm-timer', dest='algorithm_timer',
+ action = 'store_true', default = False,
+ help = 'Run the job with a timer for each algorithm' )
parser.add_option( '--block-config', dest='block_config',
action = 'store_true', default = False,
help = 'Run the job in "unit test mode"' )
+parser.add_option( '--for-compare', dest='for_compare',
+ action = 'store_true', default = False,
+ help = 'Configure the job for comparison of sequences vs blocks' )
( options, args ) = parser.parse_args()
# Set up (Py)ROOT.
@@ -35,6 +44,7 @@ ROOT.xAOD.TauJetContainer()
dataType = options.data_type
blockConfig = options.block_config
+forCompare = options.for_compare
if dataType not in ["data", "mc", "afii"] :
raise Exception ("invalid data type: " + dataType)
@@ -61,10 +71,12 @@ sh.printContent()
job = ROOT.EL.Job()
job.sampleHandler( sh )
job.options().setDouble( ROOT.EL.Job.optMaxEvents, 500 )
+if options.algorithm_timer :
+ job.options().setBool( ROOT.EL.Job.optAlgorithmTimer, True )
from AnalysisAlgorithmsConfig.FullCPAlgorithmsTest import makeSequence
-algSeq = makeSequence (dataType, blockConfig)
+algSeq = makeSequence (dataType, blockConfig, forCompare=forCompare)
print( algSeq ) # For debugging
algSeq.addSelfToJob( job )
@@ -76,13 +88,20 @@ submitDir = options.submission_dir
if options.unit_test:
import os
import tempfile
- submitDir = tempfile.mkdtemp( prefix = 'muonTest_'+dataType+'_', dir = os.getcwd() )
+ submitDir = tempfile.mkdtemp( prefix = 'fullCPTest_'+dataType+'_', dir = os.getcwd() )
os.rmdir( submitDir )
pass
+
# Run the job using the local driver. This is intentionally the local
# driver, unlike most other tests that use the direct driver. That
# way it tests whether the code works correctly with that driver,
# which is a lot more similar to the way the batch/grid drivers work.
driver = ROOT.EL.LocalDriver()
+
+if options.direct_driver :
+ # this is for testing purposes, as only the direct driver respects
+ # the limit on the number of events.
+ driver = ROOT.EL.DirectDriver()
+
driver.submit( job, submitDir )
diff --git a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/FullCPAlgorithmsTest_jobOptions.py b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/FullCPAlgorithmsTest_jobOptions.py
index 911c5cccc57a747a8a65299fe672bab0b06b875d..bf4234ecbabe5651b9fb595903d6fbde9cf738a9 100644
--- a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/FullCPAlgorithmsTest_jobOptions.py
+++ b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/FullCPAlgorithmsTest_jobOptions.py
@@ -12,10 +12,14 @@ athArgsParser.add_argument("--data-type", action = "store", dest = "data_type",
athArgsParser.add_argument( '--block-config', dest='block_config',
action = 'store_true', default = False,
help = 'Configure the job with block configuration' )
+athArgsParser.add_argument( '--for-compare', dest='for_compare',
+ action = 'store_true', default = False,
+ help = 'Configure the job for comparison of sequences vs blocks' )
athArgs = athArgsParser.parse_args()
dataType = athArgs.data_type
blockConfig = athArgs.block_config
+forCompare = athArgs.for_compare
if not dataType in ["data", "mc", "afii"] :
raise Exception ("invalid data type: " + dataType)
@@ -32,7 +36,7 @@ testFile = os.getenv ( inputfile[dataType] )
svcMgr.EventSelector.InputCollections = [testFile]
from AnalysisAlgorithmsConfig.FullCPAlgorithmsTest import makeSequence
-algSeq = makeSequence (dataType, blockConfig)
+algSeq = makeSequence (dataType, blockConfig, forCompare=forCompare)
print (algSeq) # For debugging
# Add all algorithms from the sequence to the job.