def tauCaloMVASequence(ConfigFlags):
""" Creates L2 Fast Calo sequence for Taus"""
# EV creator
InViewRoIs = "TAUCaloRoIs"
RecoSequenceName = "tauCaloMVAInViewSequence"
tauCaloMVAViewsMaker = EventViewCreatorAlgorithm("IMtauCaloMVA")
tauCaloMVAViewsMaker.ViewFallThrough = True
tauCaloMVAViewsMaker.RoIsLink = "initialRoI"
tauCaloMVAViewsMaker.RoITool = ViewCreatorInitialROITool()
tauCaloMVAViewsMaker.InViewRoIs = InViewRoIs
tauCaloMVAViewsMaker.Views = "TAUCaloMVAViews"
tauCaloMVAViewsMaker.ViewNodeName = RecoSequenceName
(tauCaloMVAInViewSequence,
sequenceOut) = tauCaloMVARecoSequence(InViewRoIs, RecoSequenceName)
tauCaloMVARecoVDV = CfgMgr.AthViews__ViewDataVerifier("tauCaloMVARecoVDV")
tauCaloMVARecoVDV.DataObjects = [
('TrigRoiDescriptorCollection', 'StoreGateSvc+TAUCaloRoIs'),
('CaloBCIDAverage', 'StoreGateSvc+CaloBCIDAverage'),
('ILArHVScaleCorr', 'ConditionStore+LArHVScaleCorrRecomputed'),
('xAOD::EventInfo', 'StoreGateSvc+EventInfo'),
('SG::AuxElement', 'StoreGateSvc+EventInfo.ActIntPerXDecor'),
('SG::AuxElement', 'StoreGateSvc+EventInfo.AveIntPerXDecor')
]
tauCaloMVAInViewSequence += tauCaloMVARecoVDV
tauCaloMVASequence = seqAND(
"tauCaloMVASequence", [tauCaloMVAViewsMaker, tauCaloMVAInViewSequence])
return (tauCaloMVASequence, tauCaloMVAViewsMaker, sequenceOut)
def precisionPhotonRecoSequence(RoIs):
""" With this function we will setup the sequence of offline EgammaAlgorithms so to make a photon for TrigEgamma
Sequence of algorithms is the following:
- egammaRecBuilder/TrigEgammaRecPhoton creates egammaObjects out of clusters and tracks. Here, at HLT photons we will only use clusters.
- photonSuperClusterBuilder algorithm will create superclusters out of the toposlusters and tracks in egammaRec under the photon hypothesis
https://gitlab.cern.ch/atlas/athena/blob/master/Reconstruction/egamma/egammaAlgs/python/egammaSuperClusterBuilder.py#L26
- TopoEgammBuilder will create photons and electrons out of trakcs and SuperClusters. Here at HLT photons the aim is to ignore electrons and not use tracks at all.
https://gitlab.cern.ch/atlas/athena/blob/master/Reconstruction/egamma/egammaAlgs/src/topoEgammaBuilder.cxx
"""
log.debug('precisionPhotonRecoSequence(RoIs = %s)', RoIs)
# First the data verifiers:
# Here we define the data dependencies. What input needs to be available for the Fexs (i.e. TopoClusters from precisionCalo) in order to run
from TriggerMenuMT.HLTMenuConfig.Egamma.PrecisionCaloSequenceSetup import precisionCaloMenuDefs
import AthenaCommon.CfgMgr as CfgMgr
ViewVerify = CfgMgr.AthViews__ViewDataVerifier(
"PrecisionPhotonPhotonViewDataVerifier")
ViewVerify.DataObjects = [
('xAOD::CaloClusterContainer',
'StoreGateSvc+' + precisionCaloMenuDefs.precisionCaloClusters),
('CaloCellContainer', 'StoreGateSvc+CaloCells')
]
# Retrieve the factories now
from TriggerMenuMT.HLTMenuConfig.Photon.TrigPhotonFactories import TrigEgammaRecPhoton, TrigPhotonSuperClusterBuilder, TrigTopoEgammaPhotons
log.debug('retrieve(precisionPhotonRecoSequence,None,RoIs = %s)', RoIs)
# The sequence of these algorithms
thesequence = parOR(
"precisionPhotonAlgs"
) # This thing creates the sequence with name precisionPhotonAlgs
thesequence += ViewVerify
# Add to the sequence the three steps:
# - TrigEgammaBuilder, TrigPhotonSuperClusters, TrigTopoEgammaPhotons
TrigEgammaAlgo = TrigEgammaRecPhoton()
TrigEgammaAlgo.InputTopoClusterContainerName = precisionCaloMenuDefs.precisionCaloClusters
thesequence += TrigEgammaAlgo
trigPhotonAlgo = TrigPhotonSuperClusterBuilder()
trigPhotonAlgo.InputEgammaRecContainerName = TrigEgammaAlgo.egammaRecContainer
thesequence += trigPhotonAlgo
trigTopoEgammaAlgo = TrigTopoEgammaPhotons()
trigTopoEgammaAlgo.SuperPhotonRecCollectionName = trigPhotonAlgo.SuperPhotonRecCollectionName
collectionOut = trigTopoEgammaAlgo.PhotonOutputName
thesequence += trigTopoEgammaAlgo
return (thesequence, collectionOut)
def fastPhotonMenuSequence():
"""Creates secpond step photon sequence"""
from TriggerMenuMT.HLTMenuConfig.CommonSequences.CaloSequenceSetup import CaloMenuDefs
ViewVerify = CfgMgr.AthViews__ViewDataVerifier(
"FastPhotonViewDataVerifier")
ViewVerify.DataObjects = [('xAOD::TrigEMClusterContainer',
'StoreGateSvc+' + CaloMenuDefs.L2CaloClusters),
('TrigRoiDescriptorCollection',
'StoreGateSvc+EMIDRoIs')]
from TrigEgammaHypo.TrigEgammaFastPhotonFexMTConfig import EgammaFastPhotonFex_1
thePhotonFex = EgammaFastPhotonFex_1()
thePhotonFex.TrigEMClusterName = CaloMenuDefs.L2CaloClusters
thePhotonFex.PhotonsName = recordable("HLT_FastPhotons")
#thePhotonFex.RoIs="EMIDRoIs"
l2PhotonViewsMaker = EventViewCreatorAlgorithm("IMl2Photon")
l2PhotonViewsMaker.RoIsLink = "initialRoI"
l2PhotonViewsMaker.InViewRoIs = "EMIDRoIs"
#l2PhotonViewsMaker.InViewRoIs = "EMCaloRoIs"
l2PhotonViewsMaker.RoITool = ViewCreatorInitialROITool()
l2PhotonViewsMaker.Views = "EMPhotonViews"
l2PhotonViewsMaker.ViewFallThrough = True
l2PhotonViewsMaker.RequireParentView = True
thePhotonFex.RoIs = l2PhotonViewsMaker.InViewRoIs
photonInViewAlgs = parOR("photonInViewAlgs", [ViewVerify, thePhotonFex])
l2PhotonViewsMaker.ViewNodeName = "photonInViewAlgs"
from TrigEgammaHypo.TrigEgammaHypoConf import TrigEgammaFastPhotonHypoAlgMT
thePhotonHypo = TrigEgammaFastPhotonHypoAlgMT()
thePhotonHypo.Photons = thePhotonFex.PhotonsName
thePhotonHypo.RunInView = True
# this needs to be added:
#electronDecisionsDumper = DumpDecisions("electronDecisionsDumper", Decisions = theElectronHypo.Output )
photonAthSequence = seqAND("photonAthSequence",
[l2PhotonViewsMaker, photonInViewAlgs])
from TrigEgammaHypo.TrigEgammaFastPhotonHypoTool import TrigEgammaFastPhotonHypoToolFromDict
return MenuSequence(Maker=l2PhotonViewsMaker,
Sequence=photonAthSequence,
Hypo=thePhotonHypo,
HypoToolGen=TrigEgammaFastPhotonHypoToolFromDict)
def HLTRoITopoRecoSequence(RoIs):
import AthenaCommon.CfgMgr as CfgMgr
HLTRoITopoRecoSequenceVDV = CfgMgr.AthViews__ViewDataVerifier(
"HLTRoITopoRecoSequenceVDV")
HLTRoITopoRecoSequenceVDV.DataObjects = [
('TrigRoiDescriptorCollection', 'StoreGateSvc+PrecisionCaloRoIs'),
('CaloBCIDAverage', 'StoreGateSvc+CaloBCIDAverage'),
('ILArHVScaleCorr', 'ConditionStore+LArHVScaleCorrRecomputed')
]
cellMaker = HLTCellMaker(RoIs, algSuffix="RoI")
topoClusterMaker = _algoHLTTopoCluster(inputEDM=cellMaker.CellsName,
algSuffix="RoI")
RecoSequence = parOR(
"RoITopoClusterRecoSequence",
[HLTRoITopoRecoSequenceVDV, cellMaker, topoClusterMaker])
return (RecoSequence, topoClusterMaker.CaloClusters)
def fastCaloRecoSequence(InViewRoIs,
doRinger=False,
ClustersName="HLT_FastCaloEMClusters",
RingerKey="HLT_FastCaloRinger"):
fastCaloAlg = _algoL2Egamma(inputEDM=InViewRoIs,
doRinger=doRinger,
ClustersName=ClustersName,
RingerKey=RingerKey)
import AthenaCommon.CfgMgr as CfgMgr
fastCaloVDV = CfgMgr.AthViews__ViewDataVerifier("fastCaloVDV")
fastCaloVDV.DataObjects = [
('CaloBCIDAverage', 'StoreGateSvc+CaloBCIDAverage'),
('TrigRoiDescriptorCollection', 'StoreGateSvc+EMCaloRoIs')
]
fastCaloInViewSequence = seqAND('fastCaloInViewSequence',
[fastCaloVDV, fastCaloAlg])
sequenceOut = fastCaloAlg.ClustersName
return (fastCaloInViewSequence, sequenceOut)
def makeInDetAlgs(whichSignature='',
separateTrackParticleCreator='',
rois='EMViewRoIs',
doFTF=True,
viewVerifier='IDViewDataVerifier'):
#If signature specified add suffix to the algorithms
signature = whichSignature if whichSignature else ''
if signature != "" and separateTrackParticleCreator == "":
separateTrackParticleCreator = signature
if signature == "":
raise ValueError('makeInDetAlgs() No signature specified')
#Global keys/names for Trigger collections
from .InDetTrigCollectionKeys import TrigPixelKeys, TrigSCTKeys
from InDetRecExample.InDetKeys import InDetKeys
from TrigInDetConfig.TrigInDetConfig import InDetCacheNames
from AthenaCommon.GlobalFlags import globalflags
viewAlgs = []
ViewDataVerifier = None
if viewVerifier:
import AthenaCommon.CfgMgr as CfgMgr
ViewDataVerifier = CfgMgr.AthViews__ViewDataVerifier(viewVerifier +
signature)
ViewDataVerifier.DataObjects = [
('InDet::PixelClusterContainerCache',
InDetCacheNames.Pixel_ClusterKey),
('PixelRDO_Cache', InDetCacheNames.PixRDOCacheKey),
('InDet::SCT_ClusterContainerCache',
InDetCacheNames.SCT_ClusterKey),
('SCT_RDO_Cache', InDetCacheNames.SCTRDOCacheKey),
('SpacePointCache', InDetCacheNames.SpacePointCachePix),
('SpacePointCache', InDetCacheNames.SpacePointCacheSCT),
('IDCInDetBSErrContainer_Cache', InDetCacheNames.SCTBSErrCacheKey),
('IDCInDetBSErrContainer_Cache',
InDetCacheNames.SCTFlaggedCondCacheKey),
('xAOD::EventInfo', 'StoreGateSvc+EventInfo'),
('TagInfo', 'DetectorStore+ProcessingTags')
]
viewAlgs.append(ViewDataVerifier)
# Load RDOs if we aren't loading bytestream
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
topSequence.SGInputLoader.Load += [('TagInfo',
'DetectorStore+ProcessingTags')]
if not globalflags.InputFormat.is_bytestream():
ViewDataVerifier.DataObjects += [
('PixelRDO_Container', InDetKeys.PixelRDOs()),
('SCT_RDO_Container', InDetKeys.SCT_RDOs()),
('IDCInDetBSErrContainer', InDetKeys.SCT_ByteStreamErrs())
]
topSequence.SGInputLoader.Load += [
('PixelRDO_Container', InDetKeys.PixelRDOs()),
('SCT_RDO_Container', InDetKeys.SCT_RDOs()),
('IDCInDetBSErrContainer', InDetKeys.SCT_ByteStreamErrs())
]
from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
from AthenaCommon.AppMgr import ToolSvc
#Only add raw data decoders if we're running over raw data
if globalflags.InputFormat.is_bytestream():
#Pixel
from PixelRawDataByteStreamCnv.PixelRawDataByteStreamCnvConf import PixelRodDecoder
InDetPixelRodDecoder = PixelRodDecoder(name="InDetPixelRodDecoder_" +
signature)
# Disable duplcated pixel check for data15 because duplication mechanism was used.
from RecExConfig.RecFlags import rec
if len(rec.projectName()) >= 6 and rec.projectName()[:6] == "data15":
InDetPixelRodDecoder.CheckDuplicatedPixel = False
ToolSvc += InDetPixelRodDecoder
from PixelRawDataByteStreamCnv.PixelRawDataByteStreamCnvConf import PixelRawDataProviderTool
InDetPixelRawDataProviderTool = PixelRawDataProviderTool(
name="InDetPixelRawDataProviderTool_" + signature,
Decoder=InDetPixelRodDecoder,
checkLVL1ID=False)
ToolSvc += InDetPixelRawDataProviderTool
if (InDetTrigFlags.doPrintConfigurables()):
print(InDetPixelRawDataProviderTool) # noqa: ATL901
# load the PixelRawDataProvider
from PixelRawDataByteStreamCnv.PixelRawDataByteStreamCnvConf import PixelRawDataProvider
InDetPixelRawDataProvider = PixelRawDataProvider(
name="InDetPixelRawDataProvider_" + signature,
RDOKey=InDetKeys.PixelRDOs(),
ProviderTool=InDetPixelRawDataProviderTool,
)
InDetPixelRawDataProvider.isRoI_Seeded = True
InDetPixelRawDataProvider.RoIs = rois
InDetPixelRawDataProvider.RDOCacheKey = InDetCacheNames.PixRDOCacheKey
viewAlgs.append(InDetPixelRawDataProvider)
if (InDetTrigFlags.doPrintConfigurables()):
print(InDetPixelRawDataProvider) # noqa: ATL901
#SCT
from SCT_RawDataByteStreamCnv.SCT_RawDataByteStreamCnvConf import SCT_RodDecoder
InDetSCTRodDecoder = SCT_RodDecoder(name="InDetSCTRodDecoder_" +
signature)
ToolSvc += InDetSCTRodDecoder
from SCT_RawDataByteStreamCnv.SCT_RawDataByteStreamCnvConf import SCTRawDataProviderTool
InDetSCTRawDataProviderTool = SCTRawDataProviderTool(
name="InDetSCTRawDataProviderTool_" + signature,
Decoder=InDetSCTRodDecoder)
ToolSvc += InDetSCTRawDataProviderTool
if (InDetTrigFlags.doPrintConfigurables()):
print(InDetSCTRawDataProviderTool) # noqa: ATL901
# load the SCTRawDataProvider
from SCT_RawDataByteStreamCnv.SCT_RawDataByteStreamCnvConf import SCTRawDataProvider
InDetSCTRawDataProvider = SCTRawDataProvider(
name="InDetSCTRawDataProvider_" + signature,
RDOKey=InDetKeys.SCT_RDOs(),
ProviderTool=InDetSCTRawDataProviderTool)
InDetSCTRawDataProvider.isRoI_Seeded = True
InDetSCTRawDataProvider.RoIs = rois
InDetSCTRawDataProvider.RDOCacheKey = InDetCacheNames.SCTRDOCacheKey
InDetSCTRawDataProvider.BSErrCacheKey = InDetCacheNames.SCTBSErrCacheKey
from RegionSelector.RegSelToolConfig import makeRegSelTool_SCT
InDetSCTRawDataProvider.RegSelTool = makeRegSelTool_SCT()
viewAlgs.append(InDetSCTRawDataProvider)
# load the SCTEventFlagWriter
from SCT_RawDataByteStreamCnv.SCT_RawDataByteStreamCnvConf import SCTEventFlagWriter
InDetSCTEventFlagWriter = SCTEventFlagWriter(
name="InDetSCTEventFlagWriter_" + signature)
viewAlgs.append(InDetSCTEventFlagWriter)
#Pixel clusterisation
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import TrigPixelLorentzAngleTool, TrigSCTLorentzAngleTool
from PixelConditionsAlgorithms.PixelConditionsAlgorithmsConf import PixelConfigCondAlg
PixelConfigCondAlg.UseCalibConditions = False
from SiClusterizationTool.SiClusterizationToolConf import InDet__ClusterMakerTool
InDetClusterMakerTool = InDet__ClusterMakerTool(
name="InDetClusterMakerTool_" + signature,
SCTLorentzAngleTool=TrigSCTLorentzAngleTool,
PixelLorentzAngleTool=TrigPixelLorentzAngleTool)
ToolSvc += InDetClusterMakerTool
from SiClusterizationTool.SiClusterizationToolConf import InDet__MergedPixelsTool
InDetMergedPixelsTool = InDet__MergedPixelsTool(
name="InDetMergedPixelsTool_" + signature,
globalPosAlg=InDetClusterMakerTool,
MinimalSplitSize=0,
MaximalSplitSize=49,
MinimalSplitProbability=0,
DoIBLSplitting=True,
)
# Enable duplcated RDO check for data15 because duplication mechanism was used.
from RecExConfig.RecFlags import rec
if len(rec.projectName()) >= 6 and rec.projectName()[:6] == "data15":
InDetMergedPixelsTool.CheckDuplicatedRDO = True
ToolSvc += InDetMergedPixelsTool
from SiClusterizationTool.SiClusterizationToolConf import InDet__PixelGangedAmbiguitiesFinder
InDetPixelGangedAmbiguitiesFinder = InDet__PixelGangedAmbiguitiesFinder(
name="InDetPixelGangedAmbiguitiesFinder_" + signature)
ToolSvc += InDetPixelGangedAmbiguitiesFinder
from InDetPrepRawDataFormation.InDetPrepRawDataFormationConf import InDet__PixelClusterization
InDetPixelClusterization = InDet__PixelClusterization(
name="InDetPixelClusterization_" + signature,
clusteringTool=InDetMergedPixelsTool,
gangedAmbiguitiesFinder=InDetPixelGangedAmbiguitiesFinder,
DataObjectName=InDetKeys.PixelRDOs(),
AmbiguitiesMap=TrigPixelKeys.PixelClusterAmbiguitiesMap,
ClustersName=TrigPixelKeys.Clusters)
InDetPixelClusterization.isRoI_Seeded = True
InDetPixelClusterization.RoIs = rois
InDetPixelClusterization.ClusterContainerCacheKey = InDetCacheNames.Pixel_ClusterKey
viewAlgs.append(InDetPixelClusterization)
# Create SCT_ConditionsSummaryTool
from SCT_ConditionsTools.SCT_ConditionsSummaryToolSetup import SCT_ConditionsSummaryToolSetup
sct_ConditionsSummaryToolSetup = SCT_ConditionsSummaryToolSetup(
"InDetSCT_ConditionsSummaryTool_" + signature)
sct_ConditionsSummaryToolSetup.setup()
InDetSCT_ConditionsSummaryTool = sct_ConditionsSummaryToolSetup.getTool(
) # noqa: F841
sct_ConditionsSummaryToolSetupWithoutFlagged = SCT_ConditionsSummaryToolSetup(
"InDetSCT_ConditionsSummaryToolWithoutFlagged_" + signature)
sct_ConditionsSummaryToolSetupWithoutFlagged.setup()
InDetSCT_ConditionsSummaryToolWithoutFlagged = sct_ConditionsSummaryToolSetupWithoutFlagged.getTool(
)
# Add conditions tools to SCT_ConditionsSummaryTool
from SCT_ConditionsTools.SCT_ConfigurationConditionsToolSetup import SCT_ConfigurationConditionsToolSetup
sct_ConfigurationConditionsToolSetup = SCT_ConfigurationConditionsToolSetup(
)
sct_ConfigurationConditionsToolSetup.setToolName(
"InDetSCT_ConfigurationConditionsTool_" + signature)
sct_ConfigurationConditionsToolSetup.setup()
InDetSCT_ConditionsSummaryToolWithoutFlagged.ConditionsTools.append(
sct_ConfigurationConditionsToolSetup.getTool().getFullName())
from SCT_ConditionsTools.SCT_ReadCalibDataToolSetup import SCT_ReadCalibDataToolSetup
sct_ReadCalibDataToolSetup = SCT_ReadCalibDataToolSetup()
sct_ReadCalibDataToolSetup.setToolName("InDetSCT_ReadCalibDataTool_" +
signature)
sct_ReadCalibDataToolSetup.setup()
InDetSCT_ConditionsSummaryToolWithoutFlagged.ConditionsTools.append(
sct_ReadCalibDataToolSetup.getTool().getFullName())
from SCT_ConditionsTools.SCT_ByteStreamErrorsToolSetup import SCT_ByteStreamErrorsToolSetup
sct_ByteStreamErrorsToolSetup = SCT_ByteStreamErrorsToolSetup()
sct_ByteStreamErrorsToolSetup.setToolName("InDetSCT_BSErrorTool_" +
signature)
sct_ByteStreamErrorsToolSetup.setConfigTool(
sct_ConfigurationConditionsToolSetup.getTool())
sct_ByteStreamErrorsToolSetup.setup()
InDetSCT_ConditionsSummaryToolWithoutFlagged.ConditionsTools.append(
sct_ByteStreamErrorsToolSetup.getTool().getFullName())
if (InDetTrigFlags.doPrintConfigurables()):
print(InDetSCT_ConditionsSummaryToolWithoutFlagged)
#
# --- SCT_ClusteringTool
#
from SiClusterizationTool.SiClusterizationToolConf import InDet__SCT_ClusteringTool
InDetSCT_ClusteringTool = InDet__SCT_ClusteringTool(
name="InDetSCT_ClusteringTool_" + signature,
globalPosAlg=InDetClusterMakerTool,
conditionsTool=InDetSCT_ConditionsSummaryToolWithoutFlagged)
if InDetTrigFlags.doSCTIntimeHits():
if InDetTrigFlags.InDet25nsec():
InDetSCT_ClusteringTool.timeBins = "01X"
else:
InDetSCT_ClusteringTool.timeBins = "X1X"
#
# --- SCT_Clusterization algorithm
#
from InDetPrepRawDataFormation.InDetPrepRawDataFormationConf import InDet__SCT_Clusterization
InDetSCT_Clusterization = InDet__SCT_Clusterization(
name="InDetSCT_Clusterization_" + signature,
clusteringTool=InDetSCT_ClusteringTool,
# ChannelStatus = InDetSCT_ChannelStatusAlg,
DataObjectName=InDetKeys.SCT_RDOs(),
ClustersName=TrigSCTKeys.Clusters,
#Adding the suffix to flagged conditions
SCT_FlaggedCondData="SCT_FlaggedCondData_TRIG",
conditionsTool=InDetSCT_ConditionsSummaryToolWithoutFlagged)
InDetSCT_Clusterization.isRoI_Seeded = True
InDetSCT_Clusterization.RoIs = rois
InDetSCT_Clusterization.ClusterContainerCacheKey = InDetCacheNames.SCT_ClusterKey
InDetSCT_Clusterization.FlaggedCondCacheKey = InDetCacheNames.SCTFlaggedCondCacheKey
from RegionSelector.RegSelToolConfig import makeRegSelTool_SCT
InDetSCT_Clusterization.RegSelTool = makeRegSelTool_SCT()
viewAlgs.append(InDetSCT_Clusterization)
#Space points and FTF
from SiSpacePointTool.SiSpacePointToolConf import InDet__SiSpacePointMakerTool
InDetSiSpacePointMakerTool = InDet__SiSpacePointMakerTool(
name="InDetSiSpacePointMakerTool_" + signature)
from AthenaCommon.DetFlags import DetFlags
from SiSpacePointFormation.SiSpacePointFormationConf import InDet__SiTrackerSpacePointFinder
from SiSpacePointFormation.InDetOnlineMonitor import InDetMonitoringTool
InDetSiTrackerSpacePointFinder = InDet__SiTrackerSpacePointFinder(
name="InDetSiTrackerSpacePointFinder_" + signature,
SiSpacePointMakerTool=InDetSiSpacePointMakerTool,
PixelsClustersName=TrigPixelKeys.Clusters,
SpacePointsPixelName=TrigPixelKeys.SpacePoints,
SCT_ClustersName=TrigSCTKeys.Clusters,
SpacePointsSCTName=TrigSCTKeys.SpacePoints,
SpacePointsOverlapName=InDetKeys.OverlapSpacePoints(),
ProcessPixels=DetFlags.haveRIO.pixel_on(),
ProcessSCTs=DetFlags.haveRIO.SCT_on(),
ProcessOverlaps=DetFlags.haveRIO.SCT_on(),
SpacePointCacheSCT=InDetCacheNames.SpacePointCacheSCT,
SpacePointCachePix=InDetCacheNames.SpacePointCachePix,
monTool=InDetMonitoringTool())
viewAlgs.append(InDetSiTrackerSpacePointFinder)
# Condition algorithm for SiTrackerSpacePointFinder
if InDetSiTrackerSpacePointFinder.ProcessSCTs:
from AthenaCommon.AlgSequence import AthSequencer
condSeq = AthSequencer("AthCondSeq")
if not hasattr(condSeq, "InDetSiElementPropertiesTableCondAlg"):
# Setup alignment folders and conditions algorithms
from SiSpacePointFormation.SiSpacePointFormationConf import InDet__SiElementPropertiesTableCondAlg
condSeq += InDet__SiElementPropertiesTableCondAlg(
name="InDetSiElementPropertiesTableCondAlg")
#FIXME have a flag for now set for True( as most cases call FTF) but potentially separate
if doFTF:
from TrigFastTrackFinder.TrigFastTrackFinder_Config import TrigFastTrackFinderBase
theFTF = TrigFastTrackFinderBase(
"TrigFastTrackFinder_" + whichSignature, whichSignature)
theFTF.RoIs = rois
theFTF.TracksName = "TrigFastTrackFinder_Tracks_" + separateTrackParticleCreator
#the following doCloneRemoval modification should be set up in the InDetTrigSliceSettings once legacy trigger not needed
if whichSignature == "Electron":
theFTF.doCloneRemoval = True
viewAlgs.append(theFTF)
from TrigInDetConf.TrigInDetPostTools import InDetTrigParticleCreatorToolFTF
from TrigEDMConfig.TriggerEDMRun3 import recordable
from InDetTrigParticleCreation.InDetTrigParticleCreationConf import InDet__TrigTrackingxAODCnvMT
trackCollection = "HLT_IDTrack_" + separateTrackParticleCreator + "_FTF"
theTrackParticleCreatorAlg = InDet__TrigTrackingxAODCnvMT(
name="InDetTrigTrackParticleCreatorAlg" + whichSignature,
TrackName="TrigFastTrackFinder_Tracks_" +
separateTrackParticleCreator,
ParticleCreatorTool=InDetTrigParticleCreatorToolFTF)
if separateTrackParticleCreator == "BeamSpot":
theTrackParticleCreatorAlg.TrackParticlesName = trackCollection
else:
theTrackParticleCreatorAlg.TrackParticlesName = recordable(
trackCollection)
viewAlgs.append(theTrackParticleCreatorAlg)
return viewAlgs, ViewDataVerifier
def runTest( self ):
topSequence = AlgSequence()
evca1 = CfgMgr.EventViewCreatorAlgorithm("evca1")
evca2 = CfgMgr.EventViewCreatorAlgorithm("evca2")
vdv1 = CfgMgr.AthViews__ViewDataVerifier("vdv1")
vdv2 = CfgMgr.AthViews__ViewDataVerifier("vdv2")
# Test error for empty sequence
topSequence += seqOR( "makeViewSequence" )
with self.assertRaisesRegex( RuntimeError, "Please remove makeViewSequence" ):
findViewAlgs( topSequence.getChildren(), {} )
# Add an algorithm to the sequence
topSequence.makeViewSequence += evca1
#topSequence.makeViewSequence += evca2
# Return the algorithm assuming it's in a view, or not
self.assertEqual( findViewAlgs( topSequence.getChildren(), {} ),
( [ "evca1" ], [] ) )
self.assertEqual( findViewAlgs( topSequence.getChildren(), {"makeViewSequence":False} ),
( [], [ "evca1" ] ) )
# Add a nested sequence
topSequence.makeViewSequence += seqOR( "viewSequence" )
topSequence.makeViewSequence.viewSequence += vdv1
# Return the algorithms depending on where the view is entered
self.assertEqual( findViewAlgs( topSequence.getChildren(), {} ),
( [ "evca1", "vdv1" ], [] ) )
self.assertEqual( findViewAlgs( topSequence.getChildren(), {"makeViewSequence":False} ),
( [], [ "evca1", "vdv1" ] ) )
self.assertEqual( findViewAlgs( topSequence.getChildren(), {"viewSequence":False} ),
( [ "evca1" ], [ "vdv1" ] ) )
# Check that the test finds view nodes by name
viewNodeDict = {"makeViewSequence":False, "aFakeNode":False}
findViewAlgs( topSequence.getChildren(), viewNodeDict )
self.assertEqual( viewNodeDict, {"makeViewSequence":True, "aFakeNode":False} )
# Check misconfigured EVCA
evca1.ViewNodeName = "aFakeNode"
with self.assertRaisesRegex( RuntimeError, "no corresponding upstream EventViewCreatorAlgorithm" ):
checkVDV( topSequence, [topSequence.name()], {} )
evca1.ViewNodeName = "viewSequence"
with self.assertRaisesRegex( RuntimeError, "no external data" ):
checkVDV( topSequence, [topSequence.name()], {} )
evca1.RequireParentView = True
checkVDV( topSequence, [topSequence.name()], {} )
# Check for nested view CF working
topSequence.makeViewSequence.viewSequence += seqOR( "nestedSequence" )
topSequence.makeViewSequence.viewSequence.nestedSequence += vdv2
checkVDV( topSequence, [topSequence.name()], {} )
# Check duplicate EVCA config
evca2.ViewNodeName = "aFakeNode"
topSequence.makeViewSequence += evca2
checkVDV( topSequence, [topSequence.name()], {} )
evca2.ViewNodeName = "viewSequence"
with self.assertRaisesRegex( RuntimeError, "Found duplicate view node name" ):
checkVDV( topSequence, [topSequence.name()], {} )
def precisionElectronRecoSequence(RoIs):
""" With this function we will setup the sequence of offline EgammaAlgorithms so to make a electron for TrigEgamma
Sequence of algorithms is the following:
- egammaRecBuilder/TrigEgammaRecElectron creates egammaObjects out of clusters and tracks.
- electronSuperClusterBuilder algorithm will create superclusters out of the toposlusters and tracks in egammaRec under the electron hypothesis
https://gitlab.cern.ch/atlas/athena/blob/master/Reconstruction/egamma/egammaAlgs/python/egammaSuperClusterBuilder.py#L26
- TopoEgammBuilder will create photons and electrons out of trakcs and SuperClusters. Here at HLT electrons the aim is to ignore photons.
https://gitlab.cern.ch/atlas/athena/blob/master/Reconstruction/egamma/egammaAlgs/src/topoEgammaBuilder.cxx
"""
log.debug('precisionElectronRecoSequence(RoIs = %s)', RoIs)
# First the data verifiers:
# Here we define the data dependencies. What input needs to be available for the Fexs (i.e. TopoClusters from precisionCalo) in order to run
from TriggerMenuMT.HLTMenuConfig.Egamma.PrecisionCaloSequenceSetup import precisionCaloMenuDefs
import AthenaCommon.CfgMgr as CfgMgr
## Taking Fast Track information computed in 2nd step ##
TrackCollection = "TrigFastTrackFinder_Tracks_Electron"
ViewVerifyTrk = CfgMgr.AthViews__ViewDataVerifier(
"FastTrackViewDataVerifier")
ViewVerifyTrk.DataObjects = [
('TrackCollection', 'StoreGateSvc+' + TrackCollection),
('xAOD::CaloClusterContainer',
'StoreGateSvc+' + precisionCaloMenuDefs.precisionCaloClusters),
('CaloCellContainer', 'StoreGateSvc+CaloCells'),
('SG::AuxElement', 'StoreGateSvc+EventInfo.AveIntPerXDecor'),
('IDCInDetBSErrContainer', 'StoreGateSvc+SCT_FlaggedCondData_TRIG'),
('TrigRoiDescriptorCollection', 'StoreGateSvc+precisionElectron'),
('IDCInDetBSErrContainer', 'StoreGateSvc+SCT_ByteStreamErrs')
] # the load below doesn't always work
# These objects must be loaded from SGIL if not from CondInputLoader
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
from IOVDbSvc.CondDB import conddb
if not conddb.folderRequested("PixelClustering/PixelClusNNCalib"):
ViewVerifyTrk.DataObjects += [
('TTrainedNetworkCollection', 'ConditionStore+PixelClusterNN'),
('TTrainedNetworkCollection',
'ConditionStore+PixelClusterNNWithTrack')
]
if globalflags.InputFormat.is_bytestream():
ViewVerifyTrk.DataObjects += [
('InDetBSErrContainer', 'StoreGateSvc+PixelByteStreamErrs'),
('IDCInDetBSErrContainer', 'StoreGateSvc+SCT_ByteStreamErrs')
]
else:
topSequence.SGInputLoader.Load += [('TRT_RDO_Container',
'StoreGateSvc+TRT_RDOs')]
ViewVerifyTrk.DataObjects += [('TRT_RDO_Container',
'StoreGateSvc+TRT_RDOs')]
""" Precision Track Related Setup.... """
PTAlgs = []
PTTracks = []
PTTrackParticles = []
from TrigInDetConfig.InDetPT import makeInDetPrecisionTracking
PTTracks, PTTrackParticles, PTAlgs = makeInDetPrecisionTracking(
"electron", ViewVerifyTrk, inputFTFtracks=TrackCollection, rois=RoIs)
PTSeq = parOR("precisionTrackingInElectrons", PTAlgs)
trackParticles = PTTrackParticles[-1]
electronPrecisionTrack = parOR("electronPrecisionTrack")
electronPrecisionTrack += ViewVerifyTrk
electronPrecisionTrack += PTSeq
""" Retrieve the factories now """
from TriggerMenuMT.HLTMenuConfig.Electron.TrigElectronFactories import TrigEgammaRecElectron, TrigElectronSuperClusterBuilder, TrigTopoEgammaElectronCfg
from TriggerMenuMT.HLTMenuConfig.Egamma.TrigEgammaFactories import TrigEMTrackMatchBuilder
#The sequence of these algorithms
thesequence = parOR("precisionElectron_" + RoIs)
# Create the sequence of three steps:
# - TrigEgammaRecElectron, TrigElectronSuperClusterBuilder, TrigTopoEgammaElectron
trackMatchBuilder = TrigEMTrackMatchBuilder()
trackMatchBuilder.TrackParticlesName = trackParticles
TrigEgammaAlgo = TrigEgammaRecElectron()
TrigEgammaAlgo.InputTopoClusterContainerName = precisionCaloMenuDefs.precisionCaloClusters
TrigEgammaAlgo.TrackMatchBuilderTool = trackMatchBuilder
thesequence += TrigEgammaAlgo
trigElectronAlgo = TrigElectronSuperClusterBuilder()
trigElectronAlgo.InputEgammaRecContainerName = TrigEgammaAlgo.egammaRecContainer
thesequence += trigElectronAlgo
trigTopoEgammaAlgo = TrigTopoEgammaElectronCfg()
trigTopoEgammaAlgo.SuperElectronRecCollectionName = trigElectronAlgo.SuperElectronRecCollectionName
collectionOut = trigTopoEgammaAlgo.ElectronOutputName
thesequence += trigTopoEgammaAlgo
from TriggerMenuMT.HLTMenuConfig.Egamma.TrigEgammaFactories import TrigElectronIsoBuilderCfg
isoBuilder = TrigElectronIsoBuilderCfg()
thesequence += isoBuilder
return (thesequence, electronPrecisionTrack, collectionOut)
