def __init__(self, name="InDetTrigTrackSlimmer_EF", type="electron"):
super(InDet__TrigTrackSlimmer, self).__init__(name)
from AthenaCommon.AppMgr import ToolSvc
from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTrackSummaryToolSharedHits
TrkSlimmingName = "InDetTrigTrackSlimmingTool"
keepPars = False
keepOut = False
if type == "photon" or type == "electron":
TrkSlimmingName = "InDetTrigTrackSlimmingToolParams"
keepPars = True
keepOut = True
#slimming tool
from TrkTrackSlimmingTool.TrkTrackSlimmingToolConf import Trk__TrackSlimmingTool as ConfigurableTrackSlimmingTool
InDetTrkSlimmingTool = \
ConfigurableTrackSlimmingTool(name = TrkSlimmingName,
KeepParameters = keepPars,
KeepOutliers = keepOut )
ToolSvc += InDetTrkSlimmingTool
self.TrackSlimmingTool = InDetTrkSlimmingTool
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrkSlimmingTool
#optional update of the track summary
self.SummaryTool = InDetTrigTrackSummaryToolSharedHits
def __init__(self,
name="SiTrigSpacePointFinder_Electron_EF",
type="electron",
lowPt=False):
super(InDet__SiTrigSpacePointFinder, self).__init__(name)
from AthenaCommon.AppMgr import ToolSvc
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import \
InDetTrigSiSpacePointMakerTool,SCT_TrigSpacePointTool
from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
if (InDetTrigFlags.doPrintConfigurables()):
print(SCT_TrigSpacePointTool)
ToolSvc += SCT_TrigSpacePointTool
# Condition algorithm for SiTrigSpacePointFinder
from AthenaCommon.AlgSequence import AthSequencer
condSeq = AthSequencer("AthCondSeq")
if not hasattr(condSeq, "InDetSiElementPropertiesTableCondAlg"):
from SiSpacePointFormation.SiSpacePointFormationConf import InDet__SiElementPropertiesTableCondAlg
condSeq += InDet__SiElementPropertiesTableCondAlg(
name="InDetSiElementPropertiesTableCondAlg")
self.SiSpacePointMakerTool = InDetTrigSiSpacePointMakerTool
self.SCTSpacePointTrigHelperTool = SCT_TrigSpacePointTool
self.ProcessPixels = True
self.ProcessSCTs = True
self.ProcessOverlaps = InDetTrigFlags.doOverlapSP()
if type == 'cosmicsN':
from InDetTrigRecExample.InDetTrigConfigRecLoadToolsCosmics import \
InDetTrigSiSpacePointMakerToolCosmics, SCT_TrigSpacePointToolCosmics
self.SiSpacePointMakerTool = InDetTrigSiSpacePointMakerToolCosmics
self.SCTSpacePointTrigHelperTool = SCT_TrigSpacePointToolCosmics
self.SpacePointsSCTName = "SCT_CosmicsTrigSpacePoints"
self.SpacePointsPixelName = "PixelCosmicsTrigSpacePoints"
from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
self.EtaHalfWidth = InDetTrigSliceSettings[('etaHalfWidth', type)]
self.PhiHalfWidth = InDetTrigSliceSettings[('phiHalfWidth', type)]
self.doFullScan = InDetTrigSliceSettings[('doFullScan', type)]
#monitoring
from SiTrigSpacePointFormation.SiTrigSpacePointFormatMonitoring import SiTrigSpacePointFormatValidationMonitor
from SiTrigSpacePointFormation.SiTrigSpacePointFormatMonitoring import SiTrigSpacePointFormatOnlineMonitor
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
sitime = TrigTimeHistToolConfig("SiTime")
sitime.TimerHistLimits = [0, 50]
self.AthenaMonTools = [
SiTrigSpacePointFormatValidationMonitor(type=type),
SiTrigSpacePointFormatOnlineMonitor(type=type), sitime
]
from InDetAmbiTrackSelectionTool.InDetAmbiTrackSelectionToolConf import InDet__InDetAmbiTrackSelectionTool
InDetTrigAmbiTrackSelectionToolLowPt = \
InDet__InDetAmbiTrackSelectionTool(name = 'InDetTrigAmbiTrackSelectionToolLowPt',
AssociationTool = InDetTrigPrdAssociationTool,
DriftCircleCutTool = InDetTrigTRTDriftCircleCut,
minHits = EFIDTrackingCutsLowPt.minClusters()-2,
minNotShared = EFIDTrackingCutsLowPt.minSiNotShared(),
maxShared = EFIDTrackingCutsLowPt.maxShared(),
minTRTHits = 0, # used for Si only tracking !!!
Cosmics = False, #there is a different instance
UseParameterization = False
)
ToolSvc += InDetTrigAmbiTrackSelectionToolLowPt
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigAmbiTrackSelectionToolLowPt
from InDetTrackScoringTools.InDetTrackScoringToolsConf import InDet__InDetAmbiScoringTool
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTRTDriftCircleCut
InDetTrigScoringToolLowPt = InDet__InDetAmbiScoringTool(name = 'InDetTrigScoringToolLowPt',
Extrapolator = InDetTrigExtrapolator,
SummaryTool = InDetTrigTrackSummaryTool,
useAmbigFcn = True, # this is NewTracking
useTRT_AmbigFcn= False,
minPt = InDetTrigSliceSettings[('pTmin','lowPt')],
maxRPhiImp = EFIDTrackingCutsLowPt.maxPrimaryImpact(),
maxZImp = EFIDTrackingCutsLowPt.maxZImpact(),
maxEta = EFIDTrackingCutsLowPt.maxEta(),
minSiClusters= EFIDTrackingCutsLowPt.minClusters(),
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 __init__(self, name="TrigExtProcessor_Electron_EF", type="electron"):
super(InDet__InDetTrigExtensProcessor, self).__init__(name)
from AthenaCommon.AppMgr import ToolSvc
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTrackFitter, InDetTrigPatternUpdator, InDetTrigExtrapolator, InDetTrigTrackSummaryTool
if InDetTrigFlags.trtExtensionType() is 'DAF':
# DAF Fitter setup
#
from TrkCompetingRIOsOnTrackTool.TrkCompetingRIOsOnTrackToolConf import Trk__CompetingRIOsOnTrackTool
InDetTrigCompetingRotCreator = \
Trk__CompetingRIOsOnTrackTool( name = 'InDetTrigCompetingRotCreator',
ToolForCompPixelClusters = None, # default
ToolForCompSCT_Clusters = None, # default
ToolForCompTRT_DriftCircles = InDetTrigCompetingTRT_DC_Tool )
ToolSvc += InDetTrigCompetingRotCreator
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigCompetingRotCreator
from TrkDeterministicAnnealingFilter.TrkDeterministicAnnealingFilterConf import Trk__DeterministicAnnealingFilter
InDetTrigExtensionFitter = \
Trk__DeterministicAnnealingFilter (name = 'InDetTrigDAF',
ToolForExtrapolation = InDetTrigExtrapolator,
ToolForCompetingROTsCreation = InDetTrigCompetingRotCreator,
ToolForUpdating = InDetTrigPatternUpdator,
AnnealingScheme = [200., 81., 9., 4., 1., 1., 1.],
DropOutlierCutValue = 1.E-7,
OutlierCutValue = 0.01 )
ToolSvc += InDetTrigExtensionFitter
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigExtensionFitter
else:
if type == "cosmicsN":
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTrackFitterCosmics
InDetTrigExtensionFitter = InDetTrigTrackFitterCosmics
else:
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTrackFitter
InDetTrigExtensionFitter = InDetTrigTrackFitter
ToolSvc += InDetTrigExtensionFitter
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigExtensionFitter
# get configured track extension processor
#-----------------------------------------------------------------------
from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import \
InDetTrigTRTDriftCircleCut
from InDetTrackScoringTools.InDetTrackScoringToolsConf import InDet__InDetAmbiScoringTool
InDetTrigExtScoringTool = InDet__InDetAmbiScoringTool(
name='InDetTrigExtScoringTool_' + type,
Extrapolator=InDetTrigExtrapolator,
SummaryTool=InDetTrigTrackSummaryTool,
useAmbigFcn=True, # this is NewTracking
#minPt = InDetTrigCutValues.minPT(), #see below
maxRPhiImp=InDetTrigCutValues.maxPrimaryImpact(),
maxZImp=InDetTrigCutValues.maxZImpact(),
maxEta=InDetTrigCutValues.maxEta(),
minSiClusters=InDetTrigCutValues.minClusters(),
maxSiHoles=InDetTrigCutValues.maxHoles(),
maxDoubleHoles=InDetTrigCutValues.maxDoubleHoles(),
usePixel=InDetTrigCutValues.usePixel(),
useSCT=InDetTrigCutValues.useSCT(),
doEmCaloSeed=False,
minTRTonTrk=InDetTrigCutValues.minTRTonTrk(),
#useSigmaChi2 = False # tuning from Thijs
DriftCircleCutTool=InDetTrigTRTDriftCircleCut,
)
InDetTrigExtScoringTool.minPt = InDetTrigSliceSettings[('pTmin', type)]
#
ToolSvc += InDetTrigExtScoringTool
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigExtScoringTool
if type == "cosmicsN":
from InDetTrigRecExample.InDetTrigConfigRecLoadToolsCosmics import InDetTrigTrackSummaryToolCosmics
from InDetTrackScoringTools.InDetTrackScoringToolsConf import InDet__InDetCosmicScoringTool
InDetTrigScoringToolCosmics_TRT= \
InDet__InDetCosmicScoringTool(name = 'InDetTrigCosmicScoringTool_TRT',
nWeightedClustersMin = 0,
minTRTHits = EFIDTrackingCutsCosmics.minTRTonTrk(),
SummaryTool= InDetTrigTrackSummaryToolCosmics
)
ToolSvc += InDetTrigScoringToolCosmics_TRT
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigScoringToolCosmics_TRT
self.TrackFitter = InDetTrigExtensionFitter
self.ScoringTool = InDet__InDetAmbiScoringTool(
'InDetTrigExtScoringTool_' + type)
self.RefitPrds = not (InDetTrigFlags.refitROT() or
(InDetTrigFlags.trtExtensionType() is 'DAF'))
self.suppressHoleSearch = False # does not work properly
if type == "cosmicsN":
self.ScoringTool = InDetTrigScoringToolCosmics_TRT
self.Cosmics = True
#Material effects
if InDetTrigFlags.materialInteractions():
self.matEffects = 3 # default in code is 4!!
else:
self.matEffects = 0
if type == "cosmicsN" and not InDetTrigFlags.solenoidOn():
self.matEffects = 0
#monitoring
from InDetTrigExtensProcessor.InDetTrigExtensProcessorMonitoring import InDetTrigExtensProcessorValidationMonitor
from InDetTrigExtensProcessor.InDetTrigExtensProcessorMonitoring import InDetTrigExtensProcessorOnlineMonitor
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
idexttime = TrigTimeHistToolConfig("IdExtTime")
idexttime.TimerHistLimits = [0, 200]
self.AthenaMonTools = [
InDetTrigExtensProcessorValidationMonitor(),
InDetTrigExtensProcessorOnlineMonitor(), idexttime
]
def __init__(self, name="TRTTrackExtAlg_Electron_EF", type="electron"):
super(InDet__TRT_TrigTrackExtensionAlg, self).__init__(name)
from AthenaCommon.AppMgr import ToolSvc
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigPatternPropagator, InDetTrigPatternUpdator
# TRT detector elements road builder
#
from TRT_DetElementsRoadTool_xk.TRT_DetElementsRoadTool_xkConf import InDet__TRT_DetElementsRoadMaker_xk
InDetTrigTRTDetElementsRoadMaker = InDet__TRT_DetElementsRoadMaker_xk(
name='InDetTrigTRTRoadMaker',
#DetectorStoreLocation = 'DetectorStore',
TRTManagerLocation='TRT',
MagneticFieldMode='MapSolenoid',
PropagatorTool=InDetTrigPatternPropagator)
ToolSvc += InDetTrigTRTDetElementsRoadMaker
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigTRTDetElementsRoadMaker
# Track extension to TRT tool
#
from AthenaCommon.DetFlags import DetFlags
if (DetFlags.haveRIO.TRT_on()):
if InDetTrigFlags.trtExtensionType() is 'xk':
from TRT_TrackExtensionTool_xk.TRT_TrackExtensionTool_xkConf import InDet__TRT_TrackExtensionTool_xk
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTRTDriftCircleCut
InDetTrigTRTExtensionTool = \
InDet__TRT_TrackExtensionTool_xk(name = 'InDetTrigTRTExtensionTool',
MagneticFieldMode = 'MapSolenoid', # default
TRT_ClustersContainer = 'TRT_TrigDriftCircles', # default
TrtManagerLocation = 'TRT', # default
PropagatorTool = InDetTrigPatternPropagator,
UpdatorTool = InDetTrigPatternUpdator,
#RIOonTrackToolYesDr = # default for now
#RIOonTrackToolNoDr = # default for now
RoadTool = InDetTrigTRTDetElementsRoadMaker,
DriftCircleCutTool = InDetTrigTRTDriftCircleCut,
MinNumberDriftCircles = EFIDTrackingCuts.minTRTonTrk(),
ScaleHitUncertainty = 2.,
RoadWidth = 20.,
UseParameterization = EFIDTrackingCuts.useParameterizedTRTCuts()
)
elif InDetTrigFlags.trtExtensionType() is 'DAF':
# load TRT Competing ROT tool
from TrkDeterministicAnnealingFilter.TrkDeterministicAnnealingFilterConf import Trk__DAF_SimpleWeightCalculator
InDetTrigWeightCalculator = Trk__DAF_SimpleWeightCalculator(
name='InDetTrigWeightCalculator')
ToolSvc += InDetTrigWeightCalculator
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigWeightCalculator
from InDetCompetingRIOsOnTrackTool.InDetCompetingRIOsOnTrackToolConf import InDet__CompetingTRT_DriftCirclesOnTrackTool
InDetTrigCompetingTRT_DC_Tool = \
InDet__CompetingTRT_DriftCirclesOnTrackTool( name = 'InDetTrigCompetingTRT_DC_Tool',
MagneticFieldMode = 'MapSolenoid', # default
PropagatorTool = InDetTrigPatternPropagator,
ToolForWeightCalculation= InDetTrigWeightCalculator,
ToolForTRT_DriftCircleOnTrackCreation = InDetTrigRotCreator.ToolTRT_DriftCircle)
ToolSvc += InDetTrigCompetingTRT_DC_Tool
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigCompetingTRT_DC_Tool
from TRT_TrackExtensionTool_DAF.TRT_TrackExtensionTool_DAFConf import InDet__TRT_TrackExtensionTool_DAF
InDetTrigTRTExtensionTool = \
InDet__TRT_TrackExtensionTool_DAF(name = 'InDetTrigTRTExtensionTool',
MagneticFieldMode = 'MapSolenoid', # default
TRT_DriftCircleContainer = 'TRT_TrigDriftCircles', # default
CompetingDriftCircleTool = InDetTrigCompetingTRT_DC_Tool,
PropagatorTool = InDetTrigPatternPropagator,
RoadTool = InDetTrigTRTDetElementsRoadMaker)
#
ToolSvc += InDetTrigTRTExtensionTool
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigTRTExtensionTool
self.TrackExtensionTool = InDetTrigTRTExtensionTool
#monitoring
from TRT_TrigTrackExtensionAlg.TRT_TrigTrackExtensionAlgMonitoring import TRT_TrigTrackExtensionAlgValidationMonitor
from TRT_TrigTrackExtensionAlg.TRT_TrigTrackExtensionAlgMonitoring import TRT_TrigTrackExtensionAlgOnlineMonitor
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
exttime = TrigTimeHistToolConfig("ExtTime")
exttime.TimerHistLimits = [0, 40]
self.AthenaMonTools = [
TRT_TrigTrackExtensionAlgValidationMonitor(),
TRT_TrigTrackExtensionAlgOnlineMonitor(), exttime
]
def __init__(self,
name="SiTrigTrackFinder_Electron_EF",
type="electron",
lowPt=False):
super(InDet__SiTrigSPSeededTrackFinder, self).__init__(name)
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigPrdAssociationTool, \
InDetTrigPatternPropagator, InDetTrigPatternUpdator, \
InDetTrigRotCreator, InDetTrigPixelConditionsSummarySvc, InDetTrigSCTConditionsSummarySvc
from AthenaCommon.AppMgr import ToolSvc
# configure tools used
# Space points seeds maker
#
from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
from AthenaCommon.DetFlags import DetFlags
if type == "beamgas":
from InDetTrigRecExample.InDetTrigConfigRecLoadToolsBeamGas import InDetTrigSiSpacePointsSeedMakerBeamGas
InDetTrigSiSpacePointsSeedMaker = InDetTrigSiSpacePointsSeedMakerBeamGas
elif type == "cosmicsN":
from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_Cosmic
InDetTrigSiSpacePointsSeedMaker = \
InDet__SiSpacePointsSeedMaker_Cosmic(name = 'InDetTrigSiSpacePointsSeedMaker_'+type,
pTmin = InDetTrigSliceSettings[('pTmin',type)],
maxdImpact = EFIDTrackingCutsCosmics.maxPrimaryImpact(),
maxZ = EFIDTrackingCutsCosmics.maxZImpact(),
minZ = -EFIDTrackingCutsCosmics.maxZImpact(),
SpacePointsPixelName = 'SCT_CosmicsTrigSpacePoints',
SpacePointsSCTName = 'PixelCosmicsTrigSpacePoints',
#SpacePointsOverlapName = InDetKeys.OverlapSpacePoints(),
UseAssociationTool = False,
AssociationTool = InDetTrigPrdAssociationTool)
elif lowPt:
from InDetTrigRecExample.InDetTrigConfigRecLoadToolsLowPt import InDetTrigSiSpacePointsSeedMakerLowPt
InDetTrigSiSpacePointsSeedMaker = InDetTrigSiSpacePointsSeedMakerLowPt
elif type == "heavyIon" or type == "heavyIonFS":
from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_HeavyIon
InDetTrigSiSpacePointsSeedMaker = \
InDet__SiSpacePointsSeedMaker_HeavyIon(name= 'InDetTrigSiSpacePointsSeedMaker_'+type,
pTmin = InDetTrigSliceSettings[('pTmin',type)],
maxdImpact = EFIDTrackingCutsHeavyIon.maxPrimaryImpact(),
maxZ = EFIDTrackingCutsHeavyIon.maxZImpact(),
minZ = -EFIDTrackingCutsHeavyIon.maxZImpact(),
#useOverlapSpCollection = False, #overlapCollections not used in EFID
useOverlapSpCollection = InDetTrigFlags.doOverlapSP(), #testing
usePixel = DetFlags.haveRIO.pixel_on(),
useSCT = DetFlags.haveRIO.SCT_on(),
SpacePointsSCTName = 'SCT_TrigSpacePoints',
SpacePointsPixelName = 'PixelTrigSpacePoints',
SpacePointsOverlapName = 'SPTrigOverlap',
radMax = EFIDTrackingCutsHeavyIon.radMax())
else:
from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_ATLxk
InDetTrigSiSpacePointsSeedMaker = \
InDet__SiSpacePointsSeedMaker_ATLxk( name = 'InDetTrigSiSpacePointsSeedMaker_'+type,
pTmin = InDetTrigSliceSettings[('pTmin',type)],
maxdImpact = InDetTrigCutValues.maxPrimaryImpact(),
maxZ = InDetTrigCutValues.maxZImpact(),
minZ = -InDetTrigCutValues.maxZImpact(),
#useOverlapSpCollection = False, #overlapCollections not used in EFID
useOverlapSpCollection = InDetTrigFlags.doOverlapSP(), #testing
usePixel = DetFlags.haveRIO.pixel_on(),
useSCT = DetFlags.haveRIO.SCT_on(),
SpacePointsSCTName = 'SCT_TrigSpacePoints',
SpacePointsPixelName = 'PixelTrigSpacePoints',
SpacePointsOverlapName = 'SPTrigOverlap',
radMax = InDetTrigCutValues.radMax(),
maxdImpactPPS = InDetTrigCutValues.maxdImpactPPSSeeds(),
maxdImpactSSS = InDetTrigCutValues.maxdImpactSSSSeeds(),
)
if type != "cosmicsN":
InDetTrigSiSpacePointsSeedMaker.maxRadius1 = 0.75 * InDetTrigCutValues.radMax(
)
InDetTrigSiSpacePointsSeedMaker.maxRadius2 = InDetTrigCutValues.radMax(
)
InDetTrigSiSpacePointsSeedMaker.maxRadius3 = InDetTrigCutValues.radMax(
)
# if type=="minBias":
# InDetTrigSiSpacePointsSeedMaker.maxdImpact=5.
ToolSvc += InDetTrigSiSpacePointsSeedMaker
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigSiSpacePointsSeedMaker
#InDetTrigSiSpacePointsSeedMaker.OutputLevel = 1
# Z-coordinates primary vertices finder
#
from SiZvertexTool_xk.SiZvertexTool_xkConf import InDet__SiZvertexMaker_xk
InDetTrigZvertexMaker = InDet__SiZvertexMaker_xk(
name='InDetTrigZvertexMaker_' + type,
Zmax=InDetTrigCutValues.maxZImpact(),
Zmin=-InDetTrigCutValues.maxZImpact(),
minRatio=0.17 # not default
)
if type == "heavyIon" or type == "heavyIonFS":
InDetTrigZvertexMaker.HistSize = 2000
InDetTrigZvertexMaker.minContent = 30
#InDetTrigZvertexMaker.SeedMakerTool = InDet__SiSpacePointsSeedMaker_ATLxk('InDetTrigSiSpacePointsSeedMaker_'+type)#to make it tool neutral
InDetTrigZvertexMaker.SeedMakerTool = ToolSvc.allConfigurables[
'InDetTrigSiSpacePointsSeedMaker_' + type]
ToolSvc += InDetTrigZvertexMaker
#InDetTrigZvertexMaker.OutputLevel=1
# SCT and Pixel detector elements road builder
#
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigSiDetElementsRoadMaker, InDetTrigSiComTrackFinder
# Local track finding using space point seed
#
from SiTrackMakerTool_xk.SiTrackMakerTool_xkConf import InDet__SiTrackMaker_xk
InDetTrigSiTrackMaker = InDet__SiTrackMaker_xk(
name='InDetTrigSiTrackMaker_' + type,
RoadTool=InDetTrigSiDetElementsRoadMaker,
CombinatorialTrackFinder=InDetTrigSiComTrackFinder,
pTmin=InDetTrigSliceSettings[('pTmin', type)],
nClustersMin=InDetTrigCutValues.minClusters(),
nHolesMax=InDetTrigCutValues.nHolesMax(),
nHolesGapMax=InDetTrigCutValues.nHolesGapMax(),
SeedsFilterLevel=InDetTrigCutValues.seedFilterLevel(),
Xi2max=InDetTrigCutValues.Xi2max(),
Xi2maxNoAdd=InDetTrigCutValues.Xi2maxNoAdd(),
nWeightedClustersMin=InDetTrigCutValues.nWeightedClustersMin(),
#CosmicTrack = InDetFlags.doCosmics(),
Xi2maxMultiTracks=InDetTrigCutValues.Xi2max(),
UseAssociationTool=False)
if type == "beamgas":
InDetTrigSiTrackMaker.pTmin = EFIDTrackingCutsBeamGas.minPT()
InDetTrigSiTrackMaker.nClustersMin = EFIDTrackingCutsBeamGas.minClusters(
)
InDetTrigSiTrackMaker.nHolesMax = EFIDTrackingCutsBeamGas.nHolesMax(
)
InDetTrigSiTrackMaker.UseAssociationTool = True #for BG and LowPt
elif type == "cosmicsN":
#create an additional for cosmics
from InDetTrigRecExample.InDetTrigConfigRecLoadToolsCosmics import InDetTrigSiDetElementsRoadMakerCosmics
InDetTrigSiTrackMaker.RoadTool = InDetTrigSiDetElementsRoadMakerCosmics
InDetTrigSiTrackMaker.nClustersMin = EFIDTrackingCutsCosmics.minClusters(
)
InDetTrigSiTrackMaker.nHolesMax = EFIDTrackingCutsCosmics.nHolesMax(
) #3 vs 7
InDetTrigSiTrackMaker.nHolesGapMax = EFIDTrackingCutsCosmics.nHolesGapMax(
) #3
InDetTrigSiTrackMaker.CosmicTrack = True
#InDetTrigSiTrackMaker.GoodSeedClusterCount = 3
elif type == 'electron' and InDetTrigFlags.doBremRecovery():
InDetTrigSiTrackMaker.useBremModel = True
ToolSvc += InDetTrigSiTrackMaker
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigSiTrackMaker
self.SeedsTool = InDetTrigSiSpacePointsSeedMaker
self.ZvertexTool = InDetTrigZvertexMaker
self.useZvertexTool = InDetTrigFlags.useZvertexTool()
if type == "beamgas" or type == "cosmicsN":
self.ZvertexTool = None
self.useZvertexTool = False
elif type == "heavyIon" or type == "heavyIonFS":
self.useZvertexTool = True
if lowPt:
from InDetTrigRecExample.InDetTrigConfigRecLoadToolsLowPt \
import InDetTrigSiSpacePointsSeedMakerLowPt,InDetTrigSiTrackMakerLowPt, InDetTrigZvertexMakerLowPt
self.TrackTool = InDetTrigSiTrackMakerLowPt
self.SeedsTool = InDetTrigSiSpacePointsSeedMakerLowPt
self.useZvertexTool = InDetTrigFlags.useZvertexTool()
self.ZvertexTool = InDetTrigZvertexMakerLowPt
else:
#self.TrackTool = InDetTrigSiTrackMaker
self.TrackTool = InDet__SiTrackMaker_xk('InDetTrigSiTrackMaker_' +
type)
self.EtaHalfWidth = InDetTrigSliceSettings[('etaHalfWidth', type)]
self.PhiHalfWidth = InDetTrigSliceSettings[('phiHalfWidth', type)]
self.doFullScan = InDetTrigSliceSettings[('doFullScan', type)]
#monitoring
from SiTrigSPSeededTrackFinder.SiTrigSPSeededTrackFinderMonitoring import \
SiTrigSPSeededTrackFinderValidationMonitor, \
SiTrigSPSeededTrackFinderOnlineMonitor
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
sitrktime = TrigTimeHistToolConfig("SiTRKTime")
sitrktime.TimerHistLimits = [0, 200]
self.AthenaMonTools = [
SiTrigSPSeededTrackFinderValidationMonitor(type=type),
SiTrigSPSeededTrackFinderOnlineMonitor(type=type), sitrktime
]
def __init__(self,
name="TrigAmbiguitySolver_Electron_EF",
type="electron",
lowPt=False):
super(InDet__InDetTrigAmbiguitySolver, self).__init__(name)
slice = type
if name.find('FTK') > -1:
slice = 'FTK'
from AthenaCommon.AppMgr import ToolSvc
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigPrdAssociationTool, \
InDetTrigTrackFitter, InDetTrigExtrapolator, InDetTrigTrackSummaryTool, \
InDetTrigTRTDriftCircleCut
# load InnerDetector TrackSelectionTool
#
from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
from InDetTrackScoringTools.InDetTrackScoringToolsConf import InDet__InDetAmbiScoringTool
#ptint
ptintcut = InDetTrigSliceSettings[('pTmin', slice)]
if slice == 'minBias':
ptintcut = 0.95 * InDetTrigSliceSettings[('pTmin', slice)]
elif slice == 'minBias400':
ptintcut = 0.95 * InDetTrigSliceSettings[('pTmin', slice)]
InDetTrigScoringTool = InDet__InDetAmbiScoringTool(
name='InDetTrigScoringTool_' + slice,
Extrapolator=InDetTrigExtrapolator,
SummaryTool=InDetTrigTrackSummaryTool,
useAmbigFcn=True, # this is NewTracking
useTRT_AmbigFcn=False,
#to have a steeper turn-n curve
minPt=ptintcut,
maxRPhiImp=InDetTrigCutValues.maxPrimaryImpact(),
maxZImp=InDetTrigCutValues.maxZImpact(),
maxEta=InDetTrigCutValues.maxEta(),
minSiClusters=InDetTrigCutValues.minClusters(),
maxSiHoles=InDetTrigCutValues.maxHoles(),
maxPixelHoles=InDetTrigCutValues.maxPixelHoles(),
maxSCTHoles=InDetTrigCutValues.maxSCTHoles(),
maxDoubleHoles=InDetTrigCutValues.maxDoubleHoles(),
usePixel=InDetTrigCutValues.usePixel(),
useSCT=InDetTrigCutValues.useSCT(),
minTRTonTrk=0, # no TRT here
DriftCircleCutTool=InDetTrigTRTDriftCircleCut,
doEmCaloSeed=False,
#BeamPositionSvc = default instance ,
)
if slice == 'beamgas':
InDetTrigScoringTool.minPt = EFIDTrackingCutsBeamGas.minPT()
InDetTrigScoringTool.maxRPhiImp = EFIDTrackingCutsBeamGas.maxPrimaryImpact(
)
InDetTrigScoringTool.maxZImp = EFIDTrackingCutsBeamGas.maxZImpact()
InDetTrigScoringTool.minSiClusters = EFIDTrackingCutsBeamGas.minClusters(
)
InDetTrigScoringTool.maxSiHoles = EFIDTrackingCutsBeamGas.maxHoles(
)
InDetTrigScoringTool.useTRT_AmbigFcn = False
InDetTrigScoringTool.useSigmaChi2 = True
if slice == 'FTK' or slice == 'FTKRefit' or slice == 'FTKMon':
InDetTrigScoringTool.minSiClusters = FTKTrackingCuts.minClusters()
InDetTrigScoringTool.maxSiHoles = FTKTrackingCuts.maxHoles()
InDetTrigScoringTool.maxPixelHoles = FTKTrackingCuts.maxPixelHoles(
)
InDetTrigScoringTool.maxSCTHoles = FTKTrackingCuts.maxSCTHoles()
InDetTrigScoringTool.maxDoubleHoles = FTKTrackingCuts.maxDoubleHoles(
)
#
ToolSvc += InDetTrigScoringTool
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigScoringTool
# load Ambiguity Processor
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import \
InDetTrigAmbiTrackSelectionTool
from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__SimpleAmbiguityProcessorTool
InDetTrigAmbiguityProcessor = \
Trk__SimpleAmbiguityProcessorTool(name = 'InDetTrigAmbiguityProcessor_'+slice,
#AssoTool = InDetTrigPrdAssociationTool,
Fitter = InDetTrigTrackFitter,
SelectionTool = InDetTrigAmbiTrackSelectionTool,
RefitPrds = not InDetTrigFlags.refitROT()
)
InDetTrigAmbiguityProcessor.ScoringTool = InDet__InDetAmbiScoringTool(
'InDetTrigScoringTool_' + slice)
if slice == 'beamgas':
from InDetTrigRecExample.InDetTrigConfigRecLoadToolsBeamGas import \
InDetTrigAmbiTrackSelectionToolBeamGas
InDetTrigAmbiguityProcessor.SelectionTool = InDetTrigAmbiTrackSelectionToolBeamGas
elif slice == 'cosmicsN':
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTrackFitterCosmics
from InDetTrigRecExample.InDetTrigConfigRecLoadToolsCosmics \
import InDetTrigScoringToolCosmics_SiPattern, InDetTrigAmbiTrackSelectionToolCosmicsN
InDetTrigAmbiguityProcessor.Fitter = InDetTrigTrackFitterCosmics
InDetTrigAmbiguityProcessor.SuppressHoleSearch = False
InDetTrigAmbiguityProcessor.SelectionTool = InDetTrigAmbiTrackSelectionToolCosmicsN
InDetTrigAmbiguityProcessor.ScoringTool = InDetTrigScoringToolCosmics_SiPattern
#InDetTrigAmbiguityProcessor.SuppressTrackFit = True
#InDetTrigAmbiguityProcessor.ForceRefit = False
InDetTrigAmbiguityProcessor.RefitPrds = False
elif slice == 'electron' and InDetTrigFlags.doBremRecovery():
InDetTrigAmbiguityProcessor.tryBremFit = True
import AthenaCommon.SystemOfUnits as Units
InDetTrigAmbiguityProcessor.pTminBrem = 5 * Units.GeV
elif slice == 'FTK' or slice == 'FTKRefit' or slice == 'FTKMon':
from TrigInDetConf.TrigInDetRecToolsFTK import InDetTrigAmbiTrackSelectionToolFTK, InDetTrigTrackFitterFTK
InDetTrigAmbiguityProcessor.SelectionTool = InDetTrigAmbiTrackSelectionToolFTK
InDetTrigAmbiguityProcessor.Fitter = InDetTrigTrackFitterFTK
#InDetTrigAmbiguityProcessor.RefitPrds =
if InDetTrigFlags.materialInteractions() and InDetTrigFlags.solenoidOn(
):
InDetTrigAmbiguityProcessor.MatEffects = 3
else:
InDetTrigAmbiguityProcessor.MatEffects = 0
ToolSvc += InDetTrigAmbiguityProcessor
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigAmbiguityProcessor
self.AmbiguityProcessor = InDetTrigAmbiguityProcessor
if lowPt:
from InDetTrigRecExample.InDetTrigConfigRecLoadToolsLowPt import InDetTrigAmbiguityProcessorLowPt
self.AmbiguityProcessor = InDetTrigAmbiguityProcessorLowPt
self.OutputTracksLabel = "AmbigSolvLowPt"
#use either SPSeeded or FTF tracks
self.InputTracksLabel = ""
#FIX
#InDetTrigExtrapolator.ApplyMaterialEffects = False
#monitoring
from InDetTrigAmbiguitySolver.InDetTrigAmbiguitySolverMonitoring import InDetTrigAmbiguitySolverValidationMonitor
from InDetTrigAmbiguitySolver.InDetTrigAmbiguitySolverMonitoring import InDetTrigAmbiguitySolverOnlineMonitor
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
ambtime = TrigTimeHistToolConfig("AmbTime")
ambtime.TimerHistLimits = [0, 100]
if InDetTrigSliceSettings[('doFullScan', slice)]:
ambtime.TimerHistLimits = [0, 500]
self.AthenaMonTools = [
InDetTrigAmbiguitySolverValidationMonitor(),
InDetTrigAmbiguitySolverOnlineMonitor(), ambtime
]
def __init__(self, name="SCTClustering_Electron_EF", type="electron"):
super(InDet__SCT_TrgClusterization, self).__init__(name)
from AthenaCommon.AppMgr import ToolSvc
from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from SCT_ConditionsTools.SCT_ConditionsToolsConf import SCT_ByteStreamErrorsTool
from InDetTrigRecExample.InDetTrigConditionsAccess import SCT_ConditionsSetup
InDetTrigBSErrorTool = SCT_ByteStreamErrorsTool(
name=SCT_ConditionsSetup.instanceName(
"InDetSCT_ByteStreamErrorsTool"))
from SCT_RawDataByteStreamCnv.SCT_RawDataByteStreamCnvConf import SCT_RodDecoder
InDetTrigSCTRodDecoder = SCT_RodDecoder(name="InDetTrigSCTRodDecoder")
ToolSvc += InDetTrigSCTRodDecoder
if (InDetTrigFlags.doPrintConfigurables()):
print(InDetTrigSCTRodDecoder)
from SCT_RawDataByteStreamCnv.SCT_RawDataByteStreamCnvConf import SCTRawDataProviderTool
from InDetTrigRecExample.InDetTrigConditionsAccess import SCT_ConditionsSetup
InDetTrigSCTRawDataProviderTool = SCTRawDataProviderTool(
name="InDetTrigSCTRawDataProviderTool",
Decoder=InDetTrigSCTRodDecoder)
ToolSvc += InDetTrigSCTRawDataProviderTool
from InDetTrigRawDataProvider.InDetTrigRawDataProviderConf import InDet__TrigSCTRawDataProvider
InDetTrigSCTRawDataProvider = \
InDet__TrigSCTRawDataProvider(name="TrigSCTRawDataProvider_EF",
RDOKey = EF_SCTRDOKey,
RawDataTool = InDetTrigSCTRawDataProviderTool)
ToolSvc += InDetTrigSCTRawDataProvider
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigClusterMakerTool
from SCT_ConditionsTools.SCT_ConditionsToolsConf import SCT_ConditionsSummaryTool
self.conditionsSummaryTool = SCT_ConditionsSummaryTool(
SCT_ConditionsSetup.instanceName(
'InDetSCT_ConditionsSummaryToolWithoutFlagged'))
# SCT_ClusteringTool (public)
from SiClusterizationTool.SiClusterizationToolConf import InDet__SCT_ClusteringTool
InDetTrigSCT_ClusteringTool = \
InDet__SCT_ClusteringTool(name = "InDetTrigSCT_ClusteringTool",
globalPosAlg = InDetTrigClusterMakerTool,
conditionsTool = self.conditionsSummaryTool
)
if InDetTrigFlags.doSCTIntimeHits():
if InDetTrigFlags.InDet25nsec():
InDetTrigSCT_ClusteringTool.timeBins = "01X"
else:
InDetTrigSCT_ClusteringTool.timeBins = "X1X"
ToolSvc += InDetTrigSCT_ClusteringTool
self.RawDataProvider = InDetTrigSCTRawDataProvider
self.clusteringTool = InDetTrigSCT_ClusteringTool
self.SCT_RDOContainerName = EF_SCTRDOKey
from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
self.EtaHalfWidth = InDetTrigSliceSettings[('etaHalfWidth', type)]
self.PhiHalfWidth = InDetTrigSliceSettings[('phiHalfWidth', type)]
self.doFullScan = InDetTrigSliceSettings[('doFullScan', type)]
if InDetTrigFlags.cutSCTOccupancy():
self.maxRDOs = 384 #used to be 77 but it was reached quite frequently
#monitoring
from InDetTrigPrepRawDataFormat.InDetTrigPrepRawDataFormatMonitoring import SctTrigPrepRawDataFormatValidationMonitor
from InDetTrigPrepRawDataFormat.InDetTrigPrepRawDataFormatMonitoring import SctTrigPrepRawDataFormatOnlineMonitor
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
scttime = TrigTimeHistToolConfig("SctTime")
scttime.TimerHistLimits = [0, 100]
self.AthenaMonTools = [
SctTrigPrepRawDataFormatValidationMonitor(type=type),
SctTrigPrepRawDataFormatOnlineMonitor(type=type), scttime
]
def __init__(self,
name="InDetTrigTRT_TrackSegmentsFinder_Photon_EF",
type="photon",
seqType="InsideOut"):
super(InDet__TRT_TrigTrackSegmentsFinder, self).__init__(name)
from AthenaCommon.AppMgr import ToolSvc
from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigPrdAssociationTool, InDetTrigPatternPropagator, InDetTrigPatternUpdator, InDetTrigTRTDriftCircleCut
from InDetTrigRecExample.InDetTrigConfigRecLoadToolsBack import InDetTrigTRTDetElementsRoadMaker
from AthenaCommon.SystemOfUnits import GeV
if seqType == "TRTOnly":
from InDetTrigRecExample.ConfiguredNewTrackingTrigCuts import EFIDTrackingCutsTRT
InDetTrigCutValues = EFIDTrackingCutsTRT
suffixTRT = "_TRTOnly"
else:
from InDetTrigRecExample.ConfiguredNewTrackingTrigCuts import EFIDTrackingCuts
InDetTrigCutValues = EFIDTrackingCuts
suffixTRT = ""
# Track extension to TRT tool
# if new tracking is OFF then xk extension type (no DAF) has to be used!!
from TRT_TrackExtensionTool_xk.TRT_TrackExtensionTool_xkConf import InDet__TRT_TrackExtensionTool_xk
InDetTrigTRTExtensionTool = InDet__TRT_TrackExtensionTool_xk(
name='InDetTrigTRTExtensionTool' + suffixTRT,
MagneticFieldMode='MapSolenoid', # default
TRT_ClustersContainer='TRT_TrigDriftCircles', # default
TrtManagerLocation='TRT', # default
PropagatorTool=InDetTrigPatternPropagator,
UpdatorTool=InDetTrigPatternUpdator,
DriftCircleCutTool=InDetTrigTRTDriftCircleCut,
UseDriftRadius=not InDetTrigFlags.noTRTTiming(),
RoadTool=InDetTrigTRTDetElementsRoadMaker,
MinNumberDriftCircles=InDetTrigCutValues.minTRTonTrk(),
ScaleHitUncertainty=2.,
RoadWidth=20.,
UseParameterization=InDetTrigCutValues.useParameterizedTRTCuts())
ToolSvc += InDetTrigTRTExtensionTool
if (InDetTrigFlags.doPrintConfigurables()):
print(InDetTrigTRTExtensionTool)
if seqType == "TRTOnly":
# segment finding
MinNumberDCs = InDetTrigCutValues.minTRTonly()
else:
# back tracking has softer cuts
MinNumberDCs = InDetTrigCutValues.minSecondaryTRTonTrk()
# TRT seed maker
from TRT_TrackSegmentsTool_xk.TRT_TrackSegmentsTool_xkConf import InDet__TRT_TrackSegmentsMaker_ATLxk
InDetTrigTRT_TrackSegmentsMaker = InDet__TRT_TrackSegmentsMaker_ATLxk(
name='InDetTrigTRT_TrackSegmentsMaker_' + type + suffixTRT,
TrtManagerLocation='TRT',
TRT_ClustersContainer='TRT_TrigDriftCircles',
MagneticFieldMode='MapSolenoid',
#OutputLevel = 1,
PropagatorTool=InDetTrigPatternPropagator,
PRDtoTrackMap="",
TrackExtensionTool=InDetTrigTRTExtensionTool,
MinNumberDriftCircles=MinNumberDCs,
RemoveNoiseDriftCircles=InDetTrigFlags.removeTRTNoise())
InDetTrigTRT_TrackSegmentsMaker.pTmin = InDetTrigSliceSettings[(
'pTmin', type)]
if type == 'photon':
InDetTrigTRT_TrackSegmentsMaker.PRDtoTrackMap = 'InDetTrigPRDtoTrackMap_Photon_EF'
elif type == 'cosmicsN':
from TRT_TrackSegmentsTool_xk.TRT_TrackSegmentsTool_xkConf import InDet__TRT_TrackSegmentsMaker_BarrelCosmics
#TODO COSMICS - replace old CTB TrackSegmentsMaker
InDetTrigTRT_TrackSegmentsMaker_CTB = \
InDet__TRT_TrackSegmentsMaker_BarrelCosmics(name= 'InDetTrigTRT_TrackSegmentsMaker_CTB',
TrtManagerLocation = 'TRT' ,
TRT_ClustersContainer = 'TRT_TrigDriftCircles',
#MagneticField = InDetTrigFlags.solenoidOn(),
#TRTResolution = 99.0,
#DriftCircleCut = 4.0,
#TRTHitsOnTrack = 20,
#UseDriftTime = False,
)
ToolSvc += InDetTrigTRT_TrackSegmentsMaker_CTB
if (InDetTrigFlags.doPrintConfigurables()):
print(InDetTrigTRT_TrackSegmentsMaker_CTB)
ToolSvc += InDetTrigTRT_TrackSegmentsMaker
if (InDetTrigFlags.doPrintConfigurables()):
print(InDetTrigTRT_TrackSegmentsMaker)
# TRT track reconstruction
self.SegmentsMakerTool = InDetTrigTRT_TrackSegmentsMaker
# if type is 'cosmicsN':
# self.SegmentsMakerTool = InDetTrigTRT_TrackSegmentsMaker_CTB
self.EtaHalfWidth = InDetTrigSliceSettings[('etaHalfWidth', type)]
self.PhiHalfWidth = InDetTrigSliceSettings[('phiHalfWidth', type)]
self.doFullScan = InDetTrigSliceSettings[('doFullScan', type)]
#monitoring
from TRT_TrigTrackSegmentsFinder.TRT_TrigTrackSegmentsFinderMonitoring import TRT_TrigTrackSegmentsFinderValidationMonitor
from TRT_TrigTrackSegmentsFinder.TRT_TrigTrackSegmentsFinderMonitoring import TRT_TrigTrackSegmentsFinderOnlineMonitor
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
segtime = TrigTimeHistToolConfig("SegTime")
segtime.TimerHistLimits = [0, 100]
if self.doFullScan:
segtime.TimerHistLimits = [0, 1000]
self.AthenaMonTools = [
TRT_TrigTrackSegmentsFinderValidationMonitor(),
TRT_TrigTrackSegmentsFinderOnlineMonitor(), segtime
]
def __init__(self,
name="InDetTrigTRT_StandaloneTrackFinder_Photon_EF",
type="photon",
seqType="InsideOut"):
super(InDet__TRT_TrigStandaloneTrackFinder, self).__init__(name)
from AthenaCommon.AppMgr import ToolSvc
from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTrackSummaryTool, InDetTrigTrackFitterTRT, InDetTrigExtrapolator, InDetTrigPrdAssociationTool, InDetTrigTRTDriftCircleCut
from AthenaCommon.SystemOfUnits import GeV
if seqType == "TRTOnly":
from InDetTrigRecExample.ConfiguredNewTrackingTrigCuts import EFIDTrackingCutsTRT
InDetTrigCutValues = EFIDTrackingCutsTRT
suffixTRT = "_TRTOnly"
prd_to_track_map = "" # no external PRD to track association, the PRD to track associations
# are only computed from TRT standalone tracks
else:
from InDetTrigRecExample.ConfiguredNewTrackingTrigCuts import EFIDTrackingCuts
InDetTrigCutValues = EFIDTrackingCuts
suffixTRT = ""
prd_to_track_map = "" # no external PRD to track association, the PRD to track associations
# are only computed from TRT standalone tracks
#
# set up special Scoring Tool for standalone TRT tracks
#
from InDetTrackScoringTools.InDetTrackScoringToolsConf import InDet__InDetTrtTrackScoringTool
InDetTrigTRT_StandaloneScoringTool = InDet__InDetTrtTrackScoringTool(
name='InDetTrigTRT_StandaloneScoringTool_' + type + suffixTRT,
SummaryTool=InDetTrigTrackSummaryTool,
DriftCircleCutTool=InDetTrigTRTDriftCircleCut,
useAmbigFcn=True,
useSigmaChi2=False,
PtMin=InDetTrigSliceSettings[('pTmin', type)],
minTRTonTrk=InDetTrigCutValues.minTRTonly(),
maxEta=2.1)
ToolSvc += InDetTrigTRT_StandaloneScoringTool
if (InDetTrigFlags.doPrintConfigurables()):
print(InDetTrigTRT_StandaloneScoringTool)
# import InDetRecExample.TrackingCommon as TrackingCommon
# asso_tool = TrackingCommon.getInDetTrigPRDtoTrackMapToolGangedPixels()
prefix = 'InDet'
suffix = ''
#
# set up TRT_SegmentToTrackTool
#
from TRT_SegmentToTrackTool.TRT_SegmentToTrackToolConf import InDet__TRT_SegmentToTrackTool
InDetTrigTRT_SegmentToTrackTool = InDet__TRT_SegmentToTrackTool(name = 'InDetTrigTRT_SegmentToTrackTool_'+type+suffixTRT,
RefitterTool = InDetTrigTrackFitterTRT,
Extrapolator = InDetTrigExtrapolator,
PRDtoTrackMap = prefix+'PRDtoTrackMap'+suffix \
if seqType != "InsideOutAndTRTOnly" else "",
TrackSummaryTool = InDetTrigTrackSummaryTool,
ScoringTool = InDetTrigTRT_StandaloneScoringTool,
FinalRefit = True,
SuppressHoleSearch = True,
MaxSharedHitsFraction = InDetTrigCutValues.maxTRTonlyShared()
)
ToolSvc += InDetTrigTRT_SegmentToTrackTool
if (InDetTrigFlags.doPrintConfigurables()):
print(InDetTrigTRT_SegmentToTrackTool)
self.TRT_SegToTrackTool = InDetTrigTRT_SegmentToTrackTool
self.MinNumDriftCircles = InDetTrigCutValues.minTRTonly()
self.PRDtoTrackMap = prd_to_track_map
self.MaterialEffects = 0
#monitoring
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
standtime = TrigTimeHistToolConfig("StandTime")
standtime.TimerHistLimits = [0, 100]
if InDetTrigSliceSettings[('doFullScan', type)]:
standtime.TimerHistLimits = [0, 1000]
from TRT_TrigStandaloneTrackFinder.TRT_TrigStandaloneTrackFinderMonitoring import TRT_TrigStandaloneTrackFinderValidationMonitor
from TRT_TrigStandaloneTrackFinder.TRT_TrigStandaloneTrackFinderMonitoring import TRT_TrigStandaloneTrackFinderOnlineMonitor
self.AthenaMonTools = [
TRT_TrigStandaloneTrackFinderValidationMonitor(),
TRT_TrigStandaloneTrackFinderOnlineMonitor(), standtime
]
def __init__(self,
name="TRTSeededTrigAmbiguitySolver_Electron_EF",
type="electron"):
super(InDet__InDetTrigAmbiguitySolver, self).__init__(name)
from AthenaCommon.AppMgr import ToolSvc
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigPrdAssociationTool, InDetTrigTrackFitter, InDetTrigExtrapolator, InDetTrigTrackSummaryTool, InDetTrigTRTDriftCircleCut
from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
from InDetTrigRecExample.ConfiguredNewTrackingTrigCuts import EFIDTrackingCuts
InDetTrigCutValues = EFIDTrackingCuts
# load InnerDetector TrackSelectionTool
#
from InDetAmbiTrackSelectionTool.InDetAmbiTrackSelectionToolConf import InDet__InDetAmbiTrackSelectionTool
TRTSeededInDetTrigAmbiTrackSelectionTool = InDet__InDetAmbiTrackSelectionTool(
name='TRTSeededInDetTrigAmbiTrackSelectionTool',
DriftCircleCutTool=InDetTrigTRTDriftCircleCut,
AssociationTool=TrackingCommon.
getInDetTrigPRDtoTrackMapToolGangedPixels(),
minScoreShareTracks=-1., # off !
minHits=InDetTrigCutValues.minSecondaryClusters(),
minNotShared=InDetTrigCutValues.minSecondarySiNotShared(),
maxShared=InDetTrigCutValues.maxSecondaryShared(),
minTRTHits=InDetTrigCutValues.minSecondaryTRTonTrk(),
UseParameterization=InDetTrigCutValues.useParameterizedTRTCuts())
ToolSvc += TRTSeededInDetTrigAmbiTrackSelectionTool
if (InDetTrigFlags.doPrintConfigurables()):
print(TRTSeededInDetTrigAmbiTrackSelectionTool)
from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
from InDetTrackScoringTools.InDetTrackScoringToolsConf import InDet__InDetAmbiScoringTool
TRTSeededInDetTrigScoringTool = InDet__InDetAmbiScoringTool(
name='TRTSeededInDetTrigScoringTool_' + type,
Extrapolator=InDetTrigExtrapolator,
DriftCircleCutTool=InDetTrigTRTDriftCircleCut,
SummaryTool=InDetTrigTrackSummaryTool,
useTRT_AmbigFcn=True,
useAmbigFcn=False,
maxRPhiImp=InDetTrigCutValues.maxSecondaryImpact(),
maxZImp=InDetTrigCutValues.maxZImpact(),
maxEta=InDetTrigCutValues.maxEta(),
minSiClusters=InDetTrigCutValues.minSecondaryClusters(),
maxSiHoles=InDetTrigCutValues.maxSecondaryHoles(),
maxPixelHoles=InDetTrigCutValues.maxSecondaryPixelHoles(),
maxSCTHoles=InDetTrigCutValues.maxSecondarySCTHoles(),
maxDoubleHoles=InDetTrigCutValues.maxSecondaryDoubleHoles(),
usePixel=InDetTrigCutValues.usePixel(),
useSCT=InDetTrigCutValues.useSCT(),
minTRTonTrk=InDetTrigCutValues.minSecondaryTRTonTrk(),
doEmCaloSeed=False,
#useSigmaChi2 = False
)
TRTSeededInDetTrigScoringTool.minPt = InDetTrigSliceSettings[('pTmin',
type)]
#
ToolSvc += TRTSeededInDetTrigScoringTool
if (InDetTrigFlags.doPrintConfigurables()):
print(TRTSeededInDetTrigScoringTool)
# load Ambiguity Processor
#
from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__SimpleAmbiguityProcessorTool
TRTSeededInDetTrigAmbiguityProcessor = Trk__SimpleAmbiguityProcessorTool(
name='TRTSeededInDetTrigAmbiguityProcessor',
Fitter=InDetTrigTrackFitter,
AssociationTool=TrackingCommon.
getInDetTrigPRDtoTrackMapToolGangedPixels(),
TrackSummaryTool=InDetTrigTrackSummaryTool,
SelectionTool=TRTSeededInDetTrigAmbiTrackSelectionTool,
RefitPrds=not InDetTrigFlags.refitROT(),
SuppressTrackFit=False,
SuppressHoleSearch=False,
ScoringTool=TRTSeededInDetTrigScoringTool)
if InDetTrigFlags.materialInteractions():
TRTSeededInDetTrigAmbiguityProcessor.MatEffects = InDetTrigFlags.materialInteractionsType(
)
else:
TRTSeededInDetTrigAmbiguityProcessor.MatEffects = 0
ToolSvc += TRTSeededInDetTrigAmbiguityProcessor
if (InDetTrigFlags.doPrintConfigurables()):
print(TRTSeededInDetTrigAmbiguityProcessor)
self.AmbiguityProcessor = TRTSeededInDetTrigAmbiguityProcessor
self.InputTracksLabel = 'TRTSeededTracks'
self.OutputTracksLabel = 'TRTSeededAmbigSolv'
#monitoring
from InDetTrigAmbiguitySolver.InDetTrigAmbiguitySolverMonitoring import InDetTrigAmbiguitySolverValidationMonitor
from InDetTrigAmbiguitySolver.InDetTrigAmbiguitySolverMonitoring import InDetTrigAmbiguitySolverOnlineMonitor
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
ambtime = TrigTimeHistToolConfig("AmbTime")
ambtime.TimerHistLimits = [0, 200]
self.AthenaMonTools = [
InDetTrigAmbiguitySolverValidationMonitor(),
InDetTrigAmbiguitySolverOnlineMonitor(), ambtime
]
def __init__(self,
name="InDetTrigTRT_SeededTrackFinder_Photon_EF",
type="photon"):
super(InDet__TRT_TrigSeededTrackFinder, self).__init__(name)
from AthenaCommon.AppMgr import ToolSvc
from InDetTrigRecExample.ConfiguredNewTrackingTrigCuts import EFIDTrackingCuts
InDetTrigCutValues = EFIDTrackingCuts
from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigPrdAssociationTool, InDetTrigPatternPropagator, InDetTrigPatternUpdator, InDetTrigRotCreator, InDetTrigExtrapolator, InDetTrigTrackFitter, InDetTrigSCTConditionsSummaryTool
if InDetTrigFlags.loadTRTSeededSPFinder():
# configure tools used
# TRT seeded space points seed maker
#
from TRT_SeededSpacePointFinderTool.TRT_SeededSpacePointFinderToolConf import InDet__TRT_SeededSpacePointFinder_ATL
InDetTrigTRT_SeededSpacePointFinder = InDet__TRT_SeededSpacePointFinder_ATL(
name='InDetTrigTRT_SeededSpFinder_' + type,
SpacePointsSCTName="SCT_TrigSpacePoints",
#SpacePointsOverlapName = None ,
PRDtoTrackMap="",
NeighborSearch=True,
LoadFull=False,
#DoCosmics
)
if type == 'photon':
InDetTrigTRT_SeededSpacePointFinder.PRDtoTrackMap = 'InDetTrigPRDtoTrackMap_Photon_EF'
elif InDetTrigFlags.loadSimpleTRTSeededSPFinder():
from RegionSelector.RegSelSvcDefault import RegSelSvcDefault
InDetTrigRegSelSvc = RegSelSvcDefault()
InDetTrigRegSelSvc.enablePixel = DetFlags.pixel_on()
InDetTrigRegSelSvc.enableSCT = DetFlags.SCT_on()
ServiceMgr += InDetTrigRegSelSvc
if (InDetTrigFlags.doPrintConfigurables()):
print(InDetTrigRegSelSvc)
from TRT_SeededSpacePointFinderTool.TRT_SeededSpacePointFinderToolConf import InDet__SimpleTRT_SeededSpacePointFinder_ATL
InDetTrigTRT_SeededSpacePointFinder = InDet__SimpleTRT_SeededSpacePointFinder_ATL(
name='InDetTrigTRT_SeededSpFinder_' + type,
SpacePointsSCTName="SCT_TrigSpacePoints",
#SpacePointsOverlapName = None,
PerigeeCut=1000.,
DirectionPhiCut=.3,
DirectionEtaCut=1.,
MaxHoles=2,
PRDtoTrackMap="",
RestrictROI=True)
if type == 'photon':
InDetTrigTRT_SeededSpacePointFinder.PRDtoTrackMap = 'InDetTrigPRDtoTrackMap_Photon_EF' # @TODO correct ?
ToolSvc += InDetTrigTRT_SeededSpacePointFinder
if (InDetTrigFlags.doPrintConfigurables()):
print(InDetTrigTRT_SeededSpacePointFinder)
# Silicon det elements road maker tool
#
from SiDetElementsRoadTool_xk.SiDetElementsRoadTool_xkConf import InDet__SiDetElementsRoadMaker_xk
InDetTrigTRT_SeededSiRoadMaker = InDet__SiDetElementsRoadMaker_xk(
name='InDetTrigTRT_SeededSiRoad',
PropagatorTool=InDetTrigPatternPropagator,
PixManagerLocation="Pixel",
SCTManagerLocation="SCT",
RoadWidth=35.,
MaxStep=20.)
ToolSvc += InDetTrigTRT_SeededSiRoadMaker
if (InDetTrigFlags.doPrintConfigurables()):
print(InDetTrigTRT_SeededSiRoadMaker)
# Local combinatorial track finding using space point seed and detector element road
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigSiComTrackFinder
# uncomment the following only if modification to the previously defined InDetTrigSiComTrackFinder are needed
# and also change the name of the instance
#
# if (DetFlags.haveRIO.SCT_on()):
# InDetTrigSiComTrackFinder.SctSummaryTool = InDetTrigSCTConditionsSummaryTool
# else:
# InDetTrigSiComTrackFinder.SctSummaryTool = None
# ToolSvc += InDetTrigSiComTrackFinder
# if (InDetTrigFlags.doPrintConfigurables()):
# print (InDetTrigSiComTrackFinder)
# TRT seeded back tracking tool
#
from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
from TRT_SeededTrackFinderTool.TRT_SeededTrackFinderToolConf import InDet__TRT_SeededTrackFinder_ATL
InDetTrigTRT_SeededTrackTool = InDet__TRT_SeededTrackFinder_ATL(
name='InDetTrigTRT_SeededTrackTool_' + type,
PropagatorTool=InDetTrigPatternPropagator,
UpdatorTool=InDetTrigPatternUpdator,
RoadTool=InDetTrigTRT_SeededSiRoadMaker,
SeedTool=InDetTrigTRT_SeededSpacePointFinder,
CombinatorialTrackFinder=InDetTrigSiComTrackFinder,
nHolesMax=InDetTrigCutValues.SecondarynHolesMax(),
nHolesGapMax=2 * InDetTrigCutValues.SecondarynHolesGapMax(),
Xi2max=InDetTrigCutValues.SecondaryXi2max(),
Xi2maxNoAdd=InDetTrigCutValues.SecondaryXi2maxNoAdd(),
ConsistentSeeds=True,
BremCorrection=False)
InDetTrigTRT_SeededTrackTool.pTmin = InDetTrigSliceSettings[('pTmin',
type)]
ToolSvc += InDetTrigTRT_SeededTrackTool
if (InDetTrigFlags.doPrintConfigurables()):
print(InDetTrigTRT_SeededTrackTool)
self.RefitterTool = InDetTrigTrackFitter
self.TrackTool = InDetTrigTRT_SeededTrackTool
self.TrackExtensionTool = ToolSvc.InDetTrigTRTExtensionTool
self.TrtExtension = True
self.FinalRefit = False
self.OutputSegments = False
self.EtaHalfWidth = InDetTrigSliceSettings[('etaHalfWidth', type)]
self.PhiHalfWidth = InDetTrigSliceSettings[('phiHalfWidth', type)]
self.doFullScan = InDetTrigSliceSettings[('doFullScan', type)]
#monitoring
from TRT_TrigSeededTrackFinder.TRT_TrigSeededTrackFinderMonitoring import TRT_TrigSeededTrackFinderValidationMonitor
from TRT_TrigSeededTrackFinder.TRT_TrigSeededTrackFinderMonitoring import TRT_TrigSeededTrackFinderOnlineMonitor
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
seedtime = TrigTimeHistToolConfig("SeedTime")
seedtime.TimerHistLimits = [0, 80]
self.AthenaMonTools = [
TRT_TrigSeededTrackFinderValidationMonitor(),
TRT_TrigSeededTrackFinderOnlineMonitor(), seedtime
]
def __init__(self,
name="InDetTrigTRT_StandaloneTrackFinder_Photon_EF",
type="photon",
seqType="InsideOut"):
super(InDet__TRT_TrigStandaloneTrackFinder, self).__init__(name)
from AthenaCommon.AppMgr import ToolSvc
from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTrackSummaryTool, InDetTrigTrackFitterTRT, InDetTrigExtrapolator, InDetTrigPrdAssociationTool, InDetTrigTRTDriftCircleCut
from AthenaCommon.SystemOfUnits import GeV
if seqType is "TRTOnly":
from InDetTrigRecExample.ConfiguredNewTrackingTrigCuts import EFIDTrackingCutsTRT
InDetTrigCutValues = EFIDTrackingCutsTRT
suffixTRT = "_TRTOnly"
resetPRD = True
else:
from InDetTrigRecExample.ConfiguredNewTrackingTrigCuts import EFIDTrackingCuts
InDetTrigCutValues = EFIDTrackingCuts
suffixTRT = ""
resetPRD = True
#
# set up special Scoring Tool for standalone TRT tracks
#
from InDetTrackScoringTools.InDetTrackScoringToolsConf import InDet__InDetTrtTrackScoringTool
InDetTrigTRT_StandaloneScoringTool = InDet__InDetTrtTrackScoringTool(
name='InDetTrigTRT_StandaloneScoringTool_' + type + suffixTRT,
SummaryTool=InDetTrigTrackSummaryTool,
DriftCircleCutTool=InDetTrigTRTDriftCircleCut,
useAmbigFcn=True,
useSigmaChi2=False,
PtMin=InDetTrigSliceSettings[('pTmin', type)],
minTRTonTrk=InDetTrigCutValues.minTRTonly(),
maxEta=2.1)
ToolSvc += InDetTrigTRT_StandaloneScoringTool
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigTRT_StandaloneScoringTool
#
# set up TRT_SegmentToTrackTool
#
from TRT_SegmentToTrackTool.TRT_SegmentToTrackToolConf import InDet__TRT_SegmentToTrackTool
InDetTrigTRT_SegmentToTrackTool = InDet__TRT_SegmentToTrackTool(
name='InDetTrigTRT_SegmentToTrackTool_' + type + suffixTRT,
RefitterTool=InDetTrigTrackFitterTRT,
Extrapolator=InDetTrigExtrapolator,
AssociationTool=InDetTrigPrdAssociationTool,
ScoringTool=InDetTrigTRT_StandaloneScoringTool,
FinalRefit=True,
UseAssociationTool=True,
SuppressHoleSearch=True,
MaxSharedHitsFraction=InDetTrigCutValues.maxTRTonlyShared())
if seqType is "InsideOutAndTRTOnly":
InDetTrigTRT_SegmentToTrackTool.AssociationTool = None
InDetTrigTRT_SegmentToTrackTool.UseAssociationTool = False
ToolSvc += InDetTrigTRT_SegmentToTrackTool
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigTRT_SegmentToTrackTool
self.TRT_SegToTrackTool = InDetTrigTRT_SegmentToTrackTool
self.MinNumDriftCircles = InDetTrigCutValues.minTRTonly()
self.ResetPRD = resetPRD
self.MaterialEffects = 0
#monitoring
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
standtime = TrigTimeHistToolConfig("StandTime")
standtime.TimerHistLimits = [0, 100]
if InDetTrigSliceSettings[('doFullScan', type)]:
standtime.TimerHistLimits = [0, 1000]
from TRT_TrigStandaloneTrackFinder.TRT_TrigStandaloneTrackFinderMonitoring import TRT_TrigStandaloneTrackFinderValidationMonitor
from TRT_TrigStandaloneTrackFinder.TRT_TrigStandaloneTrackFinderMonitoring import TRT_TrigStandaloneTrackFinderOnlineMonitor
self.AthenaMonTools = [
TRT_TrigStandaloneTrackFinderValidationMonitor(),
TRT_TrigStandaloneTrackFinderOnlineMonitor(), standtime
]
def __init__(self,
name="InDetTrigConversionFinder_Electron_EFID",
type="electron"):
super(InDet__TrigConversionFinder, self).__init__(name)
from AthenaCommon.AppMgr import ToolSvc
from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import \
InDetTrigExtrapolator, InDetTrigTrackSummaryTool
#
from TrkVKalVrtFitter.TrkVKalVrtFitterConf import Trk__TrkVKalVrtFitter
InDetTrigConversionVxFitterTool = Trk__TrkVKalVrtFitter(
name="InDetTrigConversionVxFitter",
Extrapolator=InDetTrigExtrapolator,
IterationNumber=30,
MakeExtendedVertex=True,
FirstMeasuredPoint=True,
# MagFieldSvc = InDetTrigMagField,
Robustness=6,
usePhiCnst=True,
useThetaCnst=True,
InputParticleMasses=[0.511, 0.511],
VertexForConstraint=[0., 0., 0.],
CovVrtForConstraint=[
0.015 * 0.015, 0., 0.015 * 0.015, 0., 0., 10000. * 10000.
])
ToolSvc += InDetTrigConversionVxFitterTool
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigConversionVxFitterTool
# Distance of minimum approach utility
#
from TrkVertexSeedFinderUtils.TrkVertexSeedFinderUtilsConf import Trk__SeedNewtonTrkDistanceFinder
InDetTrigConversionTrkDistanceFinder = Trk__SeedNewtonTrkDistanceFinder(
name='InDetTrigConversionTrkDistanceFinder')
ToolSvc += InDetTrigConversionTrkDistanceFinder
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigConversionTrkDistanceFinder
# Helper Tool
#
from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__ConversionFinderUtils
InDetTrigConversionHelper = InDet__ConversionFinderUtils(
name="InDetTrigConversionFinderUtils",
#OutputLevel = 1
)
ToolSvc += InDetTrigConversionHelper
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigConversionHelper
# Track selector tool
#
from InDetTrackSelectorTool.InDetTrackSelectorToolConf import InDet__InDetConversionTrackSelectorTool
InDetTrigConversionTrackSelector = InDet__InDetConversionTrackSelectorTool(
name="InDetTrigConversionTrackSelector",
TrackSummaryTool=InDetTrigTrackSummaryTool,
Extrapolator=InDetTrigExtrapolator,
maxSiD0=10000., #50.0,
maxTrtD0=10000., #100.,
maxSiZ0=10000., #350.0,
maxTrtZ0=10000., #1400.,
minPt=InDetTrigSliceSettings[('pTmin', type)],
RatioCut1=0.0, #0.5,
RatioCut2=0.1,
RatioCut3=0.1)
ToolSvc += InDetTrigConversionTrackSelector
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigConversionTrackSelector
# Track pairs selector
#
from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__TrackPairsSelector
InDetTrigConversionTrackPairsSelector = InDet__TrackPairsSelector(
name="InDetTrigConversionTrackPairsSelector",
ConversionFinderHelperTool=InDetTrigConversionHelper,
DistanceTool=InDetTrigConversionTrkDistanceFinder,
MaxFirstHitRadius=500.,
#OutputLevel = 1,
MaxDistBetweenTracks=[10., 50., 50.], #[6.,80.,30.],
MaxEta=[0.3, 0.5, 0.5] #[0.5,1.0,0.5]
)
ToolSvc += InDetTrigConversionTrackPairsSelector
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigConversionTrackPairsSelector
# Vertex point estimator
#
from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__VertexPointEstimator
InDetTrigConversionVtxPointEstimator = InDet__VertexPointEstimator(
name="InDetTrigConversionVtxPointEstimator",
MinDeltaR=[-5., -25., -50.],
MaxDeltaR=[5., 10., 10.],
MaxPhi=[0.05, 0.5, 0.5]) #[0.05, 0.1, 0.1])
ToolSvc += InDetTrigConversionVtxPointEstimator
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigConversionVtxPointEstimator
# Conversion post selector
#
from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__ConversionPostSelector
InDetTrigConversionPostSelector = InDet__ConversionPostSelector(
name="InDetTrigConversionPostSelector",
MaxChi2Vtx=[50., 50., 50.], #[40.,100.,80.],
MaxInvariantMass=[10000., 10000., 10000.], #[60.,60.,30.],
MinFitMomentum=[0., 0., 0.], #[2000.,2000.,2000.],
MinRadius=[-10000., -10000., -10000.], #[30.,35.,250.],
MinPt=0.,
MaxdR=-10000., #-250.,
MaxPhiVtxTrk=10000.) #0.2)
ToolSvc += InDetTrigConversionPostSelector
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigConversionPostSelector
# Single track conversion tool
#
from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__SingleTrackConversionTool
InDetTrigSingleTrackConversion = InDet__SingleTrackConversionTool(
name="InDetTrigSingleTrackConversionTool",
ConversionFinderHelperTool=InDetTrigConversionHelper,
TrackSummaryTool=InDetTrigTrackSummaryTool,
Extrapolator=InDetTrigExtrapolator,
MinInitialHitRadius=70.,
MinRatioOfHLhits=0.95)
ToolSvc += InDetTrigSingleTrackConversion
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigSingleTrackConversion
from InDetConversionFinderTools.InDetConversionFinderToolsConf import InDet__InDetConversionFinderTools
InDetTrigConversionFinderTools = InDet__InDetConversionFinderTools(
name="InDetTrigConversionFinderTools",
VertexFitterTool=InDetTrigConversionVxFitterTool,
TrackSelectorTool=InDetTrigConversionTrackSelector,
TrackPairsSelector=InDetTrigConversionTrackPairsSelector,
ConversionFinderHelperTool=InDetTrigConversionHelper,
VertexPointEstimator=InDetTrigConversionVtxPointEstimator,
PostSelector=InDetTrigConversionPostSelector,
SingleTrackConversionTool=InDetTrigSingleTrackConversion,
Extrapolator=InDetTrigExtrapolator,
RemoveTrtTracks=False,
#OutputLevel = 1,
IsConversion=True)
ToolSvc += InDetTrigConversionFinderTools
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigConversionFinderTools
self.VertexFinderTool = InDetTrigConversionFinderTools
#monitoring
from InDetTrigConversionFinder.InDetTrigConversionFinderMonitoring import InDetTrigConversionFinderValidationMonitor
from InDetTrigConversionFinder.InDetTrigConversionFinderMonitoring import InDetTrigConversionFinderOnlineMonitor
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
convtime = TrigTimeHistToolConfig("ConvVxTime")
convtime.TimerHistLimits = [0, 200]
self.AthenaMonTools = [
InDetTrigConversionFinderValidationMonitor(),
InDetTrigConversionFinderOnlineMonitor(), convtime
]
