def __init__(self, instance, name):
super( DvHypoSplit, self ).__init__( name )
mlog = logging.getLogger('DvHypoConfig.py')
AllowedInstances = ["EF"]
if instance not in AllowedInstances :
mlog.error("Instance "+instance+" is not supported!")
return None
if instance=="EF" :
self.AcceptAll = False
self.Instance = "EF"
self.UseBeamSpotFlag = False
self.JetKey = "SplitJet"
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig("TimeHistogramForTrigDvHypo")
time.TimerHistLimits = [0,0.4]
self.AthenaMonTools = [ time ]
if instance=="EF" :
from TrigBjetHypo.TrigDvHypoMonitoring import TrigEFDvHypoValidationMonitoring, TrigEFDvHypoOnlineMonitoring
validation = TrigEFDvHypoValidationMonitoring()
online = TrigEFDvHypoOnlineMonitoring()
self.AthenaMonTools += [ validation, online ]
def __init__(self, instance, algo, name):
super( DvFex, self ).__init__( name )
mlog = logging.getLogger('BjetHypoConfig.py') ## SURE??
AllowedInstances = ["EF"]
AllowedAlgos = ["EFID"]
# Pre-configuring
if instance not in AllowedInstances :
mlog.error("Instance "+instance+" is not supported!")
return None
self.JetKey = "SplitJet"
self.AlgoId = -1
if instance == "EF" and algo == "EFID" :
self.AlgoId = 1
if self.AlgoId == -1:
mlog.error("AlgoId is wrongly set!")
return None
self.UseEtaPhiTrackSel = False
if algo=="EFID" :
self.TrkSel_Chi2 = 0.0
self.TrkSel_BLayer = 0 #1
self.TrkSel_PixHits = 0
self.TrkSel_SiHits = 0 #7
self.TrkSel_D0 = 1.0*mm #300.0*mm
self.TrkSel_Z0 = 1500.0*mm
self.TrkSel_Pt = 1000.0*MeV #500.0*MeV
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig("TimeHistogramForTrigBjetHypo")
time.TimerHistLimits = [0,2]
self.AthenaMonTools = [ time ]
#self.validation = False
#self.onlinemon = False
if instance=="EF" :
from TrigBjetHypo.TrigDvFexMonitoring import TrigEFDvFexValidationMonitoring, TrigEFDvFexOnlineMonitoring
validation = TrigEFDvFexValidationMonitoring()
online = TrigEFDvFexOnlineMonitoring()
self.AthenaMonTools+=[validation,online]
def __init__(self, name = "EFMultiMuFex_Tau2"):
super( EFMultiMuFex_Tau2 , self ).__init__( name )
# AcceptAll flag: if true take events regardless of cuts
self.AcceptAll = False
# L2 Bmumu cuts
self.OppositeSign = False
self.LowerMassCut = 0.
self.UpperMassCut = 2900.
self.MuonAlgo = "TrigMuSuperEF"
self.NMassMuon = 2
self.CheckNinputTE = False
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig("Time")
from TrigBphysHypo.TrigEFMultiMuFexMonitoring import TrigEFMultiMuFexValidationMonitoring
validation = TrigEFMultiMuFexValidationMonitoring()
from TrigBphysHypo.TrigEFMultiMuFexMonitoring import TrigEFMultiMuFexOnlineMonitoring
online = TrigEFMultiMuFexOnlineMonitoring()
self.AthenaMonTools = [ validation, online, time ]
def __init__(self,
name='EFROBListWriter',
addCTPResult=False,
addL2Result=False,
addEFResult=False,
etaWidth=0.1,
phiWidth=0.1):
super(EFROBListWriter, self).__init__(name)
self.AddCTPResult = addCTPResult
self.AddL2Result = addL2Result
self.AddEFResult = addEFResult
self.etaWidth = etaWidth
self.phiWidth = phiWidth
from TrigDetCalib.TrigDetCalibMonitoring import TrigROBListWriterValidationMonitoring
from TrigDetCalib.TrigDetCalibMonitoring import TrigROBListWriterOnlineMonitoring
from TrigDetCalib.TrigDetCalibMonitoring import TrigROBListWriterCosmicMonitoring
validation = TrigROBListWriterValidationMonitoring()
online = TrigROBListWriterOnlineMonitoring()
cosmic = TrigROBListWriterCosmicMonitoring()
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig(name + '_Time')
self.AthenaMonTools = [validation, online, time, cosmic]
def __init__(self, name, ptElectronMin, pidKey, defaultThreshold=4650.):
super(TrigBphysElectronCounter_bBee, self).__init__(name)
self.nEfElectron = 2
self.ptElectronMin = []
self.setEFElectronThresholds(self.ptElectronMin, defaultThreshold)
self.electronCollectionKey = "egamma_Electrons"
self.overlapdR = 0.005
# set up PID - defined in TrigHypothesis/TrigEgammaHypo/python/TrigEgammaPidTools
from TrigEgammaHypo.TrigEgammaPidTools import (ElectronToolName,
BLooseISEMBits,
ElectronIsEMBits)
if pidKey == None or not pidKey in ElectronToolName.keys():
log.info(
" Setting up bphys electron chain with no electron PID requirement"
)
self.ApplyIsEM = False
else:
self.ApplyIsEM = True
if "LH" in ElectronToolName[pidKey]:
self.AthenaElectronLHIDSelectorToolName = 'AsgElectronLikelihoodTool/' + ElectronToolName[
pidKey]
self.UseAthenaElectronLHIDSelectorTool = True
self.IsEMrequiredBits = 0
else:
self.egammaElectronCutIDToolName = ElectronToolName[pidKey]
self.UseAthenaElectronLHIDSelectorTool = False
if pidKey in BLooseISEMBits.keys():
self.IsEMrequiredBits = BLooseISEMBits[pidKey]
else:
self.IsEMrequiredBits = ElectronIsEMBits[pidKey]
time = TrigTimeHistToolConfig("Time")
validation = TrigBphysElectronCounterValidationMonitoring()
online = TrigBphysElectronCounterOnlineMonitoring()
self.AthenaMonTools = [validation, online, time]
def __init__(self, name="T2CaloTau_Tau_custom"):
super(T2CaloTau_Tau_custom, self).__init__(name)
self.EtaWidth = 0.4
self.PhiWidth = 0.4
self.EtaWidthForID = 0.3
self.PhiWidthForID = 0.3
tauAllCaloDRFex = TauAllCaloDRFexConfig()
self.IAlgToolList = [tauAllCaloDRFex]
self.TimerNtuple = "T2CaloTau.T2CaTautTot"
self.TrigTauClusterKey = "T2CaloTrigTauCluster"
# monitoring part. To switch off do in topOption TriggerFlags.enableMonitoring = []
from TrigT2CaloTau.TrigT2CaloTauMonitoring import T2CaloTauValidationMonitoring, T2CaloTauOnlineMonitoring, T2CaloTauCosmicMonitoring
validation = T2CaloTauValidationMonitoring()
online = T2CaloTauOnlineMonitoring()
cosmic = T2CaloTauCosmicMonitoring()
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig("Time")
self.AthenaMonTools = [time, validation, online, cosmic]
def __init__(self, name):
super(L2ElectronFexBase, self).__init__(name)
from TrigEgammaHypo.TrigL2ElectronHypoMonitoring import TrigL2ElectronFexValidationMonitoring, TrigL2ElectronFexOnlineMonitoring
validation = TrigL2ElectronFexValidationMonitoring()
online = TrigL2ElectronFexOnlineMonitoring()
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig("Time")
self.AthenaMonTools = [time, validation, online]
# Tracking cuts
self.TrackPt = 1.0 * GeV
self.TrackPtHighEt = 2.0 * GeV
self.ClusEt = 20.0 * GeV
self.CaloTrackdEtaNoExtrap = 0.3
self.CaloTrackdEtaNoExtrapHighEt = 0.2
# Calo-Tracking matching cuts
self.CaloTrackdETA = 0.3
self.CaloTrackdPHI = 0.3
self.CaloTrackdEoverPLow = 0.0
self.CaloTrackdEoverPHigh = 999.0
self.ParticleCaloExtensionTool = ParticleCaloExtensionTool
def __init__(self,
name='TrigCheckForMuons_pebM',
etaWidth=0.3,
phiWidth=0.3):
super(TrigCheckForMuons_pebM, self).__init__(name)
self.AddCTPResult = True
self.AddHLTResult = True
self.etaWidth = etaWidth
self.phiWidth = phiWidth
self.MaxRoIsPerEvent = -1
self.muonLabels = ["MuonEFInfo", ""]
self.PEBInfoLabel = "pebM"
from TrigDetCalib.TrigDetCalibMonitoring import TrigROBListWriterValidationMonitoring
from TrigDetCalib.TrigDetCalibMonitoring import TrigROBListWriterOnlineMonitoring
from TrigDetCalib.TrigDetCalibMonitoring import TrigROBListWriterCosmicMonitoring
validation = TrigROBListWriterValidationMonitoring(
name + "ValidationMonitoring")
online = TrigROBListWriterOnlineMonitoring(name + "OnlineMonitoring")
cosmic = TrigROBListWriterCosmicMonitoring(name + "CosmicMonitoring")
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig(name + '_Time')
self.AthenaMonTools = [validation, online, time, cosmic]
def __init__(self, name="L2MultiMuFex_Upsi"):
super(TrigL2MultiMuFex, self).__init__(name)
# AcceptAll flag: if true take events regardless of cuts
self.AcceptAll = False
# L2 Bmumu cuts
# self.TrackPTthr = 1.4
# self.TrackAlgoId = 2
# self.pTsumTrackPair = 0.
self.LowerMassCut = 7000.
self.UpperMassCut = 13000.
self.doVertexFit = True
self.TrigL2VertexFitter = L2VFitTool
self.TrigVertexingTool = VertexTool
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig("Time")
from TrigBphysHypo.TrigL2MultiMuFexMonitoring import TrigL2MultiMuFexValidationMonitoring
validation = TrigL2MultiMuFexValidationMonitoring()
from TrigBphysHypo.TrigL2MultiMuFexMonitoring import TrigL2MultiMuFexOnlineMonitoring
online = TrigL2MultiMuFexOnlineMonitoring()
self.AthenaMonTools = [validation, online, time]
def __init__(self, name="TrigTauRecMerged_TauFTK"):
super(TrigTauRecMerged_TauFTK, self).__init__(name)
self._mytools = []
# monitoring part. To switch off do in topOption TriggerFlags.enableMonitoring = []
from TrigTauRec.TrigTauRecMonitoring import TrigTauRecValidationMonitoring, TrigTauRecOnlineMonitoring
validation = TrigTauRecValidationMonitoring()
online = TrigTauRecOnlineMonitoring()
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig("Time")
self.AthenaMonTools = [time, validation, online]
import TrigTauRec.TrigTauAlgorithmsHolder as taualgs
tools = []
taualgs.setPrefix("TrigTauFTK_")
# Collection name
self.OutputCollection = "TrigTauRecPreselection"
# Only include tools needed for pre-selection
# Set seedcalo energy scale (Full RoI)
tools.append(taualgs.getJetSeedBuilder())
#use FTK vertices
tools.append(taualgs.getTauVertexFinder(doUseTJVA=True))
# Set LC energy scale (0.2 cone) and intermediate axis (corrected for vertex: useless at trigger)
tools.append(taualgs.getTauAxis())
# Count tracks with deltaZ0 cut of 2mm -> Need to remove quality criteria for fast-tracks here
# Insert bypass later?
tools.append(
taualgs.getTauTrackFinder(applyZ0cut=True,
maxDeltaZ0=2,
noSelector=False))
# Calibrate to TES
tools.append(
taualgs.getEnergyCalibrationLC(correctEnergy=True,
correctAxis=False,
postfix='_onlyEnergy'))
# Calculate cell-based quantities: strip variables, EM and Had energies/radii, centFrac, isolFrac and ring energies
tools.append(taualgs.getCellVariables(cellConeSize=0.2))
# tools.append(taualgs.getElectronVetoVars())
# Variables combining tracking and calorimeter information
tools.append(taualgs.getTauCommonCalcVars())
# Cluster-based sub-structure, with dRMax also
tools.append(taualgs.getTauSubstructure())
# tools.append(taualgs.getEnergyCalibrationLC(correctEnergy=False, correctAxis=True, postfix='_onlyAxis'))
tools.append(taualgs.getPileUpCorrection())
for tool in tools:
tool.inTrigger = True
tool.calibFolder = 'TrigTauRec/00-11-02/'
pass
self.Tools = tools
#necessary to write out deltaZ0 between tracks and lead trk
#self.theTauPVTool = taualgs.getTauPVTrackTool()
#self.useTauPVTool = True;
## add beam type flag
from AthenaCommon.BeamFlags import jobproperties
self.BeamType = jobproperties.Beam.beamType()
def __init__(self, instance, version, cut, name):
super(BjetHypo, self).__init__(name)
mlog = logging.getLogger('BjetHypoConfig.py')
AllowedCuts = [
"loose", "medium", "tight", "offloose", "offmedium", "offtight",
"mv2c2040", "mv2c2050", "mv2c2060", "mv2c2070", "mv2c2077",
"mv2c2085", "mv2c1040", "mv2c1050", "mv2c1060", "mv2c1070",
"mv2c1077", "mv2c1085", "hmv2c1040", "hmv2c1050", "hmv2c1060",
"hmv2c1070", "hmv2c1077", "hmv2c1085"
]
AllowedVersions = [
"2012", "2015", "2017", "2018", "MuJetChain_2012",
"MuJetChain_2015"
]
AllowedInstances = ["EF", "MuJetChain"]
if instance not in AllowedInstances:
mlog.error("Instance " + instance + " is not supported!")
return None
if version not in AllowedVersions:
mlog.error("Version " + version + " is not supported!")
return None
if cut not in AllowedCuts:
mlog.error("Cut " + cut + " is not supported!")
return None
if instance == "EF":
self.AcceptAll = False
self.Instance = "EF"
self.UseBeamSpotFlag = False
self.JetKey = ""
if instance == "EF":
from TrigBjetHypo.TrigBjetHypoMonitoring import TrigEFBjetHypoValidationMonitoring, TrigEFBjetHypoOnlineMonitoring
validation = TrigEFBjetHypoValidationMonitoring()
online = TrigEFBjetHypoOnlineMonitoring()
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig("TimeHistogramForTrigBjetHypo")
time.TimerHistLimits = [0, 0.4]
self.AthenaMonTools = [time, validation, online]
if instance == "EF":
if version == "2012":
self.MethodTag = "COMB"
if cut == "loose":
self.CutXCOMB = 0.25
elif cut == "medium":
self.CutXCOMB = 1.25
elif cut == "tight":
self.CutXCOMB = 2.65
if version == "2015":
self.MethodTag = "MV2c20"
# These are the offline working points
if cut == "mv2c2040":
# Actually XX% efficient
self.CutMV2c20 = 0.75
elif cut == "mv2c2050":
# Actually XX% efficient
self.CutMV2c20 = 0.5
elif cut == "mv2c2060":
# Actually 62% efficient
self.CutMV2c20 = -0.0224729
elif cut == "mv2c2070":
# Actually 72% efficient
self.CutMV2c20 = -0.509032
elif cut == "mv2c2077":
# Actually 79% efficient
self.CutMV2c20 = -0.764668
elif cut == "mv2c2085":
# Actually 87% efficient
self.CutMV2c20 = -0.938441
if version == "2017":
self.MethodTag = "MV2c10"
# These are the offline working points
if cut == "mv2c1040":
# Actually ~45% efficient
self.CutMV2c10 = 0.978
elif cut == "mv2c1050":
# Actually ~55% efficient
self.CutMV2c10 = 0.948
elif cut == "mv2c1060":
# Actually ~65% efficient
self.CutMV2c10 = 0.846
elif cut == "mv2c1070":
# Actually ~75% efficient
self.CutMV2c10 = 0.580
elif cut == "mv2c1077":
# Actually ~80% efficient
self.CutMV2c10 = 0.162
elif cut == "mv2c1085":
# Actually ~90% efficient
self.CutMV2c10 = -0.494
if version == "2018":
# self.MethodTag = "MV2c10_hybrid" # Temporary use mv2c00 for hybrid tuning
self.MethodTag = "MV2c00"
# These are the offline working points
if cut == "hmv2c1040":
# Actually ~45% efficient
self.CutMV2c10_hybrid = 0.973
elif cut == "hmv2c1050":
# Actually ~55% efficient
self.CutMV2c10_hybrid = 0.939
elif cut == "hmv2c1060":
# Actually ~65% efficient
self.CutMV2c10_hybrid = 0.835
elif cut == "hmv2c1070":
# Actually ~75% efficient
self.CutMV2c10_hybrid = 0.588
elif cut == "hmv2c1077":
# Actually ~80% efficient
self.CutMV2c10_hybrid = 0.192
elif cut == "hmv2c1085":
# Actually ~90% efficient
self.CutMV2c10_hybrid = -0.402
def __init__(self, instance, version, btagReqs, name):
super(BjetHypoAllTE, self).__init__(name)
mlog = logging.getLogger('BjetHypoAllTEConfig.py')
#mlog.setLevel(0)
AllowedVersions = ["2017"]
AllowedInstances = ["EF"]
if instance not in AllowedInstances:
mlog.error("Instance " + instance + " is not supported!")
return None
if version not in AllowedVersions:
mlog.error("Version " + version + " is not supported!")
return None
mlog.debug("btagReqs were")
mlog.debug(btagReqs)
#
# Main idea here is that the btagReqs contains a list of the different btagging requiremnts
# eg: 2b55_2j55 would contain a list of two requirements (55,b,2) and (55,j,2)
# The following python code:
# - updates the requirements to properly handle overlap
# - formats these requirements as expected by c++
# - checks if the beamspot is needed
# The c++ code then recieves a list of requirements to be "AND"ed
# and a list of requrirements to be "OR"ed
# to handle chains like 2b55_j100 the "OR" requirments need sub-requirements that are "AND"ed
#
# Format cut values
#
for req in btagReqs:
# Et in MeV
req[0] = float(req[0]) * 1000
# req[1] has to be one of possiblities in AllowedCuts below
req[1] = req[1].replace("bmv", "mv").replace("boff", "")
# Mulitplicity Requirement
req[2] = int(req[2])
mlog.debug("btagReqs are")
mlog.debug(btagReqs)
#
# These have to be ordered from tighest to loosest
#
if version == "2017":
self.Tagger = "MV2c10_discriminant"
# All possible cuts
AllowedCuts = [
"mv2c1040", "mv2c1050", "mv2c1060", "mv2c1070", "mv2c1077",
"mv2c1085", "perf"
]
# Subset of cuts requireing a BS to be valid
CutsRequiringBS = [
"mv2c1040", "mv2c1050", "mv2c1060", "mv2c1070", "mv2c1077",
"mv2c1085"
]
#
# Check that the b-tagging operating points are supported
#
for req in btagReqs:
if req[1] not in AllowedCuts:
mlog.error("Cut " + req[1] + " is not supported!")
return None
#
# Set the b-tag key
#
self.BTaggingKey = "HLTBjetFex"
#
# Use the BS for EF
#
if instance == "EF":
self.UseBeamSpotFlag = False
#
# Override beamspot valid if not btagging
#
self.OverrideBeamSpotValid = True
for req in btagReqs:
if req[1] in CutsRequiringBS:
self.OverrideBeamSpotValid = False
#
# Get a list of differnt operation points in this chain
# (CutsInThisChain is a unique list of indices for of AllowedCuts)
CutsInThisChain = []
for req in btagReqs:
if req[1] not in CutsInThisChain:
CutsInThisChain.append(AllowedCuts.index(req[1]))
CutsInThisChain.sort()
#
# Make a list of jet multiplicities requirements
# fullTrigReqAND is the AND of them
# eg: 2b35_2j25 is the AND of 2b35 and 4j35)
fullTrigReqAND = {}
for jetReq in btagReqs:
thisPt = jetReq[0]
thisBTag = AllowedCuts.index(jetReq[1])
thisMult = jetReq[2]
# Upper cut on btagging
# (Used below for cases when the btagging is on lower pt jets, set it to 99 now)
# eg: j100_2b55
thisMaxBTag = 99
#
# Add/Increment this combination of pt and btag.
#
if (thisPt, thisBTag, thisMaxBTag) not in fullTrigReqAND:
fullTrigReqAND[(thisPt, thisBTag, thisMaxBTag)] = thisMult
else:
fullTrigReqAND[(thisPt, thisBTag, thisMaxBTag)] += thisMult
#
# For each btagging point requested add to the multiplicity of the looser btag requirments
# This is effectively dealing with the overlap
# eg: for 2b_2j, the multiplicity of the 2b reqirement is added the "j" multiplcity
#
for point in CutsInThisChain:
if point > thisBTag:
if (thisPt, point, thisMaxBTag) not in fullTrigReqAND:
fullTrigReqAND[(thisPt, point, thisMaxBTag)] = thisMult
else:
fullTrigReqAND[(thisPt, point,
thisMaxBTag)] += thisMult
#
# Update the pt thresholds
# (for tagging requirements with the same operating point but differnet pTs,
# add the larger pt multiplcity to the smaller Pt to deal with overlap)
# eg: b150_b50 gives two requirements 150b and 2b50
for jetDef in fullTrigReqAND:
for otherJetDefs in fullTrigReqAND:
if jetDef == otherJetDefs:
continue
if jetDef[0] > otherJetDefs[0] and jetDef[1] == otherJetDefs[1]:
fullTrigReqAND[otherJetDefs] += fullTrigReqAND[jetDef]
mlog.debug("full btagReqsAND are")
mlog.debug(fullTrigReqAND)
#
# Format lists in a way that can be passed to the c++
#
EtThresholds = []
BTagMin = []
BTagMax = []
Multiplicities = []
for reqAND in fullTrigReqAND:
EtThresholds.append(float(reqAND[0]))
BTagMin.append(float(self.getCutValue(AllowedCuts[reqAND[1]])))
BTagMax.append(float(reqAND[2]))
Multiplicities.append(int(fullTrigReqAND[reqAND]))
mlog.debug("EtThresholds:")
mlog.debug(EtThresholds)
self.EtThresholds = EtThresholds
mlog.debug("BTagMin:")
mlog.debug(BTagMin)
self.BTagMin = BTagMin
mlog.debug("BTagMax:")
mlog.debug(BTagMax)
self.BTagMax = BTagMax
mlog.debug("Multiplicities:")
mlog.debug(Multiplicities)
self.Multiplicities = Multiplicities
#
# Handle the cases where have a higher pt looser leg
# Here we need to make requirements that get OR
# eg: j100_2b55 passes only if:
# - (j100 & 3b55) || (j100 & 2b55 & !b100)
#
# NOTE: At the moment the following logic only hold for one highpt/looser requiremnt
# It will need to be extending to handle more than 2 operating points if needed.
# (eg: j100_2btight55 work fine, but j100_bloose55_btight35 would not)
#
fullTrigReqOR = []
# Loop on unique pairs
for jetDef in fullTrigReqAND:
for otherJetDefs in fullTrigReqAND:
if jetDef == otherJetDefs:
continue
# check if pt is harder
jetDef_ptBigger = jetDef[0] > otherJetDefs[0]
mlog.debug("jetDef_ptBigger: " + str(jetDef_ptBigger) + " ( " +
str(jetDef[0]) + " > " + str(otherJetDefs[0]) +
" )")
# check if btagging is looser (higher AllowedCuts index means looser btagging)
jetDef_btagLooser = jetDef[1] > otherJetDefs[1]
mlog.debug("jetDef_btagLooser: " + str(jetDef_btagLooser) +
" ( " + str(jetDef[1]) + " > " +
str(otherJetDefs[1]) + " )")
# if both harder and looser, add two cases to be ORed as example above
if jetDef_ptBigger and jetDef_btagLooser:
# 1st) both requirements pass the tighter btagging
# eg: j100 & 3b55 (in our example above)
fullTrigReqOR.append({
otherJetDefs:
(fullTrigReqAND[otherJetDefs] + fullTrigReqAND[jetDef])
})
# 2nd) this requriemnts has two sub requirements
# - the tighter btagging requirement passes with its multiplicity
# eg: 2b55
# - the looser btagging requirement passes with its multiplicity, and an upper cut on btagging
# eg: j100 & !b100
# (upper cut is given by the 3rd index in the requirement
fullTrigReqOR.append({
otherJetDefs:
fullTrigReqAND[otherJetDefs],
(jetDef[0], jetDef[1], otherJetDefs[1]):
fullTrigReqAND[jetDef]
})
#
# Format lists of ORs in a way that can be passed to the c++
#
mlog.debug("full btagReqsOR are")
mlog.debug(fullTrigReqOR)
EtThresholdsOR = []
BTagMinOR = []
BTagMaxOR = []
MultiplicitiesOR = []
for jetReqAndComo in fullTrigReqOR:
thisEtThresholdsOR = []
thisBTagMinOR = []
thisBTagMaxOR = []
thisMultiplicitiesOR = []
for jetReq in jetReqAndComo:
thisEtThresholdsOR.append(jetReq[0])
thisBTagMinOR.append(self.getCutValue(AllowedCuts[jetReq[1]]))
if jetReq[2] < len(AllowedCuts):
thisBTagMaxOR.append(
self.getCutValue(AllowedCuts[jetReq[2]]))
else:
thisBTagMaxOR.append(jetReq[2])
thisMultiplicitiesOR.append(jetReqAndComo[jetReq])
EtThresholdsOR.append(thisEtThresholdsOR)
BTagMinOR.append(thisBTagMinOR)
BTagMaxOR.append(thisBTagMaxOR)
MultiplicitiesOR.append(thisMultiplicitiesOR)
mlog.debug("EtThresholdsOR:")
mlog.debug(EtThresholdsOR)
self.EtThresholdsOR = EtThresholdsOR
mlog.debug("BTagMinOR:")
mlog.debug(BTagMinOR)
self.BTagMinOR = BTagMinOR
mlog.debug("BTagMaxOR:")
mlog.debug(BTagMaxOR)
self.BTagMaxOR = BTagMaxOR
mlog.debug("MultiplicitiesOR:")
mlog.debug(MultiplicitiesOR)
self.MultiplicitiesOR = MultiplicitiesOR
from TrigBjetHypo.TrigBjetHypoMonitoring import TrigEFBjetHypoAllTEValidationMonitoring, TrigEFBjetHypoAllTEOnlineMonitoring
validation = TrigEFBjetHypoAllTEValidationMonitoring()
online = TrigEFBjetHypoAllTEOnlineMonitoring()
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig("TimeHistogramForTrigBjetHypoAllTE")
time.TimerHistLimits = [0, 0.4]
self.AthenaMonTools = [time, validation, online]
def __init__(self, name="TrigSiTrack_Bphysics"):
TrigSiTrack.__init__(self, name)
from __main__ import ToolSvc
trtTool = TrigTRT_TrackExtensionTool(OfflineClusters=False)
ToolSvc += trtTool
fitTool = TrigInDetTrackFitter(OfflineClusters=False)
ToolSvc += fitTool
self.Tool_SpacePointProviderTool = ospTool
self.Tool_TRTExtensionTool = trtTool
self.Tool_ReFitterTool = fitTool
self.Map_Layer1 = [0, 1, 7]
self.Map_Layer2 = [1, 2, 7, 8]
self.Map_Layer3 = [2, 8, 9]
self.Map_Layer4 = [3, 10, 11]
self.Map_Layer5 = [4, 12, 13]
self.Map_Layer6 = [5, 14, 15]
self.Map_Layer7 = [6, 16, 17, 18]
self.RoI_HalfWidthPhi = 0.75
self.RoI_HalfWidthEta = 0.75
if TrigSiTrackFlags.LoosenCuts:
self.Seeding_PreCutRZ = TrigSiTrackLoosenCuts.Seeding_PreCutRZ
self.Seeding_PreCutRPhi = TrigSiTrackLoosenCuts.Seeding_PreCutRPhi
self.Seeding_CutRZ = TrigSiTrackLoosenCuts.Seeding_CutRZ
else:
self.Seeding_PreCutRZ = 10.0
self.Seeding_PreCutRPhi = 0.0004
self.Seeding_CutRZ = 1.5
self.Vertexing_Enable = True
self.Vertexing_CutRZ = 200.0
self.Vertexing_CutRPhi = 0.00025
self.Vertexing_MaxVertices = 3
self.Vertexing_WindowSize = 2.0
self.Vertexing_WindowSegments = 4
if TrigSiTrackFlags.LoosenCuts:
self.Extension_PreCutRZ = TrigSiTrackLoosenCuts.Extension_PreCutRZ
self.Extension_PreCutRPhi = TrigSiTrackLoosenCuts.Extension_PreCutRPhi
self.Extension_PreCutRPhiDiff = TrigSiTrackLoosenCuts.Extension_PreCutRPhiDiff
self.Extension_CutRZ = TrigSiTrackLoosenCuts.Extension_CutRZ
self.Extension_CutRPhi = TrigSiTrackLoosenCuts.Extension_CutRPhi
else:
self.Extension_PreCutRZ = 10.0
self.Extension_PreCutRPhi = 0.0003
self.Extension_PreCutRPhiDiff = 0.0003
self.Extension_CutRZ = 4.0
self.Extension_CutRPhi = 0.007
self.Extension_CutSpacePoints = 2
self.Extension_MergeSeeds = True
self.Extension_MergeSeedsCut = 20.0
self.Extension_SolveTracks = True
self.Extension_SolveTracksCut = 20.0
self.Extension_SolveShared = True
self.Extension_Refit = True
self.Extension_TRTExtension = True
self.Extension_UseMagneticField = False
# monitoring histograms
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig("TimeHistogramForTrigSiTrack")
time.TimerHistLimits = [0, 50]
self.AthenaMonTools = [
TrigSiTrack_ValidationMonitoring(),
TrigSiTrack_OnlineMonitoring(), time
]
def __init__(self, name="TrigSiTrack_Cosmics"):
TrigSiTrack.__init__(self, name)
from __main__ import ToolSvc
trtTool = TrigTRT_TrackExtensionTool(OfflineClusters=False)
ToolSvc += trtTool
fitTool = TrigInDetTrackFitter(OfflineClusters=False)
ToolSvc += fitTool
self.Tool_SpacePointProviderTool = ospTool
self.Tool_TRTExtensionTool = trtTool
self.Tool_ReFitterTool = fitTool
self.Map_Layer1 = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18
]
self.Map_Layer2 = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18
]
self.Map_Layer3 = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18
]
self.Map_Layer4 = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18
]
self.Map_Layer5 = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18
]
self.Map_Layer6 = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18
]
self.Map_Layer7 = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18
]
self.Map_UsePixel = False
self.RoI_HalfWidthPhi = 3.141
self.RoI_HalfWidthEta = 5.0
self.Seeding_PreCutRZ = 10.0 * 50
self.Seeding_PreCutRPhi = 0.005 ### TUNED
self.Seeding_CutRZ = 1.5 * 50
self.Vertexing_Enable = False
self.Vertexing_CutRZ = 1000.0 ### TUNED
self.Extension_PreCutRZ = 10.0 * 50
self.Extension_PreCutRPhi = 0.03 ### TUNED
self.Extension_PreCutRPhiDiff = 0.03 ### TUNED
self.Extension_CutRZ = 400.0 ### TUNED
self.Extension_CutRPhi = 0.7 ### TUNED
self.Extension_CutSpacePoints = 2
self.Extension_MergeSeeds = True
self.Extension_MergeSeedsCut = 20.0
self.Extension_SolveTracks = True
self.Extension_SolveTracksCut = 20.0
self.Extension_Refit = True
self.Extension_TRTExtension = False
self.Extension_UseMagneticField = False
self.Debug_Tuning12 = False
self.Debug_Tuning123 = False
self.Debug_Shift = False
self.Debug_ForcedShift = False
self.Debug_ShiftX = 0.0
self.Debug_ShiftY = 0.0
# monitoring histograms
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig("TimeHistogramForTrigSiTrack")
time.TimerHistLimits = [0, 50]
self.AthenaMonTools = [
TrigSiTrack_Cosmic_Monitoring(),
TrigSiTrack_ValidationMonitoring(),
TrigSiTrack_OnlineMonitoring(), time
]
def __init__(self, name,threshold):
super( EFTrackHypo_e, self ).__init__( name )
# AcceptAll flag: if true take events regardless of cuts
self.AcceptAll = False
self.AthenaMonTools = [ EFTrackHypo_ValidationMonitoring(), TrigTimeHistToolConfig("Time") ]
def __init__(self, name="TrigTauRecMerged_Tau2012"):
super(TrigTauRecMerged_Tau2012, self).__init__(name)
self._mytools = []
# monitoring part. To switch off do in topOption TriggerFlags.enableMonitoring = []
from TrigTauRec.TrigTauRecMonitoring import TrigTauRecValidationMonitoring, TrigTauRecOnlineMonitoring
validation = TrigTauRecValidationMonitoring()
online = TrigTauRecOnlineMonitoring()
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig("Time")
self.AthenaMonTools = [time, validation, online]
# Don't try to retrieve for now, should be handled globally
#if not hasattr(ToolSvc, "LumiBlockMuTool"):
# from LumiBlockComps.LumiBlockCompsConf import LumiBlockMuTool
# ToolSvc += CfgMgr.LumiBlockMuTool("LumiBlockMuTool")
import TrigTauRec.TrigTauAlgorithmsHolder as taualgs
tools = []
taualgs.setPrefix("TrigTau2012_")
#what should run in trigger???
#same as tauRec (but without Pi0 cluster finder)
tools.append(taualgs.getJetSeedBuilder())
tools.append(taualgs.getTauVertexFinder(
doUseTJVA=False)) #don't use TJVA by default
tools.append(taualgs.getTauAxis())
tools.append(taualgs.getTauTrackFinder(applyZ0cut=True, maxDeltaZ0=2))
tools.append(
taualgs.getEnergyCalibrationLC(correctEnergy=True,
correctAxis=False,
postfix='_onlyEnergy'))
tools.append(
taualgs.getCellVariables(cellConeSize=0.2)) #cellConeSize 0.2!!
#tools.append(taualgs.getElectronVetoVars()) #needed?
tools.append(taualgs.getTauVertexVariables())
tools.append(taualgs.getTauCommonCalcVars())
tools.append(taualgs.getTauSubstructure())
tools.append(
taualgs.getEnergyCalibrationLC(correctEnergy=False,
correctAxis=True,
postfix='_onlyAxis'))
for tool in tools:
tool.inTrigger = True
tool.calibFolder = 'TrigTauRec/00-11-02/'
pass
self.Tools = tools
#necessary to write out deltaZ0 between tracks and lead trk
#self.theTauPVTool = taualgs.getTauPVTrackTool()
#self.useTauPVTool = True;
## add beam type flag
from AthenaCommon.BeamFlags import jobproperties
self.BeamType = jobproperties.Beam.beamType()
def __init__(self, name="EFBMuMuXFex_noVtx"):
super(TrigEFBMuMuXFex, self).__init__(name)
# AcceptAll flag: if true take events regardless of cuts
self.AcceptAll = False
# muon part
self.OppositeSign = True # if check opposite sign of muons
self.LowerMuMuMassCut = 100.
self.UpperMuMuMassCut = 5500.
##self.LowerMuVtxMassCut = 100.
##self.UpperMuVtxMassCut = 5500.
self.MuVtxChi2Cut = 40.
# B{+/-} -> K{+/-} Mu Mu
self.DoB_KMuMuDecay = True
self.LowerKMuMuMassCut = 4500.
self.UpperKMuMuMassCut = 5900.
##self.LowerB_KMuMuMassCutVtxOff = 4500.
##self.UpperB_KMuMuMassCutVtxOff = 5900.
##self.LowerBVtxMassCut = 4500.
##self.UpperBVtxMassCut = 5900.
self.DoB_KMuMuVertexing = False
self.BVtxChi2Cut = 60. # 300 in L2
# Bd -> K*(892) Mu Mu
self.DoBd_KstarMuMuDecay = True
self.LowerKstar_KaonMassCut = 600.
self.UpperKstar_KaonMassCut = 1500.
self.LowerBd_KstarMuMuMassCut = 4600.
self.UpperBd_KstarMuMuMassCut = 6300.
##self.LowerBd_KstarMuMuMassCutVtxOff = 4600.
##self.UpperBd_KstarMuMuMassCutVtxOff = 6300.
##self.LowerKstarVtxMassCut = 600.
##self.UpperKstarVtxMassCut = 1200.
##self.LowerBdVtxMassCut = 4600.
##self.UpperBdVtxMassCut = 6000.
self.DoKstar_KPiVertexing = False
self.DoBd_KstarMuMuVertexing = False
self.KstarVtxChi2Cut = 40.
self.BdVtxChi2Cut = 60.
# Bs -> Phi(1020) Mu Mu
self.DoBs_Phi1020MuMuDecay = True
self.LowerPhi1020_KaonMassCut = 990.
self.UpperPhi1020_KaonMassCut = 1050.
self.LowerBs_Phi1020MuMuMassCut = 5000.
self.UpperBs_Phi1020MuMuMassCut = 5800.
##self.LowerBs_Phi1020MuMuMassCutVtxOff = 5000.
##self.UpperBs_Phi1020MuMuMassCutVtxOff = 5800.
##self.LowerPhi1020VtxMassCut = 990.
##self.UpperPhi1020VtxMassCut = 1060.
##self.LowerBsVtxMassCut = 4600.
##self.UpperBsVtxMassCut = 6000.
self.DoPhi1020_KKVertexing = False
self.DoBs_Phi1020MuMuVertexing = False
self.Phi1020VtxChi2Cut = 40.
self.BsVtxChi2Cut = 60.
# Lb -> L Mu Mu
self.DoLb_LambdaMuMuDecay = True
self.LowerLambda_PrPiMassCut = 1040. #1040.
self.UpperLambda_PrPiMassCut = 1250. #1220.
self.LowerLambda_PtCut = 1200.
self.LowerLb_LambdaMuMuMassCut = 3700. #5090.
self.UpperLb_LambdaMuMuMassCut = 6600. #6270.
self.LowerLb_PtCut = 8000.
self.UpperLambdaVtxMassCut = 1200.
self.LowerLbVtxMassCut = 3850.
self.UpperLbVtxMassCut = 6150.
self.DoLambda_PPiVertexing = False
self.DoLb_LambdaMuMuVertexing = False
self.DoLb_LambdaMuMuCascade = False
self.LambdaVtxChi2Cut = 90. #100.
self.LbVtxChi2Cut = 180. #100.
##self.LbVtxDistanceCut = 0.
##self.PiImpactCut = 0.
##self.PrImpactCut = 0.
# vertexing off
##self.LowerLb_LambdaMuMuMassCutVtxOff = 1080.
##self.UpperLb_LambdaMuMuMassCutVtxOff = 1180.
# Bc -> D_s* Mu Mu
self.DoBc_DsMuMuDecay = True
self.LowerPhiDs_MassCut = 980.
self.UpperPhiDs_MassCut = 1080.
self.LowerDs_MassCut = 1600.
self.UpperDs_MassCut = 2400.
self.LowerDs_PtCut = 2000.
self.LowerBc_DsMuMuMassCut = 5450.
self.UpperBc_DsMuMuMassCut = 7050.
self.LowerBcDs_PtCut = 8000.
##self.LowerDs_LxyCut = 0.3
self.LowerDs_LxyCut = -999.3
self.DoDs_Vertexing = False
self.DoBc_DsMuMuVertexing = False
self.DoBc_DsMuMuCascade = False
self.DsVtxChi2Cut = 90.
self.BcVtxChi2Cut = 120.
# Bc -> D+ Mu Mu
self.DoBc_DplusMuMuDecay = True
##self.LowerPhiDs_MassCut = 980.
##self.UpperPhiDs_MassCut = 1080.
self.LowerDplus_MassCut = 1500.
self.UpperDplus_MassCut = 2300.
self.LowerDplus_PtCut = 2000.
##self.LowerBc_DsMuMuMassCut = 1800.
self.LowerBc_DplusMuMuMassCut = 5450.
self.UpperBc_DplusMuMuMassCut = 7050.
self.LowerBcDplus_PtCut = 8000.
##self.LowerDplus_LxyCut = 0.3
self.LowerDplus_LxyCut = 0.01
self.DoDplus_Vertexing = False
self.DoBc_DplusMuMuVertexing = False
self.DoBc_DplusMuMuCascade = False
self.DplusVtxChi2Cut = 90.
self.BcDplusVtxChi2Cut = 180.
# Bc -> Dstar Mu Mu
self.DoBc_DstarMuMuDecay = True
self.LowerD0Dstar_MassCut = 1500.
self.UpperD0Dstar_MassCut = 2300.
self.UpperDstar_DMCut = 180.
self.LowerDstar_PtCut = 2000.
self.LowerDstarKpi_PtCut = 1800.
self.LowerBc_DstarMuMuMassCut = 5450.
self.UpperBc_DstarMuMuMassCut = 7050.
self.LowerBcDstar_PtCut = 8000.
self.DoD0Dstar_Vertexing = False
self.DoBc_DstarMuMuVertexing = False
self.DoBc_DstarMuMuCascade = False
self.D0DstarVtxChi2Cut = 90.
self.BcDstarVtxChi2Cut = 120.
# Bc -> D0 (Dstar with lost pi_s) Mu Mu
self.DoBc_D0MuMuDecay = True
self.LowerD0_MassCut = 1500.
self.UpperD0_MassCut = 2300.
self.LowerD0_PtCut = 2000.
self.LowerBc_D0MuMuMassCut = 5250.
self.UpperBc_D0MuMuMassCut = 6911.
self.LowerBcD0_PtCut = 8000.
self.LowerD0_LxyCut = 0.01
self.DoD0_Vertexing = False
self.DoBc_D0MuMuVertexing = False
self.DoBc_D0MuMuCascade = False
self.D0VtxChi2Cut = 90.
self.BcD0VtxChi2Cut = 120.
self.MaxBcD0ToStore = 1000
from TrigBphysHypo.TrigEFBMuMuXFexMonitoring import EFBMuMuXFexValidationMonitoring
validation = EFBMuMuXFexValidationMonitoring()
from TrigBphysHypo.TrigEFBMuMuXFexMonitoring import EFBMuMuXFexOnlineMonitoring
online = EFBMuMuXFexOnlineMonitoring()
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig("Time")
self.AthenaMonTools = [validation, online, time]
def __init__(self, name="TrigExtProcessor_Electron_EF", type="electron"):
super(InDet__InDetTrigExtensProcessor, self).__init__(name)
from AthenaCommon.AppMgr import ToolSvc
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTrackFitter, InDetTrigPatternUpdator, InDetTrigExtrapolator, InDetTrigTrackSummaryTool
if InDetTrigFlags.trtExtensionType() is 'DAF':
# DAF Fitter setup
#
from TrkCompetingRIOsOnTrackTool.TrkCompetingRIOsOnTrackToolConf import Trk__CompetingRIOsOnTrackTool
InDetTrigCompetingRotCreator = \
Trk__CompetingRIOsOnTrackTool( name = 'InDetTrigCompetingRotCreator',
ToolForCompPixelClusters = None, # default
ToolForCompSCT_Clusters = None, # default
ToolForCompTRT_DriftCircles = InDetTrigCompetingTRT_DC_Tool )
ToolSvc += InDetTrigCompetingRotCreator
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigCompetingRotCreator
from TrkDeterministicAnnealingFilter.TrkDeterministicAnnealingFilterConf import Trk__DeterministicAnnealingFilter
InDetTrigExtensionFitter = \
Trk__DeterministicAnnealingFilter (name = 'InDetTrigDAF',
ToolForExtrapolation = InDetTrigExtrapolator,
ToolForCompetingROTsCreation = InDetTrigCompetingRotCreator,
ToolForUpdating = InDetTrigPatternUpdator,
AnnealingScheme = [200., 81., 9., 4., 1., 1., 1.],
DropOutlierCutValue = 1.E-7,
OutlierCutValue = 0.01 )
ToolSvc += InDetTrigExtensionFitter
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigExtensionFitter
else:
if type == "cosmicsN":
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTrackFitterCosmics
InDetTrigExtensionFitter = InDetTrigTrackFitterCosmics
else:
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTrackFitter
InDetTrigExtensionFitter = InDetTrigTrackFitter
ToolSvc += InDetTrigExtensionFitter
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigExtensionFitter
# get configured track extension processor
#-----------------------------------------------------------------------
from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import \
InDetTrigTRTDriftCircleCut
from InDetTrackScoringTools.InDetTrackScoringToolsConf import InDet__InDetAmbiScoringTool
InDetTrigExtScoringTool = InDet__InDetAmbiScoringTool(
name='InDetTrigExtScoringTool_' + type,
Extrapolator=InDetTrigExtrapolator,
SummaryTool=InDetTrigTrackSummaryTool,
useAmbigFcn=True, # this is NewTracking
#minPt = InDetTrigCutValues.minPT(), #see below
maxRPhiImp=InDetTrigCutValues.maxPrimaryImpact(),
maxZImp=InDetTrigCutValues.maxZImpact(),
maxEta=InDetTrigCutValues.maxEta(),
minSiClusters=InDetTrigCutValues.minClusters(),
maxSiHoles=InDetTrigCutValues.maxHoles(),
maxDoubleHoles=InDetTrigCutValues.maxDoubleHoles(),
usePixel=InDetTrigCutValues.usePixel(),
useSCT=InDetTrigCutValues.useSCT(),
doEmCaloSeed=False,
minTRTonTrk=InDetTrigCutValues.minTRTonTrk(),
#useSigmaChi2 = False # tuning from Thijs
DriftCircleCutTool=InDetTrigTRTDriftCircleCut,
)
InDetTrigExtScoringTool.minPt = InDetTrigSliceSettings[('pTmin', type)]
#
ToolSvc += InDetTrigExtScoringTool
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigExtScoringTool
if type == "cosmicsN":
from InDetTrigRecExample.InDetTrigConfigRecLoadToolsCosmics import InDetTrigTrackSummaryToolCosmics
from InDetTrackScoringTools.InDetTrackScoringToolsConf import InDet__InDetCosmicScoringTool
InDetTrigScoringToolCosmics_TRT= \
InDet__InDetCosmicScoringTool(name = 'InDetTrigCosmicScoringTool_TRT',
nWeightedClustersMin = 0,
minTRTHits = EFIDTrackingCutsCosmics.minTRTonTrk(),
SummaryTool= InDetTrigTrackSummaryToolCosmics
)
ToolSvc += InDetTrigScoringToolCosmics_TRT
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigScoringToolCosmics_TRT
self.TrackFitter = InDetTrigExtensionFitter
self.ScoringTool = InDet__InDetAmbiScoringTool(
'InDetTrigExtScoringTool_' + type)
self.RefitPrds = not (InDetTrigFlags.refitROT() or
(InDetTrigFlags.trtExtensionType() is 'DAF'))
self.suppressHoleSearch = False # does not work properly
if type == "cosmicsN":
self.ScoringTool = InDetTrigScoringToolCosmics_TRT
self.Cosmics = True
#Material effects
if InDetTrigFlags.materialInteractions():
self.matEffects = 3 # default in code is 4!!
else:
self.matEffects = 0
if type == "cosmicsN" and not InDetTrigFlags.solenoidOn():
self.matEffects = 0
#monitoring
from InDetTrigExtensProcessor.InDetTrigExtensProcessorMonitoring import InDetTrigExtensProcessorValidationMonitor
from InDetTrigExtensProcessor.InDetTrigExtensProcessorMonitoring import InDetTrigExtensProcessorOnlineMonitor
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
idexttime = TrigTimeHistToolConfig("IdExtTime")
idexttime.TimerHistLimits = [0, 200]
self.AthenaMonTools = [
InDetTrigExtensProcessorValidationMonitor(),
InDetTrigExtensProcessorOnlineMonitor(), idexttime
]
def __init__(self, name="TRTTrackExtAlg_Electron_EF", type="electron"):
super(InDet__TRT_TrigTrackExtensionAlg, self).__init__(name)
from AthenaCommon.AppMgr import ToolSvc
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigPatternPropagator, InDetTrigPatternUpdator
# TRT detector elements road builder
#
from TRT_DetElementsRoadTool_xk.TRT_DetElementsRoadTool_xkConf import InDet__TRT_DetElementsRoadMaker_xk
InDetTrigTRTDetElementsRoadMaker = InDet__TRT_DetElementsRoadMaker_xk(
name='InDetTrigTRTRoadMaker',
#DetectorStoreLocation = 'DetectorStore',
TRTManagerLocation='TRT',
MagneticFieldMode='MapSolenoid',
PropagatorTool=InDetTrigPatternPropagator)
ToolSvc += InDetTrigTRTDetElementsRoadMaker
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigTRTDetElementsRoadMaker
# Track extension to TRT tool
#
from AthenaCommon.DetFlags import DetFlags
if (DetFlags.haveRIO.TRT_on()):
if InDetTrigFlags.trtExtensionType() is 'xk':
from TRT_TrackExtensionTool_xk.TRT_TrackExtensionTool_xkConf import InDet__TRT_TrackExtensionTool_xk
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTRTDriftCircleCut
InDetTrigTRTExtensionTool = \
InDet__TRT_TrackExtensionTool_xk(name = 'InDetTrigTRTExtensionTool',
MagneticFieldMode = 'MapSolenoid', # default
TRT_ClustersContainer = 'TRT_TrigDriftCircles', # default
TrtManagerLocation = 'TRT', # default
PropagatorTool = InDetTrigPatternPropagator,
UpdatorTool = InDetTrigPatternUpdator,
#RIOonTrackToolYesDr = # default for now
#RIOonTrackToolNoDr = # default for now
RoadTool = InDetTrigTRTDetElementsRoadMaker,
DriftCircleCutTool = InDetTrigTRTDriftCircleCut,
MinNumberDriftCircles = EFIDTrackingCuts.minTRTonTrk(),
ScaleHitUncertainty = 2.,
RoadWidth = 20.,
UseParameterization = EFIDTrackingCuts.useParameterizedTRTCuts()
)
elif InDetTrigFlags.trtExtensionType() is 'DAF':
# load TRT Competing ROT tool
from TrkDeterministicAnnealingFilter.TrkDeterministicAnnealingFilterConf import Trk__DAF_SimpleWeightCalculator
InDetTrigWeightCalculator = Trk__DAF_SimpleWeightCalculator(
name='InDetTrigWeightCalculator')
ToolSvc += InDetTrigWeightCalculator
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigWeightCalculator
from InDetCompetingRIOsOnTrackTool.InDetCompetingRIOsOnTrackToolConf import InDet__CompetingTRT_DriftCirclesOnTrackTool
InDetTrigCompetingTRT_DC_Tool = \
InDet__CompetingTRT_DriftCirclesOnTrackTool( name = 'InDetTrigCompetingTRT_DC_Tool',
MagneticFieldMode = 'MapSolenoid', # default
PropagatorTool = InDetTrigPatternPropagator,
ToolForWeightCalculation= InDetTrigWeightCalculator,
ToolForTRT_DriftCircleOnTrackCreation = InDetTrigRotCreator.ToolTRT_DriftCircle)
ToolSvc += InDetTrigCompetingTRT_DC_Tool
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigCompetingTRT_DC_Tool
from TRT_TrackExtensionTool_DAF.TRT_TrackExtensionTool_DAFConf import InDet__TRT_TrackExtensionTool_DAF
InDetTrigTRTExtensionTool = \
InDet__TRT_TrackExtensionTool_DAF(name = 'InDetTrigTRTExtensionTool',
MagneticFieldMode = 'MapSolenoid', # default
TRT_DriftCircleContainer = 'TRT_TrigDriftCircles', # default
CompetingDriftCircleTool = InDetTrigCompetingTRT_DC_Tool,
PropagatorTool = InDetTrigPatternPropagator,
RoadTool = InDetTrigTRTDetElementsRoadMaker)
#
ToolSvc += InDetTrigTRTExtensionTool
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigTRTExtensionTool
self.TrackExtensionTool = InDetTrigTRTExtensionTool
#monitoring
from TRT_TrigTrackExtensionAlg.TRT_TrigTrackExtensionAlgMonitoring import TRT_TrigTrackExtensionAlgValidationMonitor
from TRT_TrigTrackExtensionAlg.TRT_TrigTrackExtensionAlgMonitoring import TRT_TrigTrackExtensionAlgOnlineMonitor
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
exttime = TrigTimeHistToolConfig("ExtTime")
exttime.TimerHistLimits = [0, 40]
self.AthenaMonTools = [
TRT_TrigTrackExtensionAlgValidationMonitor(),
TRT_TrigTrackExtensionAlgOnlineMonitor(), exttime
]
def __init__(self,
name="SiTrigTrackFinder_Electron_EF",
type="electron",
lowPt=False):
super(InDet__SiTrigSPSeededTrackFinder, self).__init__(name)
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigPrdAssociationTool, \
InDetTrigPatternPropagator, InDetTrigPatternUpdator, \
InDetTrigRotCreator, InDetTrigPixelConditionsSummarySvc, InDetTrigSCTConditionsSummarySvc
from AthenaCommon.AppMgr import ToolSvc
# configure tools used
# Space points seeds maker
#
from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
from AthenaCommon.DetFlags import DetFlags
if type == "beamgas":
from InDetTrigRecExample.InDetTrigConfigRecLoadToolsBeamGas import InDetTrigSiSpacePointsSeedMakerBeamGas
InDetTrigSiSpacePointsSeedMaker = InDetTrigSiSpacePointsSeedMakerBeamGas
elif type == "cosmicsN":
from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_Cosmic
InDetTrigSiSpacePointsSeedMaker = \
InDet__SiSpacePointsSeedMaker_Cosmic(name = 'InDetTrigSiSpacePointsSeedMaker_'+type,
pTmin = InDetTrigSliceSettings[('pTmin',type)],
maxdImpact = EFIDTrackingCutsCosmics.maxPrimaryImpact(),
maxZ = EFIDTrackingCutsCosmics.maxZImpact(),
minZ = -EFIDTrackingCutsCosmics.maxZImpact(),
SpacePointsPixelName = 'SCT_CosmicsTrigSpacePoints',
SpacePointsSCTName = 'PixelCosmicsTrigSpacePoints',
#SpacePointsOverlapName = InDetKeys.OverlapSpacePoints(),
UseAssociationTool = False,
AssociationTool = InDetTrigPrdAssociationTool)
elif lowPt:
from InDetTrigRecExample.InDetTrigConfigRecLoadToolsLowPt import InDetTrigSiSpacePointsSeedMakerLowPt
InDetTrigSiSpacePointsSeedMaker = InDetTrigSiSpacePointsSeedMakerLowPt
elif type == "heavyIon" or type == "heavyIonFS":
from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_HeavyIon
InDetTrigSiSpacePointsSeedMaker = \
InDet__SiSpacePointsSeedMaker_HeavyIon(name= 'InDetTrigSiSpacePointsSeedMaker_'+type,
pTmin = InDetTrigSliceSettings[('pTmin',type)],
maxdImpact = EFIDTrackingCutsHeavyIon.maxPrimaryImpact(),
maxZ = EFIDTrackingCutsHeavyIon.maxZImpact(),
minZ = -EFIDTrackingCutsHeavyIon.maxZImpact(),
#useOverlapSpCollection = False, #overlapCollections not used in EFID
useOverlapSpCollection = InDetTrigFlags.doOverlapSP(), #testing
usePixel = DetFlags.haveRIO.pixel_on(),
useSCT = DetFlags.haveRIO.SCT_on(),
SpacePointsSCTName = 'SCT_TrigSpacePoints',
SpacePointsPixelName = 'PixelTrigSpacePoints',
SpacePointsOverlapName = 'SPTrigOverlap',
radMax = EFIDTrackingCutsHeavyIon.radMax())
else:
from SiSpacePointsSeedTool_xk.SiSpacePointsSeedTool_xkConf import InDet__SiSpacePointsSeedMaker_ATLxk
InDetTrigSiSpacePointsSeedMaker = \
InDet__SiSpacePointsSeedMaker_ATLxk( name = 'InDetTrigSiSpacePointsSeedMaker_'+type,
pTmin = InDetTrigSliceSettings[('pTmin',type)],
maxdImpact = InDetTrigCutValues.maxPrimaryImpact(),
maxZ = InDetTrigCutValues.maxZImpact(),
minZ = -InDetTrigCutValues.maxZImpact(),
#useOverlapSpCollection = False, #overlapCollections not used in EFID
useOverlapSpCollection = InDetTrigFlags.doOverlapSP(), #testing
usePixel = DetFlags.haveRIO.pixel_on(),
useSCT = DetFlags.haveRIO.SCT_on(),
SpacePointsSCTName = 'SCT_TrigSpacePoints',
SpacePointsPixelName = 'PixelTrigSpacePoints',
SpacePointsOverlapName = 'SPTrigOverlap',
radMax = InDetTrigCutValues.radMax(),
maxdImpactPPS = InDetTrigCutValues.maxdImpactPPSSeeds(),
maxdImpactSSS = InDetTrigCutValues.maxdImpactSSSSeeds(),
)
if type != "cosmicsN":
InDetTrigSiSpacePointsSeedMaker.maxRadius1 = 0.75 * InDetTrigCutValues.radMax(
)
InDetTrigSiSpacePointsSeedMaker.maxRadius2 = InDetTrigCutValues.radMax(
)
InDetTrigSiSpacePointsSeedMaker.maxRadius3 = InDetTrigCutValues.radMax(
)
# if type=="minBias":
# InDetTrigSiSpacePointsSeedMaker.maxdImpact=5.
ToolSvc += InDetTrigSiSpacePointsSeedMaker
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigSiSpacePointsSeedMaker
#InDetTrigSiSpacePointsSeedMaker.OutputLevel = 1
# Z-coordinates primary vertices finder
#
from SiZvertexTool_xk.SiZvertexTool_xkConf import InDet__SiZvertexMaker_xk
InDetTrigZvertexMaker = InDet__SiZvertexMaker_xk(
name='InDetTrigZvertexMaker_' + type,
Zmax=InDetTrigCutValues.maxZImpact(),
Zmin=-InDetTrigCutValues.maxZImpact(),
minRatio=0.17 # not default
)
if type == "heavyIon" or type == "heavyIonFS":
InDetTrigZvertexMaker.HistSize = 2000
InDetTrigZvertexMaker.minContent = 30
#InDetTrigZvertexMaker.SeedMakerTool = InDet__SiSpacePointsSeedMaker_ATLxk('InDetTrigSiSpacePointsSeedMaker_'+type)#to make it tool neutral
InDetTrigZvertexMaker.SeedMakerTool = ToolSvc.allConfigurables[
'InDetTrigSiSpacePointsSeedMaker_' + type]
ToolSvc += InDetTrigZvertexMaker
#InDetTrigZvertexMaker.OutputLevel=1
# SCT and Pixel detector elements road builder
#
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigSiDetElementsRoadMaker, InDetTrigSiComTrackFinder
# Local track finding using space point seed
#
from SiTrackMakerTool_xk.SiTrackMakerTool_xkConf import InDet__SiTrackMaker_xk
InDetTrigSiTrackMaker = InDet__SiTrackMaker_xk(
name='InDetTrigSiTrackMaker_' + type,
RoadTool=InDetTrigSiDetElementsRoadMaker,
CombinatorialTrackFinder=InDetTrigSiComTrackFinder,
pTmin=InDetTrigSliceSettings[('pTmin', type)],
nClustersMin=InDetTrigCutValues.minClusters(),
nHolesMax=InDetTrigCutValues.nHolesMax(),
nHolesGapMax=InDetTrigCutValues.nHolesGapMax(),
SeedsFilterLevel=InDetTrigCutValues.seedFilterLevel(),
Xi2max=InDetTrigCutValues.Xi2max(),
Xi2maxNoAdd=InDetTrigCutValues.Xi2maxNoAdd(),
nWeightedClustersMin=InDetTrigCutValues.nWeightedClustersMin(),
#CosmicTrack = InDetFlags.doCosmics(),
Xi2maxMultiTracks=InDetTrigCutValues.Xi2max(),
UseAssociationTool=False)
if type == "beamgas":
InDetTrigSiTrackMaker.pTmin = EFIDTrackingCutsBeamGas.minPT()
InDetTrigSiTrackMaker.nClustersMin = EFIDTrackingCutsBeamGas.minClusters(
)
InDetTrigSiTrackMaker.nHolesMax = EFIDTrackingCutsBeamGas.nHolesMax(
)
InDetTrigSiTrackMaker.UseAssociationTool = True #for BG and LowPt
elif type == "cosmicsN":
#create an additional for cosmics
from InDetTrigRecExample.InDetTrigConfigRecLoadToolsCosmics import InDetTrigSiDetElementsRoadMakerCosmics
InDetTrigSiTrackMaker.RoadTool = InDetTrigSiDetElementsRoadMakerCosmics
InDetTrigSiTrackMaker.nClustersMin = EFIDTrackingCutsCosmics.minClusters(
)
InDetTrigSiTrackMaker.nHolesMax = EFIDTrackingCutsCosmics.nHolesMax(
) #3 vs 7
InDetTrigSiTrackMaker.nHolesGapMax = EFIDTrackingCutsCosmics.nHolesGapMax(
) #3
InDetTrigSiTrackMaker.CosmicTrack = True
#InDetTrigSiTrackMaker.GoodSeedClusterCount = 3
elif type == 'electron' and InDetTrigFlags.doBremRecovery():
InDetTrigSiTrackMaker.useBremModel = True
ToolSvc += InDetTrigSiTrackMaker
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigSiTrackMaker
self.SeedsTool = InDetTrigSiSpacePointsSeedMaker
self.ZvertexTool = InDetTrigZvertexMaker
self.useZvertexTool = InDetTrigFlags.useZvertexTool()
if type == "beamgas" or type == "cosmicsN":
self.ZvertexTool = None
self.useZvertexTool = False
elif type == "heavyIon" or type == "heavyIonFS":
self.useZvertexTool = True
if lowPt:
from InDetTrigRecExample.InDetTrigConfigRecLoadToolsLowPt \
import InDetTrigSiSpacePointsSeedMakerLowPt,InDetTrigSiTrackMakerLowPt, InDetTrigZvertexMakerLowPt
self.TrackTool = InDetTrigSiTrackMakerLowPt
self.SeedsTool = InDetTrigSiSpacePointsSeedMakerLowPt
self.useZvertexTool = InDetTrigFlags.useZvertexTool()
self.ZvertexTool = InDetTrigZvertexMakerLowPt
else:
#self.TrackTool = InDetTrigSiTrackMaker
self.TrackTool = InDet__SiTrackMaker_xk('InDetTrigSiTrackMaker_' +
type)
self.EtaHalfWidth = InDetTrigSliceSettings[('etaHalfWidth', type)]
self.PhiHalfWidth = InDetTrigSliceSettings[('phiHalfWidth', type)]
self.doFullScan = InDetTrigSliceSettings[('doFullScan', type)]
#monitoring
from SiTrigSPSeededTrackFinder.SiTrigSPSeededTrackFinderMonitoring import \
SiTrigSPSeededTrackFinderValidationMonitor, \
SiTrigSPSeededTrackFinderOnlineMonitor
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
sitrktime = TrigTimeHistToolConfig("SiTRKTime")
sitrktime.TimerHistLimits = [0, 200]
self.AthenaMonTools = [
SiTrigSPSeededTrackFinderValidationMonitor(type=type),
SiTrigSPSeededTrackFinderOnlineMonitor(type=type), sitrktime
]
def __init__(self,
name="TrigAmbiguitySolver_Electron_EF",
type="electron",
lowPt=False):
super(InDet__InDetTrigAmbiguitySolver, self).__init__(name)
slice = type
if name.find('FTK') > -1:
slice = 'FTK'
from AthenaCommon.AppMgr import ToolSvc
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigPrdAssociationTool, \
InDetTrigTrackFitter, InDetTrigExtrapolator, InDetTrigTrackSummaryTool, \
InDetTrigTRTDriftCircleCut
# load InnerDetector TrackSelectionTool
#
from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
from InDetTrackScoringTools.InDetTrackScoringToolsConf import InDet__InDetAmbiScoringTool
#ptint
ptintcut = InDetTrigSliceSettings[('pTmin', slice)]
if slice == 'minBias':
ptintcut = 0.95 * InDetTrigSliceSettings[('pTmin', slice)]
elif slice == 'minBias400':
ptintcut = 0.95 * InDetTrigSliceSettings[('pTmin', slice)]
InDetTrigScoringTool = InDet__InDetAmbiScoringTool(
name='InDetTrigScoringTool_' + slice,
Extrapolator=InDetTrigExtrapolator,
SummaryTool=InDetTrigTrackSummaryTool,
useAmbigFcn=True, # this is NewTracking
useTRT_AmbigFcn=False,
#to have a steeper turn-n curve
minPt=ptintcut,
maxRPhiImp=InDetTrigCutValues.maxPrimaryImpact(),
maxZImp=InDetTrigCutValues.maxZImpact(),
maxEta=InDetTrigCutValues.maxEta(),
minSiClusters=InDetTrigCutValues.minClusters(),
maxSiHoles=InDetTrigCutValues.maxHoles(),
maxPixelHoles=InDetTrigCutValues.maxPixelHoles(),
maxSCTHoles=InDetTrigCutValues.maxSCTHoles(),
maxDoubleHoles=InDetTrigCutValues.maxDoubleHoles(),
usePixel=InDetTrigCutValues.usePixel(),
useSCT=InDetTrigCutValues.useSCT(),
minTRTonTrk=0, # no TRT here
DriftCircleCutTool=InDetTrigTRTDriftCircleCut,
doEmCaloSeed=False,
#BeamPositionSvc = default instance ,
)
if slice == 'beamgas':
InDetTrigScoringTool.minPt = EFIDTrackingCutsBeamGas.minPT()
InDetTrigScoringTool.maxRPhiImp = EFIDTrackingCutsBeamGas.maxPrimaryImpact(
)
InDetTrigScoringTool.maxZImp = EFIDTrackingCutsBeamGas.maxZImpact()
InDetTrigScoringTool.minSiClusters = EFIDTrackingCutsBeamGas.minClusters(
)
InDetTrigScoringTool.maxSiHoles = EFIDTrackingCutsBeamGas.maxHoles(
)
InDetTrigScoringTool.useTRT_AmbigFcn = False
InDetTrigScoringTool.useSigmaChi2 = True
if slice == 'FTK' or slice == 'FTKRefit' or slice == 'FTKMon':
InDetTrigScoringTool.minSiClusters = FTKTrackingCuts.minClusters()
InDetTrigScoringTool.maxSiHoles = FTKTrackingCuts.maxHoles()
InDetTrigScoringTool.maxPixelHoles = FTKTrackingCuts.maxPixelHoles(
)
InDetTrigScoringTool.maxSCTHoles = FTKTrackingCuts.maxSCTHoles()
InDetTrigScoringTool.maxDoubleHoles = FTKTrackingCuts.maxDoubleHoles(
)
#
ToolSvc += InDetTrigScoringTool
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigScoringTool
# load Ambiguity Processor
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import \
InDetTrigAmbiTrackSelectionTool
from TrkAmbiguityProcessor.TrkAmbiguityProcessorConf import Trk__SimpleAmbiguityProcessorTool
InDetTrigAmbiguityProcessor = \
Trk__SimpleAmbiguityProcessorTool(name = 'InDetTrigAmbiguityProcessor_'+slice,
#AssoTool = InDetTrigPrdAssociationTool,
Fitter = InDetTrigTrackFitter,
SelectionTool = InDetTrigAmbiTrackSelectionTool,
RefitPrds = not InDetTrigFlags.refitROT()
)
InDetTrigAmbiguityProcessor.ScoringTool = InDet__InDetAmbiScoringTool(
'InDetTrigScoringTool_' + slice)
if slice == 'beamgas':
from InDetTrigRecExample.InDetTrigConfigRecLoadToolsBeamGas import \
InDetTrigAmbiTrackSelectionToolBeamGas
InDetTrigAmbiguityProcessor.SelectionTool = InDetTrigAmbiTrackSelectionToolBeamGas
elif slice == 'cosmicsN':
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigTrackFitterCosmics
from InDetTrigRecExample.InDetTrigConfigRecLoadToolsCosmics \
import InDetTrigScoringToolCosmics_SiPattern, InDetTrigAmbiTrackSelectionToolCosmicsN
InDetTrigAmbiguityProcessor.Fitter = InDetTrigTrackFitterCosmics
InDetTrigAmbiguityProcessor.SuppressHoleSearch = False
InDetTrigAmbiguityProcessor.SelectionTool = InDetTrigAmbiTrackSelectionToolCosmicsN
InDetTrigAmbiguityProcessor.ScoringTool = InDetTrigScoringToolCosmics_SiPattern
#InDetTrigAmbiguityProcessor.SuppressTrackFit = True
#InDetTrigAmbiguityProcessor.ForceRefit = False
InDetTrigAmbiguityProcessor.RefitPrds = False
elif slice == 'electron' and InDetTrigFlags.doBremRecovery():
InDetTrigAmbiguityProcessor.tryBremFit = True
import AthenaCommon.SystemOfUnits as Units
InDetTrigAmbiguityProcessor.pTminBrem = 5 * Units.GeV
elif slice == 'FTK' or slice == 'FTKRefit' or slice == 'FTKMon':
from TrigInDetConf.TrigInDetRecToolsFTK import InDetTrigAmbiTrackSelectionToolFTK, InDetTrigTrackFitterFTK
InDetTrigAmbiguityProcessor.SelectionTool = InDetTrigAmbiTrackSelectionToolFTK
InDetTrigAmbiguityProcessor.Fitter = InDetTrigTrackFitterFTK
#InDetTrigAmbiguityProcessor.RefitPrds =
if InDetTrigFlags.materialInteractions() and InDetTrigFlags.solenoidOn(
):
InDetTrigAmbiguityProcessor.MatEffects = 3
else:
InDetTrigAmbiguityProcessor.MatEffects = 0
ToolSvc += InDetTrigAmbiguityProcessor
if (InDetTrigFlags.doPrintConfigurables()):
print InDetTrigAmbiguityProcessor
self.AmbiguityProcessor = InDetTrigAmbiguityProcessor
if lowPt:
from InDetTrigRecExample.InDetTrigConfigRecLoadToolsLowPt import InDetTrigAmbiguityProcessorLowPt
self.AmbiguityProcessor = InDetTrigAmbiguityProcessorLowPt
self.OutputTracksLabel = "AmbigSolvLowPt"
#use either SPSeeded or FTF tracks
self.InputTracksLabel = ""
#FIX
#InDetTrigExtrapolator.ApplyMaterialEffects = False
#monitoring
from InDetTrigAmbiguitySolver.InDetTrigAmbiguitySolverMonitoring import InDetTrigAmbiguitySolverValidationMonitor
from InDetTrigAmbiguitySolver.InDetTrigAmbiguitySolverMonitoring import InDetTrigAmbiguitySolverOnlineMonitor
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
ambtime = TrigTimeHistToolConfig("AmbTime")
ambtime.TimerHistLimits = [0, 100]
if InDetTrigSliceSettings[('doFullScan', slice)]:
ambtime.TimerHistLimits = [0, 500]
self.AthenaMonTools = [
InDetTrigAmbiguitySolverValidationMonitor(),
InDetTrigAmbiguitySolverOnlineMonitor(), ambtime
]
def __init__(self, name, type):
TrigFastTrackFinder.__init__(self, name)
remapped_type = remapper(type)
self.retrieveBarCodes = False #Look at truth information for spacepoints from barcodes
#self.SignalBarCodes = [10001] #single particles
self.SignalBarCodes = [11, 12] #z->mumu
self.useNewLayerNumberScheme = True
self.OutputCollectionSuffix = type
from AthenaCommon.AppMgr import ToolSvc
numberingTool = TrigL2LayerNumberTool(name="TrigL2LayerNumberTool_FTF")
numberingTool.UseNewLayerScheme = self.useNewLayerNumberScheme
ToolSvc += numberingTool
self.LayerNumberTool = numberingTool
timeHist = TrigTimeHistToolConfig("Time")
timeHist.TimerHistLimits = [0, 10000]
from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
self.doResMon = InDetTrigSliceSettings[('doResMon', remapped_type)]
self.AthenaMonTools = [
TrigFastTrackFinder_ValidationMonitoring(
"TrigFastTrackFinder_ValidationMonitoring", self.doResMon),
TrigFastTrackFinder_OnlineMonitoring(
"TrigFastTrackFinder_OnlineMonitoring", self.doResMon),
timeHist
]
if type == "FTK" or type == "FTKRefit" or type == "FTKMon":
from TrigFTK_RecExample.TrigFTKLoadTools import theFTK_DataProviderSvc
self.FTK_DataProviderSvc = theFTK_DataProviderSvc
self.FTK_Mode = True
if type == "FTKRefit":
self.FTK_Refit = True
else:
#Spacepoint conversion
from TrigOnlineSpacePointTool.TrigOnlineSpacePointToolConf import TrigSpacePointConversionTool
spTool = TrigSpacePointConversionTool().clone(
'TrigSpacePointConversionTool_' + remapped_type)
spTool.DoPhiFiltering = InDetTrigSliceSettings[('doSpPhiFiltering',
remapped_type)]
spTool.UseNewLayerScheme = self.useNewLayerNumberScheme
spTool.UseBeamTilt = False
spTool.layerNumberTool = numberingTool
ToolSvc += spTool
self.SpacePointProviderTool = spTool
self.MinSPs = 5 #Only process RoI with more than 5 spacepoints
self.Triplet_MinPtFrac = 1
self.Triplet_nMaxPhiSlice = 53
if remapped_type == "cosmics":
self.Triplet_nMaxPhiSlice = 2 #Divide detector in 2 halves for cosmics
self.Triplet_MaxBufferLength = 3
self.doSeedRedundancyCheck = InDetTrigSliceSettings[(
'checkRedundantSeeds', remapped_type)]
self.Triplet_D0Max = InDetTrigSliceSettings[('d0SeedMax',
remapped_type)]
self.Triplet_D0_PPS_Max = InDetTrigSliceSettings[('d0SeedPPSMax',
remapped_type)]
self.TrackInitialD0Max = 20.
if remapped_type == 'cosmics':
self.TrackInitialD0Max = 1000.
self.TrackZ0Max = 1000.
self.TripletDoPSS = False
self.pTmin = InDetTrigSliceSettings[('pTmin', remapped_type)]
self.DoubletDR_Max = InDetTrigSliceSettings[('dRdoubletMax',
remapped_type)]
self.SeedRadBinWidth = InDetTrigSliceSettings[('seedRadBinWidth',
remapped_type)]
if remapped_type == "cosmics":
self.Doublet_FilterRZ = False
## SCT and Pixel detector elements road builder
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigSiDetElementsRoadMaker
InDetTrigSiDetElementsRoadMaker_FTF = InDetTrigSiDetElementsRoadMaker.clone(
'InDetTrigSiDetElementsRoadMaker_FTF')
InDetTrigSiDetElementsRoadMaker_FTF.RoadWidth = 10.0
if remapped_type == "cosmics":
from InDetTrigRecExample.InDetTrigConfigRecLoadToolsCosmics import InDetTrigSiDetElementsRoadMakerCosmics
InDetTrigSiDetElementsRoadMaker_FTF = InDetTrigSiDetElementsRoadMakerCosmics.clone(
'InDetTrigSiDetElementsRoadMaker_FTF')
ToolSvc += InDetTrigSiDetElementsRoadMaker_FTF
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigSiComTrackFinder
InDetTrigSiComTrackFinder_FTF = InDetTrigSiComTrackFinder.clone(
"InDetTrigSiComTrackFinder_FTF")
ToolSvc += InDetTrigSiComTrackFinder_FTF
from InDetTrigRecExample.ConfiguredNewTrackingTrigCuts import EFIDTrackingCuts
TrackingCuts = EFIDTrackingCuts
if remapped_type == "cosmics":
from InDetTrigRecExample.ConfiguredNewTrackingTrigCuts import EFIDTrackingCutsCosmics
TrackingCuts = EFIDTrackingCutsCosmics
from SiTrackMakerTool_xk.SiTrackMakerTool_xkConf import InDet__SiTrackMaker_xk
TrackMaker_FTF = InDet__SiTrackMaker_xk(
name='InDetTrigSiTrackMaker_FTF_' + type,
RoadTool=InDetTrigSiDetElementsRoadMaker_FTF,
CombinatorialTrackFinder=InDetTrigSiComTrackFinder_FTF,
pTmin=InDetTrigSliceSettings[('pTmin', remapped_type)],
nClustersMin=TrackingCuts.minClusters(),
nHolesMax=TrackingCuts.nHolesMax(),
nHolesGapMax=TrackingCuts.nHolesGapMax(),
SeedsFilterLevel=0, # Do not use built-in seeds filter
Xi2max=TrackingCuts.Xi2max(),
Xi2maxNoAdd=TrackingCuts.Xi2maxNoAdd(),
nWeightedClustersMin=TrackingCuts.nWeightedClustersMin(),
Xi2maxMultiTracks=TrackingCuts.Xi2max(),
UseAssociationTool=False)
from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
if type == 'eGamma' and InDetTrigFlags.doBremRecovery():
TrackMaker_FTF.useBremModel = True
if remapped_type == "cosmics":
TrackMaker_FTF.RoadTool.CosmicTrack = True
ToolSvc += TrackMaker_FTF
self.initialTrackMaker = TrackMaker_FTF
from TrigInDetTrackFitter.TrigInDetTrackFitterConf import TrigInDetTrackFitter
theTrigInDetTrackFitter = TrigInDetTrackFitter()
#theTrigInDetTrackFitter.correctClusterPos = False #Flag to control whether to correct cluster position
theTrigInDetTrackFitter.correctClusterPos = True #temporarily to true to improve err(z0) estimates
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigRotCreator
theTrigInDetTrackFitter.ROTcreator = InDetTrigRotCreator
ToolSvc += theTrigInDetTrackFitter
self.trigInDetTrackFitter = theTrigInDetTrackFitter
from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
if type == 'eGamma' and InDetTrigFlags.doBremRecovery():
theTrigInDetTrackFitterBrem = TrigInDetTrackFitter(
name='theTrigInDetTrackFitterBrem', doBremmCorrection=True)
ToolSvc += theTrigInDetTrackFitterBrem
self.trigInDetTrackFitter = theTrigInDetTrackFitterBrem
self.doZFinder = InDetTrigSliceSettings[('doZFinder',
remapped_type)]
if (self.doZFinder):
from IDScanZFinder.IDScanZFinderConf import TrigZFinder
theTrigZFinder = TrigZFinder()
theTrigZFinder.NumberOfPeaks = 3
theTrigZFinder.LayerNumberTool = numberingTool
theTrigZFinder.FullScanMode = True #TODO: know this from the RoI anyway - should set for every event
ToolSvc += theTrigZFinder
self.trigZFinder = theTrigZFinder
self.doFastZVertexSeeding = True
self.zVertexResolution = 1
from TrigInDetConf.TrigInDetRecCommonTools import InDetTrigFastTrackSummaryTool
self.TrackSummaryTool = InDetTrigFastTrackSummaryTool
if remapped_type == "tauCore":
from TrigInDetConf.TrigInDetRecCommonTools import InDetTrigTrackSummaryToolWithHoleSearch
self.TrackSummaryTool = InDetTrigTrackSummaryToolWithHoleSearch
from TrigInDetTrackFitter.TrigInDetTrackFitterConf import TrigL2ResidualCalculator
resCalc = TrigL2ResidualCalculator(OfflineClusters=False)
ToolSvc += resCalc
self.TrigL2ResidualCalculator = resCalc
self.doCloneRemoval = InDetTrigSliceSettings[('doCloneRemoval',
remapped_type)]
def __init__(self, name="TrigTauRecMerged_TauPrecision"):
super(TrigTauRecMerged_TauPrecision, self).__init__(name)
self._mytools = []
# monitoring part. To switch off do in topOption TriggerFlags.enableMonitoring = []
from TrigTauRec.TrigTauRecMonitoring import TrigTauRecValidationMonitoring, TrigTauRecOnlineMonitoring
validation = TrigTauRecValidationMonitoring()
online = TrigTauRecOnlineMonitoring()
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig("Time")
self.AthenaMonTools = [time, validation, online]
import TrigTauRec.TrigTauAlgorithmsHolder as taualgs
tools = []
taualgs.setPrefix("TrigTau_")
# Collection name
self.OutputCollection = "TrigTauRecMerged"
# Include full set of tools
# Set seedcalo energy scale (Full RoI)
tools.append(taualgs.getJetSeedBuilder())
# Associate RoI vertex or Beamspot to tau - don't use TJVA
tools.append(taualgs.getTauVertexFinder(
doUseTJVA=False)) #don't use TJVA by default
# Set LC energy scale (0.2 cone) and intermediate axis (corrected for vertex: useless at trigger)
tools.append(taualgs.getTauAxis())
# Count tracks with deltaZ0 cut of 2mm for 2016 and 1mm for 2017 (see ATR-15845)
if TriggerFlags.run2Config == '2016':
tools.append(
taualgs.getTauTrackFinder(applyZ0cut=True,
maxDeltaZ0=2,
prefix='TrigTau2016_'))
else:
tools.append(
taualgs.getTauTrackFinder(applyZ0cut=True, maxDeltaZ0=1))
# Calibrate to TES
tools.append(
taualgs.getEnergyCalibrationLC(correctEnergy=True,
correctAxis=False,
postfix='_onlyEnergy'))
# Calculate cell-based quantities: strip variables, EM and Had energies/radii, centFrac, isolFrac and ring energies
tools.append(taualgs.getCellVariables(cellConeSize=0.2))
# tools.append(taualgs.getElectronVetoVars())
# Lifetime variables
tools.append(taualgs.getTauVertexVariables())
# Variables combining tracking and calorimeter information
tools.append(taualgs.getTauCommonCalcVars())
# Cluster-based sub-structure, with dRMax also
tools.append(taualgs.getTauSubstructure())
# tools.append(taualgs.getEnergyCalibrationLC(correctEnergy=False, correctAxis=True, postfix='_onlyAxis'))
tools.append(taualgs.getPileUpCorrection())
for tool in tools:
tool.inTrigger = True
tool.calibFolder = 'TrigTauRec/00-11-02/'
pass
self.Tools = tools
## add beam type flag
from AthenaCommon.BeamFlags import jobproperties
self.BeamType = jobproperties.Beam.beamType()
def __init__(self, name="TrigMuSuperEF", **kwargs):
kwargs.setdefault("doInsideOut", True)
kwargs.setdefault("doOutsideIn", True)
kwargs.setdefault("insideOutFirst", False)
kwargs.setdefault("fullScan", False)
kwargs.setdefault("StandaloneOnly", False)
kwargs.setdefault("CombinerOnly", False)
kwargs.setdefault("CaloTagOnly", False)
kwargs.setdefault("TMEF_standaloneTrackTool",
"TrigMuonEFStandaloneTrackTool")
kwargs.setdefault("MuonCombinedTool", "TMEF_MuonCombinedTool")
kwargs.setdefault("TrkToTrackParticleConvTool",
"TMEF_TrkToTrackParticleConvTool")
kwargs.setdefault("MuonCreatorTool", "TMEF_MuonCreatorTool")
kwargs.setdefault("deltaEtaRoI", 0.2)
kwargs.setdefault("deltaPhiRoI", 0.2)
kwargs.setdefault("UseL2Info", False)
kwargs.setdefault("DoCache", True)
doTrigMuonEF = kwargs["doOutsideIn"]
doTrigMuGirl = kwargs["doInsideOut"]
doStandaloneOnly = kwargs["StandaloneOnly"]
doFullScan = kwargs["fullScan"]
doCaloTagOnly = kwargs["CaloTagOnly"]
combinerOnly = kwargs["CombinerOnly"]
doCosmics = jobproperties.Beam.beamType == 'cosmics'
# turn on seeded data decoding by default
TriggerFlags.MuonSlice.doEFRoIDrivenAccess = True
# make instance
super(TrigMuSuperEFConfig, self).__init__(name, **kwargs)
# setup monitoring depending on configuration
monTools = []
# top level histograms use Combined Muons
if not doStandaloneOnly:
monTools.append(TrigMuSuperEFMonitoring())
monTools.append(TrigMuSuperEFValidationMonitoring())
# only add TrigMuonEF monitoring if it is run
if doTrigMuonEF:
if not combinerOnly:
monTools.append(TrigMuonEFStandaloneToolMonitoring())
monTools.append(TrigMuonEFStandaloneToolValidationMonitoring())
if not doStandaloneOnly:
monTools.append(TrigMuonEFCombinerToolMonitoring())
monTools.append(TrigMuonEFCombinerToolValidationMonitoring())
from AthenaCommon.CfgGetter import getPublicTool, getPublicToolClone
self.StauCreatorTool = getPublicToolClone("TMEF_StauCreatorTool",
"TMEF_MuonCreatorTool",
BuildStauContainer=True)
# only add TrigMuGirl monitoring if it is run
# if doTrigMuGirl:
kwargs.setdefault("MuGirlTool",
getPublicTool("TMEF_MuonInsideOutRecoTool"))
#from TrigMuGirl.TrigMuGirlMonitoring import TrigMuGirlToolMonitoring
#montool = TrigMuGirlToolMonitoring()
#print montool
#monTools.append( montool )
# turn off PrepRawData decoders in MuGirl
if doTrigMuGirl:
from MuGirlCandidate.MuGirlCandidateConf import MuGirlNS__CandidateTool
MuGirlNS__CandidateTool.doDecoding = False
if self.UseL2Info:
self.TMEF_standaloneTrackTool.useL2Hits = True
else:
self.TMEF_standaloneTrackTool.useL2Hits = False
# always add timing monitoring
timetool = TrigTimeHistToolConfig("Time")
timetool.NumberOfHistBins = 100
timetool.TimerHistLimits = [0, 1000]
monTools.append(timetool)
self.AthenaMonTools = monTools
def __init__(self,
name="TrigTauRecMerged_TauPrecisionMVA",
doMVATES=False,
doTrackBDT=False,
doRNN=False):
super(TrigTauRecMerged_TauPrecisionMVA, self).__init__(name)
self._mytools = []
# monitoring part. To switch off do in topOption TriggerFlags.enableMonitoring = []
from TrigTauRec.TrigTauRecMonitoring import TrigTauRecValidationMonitoring, TrigTauRecOnlineMonitoring
validation = TrigTauRecValidationMonitoring()
online = TrigTauRecOnlineMonitoring()
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig("Time")
self.AthenaMonTools = [time, validation, online]
import TrigTauRec.TrigTauAlgorithmsHolder as taualgs
tools = []
# using same prefix as in TauPrecision sequence should be safe if tools with different configurations have different names
# e.g. TauTrackFinder in 2016 using dz0=2mm instead of 1mm in 2017
taualgs.setPrefix("TrigTau_")
# Collection name
self.OutputCollection = "TrigTauRecMerged"
# Include full set of tools
# Set seedcalo energy scale (Full RoI)
tools.append(taualgs.getJetSeedBuilder())
# Associate RoI vertex or Beamspot to tau - don't use TJVA
tools.append(taualgs.getTauVertexFinder(
doUseTJVA=False)) #don't use TJVA by default
# Set LC energy scale (0.2 cone) and intermediate axis (corrected for vertex: useless at trigger)
tools.append(taualgs.getTauAxis())
# for now, use 'doMVATES=False' to detect tracktwoEF, instead of introducing new flag
if not doMVATES:
# Count tracks with deltaZ0 cut of 1mm for tracktwoEF
tools.append(
taualgs.getTauTrackFinder(applyZ0cut=True, maxDeltaZ0=1))
else:
# tightened to 0.75 mm for tracktwoMVA (until the track BDT can be used)
tools.append(
taualgs.getTauTrackFinder(applyZ0cut=True,
maxDeltaZ0=0.75,
prefix='TrigTauTightDZ_'))
if doTrackBDT:
# BDT track classification
tools.append(taualgs.getTauTrackClassifier())
# Calibrate to calo TES
tools.append(
taualgs.getEnergyCalibrationLC(correctEnergy=True,
correctAxis=False,
postfix='_onlyEnergy'))
if doMVATES:
# Compute MVA TES (ATR-17649), stores MVA TES as default tau pt()
tools.append(taualgs.getMvaTESVariableDecorator())
tools.append(taualgs.getMvaTESEvaluator())
# Calculate cell-based quantities: strip variables, EM and Had energies/radii, centFrac, isolFrac and ring energies
tools.append(taualgs.getCellVariables(cellConeSize=0.2))
# tools.append(taualgs.getElectronVetoVars())
# Lifetime variables
tools.append(taualgs.getTauVertexVariables())
# Variables combining tracking and calorimeter information
tools.append(taualgs.getTauCommonCalcVars())
# Cluster-based sub-structure, with dRMax also
tools.append(taualgs.getTauSubstructure())
# tools.append(taualgs.getEnergyCalibrationLC(correctEnergy=False, correctAxis=True, postfix='_onlyAxis'))
tools.append(taualgs.getPileUpCorrection())
if doRNN:
# RNN tau ID
tools.append(
taualgs.getTauJetRNNEvaluator(
NetworkFile0P="rnnid_config_0p_v3.json",
NetworkFile1P="rnnid_config_1p_v3.json",
NetworkFile3P="rnnid_config_mp_v3.json",
MaxTracks=10,
MaxClusters=6,
MaxClusterDR=1.0))
# flattened RNN score and WP
tools.append(taualgs.getTauWPDecoratorJetRNN())
for tool in tools:
tool.inTrigger = True
tool.calibFolder = 'TrigTauRec/00-11-02/'
pass
self.Tools = tools
## add beam type flag
from AthenaCommon.BeamFlags import jobproperties
self.BeamType = jobproperties.Beam.beamType()
def __init__(self, name="SCTClustering_Electron_EF", type="electron"):
super(InDet__SCT_TrgClusterization, self).__init__(name)
from AthenaCommon.AppMgr import ToolSvc
from InDetTrigRecExample.InDetTrigFlags import InDetTrigFlags
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from SCT_ConditionsTools.SCT_ConditionsToolsConf import SCT_ByteStreamErrorsTool
from InDetTrigRecExample.InDetTrigConditionsAccess import SCT_ConditionsSetup
InDetTrigBSErrorTool = SCT_ByteStreamErrorsTool(
name=SCT_ConditionsSetup.instanceName(
"InDetSCT_ByteStreamErrorsTool"))
from SCT_RawDataByteStreamCnv.SCT_RawDataByteStreamCnvConf import SCT_RodDecoder
InDetTrigSCTRodDecoder = SCT_RodDecoder(name="InDetTrigSCTRodDecoder")
ToolSvc += InDetTrigSCTRodDecoder
if (InDetTrigFlags.doPrintConfigurables()):
print(InDetTrigSCTRodDecoder)
from SCT_RawDataByteStreamCnv.SCT_RawDataByteStreamCnvConf import SCTRawDataProviderTool
from InDetTrigRecExample.InDetTrigConditionsAccess import SCT_ConditionsSetup
InDetTrigSCTRawDataProviderTool = SCTRawDataProviderTool(
name="InDetTrigSCTRawDataProviderTool",
Decoder=InDetTrigSCTRodDecoder)
ToolSvc += InDetTrigSCTRawDataProviderTool
from InDetTrigRawDataProvider.InDetTrigRawDataProviderConf import InDet__TrigSCTRawDataProvider
InDetTrigSCTRawDataProvider = \
InDet__TrigSCTRawDataProvider(name="TrigSCTRawDataProvider_EF",
RDOKey = EF_SCTRDOKey,
RawDataTool = InDetTrigSCTRawDataProviderTool)
ToolSvc += InDetTrigSCTRawDataProvider
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigClusterMakerTool
from SCT_ConditionsTools.SCT_ConditionsToolsConf import SCT_ConditionsSummaryTool
self.conditionsSummaryTool = SCT_ConditionsSummaryTool(
SCT_ConditionsSetup.instanceName(
'InDetSCT_ConditionsSummaryToolWithoutFlagged'))
# SCT_ClusteringTool (public)
from SiClusterizationTool.SiClusterizationToolConf import InDet__SCT_ClusteringTool
InDetTrigSCT_ClusteringTool = \
InDet__SCT_ClusteringTool(name = "InDetTrigSCT_ClusteringTool",
globalPosAlg = InDetTrigClusterMakerTool,
conditionsTool = self.conditionsSummaryTool
)
if InDetTrigFlags.doSCTIntimeHits():
if InDetTrigFlags.InDet25nsec():
InDetTrigSCT_ClusteringTool.timeBins = "01X"
else:
InDetTrigSCT_ClusteringTool.timeBins = "X1X"
ToolSvc += InDetTrigSCT_ClusteringTool
self.RawDataProvider = InDetTrigSCTRawDataProvider
self.clusteringTool = InDetTrigSCT_ClusteringTool
self.SCT_RDOContainerName = EF_SCTRDOKey
from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
self.EtaHalfWidth = InDetTrigSliceSettings[('etaHalfWidth', type)]
self.PhiHalfWidth = InDetTrigSliceSettings[('phiHalfWidth', type)]
self.doFullScan = InDetTrigSliceSettings[('doFullScan', type)]
if InDetTrigFlags.cutSCTOccupancy():
self.maxRDOs = 384 #used to be 77 but it was reached quite frequently
#monitoring
from InDetTrigPrepRawDataFormat.InDetTrigPrepRawDataFormatMonitoring import SctTrigPrepRawDataFormatValidationMonitor
from InDetTrigPrepRawDataFormat.InDetTrigPrepRawDataFormatMonitoring import SctTrigPrepRawDataFormatOnlineMonitor
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
scttime = TrigTimeHistToolConfig("SctTime")
scttime.TimerHistLimits = [0, 100]
self.AthenaMonTools = [
SctTrigPrepRawDataFormatValidationMonitor(type=type),
SctTrigPrepRawDataFormatOnlineMonitor(type=type), scttime
]
def __init__(self,
instance,
name,
PriVtxKey="xPrimVx",
TrackKey="InDetTrigTrackingxAODCnv_Bjet_IDTrig"):
super(GSCFexSplit, self).__init__(name)
mlog = logging.getLogger('BtagHypoConfig.py')
AllowedInstances = ["EF", "MuJetChain"]
if instance not in AllowedInstances:
mlog.error("Instance " + instance + " is not supported!")
return None
self.JetKey = "SplitJet"
if instance == "MuJetChain":
self.JetKey = "FarawayJet"
self.PriVtxKey = PriVtxKey
self.TrackKey = TrackKey
# IMPORT OFFLINE TOOLS
self.setupOfflineTools = True
if self.setupOfflineTools:
if JetConfigSetupStatus == None:
self.setupOfflineTools = False
else:
#self.GSCCalibrationTool = jrcf.find("AntiKt", 0.4, "EMTopo", "ajg", "reco", "Kt4")
#print self.GSCCalibrationTool
myGSCTool = JetCalibrationTool(
"myJCTool_trigger",
JetCollection="AntiKt4EMTopo",
ConfigFile=
"JES_data2016_data2015_Recommendation_Dec2016_rel21.config",
CalibSequence="JetArea_EtaJES_GSC_Insitu",
RhoKey="HLTKt4EMTopoEventShape",
IsData=True,
#DoTrigger = True
)
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += myGSCTool
self.GSCCalibrationTool = myGSCTool
print "Printing GSCCalibrationTool"
print self.GSCCalibrationTool
#JetCalibrationTool("myJCTool_trigger",
# IsData=True,
# ConfigFile="JES_2015dataset_recommendation_Feb2016.config",
# CalibSequence="JetArea_EtaJES_GSC",
# JetCollection="AntiKt4EMTopo")
# MONITORING
from TrigBjetHypo.TrigGSCFexMonitoring import TrigEFGSCFexValidationMonitoring, TrigEFGSCFexOnlineMonitoring #commented here
validation = TrigEFGSCFexValidationMonitoring() #commented here
online = TrigEFGSCFexOnlineMonitoring() #commented here
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig("TimeHistogramForTrigBjetHypo")
time.TimerHistLimits = [0, 2]
self.AthenaMonTools = [time, validation, online] #commented here
def __init__(self, name="PixelClustering_Electron_EF", type="electron"):
super(InDet__Pixel_TrgClusterization, self).__init__(name)
from AthenaCommon.AppMgr import ToolSvc
# configure tools used
from PixelRawDataByteStreamCnv.PixelRawDataByteStreamCnvConf import PixelRodDecoder
InDetTrigPixelRodDecoder = PixelRodDecoder(
name="InDetTrigPixelRodDecoder")
#InDetTrigPixelRodDecoder.OutputLevel=1
# Disable duplcated pixel check for data15 because duplication mechanism was used.
from RecExConfig.RecFlags import rec
if len(rec.projectName()) >= 6 and rec.projectName()[:6] == "data15":
InDetTrigPixelRodDecoder.CheckDuplicatedPixel = False
ToolSvc += InDetTrigPixelRodDecoder
from PixelRawDataByteStreamCnv.PixelRawDataByteStreamCnvConf import PixelRawDataProviderTool
InDetTrigPixelRawDataProviderTool = PixelRawDataProviderTool(
name="InDetTrigPixelRawDataProviderTool",
Decoder=InDetTrigPixelRodDecoder)
ToolSvc += InDetTrigPixelRawDataProviderTool
from InDetTrigRawDataProvider.InDetTrigRawDataProviderConf import InDet__TrigPixRawDataProvider
InDetTrigPixRawDataProvider = \
InDet__TrigPixRawDataProvider(name="TrigPixRawDataProvider_EF",
RawDataProviderTool = InDetTrigPixelRawDataProviderTool,
RDOKey = EF_PixRDOKey)
ToolSvc += InDetTrigPixRawDataProvider
# ClusterMakerTool (public), needed by Pixel and SCT Clusterization
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigClusterMakerTool
from InDetTrigRecExample.InDetTrigConditionsAccess import PixelConditionsSetup
# MergedPixelTool (public)
from SiClusterizationTool.SiClusterizationToolConf import InDet__MergedPixelsTool
from InDetTrigRecExample.InDetTrigConfigRecLoadTools import InDetTrigPixelConditionsSummaryTool
InDetTrigMergedPixelsTool = InDet__MergedPixelsTool(
name="InDetTrigMergedPixelsTool",
globalPosAlg=InDetTrigClusterMakerTool,
PixelConditionsSummaryTool=InDetTrigPixelConditionsSummaryTool,
#UseSpecialPixelMap = False #simpler setup for EFID
UseSpecialPixelMap=True,
MinimalSplitSize=0,
MaximalSplitSize=49,
MinimalSplitProbability=0,
)
# Enable duplcated RDO check for data15 because duplication mechanism was used.
from RecExConfig.RecFlags import rec
if len(rec.projectName()) >= 6 and rec.projectName()[:6] == "data15":
InDetTrigMergedPixelsTool.CheckDuplicatedRDO = True
ToolSvc += InDetTrigMergedPixelsTool
# PixelGangedAmbiguitiesFinder tool (public)
from SiClusterizationTool.SiClusterizationToolConf import InDet__PixelGangedAmbiguitiesFinder
InDetTrigPixelGangedAmbiguitiesFinder = InDet__PixelGangedAmbiguitiesFinder(
name="InDetTrigPixelGangedAmbiguitiesFinder")
ToolSvc += InDetTrigPixelGangedAmbiguitiesFinder
self.RawDataProvider = InDetTrigPixRawDataProvider
self.clusteringTool = InDetTrigMergedPixelsTool
self.gangedAmbiguitiesFinder = InDetTrigPixelGangedAmbiguitiesFinder
self.Pixel_RDOContainerName = EF_PixRDOKey
from AthenaCommon.GlobalFlags import globalflags
self.skipBSDecoding = globalflags.InputFormat == 'pool' and not TriggerFlags.doTransientByteStream(
)
from InDetTrigRecExample.InDetTrigSliceSettings import InDetTrigSliceSettings
self.EtaHalfWidth = InDetTrigSliceSettings[('etaHalfWidth', type)]
self.PhiHalfWidth = InDetTrigSliceSettings[('phiHalfWidth', type)]
self.doFullScan = InDetTrigSliceSettings[('doFullScan', type)]
#monitoring
from InDetTrigPrepRawDataFormat.InDetTrigPrepRawDataFormatMonitoring import PixelTrigPrepRawDataFormatValidationMonitor
from InDetTrigPrepRawDataFormat.InDetTrigPrepRawDataFormatMonitoring import PixelTrigPrepRawDataFormatOnlineMonitor
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
pixtime = TrigTimeHistToolConfig("PixTime")
pixtime.TimerHistLimits = [0, 100]
self.AthenaMonTools = [
PixelTrigPrepRawDataFormatValidationMonitor(type=type),
PixelTrigPrepRawDataFormatOnlineMonitor(type=type), pixtime
]
def __init__(self, name="EFBMuMuXFex_BcMuMuDs"):
super(TrigEFBMuMuXFex, self).__init__(name)
#self.VertexFitterTool = ToolSvc.TrigBphysFitter
# AcceptAll flag: if true take events regardless of cuts
self.AcceptAll = False
# muon part
self.OppositeSign = True # if check opposite sign of muons
self.LowerMuMuMassCut = 100.
self.UpperMuMuMassCut = 5500.
##self.LowerMuVtxMassCut = 100.
##self.UpperMuVtxMassCut = 5500.
self.MuVtxChi2Cut = 40.
# B{+/-} -> K{+/-} Mu Mu
self.DoB_KMuMuDecay = False
# Bd -> K*(892) Mu Mu
self.DoBd_KstarMuMuDecay = False
# Bs -> Phi(1020) Mu Mu
self.DoBs_Phi1020MuMuDecay = False
# Lb -> L Mu Mu
self.DoLb_LambdaMuMuDecay = False
# Bc -> D_s* Mu Mu
self.DoBc_DsMuMuDecay = True
self.LowerPhiDs_MassCut = 980.
self.UpperPhiDs_MassCut = 1080.
self.LowerDs_MassCut = 1600.
self.UpperDs_MassCut = 2400.
self.LowerBc_DsMuMuMassCut = 5450.
self.UpperBc_DsMuMuMassCut = 7050.
self.DoDs_Vertexing = True
self.DoBc_DsMuMuVertexing = True
self.DoBc_DsMuMuCascade = True
self.DsVtxChi2Cut = 90.
self.BcVtxChi2Cut = 120.
self.MaxBcToStore = 1000
# Bc -> D+ Mu Mu
self.DoBc_DplusMuMuDecay = True
self.LowerDplus_MassCut = 1500.
self.UpperDplus_MassCut = 2300.
self.LowerDplus_PtCut = 2000.
self.LowerBc_DplusMuMuMassCut = 5450.
self.UpperBc_DplusMuMuMassCut = 7050.
self.LowerBcDplus_PtCut = 8000.
##self.LowerDplus_LxyCut = 0.3
self.LowerDplus_LxyCut = 0.01
self.DoDplus_Vertexing = True
self.DoBc_DplusMuMuVertexing = True
self.DoBc_DplusMuMuCascade = True
self.DplusVtxChi2Cut = 90.
self.BcDplusVtxChi2Cut = 180.
self.MaxBcDplusToStore = 1000
# Bc -> Dstar Mu Mu
self.DoBc_DstarMuMuDecay = True
self.LowerD0Dstar_MassCut = 1500.
self.UpperD0Dstar_MassCut = 2300.
self.UpperDstar_DMCut = 180.
self.LowerDstar_PtCut = 2000.
self.LowerDstarKpi_PtCut = 1800.
self.LowerBc_DstarMuMuMassCut = 5450.
self.UpperBc_DstarMuMuMassCut = 7050.
self.LowerBcDstar_PtCut = 8000.
self.LowerD0Dstar_LxyCut = -999.
self.DoD0Dstar_Vertexing = True
self.DoBc_DstarMuMuVertexing = True
self.DoBc_DstarMuMuCascade = True
self.D0DstarVtxChi2Cut = 90.
self.BcDstarVtxChi2Cut = 120.
self.MaxBcDstarToStore = 1000
# Bc -> D0 (Dstar with lost pi_s) Mu Mu
self.DoBc_D0MuMuDecay = True
self.LowerD0_MassCut = 1500.
self.UpperD0_MassCut = 2300.
self.LowerD0_PtCut = 2000.
self.LowerBc_D0MuMuMassCut = 5250.
self.UpperBc_D0MuMuMassCut = 6911.
self.LowerBcD0_PtCut = 8000.
self.LowerD0_LxyCut = 0.01
self.DoD0_Vertexing = True
self.DoBc_D0MuMuVertexing = True
self.DoBc_D0MuMuCascade = True
self.D0VtxChi2Cut = 90.
self.BcD0VtxChi2Cut = 120.
self.MaxBcD0ToStore = 1000
from TrigBphysHypo.TrigEFBMuMuXFexMonitoring import EFBMuMuXFexValidationMonitoring
validation = EFBMuMuXFexValidationMonitoring()
from TrigBphysHypo.TrigEFBMuMuXFexMonitoring import EFBMuMuXFexOnlineMonitoring_BcMuMuDs
online = EFBMuMuXFexOnlineMonitoring_BcMuMuDs()
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig("Time")
self.AthenaMonTools = [validation, online, time]
def __init__(self, name="TrigMuSuperEF", **kwargs):
kwargs.setdefault("doInsideOut", True)
kwargs.setdefault("doOutsideIn", True)
kwargs.setdefault("insideOutFirst", False)
kwargs.setdefault("fullScan", False)
kwargs.setdefault("StandaloneOnly", False)
kwargs.setdefault("CombinerOnly", False)
kwargs.setdefault("CaloTagOnly", False)
kwargs.setdefault("TMEF_standaloneTrackTool",
"TrigMuonEFStandaloneTrackTool")
kwargs.setdefault("MuonCombinedTool", "TMEF_MuonCombinedTool")
kwargs.setdefault("TrkToTrackParticleConvTool",
"TMEF_TrkToTrackParticleConvTool")
kwargs.setdefault("MuonCreatorTool", "TMEF_MuonCreatorTool")
kwargs.setdefault("deltaEtaRoI", 0.2)
kwargs.setdefault("deltaPhiRoI", 0.2)
kwargs.setdefault("UseL2Info", False)
kwargs.setdefault("DoCache", True)
from TrkExTools.AtlasExtrapolator import AtlasExtrapolator
from TrackToCalo.TrackToCaloConf import Trk__ParticleCaloExtensionTool
from MuonTGRecTools.MuonTGRecToolsConf import Muon__MuonSystemExtensionTool
pcExtensionTool = Trk__ParticleCaloExtensionTool(
Extrapolator=AtlasExtrapolator())
muonExtTool = Muon__MuonSystemExtensionTool(
Extrapolator=AtlasExtrapolator(),
ParticleCaloExtensionTool=pcExtensionTool)
kwargs.setdefault("MuonSystemExtensionTool", muonExtTool)
doTrigMuonEF = kwargs["doOutsideIn"]
doTrigMuGirl = kwargs["doInsideOut"]
doStandaloneOnly = kwargs["StandaloneOnly"]
combinerOnly = kwargs["CombinerOnly"]
# turn on seeded data decoding by default
TriggerFlags.MuonSlice.doEFRoIDrivenAccess = True
# make instance
super(TrigMuSuperEFConfig, self).__init__(name, **kwargs)
# setup monitoring depending on configuration
monTools = []
# top level histograms use Combined Muons
if not doStandaloneOnly:
monTools.append(TrigMuSuperEFMonitoring())
monTools.append(TrigMuSuperEFValidationMonitoring())
# only add TrigMuonEF monitoring if it is run
if doTrigMuonEF:
if not combinerOnly:
monTools.append(TrigMuonEFStandaloneToolMonitoring())
monTools.append(TrigMuonEFStandaloneToolValidationMonitoring())
if not doStandaloneOnly:
monTools.append(TrigMuonEFCombinerToolMonitoring())
monTools.append(TrigMuonEFCombinerToolValidationMonitoring())
from AthenaCommon.CfgGetter import getPublicTool, getPublicToolClone
self.StauCreatorTool = getPublicToolClone("TMEF_StauCreatorTool",
"TMEF_MuonCreatorTool",
BuildStauContainer=True)
# only add TrigMuGirl monitoring if it is run
if doTrigMuGirl:
self.MuGirlTool = getPublicTool("TMEF_MuonInsideOutRecoTool")
if self.UseL2Info:
self.TMEF_standaloneTrackTool.useL2Hits = True
else:
self.TMEF_standaloneTrackTool.useL2Hits = False
# always add timing monitoring
timetool = TrigTimeHistToolConfig("Time")
timetool.NumberOfHistBins = 100
timetool.TimerHistLimits = [0, 1000]
monTools.append(timetool)
self.AthenaMonTools = monTools
def __init__(self, instance, version, algo, name):
super(BjetFexFTKVtx, self).__init__(name)
mlog = logging.getLogger('BjetHypoConfig.py')
AllowedInstances = ["EF", "MuJetChain"]
AllowedVersions = ["2012"]
AllowedAlgos = ["EFID"]
if instance not in AllowedInstances:
mlog.error("Instance " + instance + " is not supported!")
return None
if version not in AllowedVersions:
mlog.error("Version " + version + " is not supported!")
return None
self.JetKey = "SplitJet"
# Hack to get muon-jet chains working properly
if instance == "MuJetChain":
self.JetKey = "FarawayJet"
instance = "EF"
if instance == "EF":
calibInstance = "EF"
self.PriVtxKey = "PrimVertexFTK" #"EFHistoPrmVtx"
self.TrackKey = "InDetTrigTrackingxAODCnv_Bjet_IDTrig"
self.par_0_MC = getTuning_par_0_MC(calibInstance)
self.par_1_MC = getTuning_par_1_MC(calibInstance)
self.par_0_DT = getTuning_par_0_DT(calibInstance)
self.par_1_DT = getTuning_par_1_DT(calibInstance)
self.SizeIP1D_Grade1 = getTuning_SizeIP1D_Grade1(calibInstance)
self.bIP1D_Grade1 = getTuning_bIP1D_Grade1(calibInstance)
self.uIP1D_Grade1 = getTuning_uIP1D_Grade1(calibInstance)
self.SizeIP2D_Grade1 = getTuning_SizeIP2D_Grade1(calibInstance)
self.bIP2D_Grade1 = getTuning_bIP2D_Grade1(calibInstance)
self.uIP2D_Grade1 = getTuning_uIP2D_Grade1(calibInstance)
self.SizeIP3D_Grade1 = getTuning_SizeIP3D_Grade1(calibInstance)
self.bIP3D_Grade1 = getTuning_bIP3D_Grade1(calibInstance)
self.uIP3D_Grade1 = getTuning_uIP3D_Grade1(calibInstance)
self.SizeIP1D_Grade2 = getTuning_SizeIP1D_Grade2(calibInstance)
self.bIP1D_Grade2 = getTuning_bIP1D_Grade2(calibInstance)
self.uIP1D_Grade2 = getTuning_uIP1D_Grade2(calibInstance)
self.SizeIP2D_Grade2 = getTuning_SizeIP2D_Grade2(calibInstance)
self.bIP2D_Grade2 = getTuning_bIP2D_Grade2(calibInstance)
self.uIP2D_Grade2 = getTuning_uIP2D_Grade2(calibInstance)
self.SizeIP3D_Grade2 = getTuning_SizeIP3D_Grade2(calibInstance)
self.bIP3D_Grade2 = getTuning_bIP3D_Grade2(calibInstance)
self.uIP3D_Grade2 = getTuning_uIP3D_Grade2(calibInstance)
self.SizeSV = getTuning_SizeSV(calibInstance)
self.bSV = getTuning_bSV(calibInstance)
self.uSV = getTuning_uSV(calibInstance)
self.SizeMVtx = getTuning_SizeMVtx(calibInstance)
self.bMVtx = getTuning_bMVtx(calibInstance)
self.uMVtx = getTuning_uMVtx(calibInstance)
self.SizeEVtx = getTuning_SizeEVtx(calibInstance)
self.bEVtx = getTuning_bEVtx(calibInstance)
self.uEVtx = getTuning_uEVtx(calibInstance)
self.SizeNVtx = getTuning_SizeNVtx(calibInstance)
self.bNVtx = getTuning_bNVtx(calibInstance)
self.uNVtx = getTuning_uNVtx(calibInstance)
self.AlgoId = -1
if instance == "EF":
if algo == "EFID":
self.AlgoId = 1
if self.AlgoId == -1:
mlog.error("AlgoId is wrongly set!")
return None
## Unset = -1; HLT jet direction = 1; HLT track-jet direction = 2; LVL1 jet RoI direction =3
self.UseJetDirection = -1
if version == "2012":
self.UseJetDirection = 1
self.RetrieveHLTJets = True
if self.UseJetDirection == -1:
mlog.error("UseJetDirection is wrongly set!")
return None
## Unset = -1; EF jets = 3
self.TagHLTJets = -1
if version == "2012":
if instance == "EF":
self.TagHLTJets = 3
if self.TagHLTJets == -1:
mlog.error("TagHLTJets is wrongly set!")
return None
if instance == "EF":
self.Instance = "EF"
self.UseBeamSpotFlag = False
self.SetBeamSpotWidth = 1 * mm
self.UseParamFromData = False
self.useGrading = True
self.UseErrIPParam = False
self.UseEtaPhiTrackSel = False
self.Taggers = [
"IP1D", "IP2D", "IP3D", "CHI2", "MVTX", "EVTX", "NVTX", "SVTX",
"COMB"
]
if algo == "EFID":
self.TrkSelGrade1_Chi2 = 0.0
self.TrkSelGrade1_Innermost = 1
self.TrkSelGrade1_NextToInnermost = 0
self.TrkSelGrade1_PixHits = 2
self.TrkSelGrade1_SiHits = 7
self.TrkSelGrade1_D0 = 1 * mm
self.TrkSelGrade1_Z0 = 1.5 * mm
self.TrkSelGrade1_Pt = 1 * GeV
self.TrkSelGrade1_Eta = 0.4
self.TrkSelGrade1_Phi = 0.4
self.TrkSelGrade1_R = 0.4
self.TrkSelGrade2_Chi2 = 0.0
self.TrkSelGrade2_Innermost = 0
self.TrkSelGrade2_NextToInnermost = 1
self.TrkSelGrade2_PixHits = 2
self.TrkSelGrade2_SiHits = 7
self.TrkSelGrade2_D0 = 1 * mm
self.TrkSelGrade2_Z0 = 1.5 * mm
self.TrkSelGrade2_Pt = 1 * GeV
self.TrkSelGrade2_Eta = 0.4
self.TrkSelGrade2_Phi = 0.4
self.TrkSelGrade2_R = 0.4
if instance == "EF":
from TrigBjetHypo.TrigBjetFexMonitoring import TrigEFBjetFexValidationMonitoring, TrigEFBjetFexOnlineMonitoring
validation = TrigEFBjetFexValidationMonitoring()
online = TrigEFBjetFexOnlineMonitoring()
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig("TimeHistogramForTrigBjetHypo")
time.TimerHistLimits = [0, 2]
self.AthenaMonTools = [time, validation, online]
def __init__(self, name="EFBMuMuXHypo_1"):
super(TrigEFBMuMuXHypo, self).__init__(name)
# AcceptAll flag: if true take events regardless of cuts
self.AcceptAll = False
# decay modes flags
self.AcceptBplus = True
self.AcceptBd = True
self.AcceptBs = True
self.AcceptLb = True
self.AcceptBc = False
self.AcceptBcDplus = False
self.AcceptBcDstar = False
self.AcceptBcD0 = False
# mass cuts
# B+
self.LowerBplusMassCut = 4400.
self.UpperBplusMassCut = 5800.
self.BplusChi2Cut = 50.
# Bd
self.LowerBdMassCut = 4600.
self.UpperBdMassCut = 5900.
self.BdChi2Cut = 60.
self.LowerKstarMassCut = 700.
self.UpperKstarMassCut = 1100.
self.KstarChi2Cut = 400.
# Bs
self.LowerBsMassCut = 4800.
self.UpperBsMassCut = 5800.
self.BsChi2Cut = 60.
self.LowerPhi1020MassCut = 940.
self.UpperPhi1020MassCut = 1100.
self.Phi1020Chi2Cut = 400.
# Lb
self.LowerLbMassCut = 5100.
self.UpperLbMassCut = 6100.
self.LbChi2Cut = 100.
self.LowerLambdaMassCut = 1040.
self.UpperLambdaMassCut = 1200.
self.LambdaChi2Cut = 400.
# Bc
self.LowerBcMassCut = 5450.
self.UpperBcMassCut = 7050.
self.BcChi2Cut = 120.
self.LowerDsMassCut = 1600.
self.UpperDsMassCut = 2400.
self.DsChi2Cut = 90.
# BcDplus
self.LowerBcDplusMassCut = 5450.
self.UpperBcDplusMassCut = 7050.
self.BcDplusChi2Cut = 180.
self.LowerDplusMassCut = 1500.
self.UpperDplusMassCut = 2300.
self.DplusChi2Cut = 90.
# BcDstar
self.LowerBcDstarMassCut = 5450.
self.UpperBcDstarMassCut = 7050.
self.BcDstarChi2Cut = 120.
self.LowerDstarMassCut = 1500.
self.UpperDstarMassCut = 2500.
self.DstarChi2Cut = 90.
# BcD0
self.LowerBcD0MassCut = 5250.
self.UpperBcD0MassCut = 6911.
self.BcD0Chi2Cut = 120.
self.LowerD0MassCut = 1500.
self.UpperD0MassCut = 2300.
self.D0Chi2Cut = 90.
from TrigTimeMonitor.TrigTimeHistToolConfig import TrigTimeHistToolConfig
time = TrigTimeHistToolConfig("Time")
