def checkRequiredAlgPosition(seq, momAlg, requiredAlg):
topSeq = AlgSequence()
if requiredAlg in topSeq:
truthInd = topSeq.getChildren().index(requiredAlg)
if momAlg in topSeq:
index = topSeq.getChildren().index(momAlg)
else:
# then it is in seq, and seq must be in topSeq
index = topSeq.getChildren().index(seq)
# make sure requiredAlg is before index
if truthInd > index:
moveAlgInSequence(requiredAlg, topSeq, index)
else:
# will move requiredAlg in topSeq before seq and momAlg
# where is momAlg ?
seqInd = topSeq.getChildren().index(seq)
if momAlg in topSeq:
index = topSeq.getChildren().index(momAlg)
else:
index = seqInd
delattr(seq, requiredAlg.getName())
topSeq.insert(index, requiredAlg)
import AthenaCommon.CfgMgr as CfgMgr
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
from TileRecUtils.TileRecFlags import jobproperties
from TileConditions.TileInfoConfigurator import TileInfoConfigurator
tileInfoConfigurator = TileInfoConfigurator()
if tileInfoConfigurator.setupCOOLDspThreshold():
tileDigitsThresholdFilter = CfgMgr.TileDigitsThresholdFilter()
jobproperties.TileRecFlags.TileDigitsContainer = 'TileDigitsFiltered'
indices = [
i for i, alg in enumerate(topSequence.getChildren())
if alg.getType() == 'TileRawChannelMaker'
]
if len(indices):
topSequence.insert(indices[0], tileDigitsThresholdFilter)
if hasattr(topSequence, 'TileRChMaker'):
topSequence.TileRChMaker.TileDigitsContainer = jobproperties.TileRecFlags.TileDigitsContainer(
)
else:
topSequence += tileDigitsThresholdFilter
tileDigitsFilterLogger.info(
"Added TileDigitsThresholdFilter algorithm to filter Tile Digits over threshold"
)
else:
tileDigitsFilterLogger.warn(
"It is impossible to get Tile DSP thresholds from COOL; No Tile Digits filtering!"
)
from AthenaCommon.AlgSequence import AlgSequence
job=AlgSequence()
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
from AthenaCommon.AppMgr import ServiceMgr
# Add top algorithms to be run
from FastCaloSimHit.FastCaloSimHitConf import FastHitConv
theFastHitConv=FastHitConv("theFastHitConv")
from AthenaCommon.DetFlags import DetFlags
list = topSequence.getSequence()
topSequence.insert(list.index('LArDigitMaker/digitmaker1'), theFastHitConv) # put FastHitConv right before
# CaloDigi in topSequence
job.theFastHitConv.OutputLevel = ALL
job.OutputLevel = INFO
from AthenaCommon.DetFlags import DetFlags
if DetFlags.pileup.LAr_on() or DetFlags.pileup.Tile_on():
job.theFastHitConv.doPileup = True
else:
job.theFastHitConv.doPileup = False
OutputLevel = INFO
doCBNT = False
EvtMax = 5
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
assert (job == AlgSequence()) # this is a singleton
from HeapMon.EventNotifier import EventExecutionNotifier
een = EventExecutionNotifier('EventNotifier')
een.start_scan = 1
een.stop_scan = 4
job.insert(0, een)
#DetDescrVersion="ATLAS-GEO-02-01-00"
#PoolRDOInput = [ "RDO.pool.root" ]
# DetFlags modifications are best set here (uncomment RecExCommon_flags first)
#include ("RecExCond/RecExCommon_flags.py")
# switch off ID, calo, or muons
#DetFlags.ID_setOff()
#DetFlags.Calo_setOff()
#DetFlags.Muon_setOff()
print job
include("jobOptions.py")
#######################################################
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from AthenaCommon.AlgSequence import AlgSequence,AthSequencer
# create electron and muon selectors
sequencer = AthSequencer("HSG5ZHMETU_Sequencer",
StopOverride=False)
# MET selector
from D2PDMaker.D2PDMakerConf import D2PDMissingEtSelector
sequencer += D2PDMissingEtSelector( "HSG5ZHMETU_MissingEtFilter",
inputCollection = 'MET_RefFinal',
outputCollection = 'HSG5ZHMETU_NeutrinoRefFinal',
minNumberPassed = 1,
missingEtMin = 40.0*Units.GeV)
#missingEtSignificanceMin = 5.0)
HSG5D3PD_Stream.RequireAlgs.append("HSG5ZHMETU_MissingEtFilter")
if False:
# (for private production only) insert in beginning of PreD3PDSequencer
mainSequencer = AlgSequence(D3PDMakerFlags.PreD3PDAlgSeqName(),
StopOverride = False)
if not hasattr( topSequence, D3PDMakerFlags.PreD3PDAlgSeqName() ):
topSequence += mainSequencer
mainSequencer.insert(0,sequencer)
else:
topSequence+=sequencer
L1CaloMan0A2.DataType = DQMonFlags.monManDataType()
L1CaloMan0A3.FileKey = DQMonFlags.monManFileKey()
L1CaloMan0A3.Environment = DQMonFlags.monManEnvironment()
L1CaloMan0A3.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup()
L1CaloMan0A3.DataType = DQMonFlags.monManDataType()
L1CaloMan0A4.FileKey = DQMonFlags.monManFileKey()
L1CaloMan0A4.Environment = DQMonFlags.monManEnvironment()
L1CaloMan0A4.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup()
L1CaloMan0A4.DataType = DQMonFlags.monManDataType()
# Make sure we run these before RoIBResultToAOD as it also accesses
# TriggerTowers and JetElements
index = 0
for alg in topSequence:
if alg.getName() == 'RoIBResultToAOD': break
index += 1
topSequence.insert(index, L1CaloMan0A1)
topSequence.insert(index+1, L1CaloMan0A2)
topSequence.insert(index+2, L1CaloMan0A3)
topSequence.insert(index+3, L1CaloMan0A4)
L1CaloMan0B.FileKey = DQMonFlags.monManFileKey()
L1CaloMan0B.Environment = DQMonFlags.monManEnvironment()
L1CaloMan0B.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup()
L1CaloMan0B.DataType = DQMonFlags.monManDataType()
topSequence += L1CaloMan0B
L1CaloMan1A.FileKey = DQMonFlags.monManFileKey()
L1CaloMan1A.Environment = DQMonFlags.monManEnvironment()
L1CaloMan1A.ManualDataTypeSetup = DQMonFlags.monManManualDataTypeSetup()
L1CaloMan1A.DataType = DQMonFlags.monManDataType()
topSequence += L1CaloMan1A
L1CaloMan1B.FileKey = DQMonFlags.monManFileKey()
L1CaloMan1B.Environment = DQMonFlags.monManEnvironment()
from AthenaCommon.AlgSequence import AlgSequence, AthSequencer
topSequence = AlgSequence()
from AthenaCommon.DetFlags import DetFlags
if DetFlags.pileup.any_on():
index = 0
for alg in topSequence:
index += 1 #count position
if 'PileUpToolsAlg' in alg.name():
from AthenaCommon.CfgGetter import getPrivateTool
alg.PileUpTools += [getPrivateTool("MergeHijingParsTool")]
break
if 'MergeMcEventCollection' == alg.name():
from MCTruthSimAlgs.MCTruthSimAlgsConf import MergeHijingPars
mergeHijingPars = MergeHijingPars()
topSequence.insert(index, mergeHijingPars)
break
else:
try:
from TruthIO.TruthIOConf import PrintHijingPars
except:
from TruthExamples.TruthExamplesConf import PrintHijingPars
topSequence += PrintHijingPars()
## configure Athena for POOL persistency
streamAlgs = ['StreamHITS', 'StreamRDO', 'StreamESD', 'StreamAOD']
streamSeq = AthSequencer("AthOutSeq")
for stream in streamAlgs:
sSoutStream = getattr(streamSeq, stream, None)
tSoutStream = getattr(topSequence, stream, None)
if tSoutStream is not None:
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
print "Digitization jobProperties values (after FastCaloSim setup):"
#DetFlags.Print()
#GlobalFlags.Print()
#digitization.print_JobProperties()
from AthenaCommon.AppMgr import ServiceMgr
# Add top algorithms to be run
from FastCaloSimHit.FastCaloSimHitConf import FastHitConv
theFastHitConv = FastHitConv("MyFastHitConv")
#job += FastHitConv( "MyFastHitConv" ) # 1 alg, named "FastHitConv"
topSequence.insert(0, theFastHitConv)
job.MyFastHitConv.OutputLevel = ALL
job.OutputLevel = DEBUG
print topSequence
from CaloRec.CaloCellFlags import jobproperties
jobproperties.CaloCellFlags.doFastCaloSim = True
jobproperties.CaloCellFlags.doFastCaloSimNoise = False
jobproperties.CaloCellFlags.doLArCellEmMisCalib = False
from FastCaloSimHit.FastCaloCellGetter import CaloCellGetter
theCaloCellGetter = CaloCellGetter()
#jobproperties.CaloCellFlags.doFastCaloSim = False
#theCaloCellGetter._CaloCellMakerHandle.OutputLevel = 2
OutputLevel=INFO
doCBNT=False
EvtMax = 5
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
assert( job == AlgSequence() ) # this is a singleton
from HeapMon.EventNotifier import EventExecutionNotifier
een =EventExecutionNotifier('EventNotifier')
een.start_scan = 1
een.stop_scan = 4
job.insert(0,een)
#DetDescrVersion="ATLAS-GEO-02-01-00"
#PoolRDOInput = [ "RDO.pool.root" ]
# DetFlags modifications are best set here (uncomment RecExCommon_flags first)
#include ("RecExCond/RecExCommon_flags.py")
# switch off ID, calo, or muons
#DetFlags.ID_setOff()
#DetFlags.Calo_setOff()
#DetFlags.Muon_setOff()
print job
include ("jobOptions.py")
#######################################################
VrtSecInclusive_InDet = VrtSecInclusive("VrtSecInclusive_InDet")
VrtSecInclusive_leptons = VrtSecInclusive("VrtSecInclusive_leptons")
try:
end_idx = [_.getName() for _ in topSequence].index('StreamESD')
except ValueError:
try:
end_idx = [_.getName() for _ in topSequence].index('StreamAOD')
except ValueError:
local_logger = logging.getLogger('VrtSecInclusive_DV_Configuration')
local_logger.warning(
'Neither StreamESD nor StreamAOD found, VrtSecInclusive algs will be scheduled one before end of topSequence. Probably wrong!'
)
end_idx = -1
del local_logger
topSequence.insert(end_idx, VrtSecInclusive_InDet)
topSequence.insert(end_idx, VrtSecInclusive_leptons)
del end_idx
# set options for vertexing
VrtSecInclusive_InDet.do_PVvetoCut = True
VrtSecInclusive_InDet.do_d0Cut = False
VrtSecInclusive_InDet.do_z0Cut = False
VrtSecInclusive_InDet.do_d0errCut = False
VrtSecInclusive_InDet.do_z0errCut = False
VrtSecInclusive_InDet.do_d0signifCut = False
VrtSecInclusive_InDet.do_z0signifCut = False
VrtSecInclusive_InDet.doTRTPixCut = True
VrtSecInclusive_InDet.DoSAloneTRT = False
VrtSecInclusive_InDet.ImpactWrtBL = True
VrtSecInclusive_InDet.doPVcompatibilityCut = False
# (https://its.cern.ch/jira/browse/ATLASRECTS-2769?filter=-1),
# replace it as egamma is doing to use a C++ implementation
pass
# Make sure we add it before streams:
for pos, alg in enumerate(topSequence):
if LastCRWriter.getName() == alg.getName():
from CaloRingerAlgs.CaloRingerLocker import CaloRingerLocker
CRLocker = CaloRingerLocker(name = "CaloRingerLocker", \
doElectron = caloRingerFlags.buildElectronCaloRings(), \
doPhoton = caloRingerFlags.buildPhotonCaloRings(), \
EvtStoreName = CRMainAlg.EvtStore.getName(), \
MetaDataStoreName = CRMetaDataWriterAlg.MetaDataStore.getName(), \
CaloRingerDict = CRAlgBuilder.eventOutputs(), \
CaloRingerMetaDict = CRMetaDataBuilder.metaDataOutputs() \
)
topSequence.insert(pos + 1, CRLocker)
mlog.verbose(
"Successfully added CaloRingerLocker to TopSequence.")
break
else:
treatException("Could not find CaloRingerDecorator algorithm.")
except Exception, e:
treatException(
"Could not set up CaloRingerLocker. Switched off ! Reason:\n %s" %
traceback.format_exc())
from CaloRingerAlgs.CaloRingerLocker import CaloRingerLocker
CaloRingerLocker.OutputLevel = RingerOutputLevel
mlog.verbose('Changing %r output level to %s', CaloRingerLocker,
RingerOutputLevel)
#Customisation
CustomCuts = [[3.0, 400, 'TightPrimary'], [3.0, 500, 'TightPrimary'],
[3.0, 800, 'TightPrimary'], [3.0, 1200, 'TightPrimary'],
[3.0, 1000, 'Loose'], [1.5, 1000, 'TightPrimary'],
[5.0, 1000, 'TightPrimary']]
for icut in CustomCuts:
CustomType = icut[2] + 'z0' + str(int(10 * icut[0])) + 'Pt' + str(
icut[1]) + 'MeV'
print 'Building track isolation tool for type ', CustomType
TrackIsolationCustom = xAOD__TrackIsolationTool(name='TrackIsolationTool' +
CustomType)
TrackIsolationCustom.TrackSelectionTool.maxZ0SinTheta = float(icut[0])
TrackIsolationCustom.TrackSelectionTool.minPt = float(icut[1])
TrackIsolationCustom.TrackSelectionTool.CutLevel = icut[2]
ToolSvc += TrackIsolationCustom
isoBuilderCustom = IsolationBuilder(
name="IsolationBuilder" + CustomType,
CaloCellIsolationTool=None,
CaloTopoIsolationTool=None,
PFlowIsolationTool=None,
TrackIsolationTool=TrackIsolationCustom,
EgIsoTypes=[[]] if not rec.doEgamma() else ptconeList,
MuIsoTypes=[[]] if not rec.doMuon() else ptconeList,
CustomConfgurationName=CustomType,
OutputLevel=3)
topSequence.insert(index, isoBuilderCustom)
## --postInclude 'RecJobTransforms/UseFrontier.py' RAWtoESD:'IsolationAlgs/CustomTrackIsoGetter.py'
def addTruthJetsIfNotExising(truth_jets_name) :
'''
Add algorithm to create the truth jets collection unless the
collection exists already, or a truth jet finder is already running
'''
from RecExConfig.AutoConfiguration import IsInInputFile
# the jet collection name does not exist in the input file
# add a jet finder algorithm in front of the monitoring if the algorithm
# does not yet exist.
if not IsInInputFile('xAOD::JetContainer',truth_jets_name) :
try :
from RecExConfig.InputFilePeeker import inputFileSummary
print 'DEBUG addTruthJetsIfNotExising %s not in %s [file_type=%s]' % ( truth_jets_name, inputFileSummary['eventdata_itemsDic'], inputFileSummary['file_type'] )
if truth_jets_name in inputFileSummary['eventdata_itemsDic'] :
return
except :
pass
# Access the algorithm sequence:
from AthenaCommon.AlgSequence import AlgSequence,AthSequencer
topSequence = AlgSequence()
# extract the jet finder type and main parameter
import re
extract_alg=re.search('^([^0-9]+)([0-9]+)TruthJets',truth_jets_name)
if extract_alg != None :
alg_type=extract_alg.group(1)
alg_param_str=extract_alg.group(2)
else :
alg_type='AntiKt'
alg_param_str=4
jet_finder_alg_name = "jetalg"+alg_type+alg_param_str+'TruthJets'
# add the jet finder unless it exists already in the alg sequence
from InDetPhysValDecoration import findAlg,findMonMan
alg_pos=findAlg([jet_finder_alg_name])
if alg_pos == None :
from JetRec.JetRecStandard import jtm
mon_man_index=findMonMan()
# configure truth jet finding ?
from JetRec.JetRecFlags import jetFlags
jetFlags.useTruth = True
jetFlags.useTracks = False
jetFlags.truthFlavorTags = ["BHadronsInitial", "BHadronsFinal", "BQuarksFinal",
"CHadronsInitial", "CHadronsFinal", "CQuarksFinal",
"TausFinal",
"Partons",
]
# tool to create truth jet finding inputs
truth_part_copy_name='truthpartcopy'
dir(jtm)
create_truth_jet_input=None
if not hasattr(jtm,truth_part_copy_name) :
from MCTruthClassifier.MCTruthClassifierConfig import firstSimCreatedBarcode
from MCTruthClassifier.MCTruthClassifierConf import MCTruthClassifier
truth_classifier_name='JetMCTruthClassifier'
if not hasattr(jtm,truth_classifier_name) :
from AthenaCommon.AppMgr import ToolSvc
if not hasattr(ToolSvc,truth_classifier_name) :
truthClassifier = MCTruthClassifier(name = truth_classifier_name,
barcodeG4Shift = firstSimCreatedBarcode(),
ParticleCaloExtensionTool="")
else :
truthClassifier = getattr(ToolSvc,truth_classifier_name)
truthClassifier.barcodeG4Shift = firstSimCreatedBarcode()
jtm += truthClassifier
else :
truthClassifier = getattr(jtm,truth_classifier_name)
truthClassifier.barcodeG4Shift = firstSimCreatedBarcode()
from ParticleJetTools.ParticleJetToolsConf import CopyTruthJetParticles
create_truth_jet_input=CopyTruthJetParticles(truth_part_copy_name, OutputName="JetInputTruthParticles",
MCTruthClassifier=truthClassifier)
jtm +=create_truth_jet_input
else :
create_truth_jet_input=getattr(jtm,truth_part_copy_name)
jet_finder_tool = jtm.addJetFinder(truth_jets_name,
alg_type,
float(alg_param_str)/10.,
"truth",
ptmin=5000)
jet_tools=[]
from JetRec.JetFlavorAlgs import scheduleCopyTruthParticles
jet_tools += scheduleCopyTruthParticles()
jet_tools += [create_truth_jet_input]
jet_tools += jtm.jetrecs
# add the jet finder in front of the monitoring
from JetRec.JetRecConf import JetAlgorithm
from JetRec.JetRecConf import JetToolRunner
jtm += JetToolRunner("jetrun",
Tools=jet_tools,
EventShapeTools=[],
# OutputLevel = 1,
Timer=jetFlags.timeJetToolRunner()
)
# jet_finder_alg = JetAlgorithm(jet_finder_alg_name, jet_tools)
jet_finder_alg = JetAlgorithm(jet_finder_alg_name)
# jet_finder_alg.OutputLevel = 1
jet_finder_alg.Tools = [jtm.jetrun]
if mon_man_index != None :
topSequence.insert(mon_man_index,jet_finder_alg)
else :
topSequence += jet_finder_alg
import JetD3PDMaker
import TrackD3PDMaker
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
from D3PDMakerConfig.D3PDMakerFlags import D3PDMakerFlags
from D3PDMakerCoreComps.SimpleAssociation import SimpleAssociation
from D3PDMakerCoreComps.ContainedVectorMultiAssociation import ContainedVectorMultiAssociation
from D3PDMakerCoreComps.D3PDObject import make_SGDataVector_D3PDObject
# Ensure that TauCommonDetailsMerger is run.
from TauTools.TauToolsConf import TauCommonDetailsMerger
merg = TauCommonDetailsMerger("TauCommonDetailsMerger")
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
if not merg in topSequence:
# Make sure it goes before the d3pd algorithm.
topSequence.insert(-1, merg)
#-----------------------------------------------------------------------------
# Tau D3PDObject Maker
#-----------------------------------------------------------------------------
TauD3PDObject = make_SGDataVector_D3PDObject("Analysis::TauJetContainer",
D3PDMakerFlags.TauSGKey(), "tau_",
"QcdTauD3PDObject")
#-----------------------------------------------------------------------------
# Blocks
#-----------------------------------------------------------------------------
TauD3PDObject.defineBlock(0,
'Kinematics',
EventCommonD3PDMaker.FourMomFillerTool,
WriteEt=True,
