def __init__(self, name="TrigMuonEFStandaloneTrackTool", **kwargs): super(TrigMuonEFStandaloneTrackToolConfig, self).__init__(name, **kwargs) self.CscClusterProvider = CfgGetter.getPublicTool( "CscThresholdClusterBuilderTool") self.SegmentsFinderTool = CfgGetter.getPublicToolClone( "TMEF_SegmentsFinderTool", "MooSegmentFinder", WriteIntermediateResults=False, HoughPatternFinder=CfgGetter.getPublicTool("MuonLayerHoughTool"), DoSegmentCombinations=True) CfgGetter.getPublicTool("MuonHoughPatternFinderTool").RecordAll = False CfgGetter.getPublicTool("MuonLayerHoughTool").DoTruth = False CfgGetter.getPublicTool("MooTrackFitter").SLFit = False # use seeded decoding if (TriggerFlags.MuonSlice.doEFRoIDrivenAccess()): self.useMdtSeededDecoding = True self.useRpcSeededDecoding = True self.useTgcSeededDecoding = True self.useCscSeededDecoding = True # use ROB based seeded decoding instead of PRD based self.useMdtRobDecoding = True self.useRpcRobDecoding = True self.useTgcRobDecoding = False # neither available nor needed self.useCscRobDecoding = False # neither available nor needed from MuonRecExample.MuonRecFlags import muonRecFlags self.useRpcData = muonRecFlags.doRPCs() self.useTgcData = muonRecFlags.doTGCs() self.useCscData = muonRecFlags.doCSCs() # to select barrel(useMdtData=2), endcap(useMdtData=3) if muonRecFlags.doMDTs(): self.useMdtData = 1 else: self.useMdtData = 0 self.useTGCInPriorNextBC = False self.doTimeOutChecks = False self.doTimeOutGuard = False self.maxTgcHits = 0 self.maxCscHits = 0 self.maxRpcHits = 0 self.maxMdtHits = 0 self.doCache = True self.IgnoreMisalginedCSCs = True self.TrackBuilderTool = "TMEF_TrackBuilderTool" self.TrkSummaryTool = "TMEF_TrackSummaryTool" self.MuonCandidateTool = "TMEF_MuonCandidateTool" self.TrackToTrackParticleConvTool = "MuonParticleCreatorTool"
def TMEF_CombinedStauTrackBuilder(name='TMEF_CombinedStauTrackBuilder', **kwargs): kwargs.setdefault( 'MdtRotCreator', CfgGetter.getPublicTool('MdtDriftCircleOnTrackCreatorStau')) kwargs.setdefault( 'MuonHoleRecovery', CfgGetter.getPublicTool('TMEF_MuonStauSegmentRegionRecoveryTool')) return TMEF_CombinedMuonTrackBuilder(name, **kwargs)
def TMEF_MuonStauSegmentRegionRecoveryTool( name='TMEF_MuonStauSegmentRegionRecoveryTool', **kwargs): kwargs.setdefault('SeededSegmentFinder', CfgGetter.getPublicTool('MuonStauSeededSegmentFinder')) kwargs.setdefault( 'ChamberHoleRecoveryTool', CfgGetter.getPublicTool('MuonStauChamberHoleRecoveryTool')) kwargs.setdefault( 'Fitter', CfgGetter.getPublicTool('TMEF_CombinedStauTrackBuilderFit')) return CfgMgr.Muon__MuonSegmentRegionRecoveryTool(name, **kwargs)
def TMEF_MuonStauRecoTool(name='TMEF_MuonStauRecoTool', **kwargs): # kwargs.setdefault('DoSummary', True) kwargs.setdefault('DoSummary', muonCombinedRecFlags.printSummary()) kwargs.setdefault('ConsideredPDGs', [13, -13, 1000015, -1000015]) kwargs.setdefault('DoTruth', rec.doTruth()) kwargs.setdefault('MuonSegmentMaker', CfgGetter.getPublicTool('DCMathStauSegmentMaker')) kwargs.setdefault( 'MuonInsideOutRecoTool', CfgGetter.getPublicTool('TMEF_MuonStauInsideOutRecoTool')) return CfgMgr.MuonCombined__MuonStauRecoTool(name, **kwargs)
def TMEF_MuonStauSegmentRegionRecoveryTool( name='TMEF_MuonStauSegmentRegionRecoveryTool', **kwargs): kwargs.setdefault('SeededSegmentFinder', CfgGetter.getPublicTool('MuonStauSeededSegmentFinder')) kwargs.setdefault( 'ChamberHoleRecoveryTool', CfgGetter.getPublicTool('MuonStauChamberHoleRecoveryTool')) kwargs.setdefault( 'Fitter', CfgGetter.getPublicTool('TMEF_CombinedStauTrackBuilderFit')) from AthenaCommon.AthenaCommonFlags import athenaCommonFlags if athenaCommonFlags.isOnline: kwargs.setdefault('MdtCondKey', "") return CfgMgr.Muon__MuonSegmentRegionRecoveryTool(name, **kwargs)
def setTool(prop, tool_name, kwargs): if tool_name is None: kwargs.setdefault(prop, tool_name) return if prop not in kwargs: from AthenaCommon import CfgGetter if isinstance(tool_name, list): tools = [] for a_tool_name in tool_name: tools.append(CfgGetter.getPublicTool(a_tool_name)) kwargs.setdefault(prop, tools) else: kwargs.setdefault(prop, CfgGetter.getPublicTool(tool_name))
def TMEF_MuonStauInsideOutRecoTool(name='TMEF_MuonStauInsideOutRecoTool', **kwargs): kwargs.setdefault('MuonTrackBuilder', 'TMEF_CombinedMuonTrackBuilder') kwargs.setdefault( 'MuonCandidateTrackBuilderTool', CfgGetter.getPublicTool('TMEF_MuonStauCandidateTrackBuilderTool')) return CfgMgr.MuonCombined__MuonInsideOutRecoTool(name, **kwargs)
def LArPileUpToolDefault(useLArFloat=True, isOverlay=False, outputKey='LArDigitContainer_MC', outputKey_DigiHSTruth='LArDigitContainer_DigiHSTruth', name='LArPileUpToolDefault'): if isOverlay: #For all other cases, this is already done by LArConditionsCommon_MC_jobOptions.py from LArRecUtils.LArRecUtilsConf import LArSymConditionsAlg_LArfSamplMC_LArfSamplSym_ as LArfSamplSymAlg condSeq = AthSequencer("AthCondSeq") condSeq += LArfSamplSymAlg(ReadKey="LArfSampl", WriteKey="LArfSamplSym") try: from AthenaCommon import CfgGetter theTool = CfgGetter.getPublicTool("LArPileUpTool") theTool.DigitContainer = outputKey theTool.DigitContainer_DigiHSTruth = outputKey_DigiHSTruth from Digitization.DigitizationFlags import digitizationFlags theTool.DoDigiTruthReconstruction = digitizationFlags.doDigiTruth() except Exception as configException: import traceback traceback.print_exc() return theTool
def TMEF_CombinedMuonTrackBuilder(name='TMEF_CombinedMuonTrackBuilder', **kwargs): from MuonRecExample.MuonStandaloneFlags import muonStandaloneFlags kwargs.setdefault("CaloEnergyParam", "TMEF_CaloEnergyTool") kwargs.setdefault("CaloTSOS", "TMEF_CaloTrackStateOnSurface") kwargs.setdefault("CscRotCreator", "") # enabled with special version in Muid offline kwargs.setdefault("Fitter", "TMEF_iPatFitter") kwargs.setdefault("SLFitter", "TMEF_iPatSLFitter") kwargs.setdefault("MaterialAllocator", "TMEF_MaterialAllocator") kwargs.setdefault("MdtRotCreator", "MdtDriftCircleOnTrackCreator") kwargs.setdefault("MuonHoleRecovery", "") kwargs.setdefault("Propagator", "TMEF_Propagator") kwargs.setdefault("SLPropagator", "TMEF_Propagator") kwargs.setdefault("CleanCombined", True) kwargs.setdefault("CleanStandalone", True) kwargs.setdefault("BadFitChi2", 2.5) kwargs.setdefault("LargeMomentumError", 0.5) #kwargs.setdefault("LineMomentum", muonStandaloneFlags.straightLineFitMomentum()) kwargs.setdefault("LowMomentum", 10. * GeV) kwargs.setdefault("MinEnergy", 0.3 * GeV) kwargs.setdefault("PerigeeAtSpectrometerEntrance", True) kwargs.setdefault("ReallocateMaterial", False) kwargs.setdefault("Vertex2DSigmaRPhi", 100. * mm) kwargs.setdefault("Vertex3DSigmaRPhi", 6. * mm) kwargs.setdefault("Vertex3DSigmaZ", 60. * mm) if not TriggerFlags.run2Config == '2016': kwargs.setdefault("MuonErrorOptimizer", '') # note - the TrackSummaryTool is done as follows offline: # import MuonCombinedRecExample.CombinedMuonTrackSummary # combinedMuonTrackBuilder.TrackSummaryTool = ToolSvc.CombinedMuonTrackSummary # should check our config is really ok here kwargs.setdefault("TrackSummaryTool", 'TMEF_TrackSummaryTool') # extra w.r.t. Muid Offline kwargs.setdefault("Cleaner", "TMEF_TrackCleaner") from MuonRecExample.MuonRecFlags import muonRecFlags if muonRecFlags.doSegmentT0Fit(): kwargs.setdefault("MdtRotCreator", "") kwargs.setdefault("UseCaloTG", True) kwargs.setdefault("CaloMaterialProvider", "TMEF_TrkMaterialProviderTool") if muonRecFlags.enableErrorTuning(): kwargs.setdefault( "MuonErrorOptimizer", CfgGetter.getPublicToolClone( "TMEF_MuidErrorOptimisationTool", "MuonErrorOptimisationTool", PrepareForFit=False, RecreateStartingParameters=False, RefitTool=CfgGetter.getPublicToolClone( "TMEF_MuidRefitTool", "MuonRefitTool", AlignmentErrors=False, Fitter=CfgGetter.getPublicTool("iPatFitter")))) return CfgMgr.Rec__CombinedMuonTrackBuilder(name, **kwargs)
def LArPileUpToolDefault(useLArFloat=True,isOverlay=False,outputKey='LArDigitContainer_MC',outputKey_DigiHSTruth='LArDigitContainer_DigiHSTruth',name='LArPileUpToolDefault'): try: from AthenaCommon import CfgGetter theTool = CfgGetter.getPublicTool("LArPileUpTool") theTool.DigitContainer = outputKey theTool.DigitContainer_DigiHSTruth = outputKey_DigiHSTruth from Digitization.DigitizationFlags import digitizationFlags theTool.DoDigiTruthReconstruction = digitizationFlags.doDigiTruth() except Exception as configException: print configException print "ERROR Problem with configuration" return theTool
def TMEF_MuonCreatorTool(name="TMEF_MuonCreatorTool", **kwargs): from TrkExTools.AtlasExtrapolator import AtlasExtrapolator from TrackToCalo.TrackToCaloConf import Trk__ParticleCaloExtensionTool pcExtensionTool = Trk__ParticleCaloExtensionTool( Extrapolator=AtlasExtrapolator()) kwargs.setdefault("ParticleCaloExtensionTool", pcExtensionTool) kwargs.setdefault('TrackParticleCreator', 'TMEF_TrkToTrackParticleConvTool') kwargs.setdefault("AmbiguityProcessor", CfgGetter.getPublicTool('TrigMuonAmbiProcessor')) kwargs.setdefault('MakeTrackAtMSLink', True) kwargs.setdefault("CaloMaterialProvider", "TMEF_TrkMaterialProviderTool") kwargs.setdefault("FillTimingInformation", False) kwargs.setdefault("MuonSelectionTool", "") kwargs.setdefault("TrackQuery", "TMEF_MuonTrackQuery") kwargs.setdefault("TrackSummaryTool", "TMEF_TrackSummaryTool") return CfgMgr.MuonCombined__MuonCreatorTool(name, **kwargs)
"SCT_OFL", "/SCT/DAQ/Calibration/ChipNoise<tag>SctDaqCalibrationChipNoise-Apr10-01</tag>", forceMC=True) #if not conddb.folderRequested('/SCT/DAQ/Calibration/ChipGain'): # conddb.addFolderSplitOnline("SCT","/SCT/DAQ/Calibration/ChipGain","/SCT/DAQ/Calibration/ChipGain",forceMC=True) #if not conddb.folderRequested('/SCT/DAQ/Calibration/ChipNoise'): # conddb.addFolderSplitOnline("SCT","/SCT/DAQ/Calibration/ChipNoise","/SCT/DAQ/Calibration/ChipNoise",forceMC=True) # Dynamic configuration of SCT RDO type # This algorithm must be executed before SCT_Digitization from InDetOverlay.InDetOverlayConf import DynConfSCT job += DynConfSCT() job += CfgGetter.getAlgorithm("SCT_OverlayDigitization") CfgGetter.getPublicTool( "SCT_DigitizationTool").InputObjectName = "SCT_Hits" indetovl.do_SCT = True if readBS and isRealData: #job.InDetSCTRawDataProvider.EvtStore = "OriginalEvent_SG" job.InDetSCTRawDataProvider.RDOKey = "OriginalEvent_SG/SCT_RDOs" job.InDetSCTRawDataProvider.LVL1IDKey = "OriginalEvent_SG/SCT_LVL1ID" job.InDetSCTRawDataProvider.BCIDKey = "OriginalEvent_SG/SCT_BCID" #ServiceMgr.ByteStreamAddressProviderSvc.TypeNames += [ "SCT_RDO_Container/SCT_RDOs" ] #ServiceMgr.ByteStreamAddressProviderSvc.TypeNames += [ "Trk::SCT_ClusterContainer/SCT_OnlineClusters" ] else: indetovl.do_SCT = False if DetFlags.overlay.TRT_on(): if isRealData: conddb.blockFolder("/TRT/Cond/DigVers") #conddb.addFolderWithTag("TRT_OFL","/TRT/Cond/DigVers","TRTCondDigVers-Collisions-01",force=True,forceMC=True)
def __init__(self, InputCollections=None, ResolvedTrackCollectionKey=None, SiSPSeededTrackCollectionKey=None, NewTrackingCuts=None, TrackCollectionKeys=[], TrackCollectionTruthKeys=[]): from InDetRecExample.InDetJobProperties import InDetFlags from InDetRecExample.InDetKeys import InDetKeys # # --- get ToolSvc and topSequence # from AthenaCommon.AppMgr import ToolSvc from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() # # --- decide if use the association tool # if (len(InputCollections) > 0) and ( NewTrackingCuts.mode() == "LowPt" or NewTrackingCuts.mode() == "VeryLowPt" or NewTrackingCuts.mode() == "LargeD0" or NewTrackingCuts.mode() == "LowPtLargeD0" or NewTrackingCuts.mode() == "DisplacedSoftPion" or NewTrackingCuts.mode() == "BeamGas" or NewTrackingCuts.mode() == "ForwardTracks" or NewTrackingCuts.mode() == "ForwardSLHCTracks" or NewTrackingCuts.mode() == "PixelPrdAssociation" or NewTrackingCuts.mode() == "VeryForwardSLHCTracks" or NewTrackingCuts.mode() == "SLHCConversionFinding"): usePrdAssociationTool = True else: usePrdAssociationTool = False # # --- get list of already associated hits (always do this, even if no other tracking ran before) # if usePrdAssociationTool: from InDetTrackPRD_Association.InDetTrackPRD_AssociationConf import InDet__InDetTrackPRD_Association InDetPRD_Association = InDet__InDetTrackPRD_Association( name='InDetPRD_Association' + NewTrackingCuts.extension(), AssociationTool=InDetPrdAssociationTool, TracksName=list(InputCollections)) topSequence += InDetPRD_Association if (InDetFlags.doPrintConfigurables()): print InDetPRD_Association # ------------------------------------------------------------ # # ----------- SiSPSeededTrackFinder # # ------------------------------------------------------------ if InDetFlags.doSiSPSeededTrackFinder(): # # --- Space points seeds maker, use different ones for cosmics and collisions # if NewTrackingCuts.mode() == "DBM": from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_ATLxk as SiSpacePointsSeedMaker elif InDetFlags.doCosmics(): from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_Cosmic as SiSpacePointsSeedMaker elif InDetFlags.doHeavyIon(): from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_HeavyIon as SiSpacePointsSeedMaker elif NewTrackingCuts.mode() == "LowPt" or NewTrackingCuts.mode( ) == "VeryLowPt" or (NewTrackingCuts.mode() == "Pixel" and InDetFlags.doMinBias()): from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_LowMomentum as SiSpacePointsSeedMaker elif NewTrackingCuts.mode() == "BeamGas": from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_BeamGas as SiSpacePointsSeedMaker elif NewTrackingCuts.mode() == "SLHC" or NewTrackingCuts.mode( ) == "ForwardSLHCTracks" or NewTrackingCuts.mode( ) == "VeryForwardSLHCTracks": from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_ITK as SiSpacePointsSeedMaker elif NewTrackingCuts.mode() == "DisplacedSoftPion": from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_TrkSeeded as SiSpacePointsSeedMaker else: from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_ATLxk as SiSpacePointsSeedMaker InDetSiSpacePointsSeedMaker = SiSpacePointsSeedMaker( name="InDetSpSeedsMaker" + NewTrackingCuts.extension(), pTmin=NewTrackingCuts.minPT(), maxdImpact=NewTrackingCuts.maxPrimaryImpact(), maxZ=NewTrackingCuts.maxZImpact(), minZ=-NewTrackingCuts.maxZImpact(), usePixel=NewTrackingCuts.usePixel(), SpacePointsPixelName=InDetKeys.PixelSpacePoints(), # useSCT = NewTrackingCuts.useSCT(), useSCT=(NewTrackingCuts.useSCT() and NewTrackingCuts.useSCTSeeding()), SpacePointsSCTName=InDetKeys.SCT_SpacePoints(), # useOverlapSpCollection = NewTrackingCuts.useSCT(), useOverlapSpCollection=(NewTrackingCuts.useSCT() and NewTrackingCuts.useSCTSeeding()), SpacePointsOverlapName=InDetKeys.OverlapSpacePoints(), radMax=NewTrackingCuts.radMax(), RapidityCut=NewTrackingCuts.maxEta()) if NewTrackingCuts.mode() == "Offline" or InDetFlags.doHeavyIon( ) or NewTrackingCuts.mode() == "ForwardTracks": InDetSiSpacePointsSeedMaker.maxdImpactPPS = NewTrackingCuts.maxdImpactPPSSeeds( ) InDetSiSpacePointsSeedMaker.maxdImpactSSS = NewTrackingCuts.maxdImpactSSSSeeds( ) if usePrdAssociationTool: # not all classes have that property !!! InDetSiSpacePointsSeedMaker.UseAssociationTool = True InDetSiSpacePointsSeedMaker.AssociationTool = InDetPrdAssociationTool if not InDetFlags.doCosmics(): InDetSiSpacePointsSeedMaker.maxRadius1 = 0.75 * NewTrackingCuts.radMax( ) InDetSiSpacePointsSeedMaker.maxRadius2 = NewTrackingCuts.radMax( ) InDetSiSpacePointsSeedMaker.maxRadius3 = NewTrackingCuts.radMax( ) if NewTrackingCuts.mode() == "LowPt" or NewTrackingCuts.mode( ) == "VeryLowPt" or (NewTrackingCuts.mode() == "Pixel" and InDetFlags.doMinBias()): try: InDetSiSpacePointsSeedMaker.pTmax = NewTrackingCuts.maxPT() except: pass InDetSiSpacePointsSeedMaker.mindRadius = 4.0 if NewTrackingCuts.mode() == "SLHC" or NewTrackingCuts.mode( ) == "SLHCConversionFinding": InDetSiSpacePointsSeedMaker.minRadius1 = 0 InDetSiSpacePointsSeedMaker.minRadius2 = 0 InDetSiSpacePointsSeedMaker.minRadius3 = 0 InDetSiSpacePointsSeedMaker.maxRadius1 = 1000. * Units.mm InDetSiSpacePointsSeedMaker.maxRadius2 = 1000. * Units.mm InDetSiSpacePointsSeedMaker.maxRadius3 = 1000. * Units.mm if NewTrackingCuts.mode( ) == "ForwardTracks" or NewTrackingCuts.mode( ) == "ForwardSLHCTracks" or NewTrackingCuts.mode( ) == "VeryForwardSLHCTracks": InDetSiSpacePointsSeedMaker.checkEta = True InDetSiSpacePointsSeedMaker.etaMin = NewTrackingCuts.minEta() InDetSiSpacePointsSeedMaker.etaMax = NewTrackingCuts.maxEta() InDetSiSpacePointsSeedMaker.RapidityCut = NewTrackingCuts.maxEta( ) if NewTrackingCuts.mode() == "DBM": InDetSiSpacePointsSeedMaker.etaMin = NewTrackingCuts.minEta() InDetSiSpacePointsSeedMaker.etaMax = NewTrackingCuts.maxEta() InDetSiSpacePointsSeedMaker.useDBM = True if NewTrackingCuts.mode() == "PixelThreeLayer": InDetSiSpacePointsSeedMaker.SkipIBLcut = True if NewTrackingCuts.mode() == "DisplacedSoftPion": InDetSiSpacePointsSeedMaker.maxSeedsForSpacePoint = 50 InDetSiSpacePointsSeedMaker.DeltaThetaRoISP = 0.8 InDetSiSpacePointsSeedMaker.DeltaPhiRoISP = 0.8 InDetSiSpacePointsSeedMaker.RoISeedTool = RoISeedTool #InDetSiSpacePointsSeedMaker.OutputLevel = VERBOSE ToolSvc += InDetSiSpacePointsSeedMaker if (InDetFlags.doPrintConfigurables()): print InDetSiSpacePointsSeedMaker # # --- Z-coordinates primary vertices finder (only for collisions) # if InDetFlags.useZvertexTool() and NewTrackingCuts.mode() != "DBM": from SiZvertexTool_xk.SiZvertexTool_xkConf import InDet__SiZvertexMaker_xk InDetZvertexMaker = InDet__SiZvertexMaker_xk( name='InDetZvertexMaker' + NewTrackingCuts.extension(), Zmax=NewTrackingCuts.maxZImpact(), Zmin=-NewTrackingCuts.maxZImpact(), minRatio=0.17) # not default InDetZvertexMaker.SeedMakerTool = InDetSiSpacePointsSeedMaker if InDetFlags.doHeavyIon(): InDetZvertexMaker.HistSize = 2000 ###InDetZvertexMaker.minContent = 200 InDetZvertexMaker.minContent = 30 ToolSvc += InDetZvertexMaker if (InDetFlags.doPrintConfigurables()): print InDetZvertexMaker else: InDetZvertexMaker = None # # --- SCT and Pixel detector elements road builder # from SiDetElementsRoadTool_xk.SiDetElementsRoadTool_xkConf import InDet__SiDetElementsRoadMaker_xk InDetSiDetElementsRoadMaker = InDet__SiDetElementsRoadMaker_xk( name='InDetSiRoadMaker' + NewTrackingCuts.extension(), PropagatorTool=InDetPatternPropagator, usePixel=NewTrackingCuts.usePixel(), PixManagerLocation=InDetKeys.PixelManager(), useSCT=NewTrackingCuts.useSCT(), SCTManagerLocation=InDetKeys.SCT_Manager(), RoadWidth=NewTrackingCuts.RoadWidth()) #InDetSiDetElementsRoadMaker.OutputLevel = VERBOSE ToolSvc += InDetSiDetElementsRoadMaker if (InDetFlags.doPrintConfigurables()): print InDetSiDetElementsRoadMaker # # --- Local track finding using sdCaloSeededSSSpace point seed # useBremMode = NewTrackingCuts.mode( ) == "Offline" or NewTrackingCuts.mode( ) == "SLHC" or NewTrackingCuts.mode() == "DBM" from SiTrackMakerTool_xk.SiTrackMakerTool_xkConf import InDet__SiTrackMaker_xk as SiTrackMaker InDetSiTrackMaker = SiTrackMaker( name='InDetSiTrackMaker' + NewTrackingCuts.extension(), useSCT=NewTrackingCuts.useSCT(), usePixel=NewTrackingCuts.usePixel(), RoadTool=InDetSiDetElementsRoadMaker, CombinatorialTrackFinder=InDetSiComTrackFinder, pTmin=NewTrackingCuts.minPT(), pTminBrem=NewTrackingCuts.minPTBrem(), pTminSSS=InDetFlags.pT_SSScut(), nClustersMin=NewTrackingCuts.minClusters(), nHolesMax=NewTrackingCuts.nHolesMax(), nHolesGapMax=NewTrackingCuts.nHolesGapMax(), SeedsFilterLevel=NewTrackingCuts.seedFilterLevel(), Xi2max=NewTrackingCuts.Xi2max(), Xi2maxNoAdd=NewTrackingCuts.Xi2maxNoAdd(), nWeightedClustersMin=NewTrackingCuts.nWeightedClustersMin(), CosmicTrack=InDetFlags.doCosmics(), Xi2maxMultiTracks=NewTrackingCuts.Xi2max(), # was 3. useSSSseedsFilter=InDetFlags.doSSSfilter(), doMultiTracksProd=True, useBremModel=InDetFlags.doBremRecovery() and useBremMode, # only for NewTracking the brem is debugged !!! doCaloSeededBrem=InDetFlags.doCaloSeededBrem(), doHadCaloSeedSSS=InDetFlags.doHadCaloSeededSSS(), phiWidth=NewTrackingCuts.phiWidthBrem(), etaWidth=NewTrackingCuts.etaWidthBrem(), InputClusterContainerName=InDetKeys.CaloClusterROIContainer( ), # "InDetCaloClusterROIs" InputHadClusterContainerName=InDetKeys. HadCaloClusterROIContainer(), # "InDetCaloClusterROIs" UseAssociationTool=usePrdAssociationTool) if NewTrackingCuts.mode() == "SLHC" or NewTrackingCuts.mode( ) == "ForwardSLHCTracks" or NewTrackingCuts.mode( ) == "VeryForwardSLHCTracks": InDetSiTrackMaker.ITKGeometry = True if NewTrackingCuts.mode() == "DBM": InDetSiTrackMaker.MagneticFieldMode = "NoField" InDetSiTrackMaker.useBremModel = False InDetSiTrackMaker.doMultiTracksProd = False InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSPSeededFinder' InDetSiTrackMaker.pTminSSS = -1 InDetSiTrackMaker.CosmicTrack = False InDetSiTrackMaker.useSSSseedsFilter = False InDetSiTrackMaker.doCaloSeededBrem = False InDetSiTrackMaker.doHadCaloSeedSSS = False InDetSiTrackMaker.UseAssociationTool = False elif InDetFlags.doCosmics(): InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_Cosmic' elif InDetFlags.doHeavyIon(): InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_HeavyIon' elif NewTrackingCuts.mode() == "LowPt": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_LowMomentum' elif NewTrackingCuts.mode() == "VeryLowPt" or ( NewTrackingCuts.mode() == "Pixel" and InDetFlags.doMinBias()): InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_VeryLowMomentum' elif NewTrackingCuts.mode() == "BeamGas": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_BeamGas' elif NewTrackingCuts.mode() == "ForwardTracks": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_ForwardTracks' elif NewTrackingCuts.mode() == "ForwardSLHCTracks": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_ForwardSLHCTracks' elif NewTrackingCuts.mode() == "VeryForwardSLHCTracks": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_VeryForwardSLHCTracks' elif NewTrackingCuts.mode() == "SLHCConversionFinding": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_SLHCConversionTracks' elif NewTrackingCuts.mode() == "LargeD0" or NewTrackingCuts.mode( ) == "LowPtLargeD0" or NewTrackingCuts.mode( ) == "DisplacedSoftPion": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_LargeD0' elif NewTrackingCuts.mode() == "PixelThreeLayer": InDetSiTrackMaker.CombinatorialTrackFinder = InDetSiComTrackFinderThreeLayerTracking else: InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSPSeededFinder' if InDetFlags.doStoreTrackSeeds(): InDetSiTrackMaker.SeedSegmentsWrite = True InDetSiTrackMaker.SeedToTrackConversion = InDet_SeedToTrackConversion #InDetSiTrackMaker.OutputLevel = VERBOSE ToolSvc += InDetSiTrackMaker if (InDetFlags.doPrintConfigurables()): print InDetSiTrackMaker # # set output track collection name # self.__SiTrackCollection = SiSPSeededTrackCollectionKey # # --- Setup Track finder using space points seeds # from SiSPSeededTrackFinder.SiSPSeededTrackFinderConf import InDet__SiSPSeededTrackFinder if NewTrackingCuts.mode( ) == "ForwardSLHCTracks" or NewTrackingCuts.mode( ) == "ForwardTracks": InDetSiSPSeededTrackFinder = InDet__SiSPSeededTrackFinder( name='InDetSiSpTrackFinder' + NewTrackingCuts.extension(), TrackTool=InDetSiTrackMaker, TracksLocation=self.__SiTrackCollection, SeedsTool=InDetSiSpacePointsSeedMaker, useZvertexTool=InDetFlags.useZvertexTool(), ZvertexTool=InDetZvertexMaker, useNewStrategy=False, useMBTSTimeDiff=InDetFlags.useMBTSTimeDiff(), useZBoundFinding=False) if InDetFlags.doHeavyIon(): InDetSiSPSeededTrackFinder.FreeClustersCut = 2 #Heavy Ion optimization from Igor else: InDetSiSPSeededTrackFinder = InDet__SiSPSeededTrackFinder( name='InDetSiSpTrackFinder' + NewTrackingCuts.extension(), TrackTool=InDetSiTrackMaker, TracksLocation=self.__SiTrackCollection, SeedsTool=InDetSiSpacePointsSeedMaker, useZvertexTool=InDetFlags.useZvertexTool() and NewTrackingCuts.mode() != "DBM", ZvertexTool=InDetZvertexMaker, useNewStrategy=InDetFlags.useNewSiSPSeededTF() and NewTrackingCuts.mode() != "DBM", useMBTSTimeDiff=InDetFlags.useMBTSTimeDiff(), useZBoundFinding=NewTrackingCuts.doZBoundary() and NewTrackingCuts.mode() != "DBM") if InDetFlags.doHeavyIon(): InDetSiSPSeededTrackFinder.FreeClustersCut = 2 #Heavy Ion optimization from Igor #InDetSiSPSeededTrackFinder.OutputLevel =VERBOSE topSequence += InDetSiSPSeededTrackFinder if (InDetFlags.doPrintConfigurables()): print InDetSiSPSeededTrackFinder if not InDetFlags.doSGDeletion(): if InDetFlags.doTruth(): # # set up the truth info for this container # include("InDetRecExample/ConfiguredInDetTrackTruth.py") InDetTracksTruth = ConfiguredInDetTrackTruth( self.__SiTrackCollection, self.__SiTrackCollection + "DetailedTruth", self.__SiTrackCollection + "TruthCollection") # # add final output for statistics # TrackCollectionKeys += [InDetTracksTruth.Tracks()] TrackCollectionTruthKeys += [ InDetTracksTruth.TracksTruth() ] else: TrackCollectionKeys += [self.__SiTrackCollection] # ------------------------------------------------------------ # # ---------- Ambiguity solving # # ------------------------------------------------------------ if InDetFlags.doAmbiSolving(): # # --- load InnerDetector TrackSelectionTool # prob1 = InDetFlags.pixelClusterSplitProb1() prob2 = InDetFlags.pixelClusterSplitProb2() nhitsToAllowSplitting = 9 if geoFlags.Run() == 1: prob1 = InDetFlags.pixelClusterSplitProb1_run1() prob2 = InDetFlags.pixelClusterSplitProb2_run1() nhitsToAllowSplitting = 8 if InDetFlags.doTIDE_Ambi() and not ( NewTrackingCuts.mode() == "ForwardSLHCTracks" or NewTrackingCuts.mode() == "ForwardTracks" or NewTrackingCuts.mode() == "DBM"): from InDetAmbiTrackSelectionTool.InDetAmbiTrackSelectionToolConf import InDet__InDetDenseEnvAmbiTrackSelectionTool as AmbiTrackSelectionTool else: from InDetAmbiTrackSelectionTool.InDetAmbiTrackSelectionToolConf import InDet__InDetAmbiTrackSelectionTool as AmbiTrackSelectionTool InDetAmbiTrackSelectionTool = AmbiTrackSelectionTool( name='InDetAmbiTrackSelectionTool' + NewTrackingCuts.extension(), AssociationTool=InDetPrdAssociationTool, DriftCircleCutTool=InDetTRTDriftCircleCut, minHits=NewTrackingCuts.minClusters(), minNotShared=NewTrackingCuts.minSiNotShared(), maxShared=NewTrackingCuts.maxShared(), minTRTHits=0, # used for Si only tracking !!! sharedProbCut=0.10, UseParameterization=False, Cosmics=InDetFlags.doCosmics(), doPixelSplitting=InDetFlags.doPixelClusterSplitting() and NewTrackingCuts.mode != "DBM") if InDetFlags.doTIDE_Ambi() and not ( NewTrackingCuts.mode() == "ForwardSLHCTracks" or NewTrackingCuts.mode() == "ForwardTracks" or NewTrackingCuts.mode() == "DBM"): InDetAmbiTrackSelectionTool.sharedProbCut = prob1 InDetAmbiTrackSelectionTool.sharedProbCut2 = prob2 InDetAmbiTrackSelectionTool.minSiHitsToAllowSplitting = nhitsToAllowSplitting InDetAmbiTrackSelectionTool.minUniqueSCTHits = 4 InDetAmbiTrackSelectionTool.minTrackChi2ForSharedHits = 3 InDetAmbiTrackSelectionTool.InputHadClusterContainerName = InDetKeys.HadCaloClusterROIContainer( ) InDetAmbiTrackSelectionTool.doHadCaloSeed = False #Only split in cluster in region of interest InDetAmbiTrackSelectionTool.minPtSplit = InDetFlags.pixelClusterSplitMinPt( ) #Only allow split clusters on track withe pt greater than this MeV InDetAmbiTrackSelectionTool.phiWidth = 0.2 #Split cluster ROI size InDetAmbiTrackSelectionTool.etaWidth = 0.2 #Split cluster ROI size InDetAmbiTrackSelectionTool.InputEmClusterContainerName = InDetKeys.CaloClusterROIContainer( ) InDetAmbiTrackSelectionTool.doEmCaloSeed = False #Only split in cluster in region of interest InDetAmbiTrackSelectionTool.minPtConv = 10000 #Only allow split clusters on track withe pt greater than this MeV InDetAmbiTrackSelectionTool.phiWidthEM = 0.05 #Split cluster ROI size InDetAmbiTrackSelectionTool.etaWidthEM = 0.05 #Split cluster ROI size if NewTrackingCuts.mode() == "DBM": InDetAmbiTrackSelectionTool.Cosmics = False InDetAmbiTrackSelectionTool.UseParameterization = False InDetAmbiTrackSelectionTool.doPixelSplitting = False InDetAmbiTrackSelectionTool.maxShared = 1000 InDetAmbiTrackSelectionTool.maxTracksPerSharedPRD = 2 InDetAmbiTrackSelectionTool.minHits = 0 InDetAmbiTrackSelectionTool.minNotShared = 0 InDetAmbiTrackSelectionTool.minScoreShareTracks = 0.0 InDetAmbiTrackSelectionTool.minTRTHits = 0 InDetAmbiTrackSelectionTool.sharedProbCut = 0.1 if InDetFlags.doTIDE_AmbiTrackMonitoring( ) and InDetFlags.doTIDE_Ambi() and not ( NewTrackingCuts.mode() == "ForwardSLHCTracks" or NewTrackingCuts.mode() == "ForwardTracks" or NewTrackingCuts.mode() == "PixelPrdAssociation" or NewTrackingCuts.mode() == "DBM" or NewTrackingCuts.mode() == "PixelFourLayer" or NewTrackingCuts.mode() == "PixelThreeLayer"): InDetAmbiTrackSelectionTool.ObserverTool = TrackObserverTool #observerTool InDetAmbiTrackSelectionTool.MonitorAmbiguitySolving = True # if NewTrackingCuts.mode() == "ForwardTracks": # InDetAmbiTrackSelectionTool.OutputLevel = VERBOSE ToolSvc += InDetAmbiTrackSelectionTool if (InDetFlags.doPrintConfigurables()): print InDetAmbiTrackSelectionTool # # --- set up different Scoring Tool for collisions and cosmics # if InDetFlags.doCosmics() and NewTrackingCuts.mode() != "DBM": from InDetTrackScoringTools.InDetTrackScoringToolsConf import InDet__InDetCosmicScoringTool InDetAmbiScoringTool = InDet__InDetCosmicScoringTool( name='InDetCosmicsScoringTool' + NewTrackingCuts.extension(), nWeightedClustersMin=NewTrackingCuts.nWeightedClustersMin( ), minTRTHits=0, SummaryTool=InDetTrackSummaryTool) else: from InDetTrackScoringTools.InDetTrackScoringToolsConf import InDet__InDetAmbiScoringTool InDetAmbiScoringTool = InDet__InDetAmbiScoringTool( name='InDetAmbiScoringTool' + NewTrackingCuts.extension(), Extrapolator=InDetExtrapolator, SummaryTool=InDetTrackSummaryTool, DriftCircleCutTool=InDetTRTDriftCircleCut, useAmbigFcn=True, # this is NewTracking useTRT_AmbigFcn=False, minPt=NewTrackingCuts.minPT(), maxRPhiImp=NewTrackingCuts.maxPrimaryImpact(), maxZImp=NewTrackingCuts.maxZImpact(), maxEta=NewTrackingCuts.maxEta(), minSiClusters=NewTrackingCuts.minClusters(), minPixel=NewTrackingCuts.minPixel(), maxSiHoles=NewTrackingCuts.maxHoles(), maxPixelHoles=NewTrackingCuts.maxPixelHoles(), maxSCTHoles=NewTrackingCuts.maxSCTHoles(), maxDoubleHoles=NewTrackingCuts.maxDoubleHoles(), usePixel=NewTrackingCuts.usePixel(), useSCT=NewTrackingCuts.useSCT(), InputEmClusterContainerName=InDetKeys. CaloClusterROIContainer(), doEmCaloSeed=True and InDetFlags.doCaloSeededBrem(), minTRTonTrk=0, minTRTPrecisionFraction=0) # allow for some overlap for low-pt tracking #if InDetFlags.doLowPt() and not NewTrackingCuts.mode() == "LowPt": # InDetAmbiScoringTool.minPt = NewTrackingCuts.minPT()-100.*Units.MeV # if NewTrackingCuts.mode() == "ForwardTracks": # InDetAmbiScoringTool.OutputLevel = VERBOSE ToolSvc += InDetAmbiScoringTool if (InDetFlags.doPrintConfigurables()): print InDetAmbiScoringTool # # --- load Ambiguity Processor # useBremMode = NewTrackingCuts.mode( ) == "Offline" or NewTrackingCuts.mode() == "SLHC" if InDetFlags.doTIDE_Ambi() and not ( NewTrackingCuts.mode() == "ForwardSLHCTracks" or NewTrackingCuts.mode() == "ForwardTracks" or NewTrackingCuts.mode() == "DBM"): from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__DenseEnvironmentsAmbiguityProcessorTool as ProcessorTool use_low_pt_fitter = True if NewTrackingCuts.mode( ) == "LowPt" or NewTrackingCuts.mode() == "VeryLowPt" or ( NewTrackingCuts.mode() == "Pixel" and InDetFlags.doMinBias()) else False fitter_list = [(InDetTrackFitter if not use_low_pt_fitter else InDetTrackFitterLowPt)] if InDetFlags.doRefitInvalidCov(): from AthenaCommon import CfgGetter fitter_list.append(CfgGetter.getPublicTool('KalmanFitter')) fitter_list.append( CfgGetter.getPublicTool('ReferenceKalmanFitter')) InDetAmbiguityProcessor = ProcessorTool( name='InDetAmbiguityProcessor' + NewTrackingCuts.extension(), Fitter=fitter_list, ScoringTool=InDetAmbiScoringTool, SelectionTool=InDetAmbiTrackSelectionTool, SuppressHoleSearch=False, tryBremFit=InDetFlags.doBremRecovery() and useBremMode and NewTrackingCuts.mode() != "DBM", caloSeededBrem=InDetFlags.doCaloSeededBrem() and NewTrackingCuts.mode() != "DBM", pTminBrem=NewTrackingCuts.minPTBrem(), RefitPrds=True, RejectTracksWithInvalidCov=InDetFlags.doRejectInvalidCov()) else: from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__SimpleAmbiguityProcessorTool as ProcessorTool InDetAmbiguityProcessor = ProcessorTool( name='InDetAmbiguityProcessor' + NewTrackingCuts.extension(), Fitter=InDetTrackFitter, ScoringTool=InDetAmbiScoringTool, SelectionTool=InDetAmbiTrackSelectionTool, SuppressHoleSearch=False, tryBremFit=InDetFlags.doBremRecovery() and useBremMode and NewTrackingCuts.mode() != "DBM", caloSeededBrem=InDetFlags.doCaloSeededBrem() and NewTrackingCuts.mode() != "DBM", pTminBrem=NewTrackingCuts.minPTBrem(), RefitPrds=True) if InDetFlags.doTIDE_Ambi() and not ( NewTrackingCuts.mode() == "ForwardSLHCTracks" or NewTrackingCuts.mode() == "ForwardTracks" or NewTrackingCuts.mode() == "DBM"): InDetAmbiguityProcessor.SplitProbTool = NnPixelClusterSplitProbTool InDetAmbiguityProcessor.sharedProbCut = prob1 InDetAmbiguityProcessor.sharedProbCut2 = prob2 InDetAmbiguityProcessor.SplitClusterAmbiguityMap = InDetKeys.SplitClusterAmbiguityMap( ) if InDetFlags.doTIDE_RescalePixelCovariances(): InDetAmbiguityProcessor.applydRcorrection = True if NewTrackingCuts.mode() == "Pixel" or NewTrackingCuts.mode( ) == "DBM": InDetAmbiguityProcessor.SuppressHoleSearch = True if NewTrackingCuts.mode() == "LowPt" or NewTrackingCuts.mode( ) == "VeryLowPt" or (NewTrackingCuts.mode() == "Pixel" and InDetFlags.doMinBias()): if InDetAmbiguityProcessor.getName().find('Dense'): pass else: InDetAmbiguityProcessor.Fitter = InDetTrackFitterLowPt if InDetFlags.materialInteractions(): InDetAmbiguityProcessor.MatEffects = InDetFlags.materialInteractionsType( ) else: InDetAmbiguityProcessor.MatEffects = 0 # if NewTrackingCuts.mode() == "ForwardTracks": # InDetAmbiguityProcessor.OutputLevel = VERBOSE if InDetFlags.doTIDE_AmbiTrackMonitoring( ) and InDetFlags.doTIDE_Ambi() and not ( NewTrackingCuts.mode() == "ForwardSLHCTracks" or NewTrackingCuts.mode() == "ForwardTracks" or NewTrackingCuts.mode() == "PixelPrdAssociation" or NewTrackingCuts.mode() == "DBM" or NewTrackingCuts.mode() == "PixelFourLayer" or NewTrackingCuts.mode() == "PixelThreeLayer"): InDetAmbiguityProcessor.ObserverTool = TrackObserverTool #observerTool InDetAmbiguityProcessor.MonitorAmbiguitySolving = True ToolSvc += InDetAmbiguityProcessor if (InDetFlags.doPrintConfigurables()): print InDetAmbiguityProcessor # # --- set input and output collection # InputTrackCollection = self.__SiTrackCollection self.__SiTrackCollection = ResolvedTrackCollectionKey # # --- configure Ambiguity solver # from TrkAmbiguitySolver.TrkAmbiguitySolverConf import Trk__TrkAmbiguitySolver InDetAmbiguitySolver = Trk__TrkAmbiguitySolver( name='InDetAmbiguitySolver' + NewTrackingCuts.extension(), TrackInput=[InputTrackCollection], TrackOutput=self.__SiTrackCollection, AmbiguityProcessor=InDetAmbiguityProcessor) topSequence += InDetAmbiguitySolver if (InDetFlags.doPrintConfigurables()): print InDetAmbiguitySolver # # --- Delete Silicon Sp-Seeded tracks # from InDetRecExample.ConfiguredInDetSGDeletion import InDetSGDeletionAlg InDetSGDeletionAlg(key=SiSPSeededTrackCollectionKey) if ((NewTrackingCuts.mode() in ["Pixel", "SCT"]) or not InDetFlags.doSGDeletion()): if InDetFlags.doTruth(): # # set up the truth info for this container # include("InDetRecExample/ConfiguredInDetTrackTruth.py") InDetTracksTruth = ConfiguredInDetTrackTruth( self.__SiTrackCollection, self.__SiTrackCollection + "DetailedTruth", self.__SiTrackCollection + "TruthCollection") # # add final output for statistics # TrackCollectionKeys += [InDetTracksTruth.Tracks()] TrackCollectionTruthKeys += [ InDetTracksTruth.TracksTruth() ] else: TrackCollectionKeys += [self.__SiTrackCollection]
from AthenaCommon import CfgGetter MuonClusterOnTrackCreator = CfgGetter.getPublicTool("MuonClusterOnTrackCreator") MdtDriftCircleOnTrackCreator = CfgGetter.getPublicTool("MdtDriftCircleOnTrackCreator") MdtTubeHitOnTrackCreator = CfgGetter.getPublicTool("MdtTubeHitOnTrackCreator") MuonRotCreator = CfgGetter.getPublicTool('MuonRotCreator') MuonNavigator = CfgGetter.getPublicTool('MuonNavigator') MuonMaterialUpdator = CfgGetter.getPublicTool("MuonMaterialEffectsUpdator") MuonPropagator = CfgGetter.getPublicTool('MuonPropagator') MuonExtrapolator = CfgGetter.getPublicTool('MuonExtrapolator') MuonMeasUpdator = CfgGetter.getPublicTool('MuonMeasUpdator') MuonTrackSummaryHelperTool = CfgGetter.getPublicTool("MuonTrackSummaryHelperTool") MuonTrackSummaryTool = CfgGetter.getPublicTool("MuonTrackSummaryTool") AtlasExtrapolator = CfgGetter.getPublicTool("AtlasExtrapolator") MuonChi2TrackFitter = CfgGetter.getPublicTool('MuonChi2TrackFitter') MuonChi2SLTrackFitter = CfgGetter.getPublicTool("MuonChi2SLTrackFitter") DCMathSegmentMaker = CfgGetter.getPublicTool("DCMathSegmentMaker") MuonClusterizationTool = CfgGetter.getPublicTool("MuonClusterizationTool") MSVertexTrackletTool = CfgGetter.getPublicTool("MSVertexTrackletTool") MSVertexRecoTool = CfgGetter.getPublicTool("MSVertexRecoTool") MuonClusterSegmentFinderTool = CfgGetter.getPublicTool("MuonClusterSegmentFinderTool") MuonSegmentFittingTool = CfgGetter.getPublicTool("MuonSegmentFittingTool") DCMathT0FitSegmentMaker = CfgGetter.getPublicTool("DCMathT0FitSegmentMaker")
def TMEF_MuonCandidateTool(name="TMEF_MuonCandidateTool", **kwargs): kwargs.setdefault("TrackBuilder", "TMEF_CombinedMuonTrackBuilder") if beamFlags.beamType() == 'cosmics': kwargs.setdefault("TrackExtrapolationTool", CfgGetter.getPublicTool("ExtrapolateMuonToIPTool")) return CfgMgr.MuonCombined__MuonCandidateTool(name, **kwargs)
InDetKeys.Tracks(), InDetKeys.PixelTracks(), InDetKeys.SCTTracks(), "ResolvedTracks", InDetKeys.TRTTracks() ] m_d0Range = [50, 50, 50, 50, 800] m_deltaD0 = [0.8, 0.8, 0.8, 0.8, 8] m_deltaD02D = [5, 5, 5, 5, 10] m_deltaPhi = [0.005, 0.005, 0.005, 0.005, 0.01] m_deltaPhi2D = [0.02, 0.02, 0.02, 0.02, 0.05] m_deltaQoverPt = [0.05, 0.2, 0.05, 0.04, 0.1] m_deltaQoverPt2D = [0.05, 0.2, 0.05, 0.04, 0.1] from AthenaCommon import CfgGetter indet_track_fitter = CfgGetter.getPublicTool('InDetTrackFitter') for i in range(5): m_trackSplitter.append( InDet__InDetTrackSplitterTool( name=m_trackSplitterName[i], TrackFitter=indet_track_fitter, OutputUpperTracksName=m_upperTracksName[i], OutputLowerTracksName=m_lowerTracksName[i])) ToolSvc += m_trackSplitter[i] if (InDetFlags.doPrintConfigurables()): printfunc(m_trackSplitter[i]) m_trackSegmentsUpLow.append( IDAlignMonTrackSegments( name=m_trackSegmentsUpLowName[i],
ServiceMgr.EventSelector.SkipEvents = 0 from AthenaCommon.AppMgr import ServiceMgr from GaudiSvc.GaudiSvcConf import THistSvc ServiceMgr += THistSvc("THistSvc") #ServiceMgr.THistSvc.Output = ["atlasTest DATAFILE='atlasTest.muons.histo.root' OPT='RECREATE'"]; ServiceMgr.THistSvc.Output = ["truth DATAFILE='truth.root' OPT='RECREATE'"] from AthenaCommon.AlgSequence import AlgSequence job = AlgSequence() from AthenaCommon import CfgGetter from DigitizationTests.DigitizationTestsConf import DigiTestAlg, McEventCollectionTestTool, PileUpEventInfoTestTool, PixelRDOsTestTool, SCT_RDOsTestTool, TRT_RDOsTestTool job += DigiTestAlg() if DetFlags.Truth_on(): job.DigiTestAlg.DigiTestTools += [ CfgGetter.getPublicTool("McEventCollectionTestTool", checkType=True) ] if DetFlags.Truth_on(): job.DigiTestAlg.DigiTestTools += [ CfgGetter.getPublicTool("PileUpEventInfoTestTool", checkType=True) ] if DetFlags.pixel_on(): job.DigiTestAlg.DigiTestTools += [ CfgGetter.getPublicTool("PixelRDOsTestTool", checkType=True) ] if DetFlags.SCT_on(): job.DigiTestAlg.DigiTestTools += [ CfgGetter.getPublicTool("SCT_RDOsTestTool", checkType=True) ] if DetFlags.TRT_on(): job.DigiTestAlg.DigiTestTools += [
def __init__(self, NewTrackingCuts = None, SiTrackCollection = None, ExtendedTrackCollection = None, ExtendedTracksMap = None, TrackCollectionKeys=[], TrackCollectionTruthKeys=[] , doPhase = True): from InDetRecExample.InDetJobProperties import InDetFlags from AthenaCommon.DetFlags import DetFlags from InDetRecExample.InDetKeys import InDetKeys import InDetRecExample.TrackingCommon as TrackingCommon # # get ToolSvc and topSequence # from AthenaCommon.AppMgr import ToolSvc from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() # # ---------- TRT_TrackExtension # if InDetFlags.doTRTExtension() and InDetFlags.doTRTExtensionNew(): # # Track extension to TRT algorithm # # set output extension map name OutputExtendedTracks = ExtendedTracksMap if doPhase: from TRT_TrackExtensionTool_xk.TRT_TrackExtensionTool_xkConf import InDet__TRT_TrackExtensionToolCosmics InDetTRTExtensionToolPhase = TrackingCommon.getInDetTRT_ExtensionToolPhase() from TRT_TrackExtensionAlg.TRT_TrackExtensionAlgConf import InDet__TRT_TrackExtensionAlg InDetTRTExtensionPhase = InDet__TRT_TrackExtensionAlg (name = 'InDetTRT_ExtensionPhase'+NewTrackingCuts.extension(), InputTracksLocation = SiTrackCollection, ExtendedTracksLocation = OutputExtendedTracks, TrackExtensionTool = InDetTRTExtensionToolPhase) topSequence += InDetTRTExtensionPhase if (InDetFlags.doPrintConfigurables()): printfunc (InDetTRTExtensionPhase) else: cuts_args = {} if NewTrackingCuts is not None : cuts_args={'TrackingCuts': NewTrackingCuts} from TRT_TrackExtensionAlg.TRT_TrackExtensionAlgConf import InDet__TRT_TrackExtensionAlg InDetTRTExtension = InDet__TRT_TrackExtensionAlg(name = 'InDetTRT_Extension'+NewTrackingCuts.extension(), InputTracksLocation = SiTrackCollection, ExtendedTracksLocation = OutputExtendedTracks, TrackExtensionTool = TrackingCommon.getInDetTRT_ExtensionTool(**cuts_args)) #InDetTRTExtension.OutputLevel = VERBOSE topSequence += InDetTRTExtension if (InDetFlags.doPrintConfigurables()): printfunc (InDetTRTExtension) # # ------------ Track Extension Processor # if InDetFlags.doExtensionProcessor() and InDetFlags.doTRTExtensionNew(): if InDetFlags.trtExtensionType() == 'DAF' : # # --- DAF Fitter setup # from TrkCompetingRIOsOnTrackTool.TrkCompetingRIOsOnTrackToolConf import Trk__CompetingRIOsOnTrackTool InDetCompetingRotCreator = Trk__CompetingRIOsOnTrackTool( name = 'InDetCompetingRotCreator'+NewTrackingCuts.extension(), ToolForCompPixelClusters = None, # default ToolForCompSCT_Clusters = None, # default ToolForCompTRT_DriftCircles = InDetCompetingTRT_DC_Tool ) ToolSvc += InDetCompetingRotCreator if (InDetFlags.doPrintConfigurables()): printfunc (InDetCompetingRotCreator) # from TrkDeterministicAnnealingFilter.TrkDeterministicAnnealingFilterConf import Trk__DeterministicAnnealingFilter InDetExtensionFitter = Trk__DeterministicAnnealingFilter( name = 'InDetDAF'+NewTrackingCuts.extension(), ToolForExtrapolation = InDetExtrapolator, ToolForCompetingROTsCreation = InDetCompetingRotCreator, ToolForUpdating = InDetUpdator, AnnealingScheme = [200., 81., 9., 4., 1., 1., 1.], DropOutlierCutValue = 1.E-7, OutlierCutValue = 0.01 ) ToolSvc += InDetExtensionFitter if (InDetFlags.doPrintConfigurables()): printfunc (InDetExtensionFitter) else: from AthenaCommon import CfgGetter InDetExtensionFitter = CfgGetter.getPublicTool('InDetTrackFitter' if NewTrackingCuts.mode() != "LowPt" else 'InDetTrackFitterLowPt') # # --- load scoring for extension # if InDetFlags.doCosmics(): InDetExtenScoringTool = TrackingCommon.getInDetCosmicExtenScoringTool(NewTrackingCuts) else: InDetExtenScoringTool = TrackingCommon.getInDetExtenScoringTool(NewTrackingCuts) # # --- output track collection # self.__ForwardTrackCollection = ExtendedTrackCollection # # --- get configured track extension processor # if doPhase: from InDetExtensionProcessor.InDetExtensionProcessorConf import InDet__InDetExtensionProcessor InDetExtensionProcessorPhase = InDet__InDetExtensionProcessor ( name = "InDetExtensionProcessorPhase"+NewTrackingCuts.extension(), TrackName = SiTrackCollection, Cosmics = True, ExtensionMap = OutputExtendedTracks, NewTrackName = self.__ForwardTrackCollection, TrackFitter = InDetExtensionFitter, TrackSummaryTool = TrackingCommon.getInDetTrackSummaryTool(), ScoringTool = InDetExtenScoringTool, suppressHoleSearch = False, # does not work properly tryBremFit = InDetFlags.doBremRecovery(), caloSeededBrem = InDetFlags.doCaloSeededBrem(), pTminBrem = NewTrackingCuts.minPTBrem(), RefitPrds = not (InDetFlags.refitROT() or (InDetFlags.trtExtensionType() == 'DAF'))) #InDetExtensionProcessor.OutputLevel = VERBOSE if InDetFlags.materialInteractions(): InDetExtensionProcessorPhase.matEffects = InDetFlags.materialInteractionsType() else: InDetExtensionProcessorPhase.matEffects = 0 topSequence += InDetExtensionProcessorPhase if (InDetFlags.doPrintConfigurables()): printfunc (InDetExtensionProcessorPhase) else: from InDetExtensionProcessor.InDetExtensionProcessorConf import InDet__InDetExtensionProcessor InDetExtensionProcessor = InDet__InDetExtensionProcessor ( name = "InDetExtensionProcessor"+NewTrackingCuts.extension(), TrackName = SiTrackCollection, Cosmics = InDetFlags.doCosmics(), ExtensionMap = OutputExtendedTracks, NewTrackName = self.__ForwardTrackCollection, TrackFitter = InDetExtensionFitter, TrackSummaryTool = TrackingCommon.getInDetTrackSummaryTool(), ScoringTool = InDetExtenScoringTool, suppressHoleSearch = False, # does not work properly tryBremFit = InDetFlags.doBremRecovery(), caloSeededBrem = InDetFlags.doCaloSeededBrem(), pTminBrem = NewTrackingCuts.minPTBrem(), RefitPrds = not (InDetFlags.refitROT() or (InDetFlags.trtExtensionType() == 'DAF'))) #InDetExtensionProcessor.OutputLevel = VERBOSE if InDetFlags.materialInteractions(): InDetExtensionProcessor.matEffects = InDetFlags.materialInteractionsType() else: InDetExtensionProcessor.matEffects = 0 topSequence += InDetExtensionProcessor if (InDetFlags.doPrintConfigurables()): printfunc (InDetExtensionProcessor) # --- Delete Resolved Si tracks and extension map from InDetRecExample.ConfiguredInDetSGDeletion import InDetSGDeletionAlg InDetSGDeletionAlg(container = "TrackExtensionMap#", key = OutputExtendedTracks) if not InDetFlags.doMonitoringAlignment(): InDetSGDeletionAlg(key = SiTrackCollection) # # ------------ Track truth. # if not InDetFlags.doSGDeletion(): if InDetFlags.doTruth(): # # set up the truth info for this container # include ("InDetRecExample/ConfiguredInDetTrackTruth.py") InDetTracksTruth = ConfiguredInDetTrackTruth(self.__ForwardTrackCollection, self.__ForwardTrackCollection+"DetailedTruth", self.__ForwardTrackCollection+"TruthCollection") # # add final output for statistics # TrackCollectionKeys += [ InDetTracksTruth.Tracks() ] TrackCollectionTruthKeys += [ InDetTracksTruth.TracksTruth() ] else: TrackCollectionKeys += [ self.__ForwardTrackCollection ] # else: self.__ForwardTrackCollection = SiTrackCollection
def __init__(self, InputCollections=None, ResolvedTrackCollectionKey=None, SiSPSeededTrackCollectionKey=None, NewTrackingCuts=None, TrackCollectionKeys=[], TrackCollectionTruthKeys=[]): from InDetRecExample.InDetJobProperties import InDetFlags from InDetRecExample.InDetKeys import InDetKeys import InDetRecExample.TrackingCommon as TrackingCommon # # --- get ToolSvc and topSequence # from AthenaCommon.AppMgr import ToolSvc from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() # # --- decide if use the association tool # if (len(InputCollections) > 0) and ( NewTrackingCuts.mode() == "LowPt" or NewTrackingCuts.mode() == "VeryLowPt" or NewTrackingCuts.mode() == "LargeD0" or NewTrackingCuts.mode() == "R3LargeD0" or NewTrackingCuts.mode() == "LowPtLargeD0" or NewTrackingCuts.mode() == "BeamGas" or NewTrackingCuts.mode() == "ForwardTracks" or NewTrackingCuts.mode() == "ForwardSLHCTracks" or NewTrackingCuts.mode() == "Disappearing" or NewTrackingCuts.mode() == "VeryForwardSLHCTracks" or NewTrackingCuts.mode() == "SLHCConversionFinding"): usePrdAssociationTool = True else: usePrdAssociationTool = False # # --- get list of already associated hits (always do this, even if no other tracking ran before) # asso_tool = None if usePrdAssociationTool: prefix = 'InDet' suffix = NewTrackingCuts.extension() InDetPRD_Association = TrackingCommon.getInDetTrackPRD_Association( namePrefix=prefix, nameSuffix=suffix, TracksName=list(InputCollections)) # asso_tool = TrackingCommon.getConstPRD_AssociationTool(namePrefix = prefix, nameSuffix = suffix) topSequence += InDetPRD_Association if (InDetFlags.doPrintConfigurables()): printfunc(InDetPRD_Association) # ------------------------------------------------------------ # # ----------- SiSPSeededTrackFinder # # ------------------------------------------------------------ if InDetFlags.doSiSPSeededTrackFinder(): # # --- Space points seeds maker, use different ones for cosmics and collisions # if NewTrackingCuts.mode() == "DBM": from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_ATLxk as SiSpacePointsSeedMaker elif InDetFlags.doCosmics(): from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_Cosmic as SiSpacePointsSeedMaker elif InDetFlags.doHeavyIon(): from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_HeavyIon as SiSpacePointsSeedMaker elif NewTrackingCuts.mode() == "LowPt" or NewTrackingCuts.mode( ) == "VeryLowPt" or (NewTrackingCuts.mode() == "Pixel" and InDetFlags.doMinBias()): from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_LowMomentum as SiSpacePointsSeedMaker elif NewTrackingCuts.mode() == "BeamGas": from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_BeamGas as SiSpacePointsSeedMaker elif NewTrackingCuts.mode() == "SLHC" or NewTrackingCuts.mode( ) == "ForwardSLHCTracks" or NewTrackingCuts.mode( ) == "VeryForwardSLHCTracks": from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_ITK as SiSpacePointsSeedMaker else: from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_ATLxk as SiSpacePointsSeedMaker InDetSiSpacePointsSeedMaker = SiSpacePointsSeedMaker( name="InDetSpSeedsMaker" + NewTrackingCuts.extension(), pTmin=NewTrackingCuts.minPT(), maxdImpact=NewTrackingCuts.maxPrimaryImpact(), maxZ=NewTrackingCuts.maxZImpact(), minZ=-NewTrackingCuts.maxZImpact(), usePixel=NewTrackingCuts.usePixel(), SpacePointsPixelName=InDetKeys.PixelSpacePoints(), # useSCT = NewTrackingCuts.useSCT(), useSCT=(NewTrackingCuts.useSCT() and NewTrackingCuts.useSCTSeeding()), SpacePointsSCTName=InDetKeys.SCT_SpacePoints(), # useOverlapSpCollection = NewTrackingCuts.useSCT(), useOverlapSpCollection=(NewTrackingCuts.useSCT() and NewTrackingCuts.useSCTSeeding()), SpacePointsOverlapName=InDetKeys.OverlapSpacePoints(), radMax=NewTrackingCuts.radMax(), RapidityCut=NewTrackingCuts.maxEta()) if NewTrackingCuts.mode() == "Offline" or InDetFlags.doHeavyIon( ) or NewTrackingCuts.mode() == "ForwardTracks": InDetSiSpacePointsSeedMaker.maxdImpactPPS = NewTrackingCuts.maxdImpactPPSSeeds( ) InDetSiSpacePointsSeedMaker.maxdImpactSSS = NewTrackingCuts.maxdImpactSSSSeeds( ) if not InDetFlags.doHeavyIon(): InDetSiSpacePointsSeedMaker.maxSeedsForSpacePointStrips = NewTrackingCuts.MaxSeedsPerSP_Strips( ) InDetSiSpacePointsSeedMaker.maxSeedsForSpacePointPixels = NewTrackingCuts.MaxSeedsPerSP_Pixels( ) InDetSiSpacePointsSeedMaker.alwaysKeepConfirmedStripSeeds = NewTrackingCuts.KeepAllConfirmedStripSeeds( ) InDetSiSpacePointsSeedMaker.alwaysKeepConfirmedPixelSeeds = NewTrackingCuts.KeepAllConfirmedPixelSeeds( ) if NewTrackingCuts.mode() == "R3LargeD0": InDetSiSpacePointsSeedMaker.optimisePhiBinning = False InDetSiSpacePointsSeedMaker.usePixel = False InDetSiSpacePointsSeedMaker.etaMax = NewTrackingCuts.maxEta() InDetSiSpacePointsSeedMaker.maxSeedsForSpacePointStrips = NewTrackingCuts.MaxSeedsPerSP_Strips( ) InDetSiSpacePointsSeedMaker.alwaysKeepConfirmedStripSeeds = NewTrackingCuts.KeepAllConfirmedStripSeeds( ) InDetSiSpacePointsSeedMaker.maxdRadius = 150 InDetSiSpacePointsSeedMaker.seedScoreBonusConfirmationSeed = -2000 #let's be generous if usePrdAssociationTool: # not all classes have that property !!! InDetSiSpacePointsSeedMaker.PRDtoTrackMap = prefix+'PRDtoTrackMap'+suffix \ if usePrdAssociationTool else '' if not InDetFlags.doCosmics(): InDetSiSpacePointsSeedMaker.maxRadius1 = 0.75 * NewTrackingCuts.radMax( ) InDetSiSpacePointsSeedMaker.maxRadius2 = NewTrackingCuts.radMax( ) InDetSiSpacePointsSeedMaker.maxRadius3 = NewTrackingCuts.radMax( ) if NewTrackingCuts.mode() == "LowPt" or NewTrackingCuts.mode( ) == "VeryLowPt" or (NewTrackingCuts.mode() == "Pixel" and InDetFlags.doMinBias()): try: InDetSiSpacePointsSeedMaker.pTmax = NewTrackingCuts.maxPT() except: pass InDetSiSpacePointsSeedMaker.mindRadius = 4.0 if NewTrackingCuts.mode() == "SLHC" or NewTrackingCuts.mode( ) == "SLHCConversionFinding": InDetSiSpacePointsSeedMaker.minRadius1 = 0 InDetSiSpacePointsSeedMaker.minRadius2 = 0 InDetSiSpacePointsSeedMaker.minRadius3 = 0 InDetSiSpacePointsSeedMaker.maxRadius1 = 1000. * Units.mm InDetSiSpacePointsSeedMaker.maxRadius2 = 1000. * Units.mm InDetSiSpacePointsSeedMaker.maxRadius3 = 1000. * Units.mm if NewTrackingCuts.mode( ) == "ForwardTracks" or NewTrackingCuts.mode( ) == "ForwardSLHCTracks" or NewTrackingCuts.mode( ) == "VeryForwardSLHCTracks": InDetSiSpacePointsSeedMaker.checkEta = True InDetSiSpacePointsSeedMaker.etaMin = NewTrackingCuts.minEta() InDetSiSpacePointsSeedMaker.etaMax = NewTrackingCuts.maxEta() InDetSiSpacePointsSeedMaker.RapidityCut = NewTrackingCuts.maxEta( ) if NewTrackingCuts.mode() == "DBM": InDetSiSpacePointsSeedMaker.etaMin = NewTrackingCuts.minEta() InDetSiSpacePointsSeedMaker.etaMax = NewTrackingCuts.maxEta() InDetSiSpacePointsSeedMaker.useDBM = True #InDetSiSpacePointsSeedMaker.OutputLevel = VERBOSE ToolSvc += InDetSiSpacePointsSeedMaker if (InDetFlags.doPrintConfigurables()): printfunc(InDetSiSpacePointsSeedMaker) # # --- Z-coordinates primary vertices finder (only for collisions) # if InDetFlags.useZvertexTool() and NewTrackingCuts.mode() != "DBM": from SiZvertexTool_xk.SiZvertexTool_xkConf import InDet__SiZvertexMaker_xk InDetZvertexMaker = InDet__SiZvertexMaker_xk( name='InDetZvertexMaker' + NewTrackingCuts.extension(), Zmax=NewTrackingCuts.maxZImpact(), Zmin=-NewTrackingCuts.maxZImpact(), minRatio=0.17) # not default InDetZvertexMaker.SeedMakerTool = InDetSiSpacePointsSeedMaker if InDetFlags.doHeavyIon(): InDetZvertexMaker.HistSize = 2000 ###InDetZvertexMaker.minContent = 200 InDetZvertexMaker.minContent = 30 ToolSvc += InDetZvertexMaker if (InDetFlags.doPrintConfigurables()): printfunc(InDetZvertexMaker) else: InDetZvertexMaker = None # # --- SCT and Pixel detector elements road builder # from SiDetElementsRoadTool_xk.SiDetElementsRoadTool_xkConf import InDet__SiDetElementsRoadMaker_xk InDetSiDetElementsRoadMaker = InDet__SiDetElementsRoadMaker_xk( name='InDetSiRoadMaker' + NewTrackingCuts.extension(), PropagatorTool=InDetPatternPropagator, usePixel=NewTrackingCuts.usePixel(), PixManagerLocation=InDetKeys.PixelManager(), useSCT=NewTrackingCuts.useSCT(), SCTManagerLocation=InDetKeys.SCT_Manager(), RoadWidth=NewTrackingCuts.RoadWidth()) if (InDetFlags.doPrintConfigurables()): printfunc(InDetSiDetElementsRoadMaker) # Condition algorithm for InDet__SiDetElementsRoadMaker_xk if DetFlags.haveRIO.pixel_on(): # Condition algorithm for SiCombinatorialTrackFinder_xk from AthenaCommon.AlgSequence import AthSequencer condSeq = AthSequencer("AthCondSeq") if not hasattr(condSeq, "InDetSiDetElementBoundaryLinksPixelCondAlg"): from SiCombinatorialTrackFinderTool_xk.SiCombinatorialTrackFinderTool_xkConf import InDet__SiDetElementBoundaryLinksCondAlg_xk condSeq += InDet__SiDetElementBoundaryLinksCondAlg_xk( name="InDetSiDetElementBoundaryLinksPixelCondAlg", ReadKey="PixelDetectorElementCollection", WriteKey="PixelDetElementBoundaryLinks_xk", UsePixelDetectorManager=True) if NewTrackingCuts.useSCT(): from AthenaCommon.AlgSequence import AthSequencer condSeq = AthSequencer("AthCondSeq") if not hasattr(condSeq, "InDet__SiDetElementsRoadCondAlg_xk"): from SiDetElementsRoadTool_xk.SiDetElementsRoadTool_xkConf import InDet__SiDetElementsRoadCondAlg_xk condSeq += InDet__SiDetElementsRoadCondAlg_xk( name="InDet__SiDetElementsRoadCondAlg_xk") if not hasattr(condSeq, "InDetSiDetElementBoundaryLinksSCTCondAlg"): from SiCombinatorialTrackFinderTool_xk.SiCombinatorialTrackFinderTool_xkConf import InDet__SiDetElementBoundaryLinksCondAlg_xk condSeq += InDet__SiDetElementBoundaryLinksCondAlg_xk( name="InDetSiDetElementBoundaryLinksSCTCondAlg", ReadKey="SCT_DetectorElementCollection", WriteKey="SCT_DetElementBoundaryLinks_xk") # # --- Local track finding using sdCaloSeededSSSpace point seed # # @TODO ensure that PRD association map is used if usePrdAssociationTool is set is_dbm = InDetFlags.doDBMstandalone() or NewTrackingCuts.extension( ) == 'DBM' rot_creator_digital = TrackingCommon.getInDetRotCreatorDigital( ) if not is_dbm else TrackingCommon.getInDetRotCreatorDBM() from SiCombinatorialTrackFinderTool_xk.SiCombinatorialTrackFinderTool_xkConf import InDet__SiCombinatorialTrackFinder_xk track_finder = InDet__SiCombinatorialTrackFinder_xk( name='InDetSiComTrackFinder' + NewTrackingCuts.extension(), PropagatorTool=InDetPatternPropagator, UpdatorTool=InDetPatternUpdator, RIOonTrackTool=rot_creator_digital, usePixel=DetFlags.haveRIO.pixel_on(), useSCT=DetFlags.haveRIO.SCT_on() if not is_dbm else False, PixelClusterContainer=InDetKeys.PixelClusters(), SCT_ClusterContainer=InDetKeys.SCT_Clusters()) if is_dbm: track_finder.MagneticFieldMode = "NoField" track_finder.TrackQualityCut = 9.3 if (DetFlags.haveRIO.SCT_on()): track_finder.SctSummaryTool = InDetSCT_ConditionsSummaryTool else: track_finder.SctSummaryTool = None ToolSvc += track_finder useBremMode = NewTrackingCuts.mode( ) == "Offline" or NewTrackingCuts.mode( ) == "SLHC" or NewTrackingCuts.mode() == "DBM" from SiTrackMakerTool_xk.SiTrackMakerTool_xkConf import InDet__SiTrackMaker_xk as SiTrackMaker InDetSiTrackMaker = SiTrackMaker( name='InDetSiTrackMaker' + NewTrackingCuts.extension(), useSCT=NewTrackingCuts.useSCT(), usePixel=NewTrackingCuts.usePixel(), RoadTool=InDetSiDetElementsRoadMaker, CombinatorialTrackFinder=track_finder, pTmin=NewTrackingCuts.minPT(), pTminBrem=NewTrackingCuts.minPTBrem(), pTminSSS=InDetFlags.pT_SSScut(), nClustersMin=NewTrackingCuts.minClusters(), nHolesMax=NewTrackingCuts.nHolesMax(), nHolesGapMax=NewTrackingCuts.nHolesGapMax(), SeedsFilterLevel=NewTrackingCuts.seedFilterLevel(), Xi2max=NewTrackingCuts.Xi2max(), Xi2maxNoAdd=NewTrackingCuts.Xi2maxNoAdd(), nWeightedClustersMin=NewTrackingCuts.nWeightedClustersMin(), CosmicTrack=InDetFlags.doCosmics(), Xi2maxMultiTracks=NewTrackingCuts.Xi2max(), # was 3. useSSSseedsFilter=InDetFlags.doSSSfilter(), doMultiTracksProd=True, useBremModel=InDetFlags.doBremRecovery() and useBremMode, # only for NewTracking the brem is debugged !!! doCaloSeededBrem=InDetFlags.doCaloSeededBrem(), doHadCaloSeedSSS=InDetFlags.doHadCaloSeededSSS(), phiWidth=NewTrackingCuts.phiWidthBrem(), etaWidth=NewTrackingCuts.etaWidthBrem(), InputClusterContainerName=InDetKeys.CaloClusterROIContainer( ), # "InDetCaloClusterROIs" InputHadClusterContainerName=InDetKeys. HadCaloClusterROIContainer(), # "InDetCaloClusterROIs" UseAssociationTool=usePrdAssociationTool) if NewTrackingCuts.mode() == "SLHC" or NewTrackingCuts.mode( ) == "ForwardSLHCTracks" or NewTrackingCuts.mode( ) == "VeryForwardSLHCTracks": InDetSiTrackMaker.ITKGeometry = True if NewTrackingCuts.mode() == "DBM": InDetSiTrackMaker.MagneticFieldMode = "NoField" InDetSiTrackMaker.useBremModel = False InDetSiTrackMaker.doMultiTracksProd = False InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSPSeededFinder' InDetSiTrackMaker.pTminSSS = -1 InDetSiTrackMaker.CosmicTrack = False InDetSiTrackMaker.useSSSseedsFilter = False InDetSiTrackMaker.doCaloSeededBrem = False InDetSiTrackMaker.doHadCaloSeedSSS = False elif InDetFlags.doCosmics(): InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_Cosmic' elif InDetFlags.doHeavyIon(): InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_HeavyIon' elif NewTrackingCuts.mode() == "LowPt": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_LowMomentum' elif NewTrackingCuts.mode() == "VeryLowPt" or ( NewTrackingCuts.mode() == "Pixel" and InDetFlags.doMinBias()): InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_VeryLowMomentum' elif NewTrackingCuts.mode() == "BeamGas": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_BeamGas' elif NewTrackingCuts.mode() == "ForwardTracks": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_ForwardTracks' elif NewTrackingCuts.mode() == "ForwardSLHCTracks": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_ForwardSLHCTracks' elif NewTrackingCuts.mode() == "VeryForwardSLHCTracks": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_VeryForwardSLHCTracks' elif NewTrackingCuts.mode() == "SLHCConversionFinding": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_SLHCConversionTracks' elif NewTrackingCuts.mode() == "LargeD0" or NewTrackingCuts.mode( ) == "R3LargeD0" or NewTrackingCuts.mode() == "LowPtLargeD0": InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSpacePointsSeedMaker_LargeD0' else: InDetSiTrackMaker.TrackPatternRecoInfo = 'SiSPSeededFinder' if InDetFlags.doStoreTrackSeeds(): from SeedToTrackConversionTool.SeedToTrackConversionToolConf import InDet__SeedToTrackConversionTool InDet_SeedToTrackConversion = InDet__SeedToTrackConversionTool( name="InDet_SeedToTrackConversion", OutputName=InDetKeys.SiSPSeedSegments() + NewTrackingCuts.extension()) InDetSiTrackMaker.SeedToTrackConversion = InDet_SeedToTrackConversion InDetSiTrackMaker.SeedSegmentsWrite = True #InDetSiTrackMaker.OutputLevel = VERBOSE ToolSvc += InDetSiTrackMaker if (InDetFlags.doPrintConfigurables()): printfunc(InDetSiTrackMaker) # # set output track collection name # self.__SiTrackCollection = SiSPSeededTrackCollectionKey # # --- Setup Track finder using space points seeds # from SiSPSeededTrackFinder.SiSPSeededTrackFinderConf import InDet__SiSPSeededTrackFinder if NewTrackingCuts.mode( ) == "ForwardSLHCTracks" or NewTrackingCuts.mode( ) == "ForwardTracks": InDetSiSPSeededTrackFinder = InDet__SiSPSeededTrackFinder(name = 'InDetSiSpTrackFinder'+NewTrackingCuts.extension(), TrackTool = InDetSiTrackMaker, PRDtoTrackMap = prefix+'PRDtoTrackMap'+suffix \ if usePrdAssociationTool else '', TrackSummaryTool = TrackingCommon.getInDetTrackSummaryToolNoHoleSearch(), TracksLocation = self.__SiTrackCollection, SeedsTool = InDetSiSpacePointsSeedMaker, useZvertexTool = InDetFlags.useZvertexTool(), ZvertexTool = InDetZvertexMaker, useNewStrategy = False, useMBTSTimeDiff = InDetFlags.useMBTSTimeDiff(), useZBoundFinding = False) if InDetFlags.doHeavyIon(): InDetSiSPSeededTrackFinder.FreeClustersCut = 2 #Heavy Ion optimization from Igor else: InDetSiSPSeededTrackFinder = InDet__SiSPSeededTrackFinder(name = 'InDetSiSpTrackFinder'+NewTrackingCuts.extension(), TrackTool = InDetSiTrackMaker, PRDtoTrackMap = prefix+'PRDtoTrackMap'+suffix \ if usePrdAssociationTool else '', TrackSummaryTool = TrackingCommon.getInDetTrackSummaryToolNoHoleSearch(), TracksLocation = self.__SiTrackCollection, SeedsTool = InDetSiSpacePointsSeedMaker, useZvertexTool = InDetFlags.useZvertexTool() and NewTrackingCuts.mode() != "DBM", ZvertexTool = InDetZvertexMaker, useNewStrategy = InDetFlags.useNewSiSPSeededTF() and NewTrackingCuts.mode() != "DBM", useMBTSTimeDiff = InDetFlags.useMBTSTimeDiff(), useZBoundFinding = NewTrackingCuts.doZBoundary() and NewTrackingCuts.mode() != "DBM") if InDetFlags.doHeavyIon(): InDetSiSPSeededTrackFinder.FreeClustersCut = 2 #Heavy Ion optimization from Igor #InDetSiSPSeededTrackFinder.OutputLevel =VERBOSE topSequence += InDetSiSPSeededTrackFinder if (InDetFlags.doPrintConfigurables()): printfunc(InDetSiSPSeededTrackFinder) if not InDetFlags.doSGDeletion(): if InDetFlags.doTruth(): # # set up the truth info for this container # include("InDetRecExample/ConfiguredInDetTrackTruth.py") InDetTracksTruth = ConfiguredInDetTrackTruth( self.__SiTrackCollection, self.__SiTrackCollection + "DetailedTruth", self.__SiTrackCollection + "TruthCollection") # # add final output for statistics # TrackCollectionKeys += [InDetTracksTruth.Tracks()] TrackCollectionTruthKeys += [ InDetTracksTruth.TracksTruth() ] else: TrackCollectionKeys += [self.__SiTrackCollection] # ------------------------------------------------------------ # # ---------- Ambiguity solving # # ------------------------------------------------------------ if InDetFlags.doAmbiSolving(): # # --- load InnerDetector TrackSelectionTool # prob1 = InDetFlags.pixelClusterSplitProb1() prob2 = InDetFlags.pixelClusterSplitProb2() nhitsToAllowSplitting = 9 from AtlasGeoModel.CommonGMJobProperties import CommonGeometryFlags if CommonGeometryFlags.Run() == 1: prob1 = InDetFlags.pixelClusterSplitProb1_run1() prob2 = InDetFlags.pixelClusterSplitProb2_run1() nhitsToAllowSplitting = 8 if InDetFlags.doTIDE_Ambi() and not ( NewTrackingCuts.mode() == "ForwardSLHCTracks" or NewTrackingCuts.mode() == "ForwardTracks" or NewTrackingCuts.mode() == "DBM"): from InDetAmbiTrackSelectionTool.InDetAmbiTrackSelectionToolConf import InDet__InDetDenseEnvAmbiTrackSelectionTool as AmbiTrackSelectionTool else: from InDetAmbiTrackSelectionTool.InDetAmbiTrackSelectionToolConf import InDet__InDetAmbiTrackSelectionTool as AmbiTrackSelectionTool InDetAmbiTrackSelectionTool = AmbiTrackSelectionTool( name='InDetAmbiTrackSelectionTool' + NewTrackingCuts.extension(), DriftCircleCutTool=InDetTRTDriftCircleCut, AssociationTool=TrackingCommon. getInDetPRDtoTrackMapToolGangedPixels(), minHits=NewTrackingCuts.minClusters(), minNotShared=NewTrackingCuts.minSiNotShared(), maxShared=NewTrackingCuts.maxShared(), minTRTHits=0, # used for Si only tracking !!! sharedProbCut=0.10, UseParameterization=False, Cosmics=InDetFlags.doCosmics(), doPixelSplitting=InDetFlags.doPixelClusterSplitting() and NewTrackingCuts.mode != "DBM") if InDetFlags.doTIDE_Ambi() and not ( NewTrackingCuts.mode() == "ForwardSLHCTracks" or NewTrackingCuts.mode() == "ForwardTracks" or NewTrackingCuts.mode() == "DBM"): InDetAmbiTrackSelectionTool.sharedProbCut = prob1 InDetAmbiTrackSelectionTool.sharedProbCut2 = prob2 InDetAmbiTrackSelectionTool.minSiHitsToAllowSplitting = nhitsToAllowSplitting InDetAmbiTrackSelectionTool.minUniqueSCTHits = 4 InDetAmbiTrackSelectionTool.minTrackChi2ForSharedHits = 3 InDetAmbiTrackSelectionTool.InputHadClusterContainerName = InDetKeys.HadCaloClusterROIContainer( ) + "Bjet" InDetAmbiTrackSelectionTool.doHadCaloSeed = InDetFlags.doCaloSeededAmbi( ) #Do special cuts in region of interest InDetAmbiTrackSelectionTool.minPtSplit = InDetFlags.pixelClusterSplitMinPt( ) #Only allow split clusters on track withe pt greater than this MeV InDetAmbiTrackSelectionTool.maxSharedModulesInROI = 3 #Maximum number of shared modules for tracks in ROI InDetAmbiTrackSelectionTool.minNotSharedInROI = 2 #Minimum number of unique modules for tracks in ROI InDetAmbiTrackSelectionTool.minSiHitsToAllowSplittingInROI = 7 #Minimum number of Si hits to allow splittings for tracks in ROI InDetAmbiTrackSelectionTool.phiWidth = 0.1 #Split cluster ROI size InDetAmbiTrackSelectionTool.etaWidth = 0.1 #Split cluster ROI size InDetAmbiTrackSelectionTool.InputEmClusterContainerName = InDetKeys.CaloClusterROIContainer( ) InDetAmbiTrackSelectionTool.doEmCaloSeed = False #Only split in cluster in region of interest InDetAmbiTrackSelectionTool.minPtConv = 10000 #Only allow split clusters on track withe pt greater than this MeV InDetAmbiTrackSelectionTool.phiWidthEM = 0.05 #Split cluster ROI size InDetAmbiTrackSelectionTool.etaWidthEM = 0.05 #Split cluster ROI size if NewTrackingCuts.mode() == "DBM": InDetAmbiTrackSelectionTool.Cosmics = False InDetAmbiTrackSelectionTool.UseParameterization = False InDetAmbiTrackSelectionTool.doPixelSplitting = False InDetAmbiTrackSelectionTool.maxShared = 1000 InDetAmbiTrackSelectionTool.maxTracksPerSharedPRD = 2 InDetAmbiTrackSelectionTool.minHits = 0 InDetAmbiTrackSelectionTool.minNotShared = 0 InDetAmbiTrackSelectionTool.minScoreShareTracks = 0.0 InDetAmbiTrackSelectionTool.minTRTHits = 0 InDetAmbiTrackSelectionTool.sharedProbCut = 0.1 # if NewTrackingCuts.mode() == "ForwardTracks": # InDetAmbiTrackSelectionTool.OutputLevel = VERBOSE ToolSvc += InDetAmbiTrackSelectionTool if (InDetFlags.doPrintConfigurables()): printfunc(InDetAmbiTrackSelectionTool) # # --- set up different Scoring Tool for collisions and cosmics # if InDetFlags.doCosmics() and NewTrackingCuts.mode() != "DBM": InDetAmbiScoringTool = TrackingCommon.getInDetCosmicsScoringTool( NewTrackingCuts) elif (NewTrackingCuts.mode() == "R3LargeD0" and InDetFlags.nnCutLargeD0Threshold > 0): # Set up NN config InDetAmbiScoringTool = TrackingCommon.getInDetNNScoringTool( NewTrackingCuts) else: InDetAmbiScoringTool = TrackingCommon.getInDetAmbiScoringTool( NewTrackingCuts) # # --- load Ambiguity Processor # useBremMode = NewTrackingCuts.mode( ) == "Offline" or NewTrackingCuts.mode() == "SLHC" if InDetFlags.doTIDE_Ambi() and not ( NewTrackingCuts.mode() == "ForwardSLHCTracks" or NewTrackingCuts.mode() == "ForwardTracks" or NewTrackingCuts.mode() == "DBM"): # DenseEnvironmentsAmbiguityProcessorTool from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__DenseEnvironmentsAmbiguityProcessorTool as ProcessorTool use_low_pt_fitter = True if NewTrackingCuts.mode( ) == "LowPt" or NewTrackingCuts.mode() == "VeryLowPt" or ( NewTrackingCuts.mode() == "Pixel" and InDetFlags.doMinBias()) else False from AthenaCommon import CfgGetter from InDetRecExample.TrackingCommon import setDefaults if len(NewTrackingCuts.extension()) > 0: fitter_args = setDefaults( {}, SplitClusterMapExtension=NewTrackingCuts.extension()) fitter_list=[ CfgGetter.getPublicToolClone('InDetTrackFitter'+NewTrackingCuts.extension(), 'InDetTrackFitter',**fitter_args) if not use_low_pt_fitter \ else CfgGetter.getPublicToolClone('InDetTrackFitterLowPt'+NewTrackingCuts.extension(), 'InDetTrackFitterLowPt',**fitter_args)] else: fitter_list=[ CfgGetter.getPublicTool('InDetTrackFitter') if not use_low_pt_fitter \ else CfgGetter.getPublicTool('InDetTrackFitterLowPt')] if InDetFlags.doRefitInvalidCov(): from AthenaCommon import CfgGetter if len(NewTrackingCuts.extension()) > 0: fitter_args = setDefaults( {}, SplitClusterMapExtension=NewTrackingCuts.extension( )) fitter_list.append( CfgGetter.getPublicToolClone( 'KalmanFitter' + NewTrackingCuts.extension(), 'KalmanFitter', **fitter_args)) fitter_list.append( CfgGetter.getPublicToolClone( 'ReferenceKalmanFitter' + NewTrackingCuts.extension(), 'ReferenceKalmanFitter', **fitter_args)) else: fitter_list.append( CfgGetter.getPublicTool('KalmanFitter')) fitter_list.append( CfgGetter.getPublicTool('ReferenceKalmanFitter')) InDetAmbiguityProcessor = ProcessorTool( name='InDetAmbiguityProcessor' + NewTrackingCuts.extension(), Fitter=fitter_list, AssociationTool=TrackingCommon. getInDetPRDtoTrackMapToolGangedPixels(), AssociationMapName='PRDToTrackMap' + NewTrackingCuts.extension(), TrackSummaryTool=TrackingCommon.getInDetTrackSummaryTool(), ScoringTool=InDetAmbiScoringTool, SelectionTool=InDetAmbiTrackSelectionTool, SuppressHoleSearch=False, tryBremFit=InDetFlags.doBremRecovery() and useBremMode and NewTrackingCuts.mode() != "DBM", caloSeededBrem=InDetFlags.doCaloSeededBrem() and NewTrackingCuts.mode() != "DBM", pTminBrem=NewTrackingCuts.minPTBrem(), RefitPrds=True, doHadCaloSeed=InDetFlags.doCaloSeededRefit(), InputHadClusterContainerName=InDetKeys. HadCaloClusterROIContainer() + "Bjet") # DenseEnvironmentsAmbiguityScoreProcessorTool from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__DenseEnvironmentsAmbiguityScoreProcessorTool as ScoreProcessorTool InDetAmbiguityScoreProcessor = ScoreProcessorTool( name='InDetAmbiguityScoreProcessor' + NewTrackingCuts.extension(), ScoringTool=InDetAmbiScoringTool, SplitProbTool=NnPixelClusterSplitProbTool if InDetFlags.doPixelClusterSplitting() and 'NnPixelClusterSplitProbTool' in globals() else None, AssociationTool=TrackingCommon. getInDetPRDtoTrackMapToolGangedPixels(), AssociationToolNotGanged=TrackingCommon. getPRDtoTrackMapTool(), AssociationMapName='PRDToTrackMap' + NewTrackingCuts.extension(), SelectionTool=InDetAmbiTrackSelectionTool) # hasScoreProcessorTool = True else: from AthenaCommon import CfgGetter from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__SimpleAmbiguityProcessorTool as ProcessorTool InDetAmbiguityProcessor = ProcessorTool( name='InDetAmbiguityProcessor' + NewTrackingCuts.extension(), Fitter=CfgGetter.getPublicTool('InDetTrackFitter'), AssociationTool=TrackingCommon. getInDetPRDtoTrackMapToolGangedPixels(), TrackSummaryTool=TrackingCommon.getInDetTrackSummaryTool(), ScoringTool=InDetAmbiScoringTool, SelectionTool=InDetAmbiTrackSelectionTool, SuppressHoleSearch=False, tryBremFit=InDetFlags.doBremRecovery() and useBremMode and NewTrackingCuts.mode() != "DBM", caloSeededBrem=InDetFlags.doCaloSeededBrem() and NewTrackingCuts.mode() != "DBM", pTminBrem=NewTrackingCuts.minPTBrem(), RefitPrds=True) InDetAmbiguityScoreProcessor = None if InDetFlags.doTIDE_Ambi() and not ( NewTrackingCuts.mode() == "ForwardSLHCTracks" or NewTrackingCuts.mode() == "ForwardTracks" or NewTrackingCuts.mode() == "DBM") and 'NnPixelClusterSplitProbTool' in globals(): if InDetAmbiguityScoreProcessor is not None: InDetAmbiguityScoreProcessor.sharedProbCut = prob1 InDetAmbiguityScoreProcessor.sharedProbCut2 = prob2 if NewTrackingCuts.extension() == "": InDetAmbiguityScoreProcessor.SplitClusterMap_old = "" elif NewTrackingCuts.extension() == "Disappearing": InDetAmbiguityScoreProcessor.SplitClusterMap_old = InDetKeys.SplitClusterAmbiguityMap( ) InDetAmbiguityScoreProcessor.SplitClusterMap_new = InDetKeys.SplitClusterAmbiguityMap( ) + NewTrackingCuts.extension() if InDetFlags.doTIDE_RescalePixelCovariances(): InDetAmbiguityProcessor.applydRcorrection = True if NewTrackingCuts.mode() == "Pixel" or NewTrackingCuts.mode( ) == "DBM": InDetAmbiguityProcessor.SuppressHoleSearch = True if NewTrackingCuts.mode() == "LowPt" or NewTrackingCuts.mode( ) == "VeryLowPt" or (NewTrackingCuts.mode() == "Pixel" and InDetFlags.doMinBias()): if InDetAmbiguityProcessor.getName().find('Dense'): pass else: from AthenaCommon import CfgGetter InDetAmbiguityProcessor.Fitter = CfgGetter.getPublicTool( 'InDetTrackFitterLowPt') if InDetFlags.materialInteractions(): InDetAmbiguityProcessor.MatEffects = InDetFlags.materialInteractionsType( ) else: InDetAmbiguityProcessor.MatEffects = 0 # if NewTrackingCuts.mode() == "ForwardTracks": # InDetAmbiguityProcessor.OutputLevel = VERBOSE ToolSvc += InDetAmbiguityProcessor if (InDetFlags.doPrintConfigurables()): printfunc(InDetAmbiguityProcessor) # add InDetAmbiguityScoreProcessor if InDetAmbiguityScoreProcessor is not None: ToolSvc += InDetAmbiguityScoreProcessor # # --- set input and output collection # InputTrackCollection = self.__SiTrackCollection self.__SiTrackCollection = ResolvedTrackCollectionKey # # --- configure Ambiguity (score) solver # from TrkAmbiguitySolver.TrkAmbiguitySolverConf import Trk__TrkAmbiguityScore # from RecExConfig.hideInput import hideInput # hideInput ('TrackCollection', self.__SiTrackCollection) InDetAmbiguityScore = Trk__TrkAmbiguityScore( name='InDetAmbiguityScore' + NewTrackingCuts.extension(), TrackInput=[InputTrackCollection], TrackOutput='ScoredMap' + 'InDetAmbiguityScore' + NewTrackingCuts.extension(), AmbiguityScoreProcessor=InDetAmbiguityScoreProcessor ) ## TODO: check the case when it is None object topSequence += InDetAmbiguityScore if (InDetFlags.doPrintConfigurables()): printfunc(InDetAmbiguityScore) # # --- configure Ambiguity solver # from TrkAmbiguitySolver.TrkAmbiguitySolverConf import Trk__TrkAmbiguitySolver from RecExConfig.hideInput import hideInput hideInput('TrackCollection', self.__SiTrackCollection) InDetAmbiguitySolver = Trk__TrkAmbiguitySolver( name='InDetAmbiguitySolver' + NewTrackingCuts.extension(), TrackInput='ScoredMap' + 'InDetAmbiguityScore' + NewTrackingCuts.extension(), TrackOutput=self.__SiTrackCollection, AmbiguityProcessor=InDetAmbiguityProcessor) topSequence += InDetAmbiguitySolver if (InDetFlags.doPrintConfigurables()): printfunc(InDetAmbiguitySolver) # # --- Delete Silicon Sp-Seeded tracks # from InDetRecExample.ConfiguredInDetSGDeletion import InDetSGDeletionAlg InDetSGDeletionAlg(key=SiSPSeededTrackCollectionKey) if ((NewTrackingCuts.mode() in ["Pixel", "SCT"]) or not InDetFlags.doSGDeletion()): if InDetFlags.doTruth(): # # set up the truth info for this container # include("InDetRecExample/ConfiguredInDetTrackTruth.py") InDetTracksTruth = ConfiguredInDetTrackTruth( self.__SiTrackCollection, self.__SiTrackCollection + "DetailedTruth", self.__SiTrackCollection + "TruthCollection") # # add final output for statistics # TrackCollectionKeys += [InDetTracksTruth.Tracks()] TrackCollectionTruthKeys += [ InDetTracksTruth.TracksTruth() ] else: TrackCollectionKeys += [self.__SiTrackCollection]
print 'NSWGeoSetup: no need to override tag on the MuonSpectrometer Node with ATLAS tag ', DetDescrVersion print 'Be aware that the job is running with NSW TDR setup!' else: GeoModelSvc.MuonVersionOverride="MuonSpectrometer-R.07.00-NSW" print GeoModelSvc #***************************************************** HERE setup MuonDetectorManager from MuonGeoModel.MuonGeoModelConf import MuonDetectorTool MuonDetectorTool = MuonDetectorTool() MuonDetectorTool.StationSelection = 2 MuonDetectorTool.SelectedStations = [ "EIL1" ] MuonDetectorTool.SelectedStations += [ "EIL2" ] MuonDetectorTool.SelectedStations += [ "EIS*" ] MuonDetectorTool.SelectedStations += [ "EIL10" ] MuonDetectorTool.SelectedStations += [ "EIL11" ] MuonDetectorTool.SelectedStations += [ "CSS*" ] MuonDetectorTool.SelectedStations += [ "CSL*" ] MuonDetectorTool.SelectedStations += [ "T4E*" ] MuonDetectorTool.SelectedStations += [ "T4F*" ] from AGDD2GeoSvc.AGDD2GeoSvcConf import AGDDtoGeoSvc Agdd2GeoSvc = AGDDtoGeoSvc() if not "NSWAGDDTool/NewSmallWheel" in Agdd2GeoSvc.Builders: from AthenaCommon import CfgGetter ToolSvc += CfgGetter.getPublicTool("NewSmallWheel", checkType=True) Agdd2GeoSvc.Builders += ["NSWAGDDTool/NewSmallWheel"] theApp.CreateSvc += ["AGDDtoGeoSvc"] ServiceMgr += Agdd2GeoSvc
MuonDetectorTool.SelectedStations += ["EIS*"] MuonDetectorTool.SelectedStations += ["EIL10"] MuonDetectorTool.SelectedStations += ["EIL11"] MuonDetectorTool.SelectedStations += ["EIL12"] MuonDetectorTool.SelectedStations += ["EIL17"] MuonDetectorTool.SelectedStations += ["CSS*"] MuonDetectorTool.SelectedStations += ["CSL*"] MuonDetectorTool.SelectedStations += ["T4E*"] MuonDetectorTool.SelectedStations += ["T4F*"] ## Additional material in the muon system from AGDD2GeoSvc.AGDD2GeoSvcConf import AGDDtoGeoSvc AGDD2Geo = AGDDtoGeoSvc() from AthenaCommon import CfgGetter if not "MuonAGDDTool/MuonSpectrometer" in AGDD2Geo.Builders: ToolSvc += CfgGetter.getPublicTool("MuonSpectrometer", checkType=True) AGDD2Geo.Builders += ["MuonAGDDTool/MuonSpectrometer"] if hasattr(simFlags, 'SimulateNewSmallWheel'): if simFlags.SimulateNewSmallWheel(): if not "NSWAGDDTool/NewSmallWheel" in AGDD2Geo.Builders: ToolSvc += CfgGetter.getPublicTool("NewSmallWheel", checkType=True) AGDD2Geo.Builders += ["NSWAGDDTool/NewSmallWheel"] theApp.CreateSvc += ["AGDDtoGeoSvc"] ServiceMgr += AGDD2Geo ## Add configured GeoModelSvc to service manager ServiceMgr += gms ## AtlasSimSkeleton._do_metadata from G4AtlasApps.SimFlags import simFlags
def __init__(self, name="TrigMuonEFSegmentFinderCosmic"): super(TrigMuonEFSegmentFinderCosmicConfig, self).__init__(name) self.CscClusterProvider = CfgGetter.getPublicTool( "CscThresholdClusterBuilderTool") from MuonRecExample.MooreTools import MooSegmentCombinationFinder self.SegmentsFinderTool = MooSegmentCombinationFinder( "SegmentsFinderToolCosmic", WriteIntermediateResults=False) # use seeded decoding if (TriggerFlags.MuonSlice.doEFRoIDrivenAccess()): self.useMdtSeededDecoding = True self.useRpcSeededDecoding = True self.useTgcSeededDecoding = True self.useCscSeededDecoding = True # use ROB based seeded decoding instead of PRD based self.useMdtRobDecoding = True self.useRpcRobDecoding = True self.useTgcRobDecoding = False # neither available nor needed self.useCscRobDecoding = False # neither available nor needed self.SegmentsFinderTool.HoughPatternFinder.RecordAll = False #self.SegmentsFinderTool.HoughPatternFinder.OutputLevel = DEBUG self.SegmentsFinderTool.HoughPatternFinder.muonHoughPatternTool = TMEF_MuonHoughPatternToolCosmic self.SegmentsFinderTool.HoughPatternFinder.muonCombinePatternTool = TMEF_MuonCombinePatternToolCosmic self.SegmentsFinderTool.MdtSegmentMaker = TMEF_MuonPatternSegmentMakerCosmic self.SegmentsFinderTool.SegmentCombiner = TMEF_MuonCurvedSegmentCombinerCosmic #self.SegmentsFinderTool.SegmentCombinationCleaner = TMEF_MuonSegmentCombinationCleanerToolCosmic #self.SegmentsFinderTool.DoSummary = False #self.SegmentsFinderTool.SegmentCombiner.DoSummary = True #self.print_level = 5 self.histoPathBase = "" self.useRpcData = muonRecFlags.doRPCs() self.useTgcData = muonRecFlags.doTGCs() self.useCscData = muonRecFlags.doCSCs() # to select barrel(useMdtData=2), endcap(useMdtData=3) if muonRecFlags.doMDTs(): self.useMdtData = 1 else: self.useMdtData = 0 self.deltaEtaRoI = 1. self.deltaPhiRoI = 1. self.useTGCInPriorNextBC = True validation_ms = TrigMuonEFSegmentFinderValidationMonitoring() online_ms = TrigMuonEFSegmentFinderOnlineMonitoring() cosmic_ms = TrigMuonEFSegmentFinderCosmicMonitoring() self.AthenaMonTools = [validation_ms, online_ms, cosmic_ms] self.doMyTiming = False time = TrigTimeHistToolConfig("Time") time.TimerHistLimits = [0, 10000] time.NumberOfHistBins = 1000 self.AthenaMonTools += [time] self.doTimeOutChecks = False self.doTimeOutGuard = False self.maxTgcHits = 0 self.maxCscHits = 0 self.maxRpcHits = 0 self.maxMdtHits = 0 self.doCache = True
def __init__(self, extension="", InputCollections=None, NewTrackingCuts=None, BarrelSegments=None, TrackCollectionKeys=[], TrackCollectionTruthKeys=[], PRDtoTrackMap=''): from InDetRecExample.InDetJobProperties import InDetFlags from InDetRecExample.InDetKeys import InDetKeys from AthenaCommon.DetFlags import DetFlags import InDetRecExample.TrackingCommon as TrackingCommon # # get ToolSvc and topSequence # from AthenaCommon.AppMgr import ToolSvc from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() # --- Always use PRD association tool (even if only 1 collection) to remove TRT # segments with significant overlaping hits usePrdAssociationTool = True #usePrdAssociationTool = True if len(InputCollections) > 0 else False # # --- get list of already associated hits (always do this, even if no other tracking ran before) # prd_to_track_map = PRDtoTrackMap if usePrdAssociationTool and extension != "_TRT": prefix = 'InDetTRTonly_' InDetTRTonly_PRD_Association = TrackingCommon.getInDetTrackPRD_Association( namePrefix=prefix, nameSuffix=extension, TracksName=list(InputCollections)) prd_to_track_map = prefix + 'PRDtoTrackMap' + extension topSequence += InDetTRTonly_PRD_Association if (InDetFlags.doPrintConfigurables()): printfunc(InDetTRTonly_PRD_Association) # # Cut values and output key for the TRT segments standalone TRT track finder # if extension == "_TRT": # TRT track segments pTmin = NewTrackingCuts.minPT() self.__TRTStandaloneTracks = InDetKeys.TRTTracks() else: # TRT standalone # pTmin = NewTrackingCuts.minSecondaryPt() pTmin = NewTrackingCuts.minTRTonlyPt( ) # new cut parameter to make it flexible... self.__TRTStandaloneTracks = InDetKeys.TRTTracks_NewT() # # --- set up special Scoring Tool for standalone TRT tracks # from InDetTrackScoringTools.InDetTrackScoringToolsConf import InDet__InDetTrtTrackScoringTool InDetTRT_StandaloneScoringTool = InDet__InDetTrtTrackScoringTool( name='InDetTRT_StandaloneScoringTool' + extension, SummaryTool=TrackingCommon.getInDetTrackSummaryTool(), DriftCircleCutTool=InDetTRTDriftCircleCut, useAmbigFcn=True, useSigmaChi2=False, PtMin=pTmin, minTRTonTrk=NewTrackingCuts.minTRTonly(), maxEta=2.1, UseParameterization=NewTrackingCuts.useTRTonlyParamCuts(), OldTransitionLogic=NewTrackingCuts.useTRTonlyOldLogic(), minTRTPrecisionFraction=NewTrackingCuts.minSecondaryTRTPrecFrac()) # InDetTRT_StandaloneScoringTool.OutputLevel = VERBOSE ToolSvc += InDetTRT_StandaloneScoringTool if (InDetFlags.doPrintConfigurables()): printfunc(InDetTRT_StandaloneScoringTool) # # set up TRT_SegmentToTrackTool # from AthenaCommon import CfgGetter from TRT_SegmentToTrackTool.TRT_SegmentToTrackToolConf import InDet__TRT_SegmentToTrackTool asso_tool = TrackingCommon.getInDetPRDtoTrackMapToolGangedPixels( ) if usePrdAssociationTool else None InDetTRT_SegmentToTrackTool = InDet__TRT_SegmentToTrackTool( name='InDetTRT_SegmentToTrackTool' + extension, RefitterTool=CfgGetter.getPublicTool('InDetTrackFitterTRT'), AssociationTool=asso_tool, TrackSummaryTool=TrackingCommon.getInDetTrackSummaryTool(), ScoringTool=InDetTRT_StandaloneScoringTool, Extrapolator=TrackingCommon.getInDetExtrapolator(), FinalRefit=True, MaxSharedHitsFraction=NewTrackingCuts.maxTRTonlyShared(), SuppressHoleSearch=True) ToolSvc += InDetTRT_SegmentToTrackTool if (InDetFlags.doPrintConfigurables()): printfunc(InDetTRT_SegmentToTrackTool) if not InDetFlags.doCosmics(): # # --- TRT standalone tracks algorithm # from TRT_StandaloneTrackFinder.TRT_StandaloneTrackFinderConf import InDet__TRT_StandaloneTrackFinder InDetTRT_StandaloneTrackFinder = InDet__TRT_StandaloneTrackFinder( name='InDetTRT_StandaloneTrackFinder' + extension, MinNumDriftCircles=NewTrackingCuts.minTRTonly(), MinPt=NewTrackingCuts.minTRTonlyPt(), InputSegmentsLocation=BarrelSegments, MaterialEffects=0, PRDtoTrackMap=prd_to_track_map, OldTransitionLogic=NewTrackingCuts.useTRTonlyOldLogic(), OutputTracksLocation=self.__TRTStandaloneTracks, TRT_SegToTrackTool=InDetTRT_SegmentToTrackTool) #InDetTRT_StandaloneTrackFinder.OutputLevel = VERBOSE topSequence += InDetTRT_StandaloneTrackFinder if InDetFlags.doPrintConfigurables(): printfunc(InDetTRT_StandaloneTrackFinder) # --- Delete TRT segments for the subdetector pattern only (back-tracking has already run by this point) from InDetRecExample.ConfiguredInDetSGDeletion import InDetSGDeletionAlg InDetSGDeletionAlg(container="Trk::SegmentCollection#", key=BarrelSegments) else: # # --- cosmics segment to track conversion for Barrel # from AthenaCommon import CfgGetter from TRT_SegmentsToTrack.TRT_SegmentsToTrackConf import InDet__TRT_SegmentsToTrack InDetTrkSegmenttoTrk = InDet__TRT_SegmentsToTrack( name="InDetTRT_SegmentsToTrack_Barrel" + extension, InputSegmentsCollection=BarrelSegments, OutputTrackCollection=self.__TRTStandaloneTracks, TrackFitter=CfgGetter.getPublicTool('InDetTrackFitter'), SummaryTool=TrackingCommon.getInDetTrackSummaryToolTRTTracks(), AssociationTool=TrackingCommon. getInDetPRDtoTrackMapToolGangedPixels() if prd_to_track_map != '' else None, InputAssociationMapName=prd_to_track_map, MinNHit=NewTrackingCuts.minTRTonly(), OutlierRemoval=True, MaterialEffects=False) #InDetTrkSegmenttoTrk.OutputLevel = VERBOSE topSequence += InDetTrkSegmenttoTrk if InDetFlags.doPrintConfigurables(): printfunc(InDetTrkSegmenttoTrk) # # # ------------ Track truth. # if (extension == "_TRT" or not InDetFlags.doSGDeletion()): if InDetFlags.doTruth(): # # set up the truth info for this container # include("InDetRecExample/ConfiguredInDetTrackTruth.py") InDetTracksTruth = ConfiguredInDetTrackTruth( self.__TRTStandaloneTracks, self.__TRTStandaloneTracks + "DetailedTruth", self.__TRTStandaloneTracks + "TruthCollection") # # add final output for statistics # TrackCollectionKeys += [InDetTracksTruth.Tracks()] TrackCollectionTruthKeys += [InDetTracksTruth.TracksTruth()] else: TrackCollectionKeys += [self.__TRTStandaloneTracks]
if hasattr(job, 'PixelDigitization'): pix = job.PixelDigitization else: ## return an error here? print "PixelDigitization not found in AlgSequence" else: ## Check for PixelDigitizationTool in list of PileUpTools try: print "trying to setup PixelDigitizationTool..." pix = job.PileUpToolsAlg.PileUpTools["PixelDigitizationTool"] except: ## return an error here? print "PixelDigitizationTool not found in list of PileUpTools" from AthenaCommon import CfgGetter pix = CfgGetter.getPublicTool("PixelDigitizationTool", checkType=True) CalibSvc = CfgGetter.getService("CalibSvc") CalibSvc.UseCalibCondDB = False CalibSvc.UsePixMapCondDB = False pix.EnableSpecialPixels = False #pix.DisableDistortions = True ########################################################### ## SLHC Flags ## Leave commented out unless overriding with text file. ## Default is to use Geom DB only #from InDetIBL_Example.SLHC_JobProperties import SLHC_Flags #SLHC_Flags.SLHC_Version = "IBL-01" ###########################################################
def __init__(self, name="TrigMuonEFStandaloneTrackTool", **kwargs): super(TrigMuonEFStandaloneTrackToolConfig, self).__init__(name, **kwargs) if MuonGeometryFlags.hasCSC(): self.CscClusterProvider = CfgGetter.getPublicTool( "CscThresholdClusterBuilderTool") self.SegmentsFinderTool = CfgGetter.getPublicToolClone( "TMEF_SegmentsFinderTool", "MooSegmentFinder", HoughPatternFinder=CfgGetter.getPublicTool("MuonLayerHoughTool"), Csc2dSegmentMaker=("Csc2dSegmentMaker/Csc2dSegmentMaker" if MuonGeometryFlags.hasCSC() else ""), Csc4dSegmentMaker=("Csc4dSegmentMaker/Csc4dSegmentMaker" if MuonGeometryFlags.hasCSC() else "")) CfgGetter.getPublicTool("MuonHoughPatternFinderTool").RecordAll = False CfgGetter.getPublicTool("MuonLayerHoughTool").DoTruth = False CfgGetter.getPublicTool("MooTrackFitter").SLFit = False self.MdtRawDataProvider = "TMEF_MdtRawDataProviderTool" self.CscRawDataProvider = "TMEF_CscRawDataProviderTool" self.RpcRawDataProvider = "TMEF_RpcRawDataProviderTool" self.TgcRawDataProvider = "TMEF_TgcRawDataProviderTool" #Need to run non-MT version of decoding tools in the trigger since the caching is not available in MT versions #Need different PRD container names to run offline and trigger in same jobs, but there are many tools that depend on these containers... #Since this is legacy code only used for validation comparisons against the Run 3 triggers, will do the not-particularly-nice solution of #creating containers with unique names only if we are running offline and trigger in the same jobs, and otherwise just use the default names. #This means that the trigger output when running the trigger as part of RAWtoESD is not 100% correct (the pattern finding uses the correct containers, #so it's a small effect overall anyway), but that's an use case not currently needed for trigger validation purposes from AthenaCommon.AppMgr import ToolSvc #MDT from MuonMDT_CnvTools.MuonMDT_CnvToolsConf import Muon__MdtRdoToPrepDataTool from MuonCSC_CnvTools.MuonCSC_CnvToolsConf import Muon__CscRdoToCscPrepDataTool from MuonTGC_CnvTools.MuonTGC_CnvToolsConf import Muon__TgcRdoToPrepDataTool from MuonRPC_CnvTools.MuonRPC_CnvToolsConf import Muon__RpcRdoToPrepDataTool MdtRdoToMdtPrepDataTool = Muon__MdtRdoToPrepDataTool( name="TrigEFMdtRdoToPrepDataTool") CscRdoToCscPrepDataTool = Muon__CscRdoToCscPrepDataTool( name="TrigEFCscRdoToPrepDataTool") TgcRdoToTgcPrepDataTool = Muon__TgcRdoToPrepDataTool( name="TrigEFTgcRdoToPrepDataTool") RpcRdoToRpcPrepDataTool = Muon__RpcRdoToPrepDataTool( name="TrigEFRpcRdoToPrepDataTool") if not rec.doRDOTrigger and rec.doESD: MdtRdoToMdtPrepDataTool.OutputCollection = "TrigMDT_DriftCircles" CscRdoToCscPrepDataTool.OutputCollection = "TrigCSC_Measurements" TgcRdoToTgcPrepDataTool.OutputCollection = "TrigTGC_Measurements" TgcRdoToTgcPrepDataTool.OutputCoinCollection = "TrigerT1CoinDataCollection" RpcRdoToRpcPrepDataTool.TriggerOutputCollection = "TrigRPC_Measurements" #InputCollection is really the output RPC coin collection... RpcRdoToRpcPrepDataTool.InputCollection = "TrigRPC_triggerHits" else: MdtRdoToMdtPrepDataTool.OutputCollection = "MDT_DriftCircles" CscRdoToCscPrepDataTool.OutputCollection = "CSC_Measurements" TgcRdoToTgcPrepDataTool.OutputCollection = "TGC_Measurements" TgcRdoToTgcPrepDataTool.OutputCoinCollection = "TrigT1CoinDataCollection" RpcRdoToRpcPrepDataTool.TriggerOutputCollection = "RPC_Measurements" RpcRdoToRpcPrepDataTool.InputCollection = "RPC_triggerHits" ToolSvc += MdtRdoToMdtPrepDataTool self.MdtPrepDataContainer = MdtRdoToMdtPrepDataTool.OutputCollection self.MdtPrepDataProvider = MdtRdoToMdtPrepDataTool #CSC ToolSvc += CscRdoToCscPrepDataTool self.CscPrepDataProvider = CscRdoToCscPrepDataTool #We use the clusters not the PRD hits directly for CSCs self.CscPrepDataContainer = "CSC_Clusters" #TGC ToolSvc += TgcRdoToTgcPrepDataTool self.TgcPrepDataProvider = TgcRdoToTgcPrepDataTool self.TgcPrepDataContainer = TgcRdoToTgcPrepDataTool.OutputCollection #RPC ToolSvc += RpcRdoToRpcPrepDataTool self.RpcPrepDataProvider = RpcRdoToRpcPrepDataTool self.RpcPrepDataContainer = RpcRdoToRpcPrepDataTool.TriggerOutputCollection self.DecodeMdtBS = DetFlags.readRDOBS.MDT_on() self.DecodeRpcBS = DetFlags.readRDOBS.RPC_on() self.DecodeTgcBS = DetFlags.readRDOBS.TGC_on() if MuonGeometryFlags.hasCSC(): self.DecodeCscBS = DetFlags.readRDOBS.CSC_on() # use seeded decoding if (TriggerFlags.MuonSlice.doEFRoIDrivenAccess()): self.useMdtSeededDecoding = True self.useRpcSeededDecoding = True self.useTgcSeededDecoding = True if MuonGeometryFlags.hasCSC(): self.useCscSeededDecoding = True # use ROB based seeded decoding instead of PRD based self.useTgcRobDecoding = False # neither available nor needed self.useCscRobDecoding = False # neither available nor needed self.useRpcData = muonRecFlags.doRPCs() self.useTgcData = muonRecFlags.doTGCs() self.useCscData = muonRecFlags.doCSCs() # to select barrel(useMdtData=2), endcap(useMdtData=3) if muonRecFlags.doMDTs(): self.useMdtData = 1 else: self.useMdtData = 0 self.useTGCInPriorNextBC = False self.doTimeOutChecks = False self.doTimeOutGuard = False self.maxTgcHits = 0 self.maxCscHits = 0 self.maxRpcHits = 0 self.maxMdtHits = 0 self.doCache = True self.IgnoreMisalginedCSCs = False self.TrackBuilderTool = "TMEF_TrackBuilderTool" self.TrkSummaryTool = "TMEF_TrackSummaryTool" self.MuonCandidateTool = "TMEF_MuonCandidateTool" self.TrackToTrackParticleConvTool = "MuonParticleCreatorTool" import MuonCondAlg.MdtCondDbAlgConfig # noqa: F401 (MDT conditions, needed for the MuonStationIntersectSvc)
def __init__(self, InputCollections=None, NewTrackingCuts=None, TrackCollectionKeys=[], TrackCollectionTruthKeys=[]): from InDetRecExample.InDetJobProperties import InDetFlags from InDetRecExample.InDetKeys import InDetKeys import InDetRecExample.TrackingCommon as TrackingCommon # # get ToolSvc and topSequence # from AthenaCommon.AppMgr import ToolSvc from AthenaCommon.AppMgr import ServiceMgr from AthenaCommon.AlgSequence import AlgSequence topSequence = AlgSequence() # # --- decide if use the association tool # asso_tool = None if len(InputCollections) > 0: usePrdAssociationTool = True prefix = 'InDetSegment' suffix = '' asso_tool = TrackingCommon.getConstPRD_AssociationTool( namePrefix=prefix, nameSuffix=suffix) else: prefix = '' suffix = '' usePrdAssociationTool = False # --- the PRD association tool is filled by the Segment making # no need to run again # ------------------------------------------------------------ # # ---------- TRT Seeded Tracking # # ------------------------------------------------------------ if InDetFlags.doTRTSeededTrackFinder(): # # --- decide which TRT seed space point finder to use # if InDetFlags.loadTRTSeededSPFinder(): # # --- defaul space point finder # from TRT_SeededSpacePointFinderTool.TRT_SeededSpacePointFinderToolConf import InDet__TRT_SeededSpacePointFinder_ATL InDetTRT_SeededSpacePointFinder = \ InDet__TRT_SeededSpacePointFinder_ATL(name = 'InDetTRT_SeededSpFinder' , SpacePointsSCTName = InDetKeys.SCT_SpacePoints(), SpacePointsOverlapName = InDetKeys.OverlapSpacePoints(), PRDtoTrackMap = prefix+'PRDtoTrackMap'+suffix \ if usePrdAssociationTool else "", NeighborSearch = True, LoadFull = False, DoCosmics = InDetFlags.doCosmics(), pTmin = NewTrackingCuts.minSecondaryPt()) # InDetTRT_SeededSpacePointFinder.OutputLevel = VERBOSE elif InDetFlags.loadSimpleTRTSeededSPFinder(): # # --- alternative version using the region selector # from RegionSelector.RegSelSvcDefault import RegSelSvcDefault InDetRegSelSvc = RegSelSvcDefault() InDetRegSelSvc.enablePixel = DetFlags.pixel_on() InDetRegSelSvc.enableSCT = DetFlags.SCT_on() ServiceMgr += InDetRegSelSvc if (InDetFlags.doPrintConfigurables()): printfunc(InDetRegSelSvc) from TRT_SeededSpacePointFinderTool.TRT_SeededSpacePointFinderToolConf import InDet__SimpleTRT_SeededSpacePointFinder_ATL InDetTRT_SeededSpacePointFinder = InDet__SimpleTRT_SeededSpacePointFinder_ATL( name='InDetTRT_SeededSpFinder', SpacePointsSCTName=InDetKeys.SCT_SpacePoints(), SpacePointsOverlapName=InDetKeys.OverlapSpacePoints(), PerigeeCut=1000., DirectionPhiCut=.3, DirectionEtaCut=1., MaxHoles=2, AssociationTool=asso_tool, RestrictROI=True) # InDetTRT_SeededSpacePointFinder.OutputLevel = VERBOSE if not usePrdAssociationTool: InDetTRT_SeededSpacePointFinder.AssociationTool = None # add either into the Tool Service ToolSvc += InDetTRT_SeededSpacePointFinder if (InDetFlags.doPrintConfigurables()): printfunc(InDetTRT_SeededSpacePointFinder) # # Silicon det elements road maker tool # from SiDetElementsRoadTool_xk.SiDetElementsRoadTool_xkConf import InDet__SiDetElementsRoadMaker_xk InDetTRT_SeededSiRoadMaker = InDet__SiDetElementsRoadMaker_xk( name='InDetTRT_SeededSiRoad', PropagatorTool=InDetPatternPropagator, usePixel=NewTrackingCuts.usePixel(), PixManagerLocation=InDetKeys.PixelManager(), useSCT=NewTrackingCuts.useSCT(), SCTManagerLocation=InDetKeys.SCT_Manager(), RoadWidth=35., MaxStep=20.) # NOT DEFAULT ? # InDetTRT_SeededSiRoadMaker.OutputLevel = VERBOSE if InDetFlags.doCosmics(): InDetTRT_SeededSiRoadMaker.RoadWidth = 50 # Condition algorithm for InDet__SiDetElementsRoadMaker_xk if NewTrackingCuts.useSCT(): from AthenaCommon.AlgSequence import AthSequencer condSeq = AthSequencer("AthCondSeq") if not hasattr(condSeq, "InDet__SiDetElementsRoadCondAlg_xk"): from SiDetElementsRoadTool_xk.SiDetElementsRoadTool_xkConf import InDet__SiDetElementsRoadCondAlg_xk condSeq += InDet__SiDetElementsRoadCondAlg_xk( name="InDet__SiDetElementsRoadCondAlg_xk") ToolSvc += InDetTRT_SeededSiRoadMaker if (InDetFlags.doPrintConfigurables()): printfunc(InDetTRT_SeededSiRoadMaker) # # --- TRT seeded back tracking tool # from TRT_SeededTrackFinderTool.TRT_SeededTrackFinderToolConf import InDet__TRT_SeededTrackFinder_ATL InDetTRT_SeededTrackTool = InDet__TRT_SeededTrackFinder_ATL( name='InDetTRT_SeededTrackMaker', PropagatorTool=InDetPatternPropagator, UpdatorTool=InDetPatternUpdator, RoadTool=InDetTRT_SeededSiRoadMaker, SeedTool=InDetTRT_SeededSpacePointFinder, CombinatorialTrackFinder=InDetSiComTrackFinder, pTmin=NewTrackingCuts.minSecondaryPt(), nHolesMax=NewTrackingCuts.SecondarynHolesMax(), # ME bugfix: nHolesGapMax = 2*NewTrackingCuts.SecondarynHolesGapMax(), nHolesGapMax=NewTrackingCuts.SecondarynHolesGapMax(), Xi2max=NewTrackingCuts.SecondaryXi2max(), Xi2maxNoAdd=NewTrackingCuts.SecondaryXi2maxNoAdd(), SearchInCaloROI=False, InputClusterContainerName=InDetKeys.CaloClusterROIContainer(), ConsistentSeeds=True, # BremCorrection = True, BremCorrection=False) if InDetFlags.doCosmics(): InDetTRT_SeededTrackTool.nWClustersMin = 0 ToolSvc += InDetTRT_SeededTrackTool if (InDetFlags.doPrintConfigurables()): printfunc(InDetTRT_SeededTrackTool) # # --- Output key for the finder # self.__TRTSeededTracks = InDetKeys.TRTSeededTracks() # # TRT seeded back tracking algorithm from AthenaCommon import CfgGetter from TRT_SeededTrackFinder.TRT_SeededTrackFinderConf import InDet__TRT_SeededTrackFinder import InDetRecExample.TrackingCommon as TrackingCommon InDetTRT_SeededTrackFinder = InDet__TRT_SeededTrackFinder(name = 'InDetTRT_SeededTrackFinder', RefitterTool = CfgGetter.getPublicTool('InDetTrackFitter'), TrackTool = InDetTRT_SeededTrackTool, PRDtoTrackMap = prefix+'PRDtoTrackMap'+suffix \ if usePrdAssociationTool else "", TrackSummaryTool = TrackingCommon.getInDetTrackSummaryToolNoHoleSearch(), TrackExtensionTool = InDetTRTExtensionTool, MinTRTonSegment = NewTrackingCuts.minSecondaryTRTonTrk(), MinTRTonly = NewTrackingCuts.minTRTonly(), TrtExtension = True, SiExtensionCuts = NewTrackingCuts.SiExtensionCuts(), minPt = NewTrackingCuts.minSecondaryPt(), maxRPhiImp = NewTrackingCuts.maxSecondaryImpact(), maxZImp = NewTrackingCuts.maxZImpact(), maxEta = NewTrackingCuts.maxEta(), Extrapolator = TrackingCommon.getInDetExtrapolator(), RejectShortExtension = NewTrackingCuts.rejectShortExtensions(), FinalRefit = False, FinalStatistics = False, OutputSegments = False, InputSegmentsLocation = InDetKeys.TRT_Segments(), OutputTracksLocation = self.__TRTSeededTracks, CaloClusterEt = NewTrackingCuts.minRoIClusterEt()) if (NewTrackingCuts.RoISeededBackTracking()): from RegionSelector.RegSelToolConfig import makeRegSelTool_SCT InDetTRT_SeededTrackFinder.RegSelTool = makeRegSelTool_SCT() InDetTRT_SeededTrackFinder.CaloSeededRoI = True # InDetTRT_SeededTrackFinder.OutputLevel = VERBOSE topSequence += InDetTRT_SeededTrackFinder if (InDetFlags.doPrintConfigurables()): printfunc(InDetTRT_SeededTrackFinder) # # ------------ Track truth. # if not InDetFlags.doSGDeletion(): if InDetFlags.doTruth(): # # set up the truth info for this container # include("InDetRecExample/ConfiguredInDetTrackTruth.py") InDetTracksTruth = ConfiguredInDetTrackTruth( self.__TRTSeededTracks, self.__TRTSeededTracks + "DetailedTruth", self.__TRTSeededTracks + "TruthCollection") # # add final output for statistics # TrackCollectionKeys += [InDetTracksTruth.Tracks()] TrackCollectionTruthKeys += [ InDetTracksTruth.TracksTruth() ] else: TrackCollectionKeys += [self.__TRTSeededTracks] # --- output track collection self.__BackTrackingTracks = self.__TRTSeededTracks # ------------------------------------------------------------ # # --- Resolve back tracking tracks ? # # ------------------------------------------------------------ if InDetFlags.doResolveBackTracks(): # # --- set up special Scoring Tool for TRT seeded tracks # if InDetFlags.doCosmics(): InDetTRT_SeededScoringTool = TrackingCommon.getInDetCosmicScoringTool_TRT( NewTrackingCuts) InDetTRT_SeededSummaryTool = TrackingCommon.getInDetTrackSummaryToolSharedHits( ) else: InDetTRT_SeededScoringTool = TrackingCommon.getInDetTRT_SeededScoringTool( NewTrackingCuts) InDetTRT_SeededSummaryTool = TrackingCommon.getInDetTrackSummaryTool( ) # # --- Load selection tool # from InDetAmbiTrackSelectionTool.InDetAmbiTrackSelectionToolConf import InDet__InDetAmbiTrackSelectionTool InDetTRT_SeededAmbiTrackSelectionTool = InDet__InDetAmbiTrackSelectionTool( name='InDetTRT_SeededAmbiTrackSelectionTool', DriftCircleCutTool=InDetTRTDriftCircleCut, AssociationTool=TrackingCommon. getInDetPRDtoTrackMapToolGangedPixels(), minScoreShareTracks=-1., # off ! minHits=NewTrackingCuts.minSecondaryClusters(), minNotShared=NewTrackingCuts.minSecondarySiNotShared(), maxShared=NewTrackingCuts.maxSecondaryShared(), minTRTHits=NewTrackingCuts.minSecondaryTRTonTrk(), UseParameterization=NewTrackingCuts.useParameterizedTRTCuts(), Cosmics=InDetFlags.doCosmics(), doPixelSplitting=InDetFlags.doPixelClusterSplitting()) # InDetTRT_SeededAmbiTrackSelectionTool.OutputLevel = DEBUG ToolSvc += InDetTRT_SeededAmbiTrackSelectionTool if (InDetFlags.doPrintConfigurables()): printfunc(InDetTRT_SeededAmbiTrackSelectionTool) # # --- load Ambiguity Processor # from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__SimpleAmbiguityProcessorTool InDetTRT_SeededAmbiguityProcessor = Trk__SimpleAmbiguityProcessorTool( name='InDetTRT_SeededAmbiguityProcessor', Fitter=CfgGetter.getPublicTool('InDetTrackFitter'), AssociationTool=TrackingCommon. getInDetPRDtoTrackMapToolGangedPixels(), TrackSummaryTool=InDetTRT_SeededSummaryTool, SelectionTool=InDetTRT_SeededAmbiTrackSelectionTool, RefitPrds=not InDetFlags.refitROT(), SuppressTrackFit=False, SuppressHoleSearch=False, ScoringTool=InDetTRT_SeededScoringTool) # InDetTRT_SeededAmbiguityProcessor.OutputLevel = DEBUG if InDetFlags.materialInteractions(): InDetTRT_SeededAmbiguityProcessor.MatEffects = InDetFlags.materialInteractionsType( ) else: InDetTRT_SeededAmbiguityProcessor.MatEffects = 0 # ToolSvc += InDetTRT_SeededAmbiguityProcessor if (InDetFlags.doPrintConfigurables()): printfunc(InDetTRT_SeededAmbiguityProcessor) # # --- load the algorithm # from TrkAmbiguitySolver.TrkAmbiguitySolverConf import Trk__TrkAmbiguityScore InDetAmbiguityScore = Trk__TrkAmbiguityScore( name='InDetTRT_SeededAmbiguityScore', TrackInput=[self.__TRTSeededTracks], TrackOutput='ScoredMap' + 'InDetTRT_SeededAmbiguityScore') topSequence += InDetAmbiguityScore self.__ResolvedTRTSeededTracks = InDetKeys.ResolvedTRTSeededTracks( ) # from TrkAmbiguitySolver.TrkAmbiguitySolverConf import Trk__TrkAmbiguitySolver InDetTRT_SeededAmbiguitySolver = Trk__TrkAmbiguitySolver( name='InDetTRT_SeededAmbiguitySolver', TrackInput='ScoredMap' + 'InDetTRT_SeededAmbiguityScore', TrackOutput=self.__ResolvedTRTSeededTracks, AmbiguityProcessor=InDetTRT_SeededAmbiguityProcessor) topSequence += InDetTRT_SeededAmbiguitySolver if (InDetFlags.doPrintConfigurables()): printfunc(InDetTRT_SeededAmbiguitySolver) # --- Delete (non-resloved) TRT seeded tracks from InDetRecExample.ConfiguredInDetSGDeletion import InDetSGDeletionAlg InDetSGDeletionAlg(key=InDetKeys.TRTSeededTracks()) # # ------------ Track truth. # if not InDetFlags.doSGDeletion(): if InDetFlags.doTruth(): # # set up the truth info for this container # include("InDetRecExample/ConfiguredInDetTrackTruth.py") InDetTracksTruth = ConfiguredInDetTrackTruth( self.__ResolvedTRTSeededTracks, self.__ResolvedTRTSeededTracks + "DetailedTruth", self.__ResolvedTRTSeededTracks + "TruthCollection") # # add final output for statistics # TrackCollectionKeys += [InDetTracksTruth.Tracks()] TrackCollectionTruthKeys += [ InDetTracksTruth.TracksTruth() ] else: TrackCollectionKeys += [self.__ResolvedTRTSeededTracks] # --- output track collection self.__BackTrackingTracks = self.__ResolvedTRTSeededTracks
def TMEF_CombinedStauTrackBuilderFit(name='TMEF_CombinedStauTrackBuilderFit', **kwargs): kwargs.setdefault( 'MdtRotCreator', CfgGetter.getPublicTool('MdtDriftCircleOnTrackCreatorStau')) return TMEF_CombinedMuonTrackBuilder(name, **kwargs)
def _do_external(self): """Place to handle the external services: GeoModel, IOVDb, frozen showers, etc """ AtlasG4Eng.G4Eng.log.verbose( 'AtlasSimSkeleton._do_external :: starting') from AthenaCommon.AppMgr import ToolSvc, ServiceMgr from Geo2G4.Geo2G4Conf import Geo2G4Svc geo2G4Svc = Geo2G4Svc() theApp.CreateSvc += ["Geo2G4Svc"] ServiceMgr += geo2G4Svc ## Enable top transforms for the ATLAS geometry geo2G4Svc.GetTopTransform = True ## Configure access to the BeamCondSvc if necessary. Assuming ## it should be on always as BeamEffectTransformation is ## currently always switched on, else something like this will ## be required here. from G4AtlasApps.SimFlags import simFlags include("InDetBeamSpotService/BeamCondSvc.py") ## GeoModel stuff ## TODO: Tidy imports etc. from GeoModelSvc.GeoModelSvcConf import GeoModelSvc from AthenaCommon.GlobalFlags import jobproperties from AtlasGeoModel import SetGeometryVersion ## Forward Region Twiss files - needed before geometry setup! if simFlags.ForwardDetectors.statusOn: if DetFlags.geometry.FwdRegion_on(): from AthenaCommon.CfgGetter import getPublicTool from AthenaCommon.AppMgr import ToolSvc ToolSvc += getPublicTool("ForwardRegionProperties") from AtlasGeoModel import GeoModelInit from AtlasGeoModel import SimEnvelopes from GeoModelSvc.GeoModelSvcConf import GeoModelSvc gms = GeoModelSvc() ## Cosmics GeoModel tweaks if jobproperties.Beam.beamType() == 'cosmics' or \ (simFlags.CavernBG.statusOn and not 'Signal' in simFlags.CavernBG.get_Value() ): from CavernInfraGeoModel.CavernInfraGeoModelConf import CavernInfraDetectorTool gms.DetectorTools += [CavernInfraDetectorTool()] ## Protects GeoModelSvc in the simulation from the AlignCallbacks gms.AlignCallbacks = False ## Muon GeoModel tweaks if DetFlags.Muon_on(): ## Turn off caching in the muon system from MuonGeoModel.MuonGeoModelConf import MuonDetectorTool MuonDetectorTool = MuonDetectorTool() MuonDetectorTool.FillCacheInitTime = 0 # default is 1 ## Additional material in the muon system from AGDD2GeoSvc.AGDD2GeoSvcConf import AGDDtoGeoSvc AGDD2Geo = AGDDtoGeoSvc() from AthenaCommon import CfgGetter if not "MuonAGDDTool/MuonSpectrometer" in AGDD2Geo.Builders: ToolSvc += CfgGetter.getPublicTool("MuonSpectrometer", checkType=True) AGDD2Geo.Builders += ["MuonAGDDTool/MuonSpectrometer"] from AtlasGeoModel.MuonGMJobProperties import MuonGeometryFlags if (MuonGeometryFlags.hasSTGC() and MuonGeometryFlags.hasMM()): if not "NSWAGDDTool/NewSmallWheel" in AGDD2Geo.Builders: ToolSvc += CfgGetter.getPublicTool("NewSmallWheel", checkType=True) AGDD2Geo.Builders += ["NSWAGDDTool/NewSmallWheel"] theApp.CreateSvc += ["AGDDtoGeoSvc"] ServiceMgr += AGDD2Geo ## Add configured GeoModelSvc to service manager ServiceMgr += gms ## Run the geometry envelope setup earlier than GeoSD self._do_GeoEnv() #TODO remove AtlasG4Eng.G4Eng.log.verbose('AtlasSimSkeleton._do_external :: done')
if muonRecFlags.writeMuonExitLayer(): topSequence += TrackRecordFilter("TrackRecordFilterMuonExitLayer", inputName="MuonExitLayer", outputName="MuonExitLayerFilter") # only do PRD truth if PRD's are being made if rec.doTruth() and DetFlags.makeRIO.Muon_on(): from MuonTruthAlgs.MuonTruthAlgsConf import MuonPRD_MultiTruthMaker topSequence += MuonPRD_MultiTruthMaker() from AthenaCommon.CfgGetter import getService getService("AtlasTrackingGeometrySvc") from MuonTruthAlgs.MuonTruthAlgsConf import Muon__MuonTruthDecorationAlg topSequence += Muon__MuonTruthDecorationAlg("MuonTruthDecorationAlg") from AthenaCommon import CfgGetter topSequence.MuonTruthDecorationAlg.MCTruthClassifier = CfgGetter.getPublicTool( "MCTruthClassifier") try: from RecExConfig.InputFilePeeker import inputFileSummary truthStrategy = inputFileSummary['metadata']['/Simulation/Parameters'][ 'TruthStrategy'] if truthStrategy in ['MC15', 'MC18', 'MC18LLP']: topSequence.MuonTruthDecorationAlg.BarcodeOffset = 10000000 except: print "Failed to read /Simulation/Parameters/ metadata" pass #load default tools: if muonRecFlags.doStandalone() or muonRecFlags.doPseudoTracking(): include("MuonRecExample/MuonRecLoadTools.py")
inputName="MuonExitLayer", outputName="MuonExitLayerFilter") # only do PRD truth if PRD's are being made if rec.doTruth() and DetFlags.makeRIO.Muon_on(): from MuonTruthAlgs.MuonTruthAlgsConf import MuonPRD_MultiTruthMaker topSequence += MuonPRD_MultiTruthMaker() from AthenaCommon.CfgGetter import getService getService("AtlasTrackingGeometrySvc") from MuonTruthAlgs.MuonTruthAlgsConf import Muon__MuonTruthDecorationAlg topSequence += Muon__MuonTruthDecorationAlg("MuonTruthDecorationAlg") from MCTruthClassifier.MCTruthClassifierConf import MCTruthClassifier from AthenaCommon import CfgGetter topSequence.MuonTruthDecorationAlg.MCTruthClassifier = CfgGetter.getPublicTool( MCTruthClassifier(name="MCTruthClassifier", ParticleCaloExtensionTool="")) topSequence.MuonTruthDecorationAlg.SDOs = ["RPC_SDO", "TGC_SDO", "MDT_SDO"] PRD_TruthMaps = ["RPC_TruthMap", "TGC_TruthMap", "MDT_TruthMap"] if (MuonGeometryFlags.hasSTGC() and MuonGeometryFlags.hasMM()): topSequence.MuonTruthDecorationAlg.SDOs += ["MM_SDO", "sTGC_SDO"] PRD_TruthMaps += ["MM_TruthMap", "STGC_TruthMap"] if not MuonGeometryFlags.hasCSC(): topSequence.MuonTruthDecorationAlg.CSCSDOs = "" else: PRD_TruthMaps += ["CSC_TruthMap"] topSequence.MuonTruthDecorationAlg.PRD_TruthMaps = PRD_TruthMaps try: from PyUtils.MetaReaderPeeker import metadata truthStrategy = metadata['TruthStrategy']