diff --git a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/CMakeLists.txt b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/CMakeLists.txt
index 1fdadc247abbb0f06be8ff523f6e20fea6574ad8..2e4a543757c77d6ecba6b8c01ffc87ff07b75783 100644
--- a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/CMakeLists.txt
+++ b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/CMakeLists.txt
@@ -36,15 +36,15 @@ else()
atlas_install_joboptions( share/*_jobOptions.py )
- atlas_add_test( testJobDataConfig
+ atlas_add_test( testJobDataCompare
SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/share/BlockConfigurationAthenaTest.sh data
PROPERTIES TIMEOUT 600 )
- atlas_add_test( testJobFullSumConfig
+ atlas_add_test( testJobFullSimCompare
SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/share/BlockConfigurationAthenaTest.sh mc
PROPERTIES TIMEOUT 600 )
- atlas_add_test( testJobFastSimConfig
+ atlas_add_test( testJobFastSimCompare
SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/share/BlockConfigurationAthenaTest.sh afii
PROPERTIES TIMEOUT 600 )
diff --git a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/python/ConfigAccumulator.py b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/python/ConfigAccumulator.py
index 8fcefef2d4185cad5199d24610f4a6cb7826a718..2434d9ca19dacacf88059bf7b68637ffb7e7873b 100644
--- a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/python/ConfigAccumulator.py
+++ b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/python/ConfigAccumulator.py
@@ -74,10 +74,11 @@ class ConfigAccumulator :
"""
- def __init__ (self, dataType, algSeq):
+ def __init__ (self, dataType, algSeq, isPhyslite=False):
if dataType not in ["data", "mc", "afii"] :
raise ValueError ("invalid data type: " + dataType)
self._dataType = dataType
+ self._isPhyslite = isPhyslite
self._algSeq = algSeq
self._containerConfig = {}
self._pass = 0
@@ -89,6 +90,12 @@ class ConfigAccumulator :
"""the data type we run on (data, mc, afii)"""
return self._dataType
+
+ def isPhyslite (self) :
+ """whether we run on PHYSLITE"""
+ return self._isPhyslite
+
+
def createAlgorithm (self, type, name) :
"""create a new algorithm and register it as the current algorithm"""
if self._pass == 0 :
@@ -134,7 +141,19 @@ class ConfigAccumulator :
DualUseConfig.addPrivateTool (self._currentAlg, type, name)
- def readName (self, containerName, sourceName=None) :
+ def setSourceName (self, containerName, sourceName) :
+ """set the (default) name of the original container
+
+ This is essentially meant to allow using e.g. the muon
+ configuration and the user not having to manually specify that
+ they want to use the Muons/AnalysisMuons container from the
+ input file.
+ """
+ if containerName not in self._containerConfig :
+ self._containerConfig[containerName] = ContainerConfig (containerName, sourceName)
+
+
+ def readName (self, containerName) :
"""get the name of the "current copy" of the given container
As extra copies get created during processing this will track
@@ -142,9 +161,7 @@ class ConfigAccumulator :
in the name of the container before the first copy.
"""
if containerName not in self._containerConfig :
- if not sourceName :
- raise Exception ("no source container for: " + containerName)
- self._containerConfig[containerName] = ContainerConfig (containerName, sourceName)
+ raise Exception ("no source container for: " + containerName)
return self._containerConfig[containerName].currentName()
@@ -157,16 +174,14 @@ class ConfigAccumulator :
return self._containerConfig[containerName].currentName()
- def wantCopy (self, containerName, sourceName=None) :
+ def wantCopy (self, containerName) :
"""ask whether we want/need a copy of the container
This usually only happens if no copy of the container has been
made yet and the copy is needed to allow modifications, etc.
"""
if containerName not in self._containerConfig :
- if not sourceName :
- raise Exception ("no source container for: " + containerName)
- self._containerConfig[containerName] = ContainerConfig (containerName, sourceName)
+ raise Exception ("no source container for: " + containerName)
return self._containerConfig[containerName].index == 0
diff --git a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/python/FullCPAlgorithmsTest.py b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/python/FullCPAlgorithmsTest.py
index 0eca2567537f52ecd9aade6a4e8441270a1bb209..6e63fd26a26ea961a8029a9d9068e24b051802f2 100644
--- a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/python/FullCPAlgorithmsTest.py
+++ b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/python/FullCPAlgorithmsTest.py
@@ -51,22 +51,25 @@ def addOutputCopyAlgorithms (algSeq, postfix, inputContainer, outputContainer, s
algSeq += copyalg
-def makeSequenceOld (dataType, algSeq, vars, forCompare) :
+def makeSequenceOld (dataType, algSeq, vars, forCompare, isPhyslite, noPhysliteBroken) :
# 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 = {} )
+ if not isPhyslite :
+ 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
# Add the pileup sequence to the job:
- algSeq += pileupSequence
vars += [ 'EventInfo.runNumber -> runNumber',
'EventInfo.eventNumber -> eventNumber', ]
@@ -74,23 +77,30 @@ def makeSequenceOld (dataType, algSeq, vars, forCompare) :
# 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, shallowViewOutput = False )
-
- from FTagAnalysisAlgorithms.FTagAnalysisSequence import makeFTagAnalysisSequence
- btagger = "DL1r"
- btagWP = "FixedCutBEff_77"
- makeFTagAnalysisSequence( jetSequence, dataType, jetContainer, noEfficiency = False, legacyRecommendations = True,
- enableCutflow=True, btagger = btagger, btagWP = btagWP )
- vars += [
- 'OutJets_%SYS%.ftag_select_' + btagger + '_' + btagWP + ' -> jet_ftag_select_%SYS%',
- ]
- if dataType != 'data' :
+ if isPhyslite :
+ input = 'AnalysisJets'
+ else :
+ input = jetContainer
+ jetSequence = makeJetAnalysisSequence( dataType, jetContainer,
+ runJvtUpdate = True,
+ enableCutflow=True, enableKinematicHistograms=True, shallowViewOutput = False,
+ runGhostMuonAssociation = not isPhyslite)
+
+ if not noPhysliteBroken :
+ from FTagAnalysisAlgorithms.FTagAnalysisSequence import makeFTagAnalysisSequence
+ btagger = "MV2c10"
+ btagWP = "FixedCutBEff_77"
+ makeFTagAnalysisSequence( jetSequence, dataType, jetContainer, noEfficiency = False, legacyRecommendations = True,
+ enableCutflow=True, btagger = btagger, btagWP = btagWP )
vars += [
- 'OutJets_%SYS%.ftag_effSF_' + btagger + '_' + btagWP + '_%SYS% -> jet_ftag_eff_%SYS%'
+ 'OutJets_%SYS%.ftag_select_' + btagger + '_' + btagWP + ' -> jet_ftag_select_%SYS%',
]
+ if dataType != 'data' :
+ vars += [
+ 'OutJets_%SYS%.ftag_effSF_' + btagger + '_' + btagWP + '_%SYS% -> jet_ftag_eff_%SYS%'
+ ]
- jetSequence.configure( inputName = jetContainer, outputName = 'AnaJets_%SYS%' )
-
+ jetSequence.configure( inputName = input, outputName = 'AnaJets_%SYS%' )
# Include, and then set up the jet analysis algorithm sequence:
from JetAnalysisAlgorithms.JetJvtAnalysisSequence import makeJetJvtAnalysisSequence
@@ -104,7 +114,7 @@ def makeSequenceOld (dataType, algSeq, vars, forCompare) :
vars += ['OutJets_%SYS%.pt -> jet_pt_%SYS%',
'OutJets_NOSYS.phi -> jet_phi',
'OutJets_NOSYS.eta -> jet_eta', ]
- if dataType != 'data':
+ if dataType != 'data' :
vars += [ 'OutJets_%SYS%.jvt_effSF_%SYS% -> jet_jvtEfficiency_%SYS%', ]
if not forCompare :
vars += [
@@ -116,23 +126,34 @@ def makeSequenceOld (dataType, algSeq, vars, forCompare) :
# Include, and then set up the muon analysis algorithm sequence:
from MuonAnalysisAlgorithms.MuonAnalysisSequence import makeMuonAnalysisSequence
+ if isPhyslite :
+ input = 'AnalysisMuons'
+ else :
+ input = 'Muons'
+
muonSequenceMedium = makeMuonAnalysisSequence( dataType, deepCopyOutput = False, shallowViewOutput = False,
workingPoint = 'Medium.NonIso', postfix = 'medium',
enableCutflow=True, enableKinematicHistograms=True, ptSelectionOutput = True )
- muonSequenceMedium.configure( inputName = 'Muons',
+ # FIX ME: the current version of the `MuonSelectionTool` doesn't work
+ # on the current version of PHYSLITE, and needs a new PHYSLITE production
+ # campaign
+ if noPhysliteBroken :
+ muonSequenceMedium.__delattr__ ('MuonSelectionAlg_medium')
+ muonSequenceMedium.configure( inputName = input,
outputName = 'AnaMuonsMedium_%SYS%' )
-
- # Add the sequence to the job:
algSeq += muonSequenceMedium
muonSequenceTight = makeMuonAnalysisSequence( dataType, deepCopyOutput = False, shallowViewOutput = False,
workingPoint = 'Tight.NonIso', postfix = 'tight',
enableCutflow=True, enableKinematicHistograms=True, ptSelectionOutput = True )
muonSequenceTight.removeStage ("calibration")
+ # FIX ME: the current version of the `MuonSelectionTool` doesn't work
+ # on the current version of PHYSLITE, and needs a new PHYSLITE production
+ # campaign
+ if noPhysliteBroken :
+ muonSequenceTight.__delattr__ ('MuonSelectionAlg_tight')
muonSequenceTight.configure( inputName = 'AnaMuonsMedium_%SYS%',
outputName = 'AnaMuons_%SYS%')
-
- # Add the sequence to the job:
algSeq += muonSequenceTight
vars += [ 'OutMuons_NOSYS.eta -> mu_eta',
'OutMuons_NOSYS.phi -> mu_phi',
@@ -148,15 +169,23 @@ def makeSequenceOld (dataType, algSeq, vars, forCompare) :
# Include, and then set up the electron analysis sequence:
from EgammaAnalysisAlgorithms.ElectronAnalysisSequence import \
makeElectronAnalysisSequence
+ if isPhyslite :
+ input = 'AnalysisElectrons'
+ else :
+ input = 'Electrons'
likelihood = True
recomputeLikelihood=False
if likelihood:
workingpoint = 'LooseLHElectron.Loose_VarRad'
else:
workingpoint = 'LooseDNNElectron.Loose_VarRad'
+ # FIXME: fails for PHYSLITE with missing data item
+ # ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000
+ if noPhysliteBroken :
+ workingpoint = workingpoint.split('.')[0] + '.NonIso'
electronSequence = makeElectronAnalysisSequence( dataType, workingpoint, postfix = 'loose',
recomputeLikelihood=recomputeLikelihood, enableCutflow=True, enableKinematicHistograms=True, shallowViewOutput = False )
- electronSequence.configure( inputName = 'Electrons',
+ electronSequence.configure( inputName = input,
outputName = 'AnaElectrons_%SYS%' )
algSeq += electronSequence
vars += [ 'OutElectrons_%SYS%.pt -> el_pt_%SYS%',
@@ -171,9 +200,13 @@ def makeSequenceOld (dataType, algSeq, vars, forCompare) :
# Include, and then set up the photon analysis sequence:
from EgammaAnalysisAlgorithms.PhotonAnalysisSequence import \
makePhotonAnalysisSequence
+ if isPhyslite :
+ input = 'AnalysisPhotons'
+ else :
+ input = 'Photons'
photonSequence = makePhotonAnalysisSequence( dataType, 'Tight.FixedCutTight', postfix = 'tight',
recomputeIsEM=False, enableCutflow=True, enableKinematicHistograms=True, shallowViewOutput = False )
- photonSequence.configure( inputName = 'Photons',
+ photonSequence.configure( inputName = input,
outputName = 'AnaPhotons_%SYS%' )
algSeq += photonSequence
vars += [ 'OutPhotons_%SYS%.pt -> ph_pt_%SYS%',
@@ -186,9 +219,13 @@ def makeSequenceOld (dataType, algSeq, vars, forCompare) :
# Include, and then set up the tau analysis algorithm sequence:
from TauAnalysisAlgorithms.TauAnalysisSequence import makeTauAnalysisSequence
+ if isPhyslite :
+ input = 'AnalysisTauJets'
+ else :
+ input = 'TauJets'
tauSequence = makeTauAnalysisSequence( dataType, 'Tight', postfix = 'tight',
enableCutflow=True, enableKinematicHistograms=True, shallowViewOutput = False )
- tauSequence.configure( inputName = 'TauJets', outputName = 'AnaTauJets_%SYS%' )
+ tauSequence.configure( inputName = input, outputName = 'AnaTauJets_%SYS%' )
# Add the sequence to the job:
algSeq += tauSequence
@@ -201,6 +238,7 @@ def makeSequenceOld (dataType, algSeq, vars, forCompare) :
vars += [ 'OutTauJets_%SYS%.tau_effSF_tight_%SYS% -> tau_effSF_tight_%SYS%', ]
+
# temporarily disabled until di-taus are supported in R22
# # Include, and then set up the tau analysis algorithm sequence:
# from TauAnalysisAlgorithms.DiTauAnalysisSequence import makeDiTauAnalysisSequence
@@ -269,6 +307,11 @@ def makeSequenceOld (dataType, algSeq, vars, forCompare) :
# Now make view containers for the inputs to the met calculation
+ metInputs = { 'jets' : 'METJets_%SYS%',
+ 'taus' : 'METTauJets_%SYS%',
+ 'muons' : 'METMuons_%SYS%',
+ 'electrons' : 'METElectrons_%SYS%',
+ 'photons' : 'METPhotons_%SYS%' }
viewalg = createAlgorithm( 'CP::AsgViewFromSelectionAlg','METElectronsViewAlg' )
viewalg.selection = [ 'selectPtEta', 'baselineSelection_loose,as_char' ]
viewalg.input = 'AnaElectrons_%SYS%'
@@ -301,12 +344,12 @@ def makeSequenceOld (dataType, algSeq, vars, forCompare) :
# 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' : 'METJets_%SYS%',
- 'taus' : 'METTauJets_%SYS%',
- 'muons' : 'METMuons_%SYS%',
- 'electrons' : 'METElectrons_%SYS%',
- 'photons' : 'METPhotons_%SYS%' },
+ if isPhyslite :
+ metSuffix = 'AnalysisMET'
+ else :
+ metSuffix = jetContainer[:-4]
+ metSequence = makeMetAnalysisSequence( dataType, metSuffix=metSuffix )
+ metSequence.configure( inputName = metInputs,
outputName = 'AnaMET_%SYS%' )
# Add the sequence to the job:
@@ -321,11 +364,19 @@ def makeSequenceOld (dataType, algSeq, vars, forCompare) :
# Make view containers holding as inputs for OR
+ orInputs = {
+ 'photons' : 'AnaPhotons_%SYS%',
+ 'muons' : 'AnaMuons_%SYS%',
+ 'jets' : 'AnaJets_%SYS%',
+ 'taus' : 'AnaTauJets_%SYS%'
+ }
+
selectalg = createAlgorithm( 'CP::AsgSelectionAlg','ORElectronsSelectAlg' )
selectalg.preselection = 'selectPtEta&&baselineSelection_loose,as_char'
selectalg.particles = 'AnaElectrons_%SYS%'
selectalg.selectionDecoration = 'preselectOR,as_char'
algSeq += selectalg
+ orInputs['electrons'] = 'AnaElectrons_%SYS%'
selectalg = createAlgorithm( 'CP::AsgSelectionAlg','ORPhotonsSelectAlg' )
selectalg.preselection = 'selectPtEta&&baselineSelection_tight,as_char'
@@ -418,22 +469,25 @@ def makeSequenceOld (dataType, algSeq, vars, forCompare) :
-def makeSequenceBlocks (dataType, algSeq, vars, forCompare) :
+def makeSequenceBlocks (dataType, algSeq, vars, forCompare, isPhyslite, noPhysliteBroken) :
- # Include, and then set up the pileup analysis sequence:
- prwfiles, lumicalcfiles = pileupConfigFiles(dataType)
+ if not isPhyslite :
+ # 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
- 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
vars += [ 'EventInfo.runNumber -> runNumber',
'EventInfo.eventNumber -> eventNumber', ]
@@ -450,6 +504,10 @@ def makeSequenceBlocks (dataType, algSeq, vars, forCompare) :
workingpoint = 'LooseLHElectron.Loose_VarRad'
else:
workingpoint = 'LooseDNNElectron.Loose_VarRad'
+ # FIXME: fails for PHYSLITE with missing data item
+ # ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000
+ if noPhysliteBroken :
+ workingpoint = workingpoint.split('.')[0] + '.NonIso'
makeElectronCalibrationConfig (configSeq, 'AnaElectrons')
makeElectronWorkingPointConfig (configSeq, 'AnaElectrons', workingpoint, postfix = 'loose',
recomputeLikelihood=recomputeLikelihood)
@@ -518,7 +576,7 @@ def makeSequenceBlocks (dataType, algSeq, vars, forCompare) :
]
- configAccumulator = ConfigAccumulator (dataType, algSeq)
+ configAccumulator = ConfigAccumulator (dataType, algSeq, isPhyslite=isPhyslite)
configSeq.fullConfigure (configAccumulator)
selalg = createAlgorithm( 'CP::AsgSelectionAlg', 'UserElectronsSelectionAlg' )
@@ -583,7 +641,7 @@ def makeSequenceBlocks (dataType, algSeq, vars, forCompare) :
-def makeSequence (dataType, useBlocks, forCompare, noSystematics, hardCuts = False) :
+def makeSequence (dataType, useBlocks, forCompare, noSystematics, hardCuts = False, isPhyslite = False, noPhysliteBroken = False) :
# do some harder cuts on all object types, this is mostly used for
# benchmarking
@@ -608,9 +666,11 @@ def makeSequence (dataType, useBlocks, forCompare, noSystematics, hardCuts = Fal
vars = []
if not useBlocks :
- makeSequenceOld (dataType, algSeq, vars=vars, forCompare=forCompare)
+ makeSequenceOld (dataType, algSeq, vars=vars, forCompare=forCompare,
+ isPhyslite=isPhyslite, noPhysliteBroken=noPhysliteBroken)
else :
- makeSequenceBlocks (dataType, algSeq, vars=vars, forCompare=forCompare)
+ makeSequenceBlocks (dataType, algSeq, vars=vars, forCompare=forCompare,
+ isPhyslite=isPhyslite, noPhysliteBroken=noPhysliteBroken)
# Add an ntuple dumper algorithm:
diff --git a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/BlockConfigurationAthenaTest.sh b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/BlockConfigurationAthenaTest.sh
index 0a6742a1329255a278537ddfce95b477e77c563e..9a9e0ec491ca50b349a13e4a4d24aa7239470fe4 100755
--- a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/BlockConfigurationAthenaTest.sh
+++ b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/BlockConfigurationAthenaTest.sh
@@ -9,8 +9,9 @@ set -e
set -u
dataType=$1
-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
+shift
+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 --error-mode resilient --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 65dffdfd2f41bd9c81129310d72f4996801c7a8d..17215820b531f2eba299ec41d28ba7efcf5bf314 100755
--- a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/FullCPAlgorithmsTest_eljob.py
+++ b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/FullCPAlgorithmsTest_eljob.py
@@ -38,10 +38,16 @@ parser.add_option( '--hard-cuts', dest='hard_cuts',
help = 'Configure the job with harder cuts' )
parser.add_option( '--block-config', dest='block_config',
action = 'store_true', default = False,
- help = 'Run the job in "unit test mode"' )
+ help = 'Configure the job with block configuration' )
parser.add_option( '--for-compare', dest='for_compare',
action = 'store_true', default = False,
help = 'Configure the job for comparison of sequences vs blocks' )
+parser.add_option( '--physlite', dest='physlite',
+ action = 'store_true', default = False,
+ help = 'Configure the job for physlite' )
+parser.add_option( '--no-physlite-broken', dest='no_physlite_broken',
+ action = 'store_true', default = False,
+ help = 'Configure the job to skip algorithms that fail on physlite test file' )
( options, args ) = parser.parse_args()
# Set up (Py)ROOT.
@@ -57,6 +63,8 @@ ROOT.xAOD.TauJetContainer()
dataType = options.data_type
blockConfig = options.block_config
forCompare = options.for_compare
+isPhyslite = options.physlite
+noPhysliteBroken = options.no_physlite_broken
if dataType not in ["data", "mc", "afii"] :
raise Exception ("invalid data type: " + dataType)
@@ -67,9 +75,14 @@ import os
sh = ROOT.SH.SampleHandler()
sh.setMetaString( 'nc_tree', 'CollectionTree' )
sample = ROOT.SH.SampleLocal (dataType)
-inputfile = {"data": 'ASG_TEST_FILE_DATA',
- "mc": 'ASG_TEST_FILE_MC',
- "afii": 'ASG_TEST_FILE_MC_AFII'}
+if isPhyslite :
+ inputfile = {"data": 'ASG_TEST_FILE_LITE_DATA',
+ "mc": 'ASG_TEST_FILE_LITE_MC',
+ "afii": 'ASG_TEST_FILE_LITE_MC_AFII'}
+else :
+ inputfile = {"data": 'ASG_TEST_FILE_DATA',
+ "mc": 'ASG_TEST_FILE_MC',
+ "afii": 'ASG_TEST_FILE_MC_AFII'}
if options.force_input :
sample.add (options.force_input)
else :
@@ -87,7 +100,10 @@ if options.algorithm_timer :
from AnalysisAlgorithmsConfig.FullCPAlgorithmsTest import makeSequence
-algSeq = makeSequence (dataType, blockConfig, forCompare=forCompare, noSystematics = options.no_systematics, hardCuts = options.hard_cuts)
+algSeq = makeSequence (dataType, blockConfig, forCompare=forCompare,
+ noSystematics = options.no_systematics,
+ hardCuts = options.hard_cuts, isPhyslite=isPhyslite,
+ noPhysliteBroken=noPhysliteBroken)
print( algSeq ) # For debugging
algSeq.addSelfToJob( job )
diff --git a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/FullCPAlgorithmsTest_jobOptions.py b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/FullCPAlgorithmsTest_jobOptions.py
index 42b67a3938b5fa8b228ee2611f84375703bd7192..14b414a4cbce1fbed4e1b4eccfdbff2cc6fefae7 100644
--- a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/FullCPAlgorithmsTest_jobOptions.py
+++ b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/FullCPAlgorithmsTest_jobOptions.py
@@ -6,6 +6,12 @@
# athena FullCPAlgorithmsTest_jobOptions.py - --myOption ...
from AthenaCommon.AthArgumentParser import AthArgumentParser
athArgsParser = AthArgumentParser()
+athArgsParser.add_argument("--force-input", action = "store", dest = "force_input",
+ default = None,
+ help = "Force the given input file")
+athArgsParser.add_argument("--force-output", action = "store", dest = "force_output",
+ default = None,
+ help = "Force the given output file")
athArgsParser.add_argument("--data-type", action = "store", dest = "data_type",
default = "data",
help = "Type of input to run over. Valid options are 'data', 'mc', 'afii'")
@@ -18,28 +24,45 @@ athArgsParser.add_argument( '--for-compare', dest='for_compare',
athArgsParser.add_argument( '--no-systematics', dest='no_systematics',
action = 'store_true', default = False,
help = 'Configure the job to with no systematics' )
+athArgsParser.add_argument( '--physlite', dest='physlite',
+ action = 'store_true', default = False,
+ help = 'Configure the job for physlite' )
+athArgsParser.add_argument( '--no-physlite-broken', dest='no_physlite_broken',
+ action = 'store_true', default = False,
+ help = 'Configure the job to skip algorithms that fail on physlite test file' )
athArgs = athArgsParser.parse_args()
dataType = athArgs.data_type
blockConfig = athArgs.block_config
forCompare = athArgs.for_compare
+isPhyslite = athArgs.physlite
+noPhysliteBroken = athArgs.no_physlite_broken
if not dataType in ["data", "mc", "afii"] :
raise Exception ("invalid data type: " + dataType)
print("Running on data type: " + dataType)
-inputfile = {"data": 'ASG_TEST_FILE_DATA',
- "mc": 'ASG_TEST_FILE_MC',
- "afii": 'ASG_TEST_FILE_MC_AFII'}
+if isPhyslite :
+ inputfile = {"data": 'ASG_TEST_FILE_LITE_DATA',
+ "mc": 'ASG_TEST_FILE_LITE_MC',
+ "afii": 'ASG_TEST_FILE_LITE_MC_AFII'}
+else :
+ inputfile = {"data": 'ASG_TEST_FILE_DATA',
+ "mc": 'ASG_TEST_FILE_MC',
+ "afii": 'ASG_TEST_FILE_MC_AFII'}
# Set up the reading of the input file:
import AthenaPoolCnvSvc.ReadAthenaPool
theApp.EvtMax = 500
testFile = os.getenv ( inputfile[dataType] )
+if athArgs.force_input :
+ testFile = athArgs.force_input
svcMgr.EventSelector.InputCollections = [testFile]
from AnalysisAlgorithmsConfig.FullCPAlgorithmsTest import makeSequence
-algSeq = makeSequence (dataType, blockConfig, forCompare=forCompare, noSystematics = athArgs.no_systematics)
+algSeq = makeSequence (dataType, blockConfig, forCompare=forCompare,
+ noSystematics = athArgs.no_systematics,
+ isPhyslite=isPhyslite, noPhysliteBroken=noPhysliteBroken)
print (algSeq) # For debugging
# Add all algorithms from the sequence to the job.
@@ -48,13 +71,12 @@ athAlgSeq += algSeq
# Set up a histogram output file for the job:
ServiceMgr += CfgMgr.THistSvc()
if not blockConfig :
- ServiceMgr.THistSvc.Output += [
- "ANALYSIS DATAFILE='FullCPAlgorithmsTest." + dataType + ".hist.root' OPT='RECREATE'"
- ]
+ outputFile = "ANALYSIS DATAFILE='FullCPAlgorithmsTest." + dataType + ".hist.root' OPT='RECREATE'"
else :
- ServiceMgr.THistSvc.Output += [
- "ANALYSIS DATAFILE='FullCPAlgorithmsConfigTest." + dataType + ".hist.root' OPT='RECREATE'"
- ]
+ outputFile = "ANALYSIS DATAFILE='FullCPAlgorithmsConfigTest." + dataType + ".hist.root' OPT='RECREATE'"
+if athArgs.force_output :
+ outputFile = athArgs.force_output
+ServiceMgr.THistSvc.Output += [ outputFile ]
# Reduce the printout from Athena:
include( "AthAnalysisBaseComps/SuppressLogging.py" )
diff --git a/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/PhysliteAthenaTest.sh b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/PhysliteAthenaTest.sh
new file mode 100755
index 0000000000000000000000000000000000000000..b7d480a6627d7b763c111f4444252a2126715281
--- /dev/null
+++ b/PhysicsAnalysis/Algorithms/AnalysisAlgorithmsConfig/share/PhysliteAthenaTest.sh
@@ -0,0 +1,32 @@
+#/bin/bash
+#
+# Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
+#
+# @author Nils Krumnack
+
+
+set -e
+set -u
+
+dataType=$1
+shift
+
+inputFile=$2
+shift
+
+rm -rf physlite_test_$dataType
+mkdir physlite_test_$dataType
+cd physlite_test_$dataType
+
+# This is the transform to run for producing PHYSLITE from AOD, whereas
+# the line below runs the transform on PHYS.
+# Reco_tf.py --maxEvents=500 --inputAODFile $input_file --outputDAODFile test_file.pool.root --reductionConf PHYS PHYSLITE --preExec 'default:from AthenaCommon.DetFlags import DetFlags; DetFlags.detdescr.all_setOff(); DetFlags.BField_setOn(); DetFlags.digitize.all_setOff(); DetFlags.detdescr.Calo_setOn(); DetFlags.simulate.all_setOff(); DetFlags.pileup.all_setOff(); DetFlags.overlay.all_setOff();DetFlags.detdescr.Muon_setOn();' --postExec 'from DerivationFrameworkJetEtMiss.JetCommon import swapAlgsInSequence;swapAlgsInSequence(topSequence,"jetalg_ConstitModCorrectPFOCSSKCHS_GPFlowCSSK", "UFOInfoAlgCSSK" );' 2>&1 | tee mylog.txt
+Reco_tf.py --maxEvents 500 --inputDAOD_PHYSFile $inputFile --outputD2AODFile test_mc.root --reductionConf PHYSLITE 2>&1 | tee my_log_physlite.txt
+
+inputPhys=/data/krumnack/test_files/DAOD_PHYS.test_file.pool.root
+inputPhyslite=/data/krumnack/test_files/DAOD_PHYSLITE.test_file.pool.root
+
+athena.py AnalysisAlgorithmsConfig/FullCPAlgorithmsTest_jobOptions.py --evtMax=500 - --data-type $dataType --no-physlite-broken --force-input $inputPhys --force-output test_ntuple_phys_$dataType.root "$@"
+athena.py AnalysisAlgorithmsConfig/FullCPAlgorithmsTest_jobOptions.py --evtMax=500 - --data-type $dataType --physlite --no-physlite-broken --force-input $inputPhyslite --force-output test_ntuple_physlite_$dataType.root "$@"
+
+acmd.py diff-root --enforce-leaves -t analysis test_ntuple_phys_$dataType.root test_ntuple_physlite_$dataType.root
diff --git a/PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/python/ElectronAnalysisConfig.py b/PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/python/ElectronAnalysisConfig.py
index c857ba78be97466cd626e65744b885f9d42aaf2d..e915d19b7fc4ed21065cd61be5bf3818b3305a22 100644
--- a/PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/python/ElectronAnalysisConfig.py
+++ b/PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/python/ElectronAnalysisConfig.py
@@ -18,8 +18,13 @@ class ElectronCalibrationConfig (ConfigBlock) :
def makeAlgs (self, config) :
+ if config.isPhyslite() :
+ config.setSourceName (self.containerName, "AnalysisElectrons")
+ else :
+ config.setSourceName (self.containerName, "Electrons")
+
# Set up a shallow copy to decorate
- if config.wantCopy (self.containerName, 'Electrons') :
+ if config.wantCopy (self.containerName) :
alg = config.createAlgorithm( 'CP::AsgShallowCopyAlg', 'ElectronShallowCopyAlg' + self.postfix )
alg.input = config.readName (self.containerName)
alg.output = config.copyName (self.containerName)
diff --git a/PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/python/PhotonAnalysisConfig.py b/PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/python/PhotonAnalysisConfig.py
index 3cbc0896e2fa77449d37bd6be913f94ab1b72232..adec672333b48eecb6efc8854db9efa6e86e8477 100644
--- a/PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/python/PhotonAnalysisConfig.py
+++ b/PhysicsAnalysis/Algorithms/EgammaAnalysisAlgorithms/python/PhotonAnalysisConfig.py
@@ -28,10 +28,15 @@ class PhotonCalibrationConfig (ConfigBlock) :
def makeAlgs (self, config) :
+ if config.isPhyslite() :
+ config.setSourceName (self.containerName, "AnalysisPhotons")
+ else :
+ config.setSourceName (self.containerName, "Photons")
+
cleaningWP = 'NoTime' if self.cleaningAllowLate else ''
# Set up a shallow copy to decorate
- if config.wantCopy (self.containerName, 'Photons') :
+ if config.wantCopy (self.containerName) :
alg = config.createAlgorithm( 'CP::AsgShallowCopyAlg', 'PhotonShallowCopyAlg' + self.postfix )
alg.input = config.readName (self.containerName)
alg.output = config.copyName (self.containerName)
diff --git a/PhysicsAnalysis/Algorithms/FTagAnalysisAlgorithms/python/FTagAnalysisSequence.py b/PhysicsAnalysis/Algorithms/FTagAnalysisAlgorithms/python/FTagAnalysisSequence.py
index 65dbe2daa1896f512e7f2ba83a1748ee0bd30ca4..21e709631b4ec1ce57ce9db686b8951d56d77971 100644
--- a/PhysicsAnalysis/Algorithms/FTagAnalysisAlgorithms/python/FTagAnalysisSequence.py
+++ b/PhysicsAnalysis/Algorithms/FTagAnalysisAlgorithms/python/FTagAnalysisSequence.py
@@ -77,6 +77,9 @@ def makeFTagAnalysisSequence( seq, dataType, jetCollection,
else:
bTagCalibFile = "xAODBTaggingEfficiency/13TeV/2020-21-13TeV-MC16-CDI-2021-04-16_v1.root"
+ # This is the new calibration file, but it seems to have issues in some cases
+ #bTagCalibFile = "xAODBTaggingEfficiency/13TeV/2022-22-13TeV-MC20-CDI-2022-07-28_v1.root"
+
# # Create the analysis algorithm sequence object:
# seq = AnaAlgSequence( "FTagAnalysisSequence" )
diff --git a/PhysicsAnalysis/Algorithms/JetAnalysisAlgorithms/python/JetAnalysisConfig.py b/PhysicsAnalysis/Algorithms/JetAnalysisAlgorithms/python/JetAnalysisConfig.py
index dbc9dd11fd2630fba0c60d780270beb1ef7362e1..752f079a96d7fe9767477cc73321d574e0322185 100644
--- a/PhysicsAnalysis/Algorithms/JetAnalysisAlgorithms/python/JetAnalysisConfig.py
+++ b/PhysicsAnalysis/Algorithms/JetAnalysisAlgorithms/python/JetAnalysisConfig.py
@@ -20,12 +20,15 @@ class PreJetAnalysisConfig (ConfigBlock) :
if self.postfix != '' and self.postfix[0] != '_' :
self.postfix = '_' + self.postfix
self.runOriginalObjectLink = False
- self.runGhostMuonAssociation = False
+ self.runGhostMuonAssociation = None
def makeAlgs (self, config) :
- config.readName (self.containerName, self.jetCollection)
+ if config.isPhyslite() :
+ config.setSourceName (self.containerName, "AnalysisJets")
+ else :
+ config.setSourceName (self.containerName, self.jetCollection)
# Relink original jets in case of b-tagging calibration
if self.runOriginalObjectLink :
@@ -38,7 +41,8 @@ class PreJetAnalysisConfig (ConfigBlock) :
alg.preselection = config.getPreselection (self.containerName, '')
# Set up the jet ghost muon association algorithm:
- if self.runGhostMuonAssociation:
+ if (self.runGhostMuonAssociation is None and not config.isPhyslite()) or \
+ (self.runGhostMuonAssociation is True):
alg = config.createAlgorithm( 'CP::JetGhostMuonAssociationAlg',
'JetGhostMuonAssociationAlg'+self.postfix )
alg.jets = config.readName (self.containerName)
@@ -360,7 +364,7 @@ class LargeRJetAnalysisConfig (ConfigBlock) :
# https://twiki.cern.ch/twiki/bin/view/AtlasProtected/JVTCalibrationRel21
def makeJetAnalysisConfig( seq, containerName, jetCollection, postfix = '',
- runGhostMuonAssociation = True,
+ runGhostMuonAssociation = None,
**kwargs):
"""Create a jet analysis algorithm sequence
The jet collection is interpreted and selects the correct function to call,
diff --git a/PhysicsAnalysis/Algorithms/MuonAnalysisAlgorithms/python/MuonAnalysisConfig.py b/PhysicsAnalysis/Algorithms/MuonAnalysisAlgorithms/python/MuonAnalysisConfig.py
index b635f16f98a678e68cbfbf67d76678851324675c..2710b26132e467396030790b92b226fb4a13dcf4 100644
--- a/PhysicsAnalysis/Algorithms/MuonAnalysisAlgorithms/python/MuonAnalysisConfig.py
+++ b/PhysicsAnalysis/Algorithms/MuonAnalysisAlgorithms/python/MuonAnalysisConfig.py
@@ -15,10 +15,16 @@ class MuonCalibrationConfig (ConfigBlock):
self.ptSelectionOutput = False
def makeAlgs (self, config) :
+
+ if config.isPhyslite() :
+ config.setSourceName (self.containerName, "AnalysisMuons")
+ else :
+ config.setSourceName (self.containerName, "Muons")
+
# Set up a shallow copy to decorate
- if config.wantCopy (self.containerName, 'Muons') :
+ if config.wantCopy (self.containerName) :
alg = config.createAlgorithm( 'CP::AsgShallowCopyAlg', 'MuonShallowCopyAlg' + self.postfix )
- alg.input = config.readName (self.containerName, "Muons")
+ alg.input = config.readName (self.containerName)
alg.output = config.copyName (self.containerName)
# Set up the eta-cut on all muons prior to everything else
@@ -27,7 +33,7 @@ class MuonCalibrationConfig (ConfigBlock):
config.addPrivateTool( 'selectionTool', 'CP::AsgPtEtaSelectionTool' )
alg.selectionTool.maxEta = 2.5
alg.selectionDecoration = 'selectEta' + self.postfix + ',as_bits'
- alg.particles = config.readName (self.containerName, "Muons")
+ alg.particles = config.readName (self.containerName)
alg.preselection = config.getPreselection (self.containerName, '')
config.addSelection (self.containerName, '', alg.selectionDecoration,
bits=2)
diff --git a/PhysicsAnalysis/Algorithms/TauAnalysisAlgorithms/python/TauAnalysisConfig.py b/PhysicsAnalysis/Algorithms/TauAnalysisAlgorithms/python/TauAnalysisConfig.py
index ac309ad19902872a32928cc65067e89a0e897467..57a6c6e24df70edd544335bceb01d6bc132ac7ca 100644
--- a/PhysicsAnalysis/Algorithms/TauAnalysisAlgorithms/python/TauAnalysisConfig.py
+++ b/PhysicsAnalysis/Algorithms/TauAnalysisAlgorithms/python/TauAnalysisConfig.py
@@ -18,6 +18,11 @@ class TauCalibrationConfig (ConfigBlock):
def makeAlgs (self, config) :
+ if config.isPhyslite() :
+ config.setSourceName (self.containerName, "AnalysisTauJets")
+ else :
+ config.setSourceName (self.containerName, "TauJets")
+
# Set up the tau truth matching algorithm:
if self.rerunTruthMatching and config.dataType() != 'data':
alg = config.createAlgorithm( 'CP::TauTruthMatchingAlg',
@@ -25,13 +30,13 @@ class TauCalibrationConfig (ConfigBlock):
config.addPrivateTool( 'matchingTool',
'TauAnalysisTools::TauTruthMatchingTool' )
alg.matchingTool.WriteTruthTaus = 1
- alg.taus = config.readName (self.containerName, 'TauJets')
+ alg.taus = config.readName (self.containerName)
alg.preselection = config.getPreselection (self.containerName, '')
# Set up the tau 4-momentum smearing algorithm:
alg = config.createAlgorithm( 'CP::TauSmearingAlg', 'TauSmearingAlg' + self.postfix )
config.addPrivateTool( 'smearingTool', 'TauAnalysisTools::TauSmearingTool' )
- alg.taus = config.readName (self.containerName, 'TauJets')
+ alg.taus = config.readName (self.containerName)
alg.tausOut = config.copyName (self.containerName)
alg.preselection = config.getPreselection (self.containerName, '')