def generateChainDefs(chainDict):
"""Delegate the creation of ChainDef instnaces to JetDEf,
then add in the top information."""
jetgroup_chain = True
chainName = chainDict['chainName']
#print 'processing chain part 1 start', chainName
theChainDef = generateHLTChainDef(chainDict)
#print 'processing chain part 2 end', chainName
listOfChainDicts = splitChainDict(chainDict)
topoAlgs = []
for subCD in listOfChainDicts:
allTopoAlgs = subCD['chainParts']['topo']
for ta in allTopoAlgs:
topoAlgs.append(ta)
# test new jet algorithm and configuration PS 15/9/2016
# now use new jet algorthm TrigHLTJetHypo2 as standard,
# and have the test chains use th run 1 hypo for comaprison PS 04/10/2016
if ('muvtx' in topoAlgs) or ('llp' in topoAlgs):
logJet.info("Adding topo to jet chain")
try:
theChainDef = _addTopoInfo(theChainDef, chainDict, topoAlgs)
except Exception, e:
tb = exc2string2()
theChainDef = process_exception(e, tb, chainName)
jetgroup_chain = False
def generateChainDefs(chainDict):
listOfChainDicts = splitChainDict(chainDict)
listOfChainDefs = []
myProvider = TauHypoProvider()
for subChainDict in listOfChainDicts:
if "IdTest" in subChainDict["chainParts"]["addInfo"]:
Tau = L2EFChain_tau_IdTest(subChainDict, myProvider)
else:
Tau = L2EFChain_tau(subChainDict, myProvider)
listOfChainDefs += [Tau.generateHLTChainDef()]
if len(listOfChainDefs) > 1:
theChainDef = mergeChainDefs(listOfChainDefs)
else:
theChainDef = listOfChainDefs[0]
#add support for topological algorithms
if chainDict["topo"]:
log.info("Adding Tau Topological Algorithm(s) to chain")
theChainDef = _addTopoInfo(theChainDef, chainDict)
return theChainDef
def generateChainDefs(chainDict):
listOfChainDicts = splitChainDict(chainDict)
subChainDict = listOfChainDicts[0] # take only the first
TestChain = L2EFChain_test(subChainDict)
theChainDef = TestChain.generateHLTChainDef()
return theChainDef
def generateChainDefs(chainDict):
listOfChainDicts = splitChainDict(chainDict)
listOfChainDefs = []
for subChainDict in listOfChainDicts:
Beamspot = L2EFChain_Beamspot(subChainDict)
listOfChainDefs += [Beamspot.generateHLTChainDef()]
if len(listOfChainDefs) > 1:
theChainDef = mergeChainDefs(listOfChainDefs)
else:
theChainDef = listOfChainDefs[0]
return theChainDef
def generateChainDefs(chainDict):
listOfChainDicts = splitChainDict(chainDict)
listOfChainDefs = []
for subChainDict in listOfChainDicts:
Monitoring = L2EFChain_Monitoring(subChainDict)
listOfChainDefs += [Monitoring.generateHLTChainDef()]
if len(listOfChainDefs) > 1:
theChainDef = mergeChainDefs(listOfChainDefs)
else:
theChainDef = listOfChainDefs[0]
return theChainDef
def generateChainDefs(chainDict):
listOfChainDicts = splitChainDict(chainDict)
listOfChainDefs = []
for subChainDict in listOfChainDicts:
Calib = L2EFChain_CalibTemplate(subChainDict)
listOfChainDefs += [Calib.generateHLTChainDef()]
if len(listOfChainDefs) > 1:
theChainDef = mergeChainDefs(listOfChainDefs)
else:
theChainDef = listOfChainDefs[0]
return theChainDef
def generateChainDefs(chainDict):
listOfChainDicts = splitChainDict(chainDict)
listOfChainDefs = []
for subChainDict in listOfChainDicts:
EnhancedBias = L2EFChain_EnhancedBiasTemplate(subChainDict)
listOfChainDefs += [EnhancedBias.generateHLTChainDef()]
if len(listOfChainDefs) > 1:
theChainDef = mergeChainDefs(listOfChainDefs)
else:
theChainDef = listOfChainDefs[0]
return theChainDef
def generateChainDefs(chainDict):
listOfChainDicts = splitChainDict(chainDict)
listOfChainDefs = []
for subChainDict in listOfChainDicts:
Streaming = L2EFChain_SeededStreamerTemplate(subChainDict)
listOfChainDefs += [Streaming.generateHLTChainDef()]
if len(listOfChainDefs) > 1:
theChainDef = mergeChainDefs(listOfChainDefs)
else:
theChainDef = listOfChainDefs[0]
return theChainDef
def generateChainDefs(chainDict):
listOfChainDicts = splitChainDict(chainDict)
listOfChainDefs = []
for subChainDict in listOfChainDicts:
MissingET = L2EFChain_met(subChainDict)
listOfChainDefs += [MissingET.generateHLTChainDef()]
if len(listOfChainDefs) > 1:
theChainDef = mergeChainDefs(listOfChainDefs)
else:
theChainDef = listOfChainDefs[0]
return theChainDef
def generateChainDefs(chainDict):
print 'generateHeavyIonChainDefs, input dict', chainDict
listOfChainDicts = splitChainDict(chainDict)
listOfChainDefs = []
for subChainDict in listOfChainDicts:
HeavyIon = L2EFChain_HI(subChainDict)
listOfChainDefs += [HeavyIon.generateHLTChainDef()]
if len(listOfChainDefs)>1:
theChainDef = mergeChainDefs(listOfChainDefs)
else:
theChainDef = listOfChainDefs[0]
return theChainDef
def generateChainDefs(chainDict):
listOfChainDicts = splitChainDict(chainDict)
listOfChainDefs = []
for subChainDict in listOfChainDicts:
Cosmic = L2EFChain_CosmicTemplate(subChainDict)
listOfChainDefs += [Cosmic.generateHLTChainDef()]
if len(listOfChainDefs)>1:
theChainDef = mergeChainDefs(listOfChainDefs)
else:
theChainDef = listOfChainDefs[0]
#if chainDict["topo"]:
# theChainDef = _addTopoInfo(theChainDef,chainDict)
return theChainDef
def generateChainDefs(chainDict):
listOfChainDicts = splitChainDict(chainDict)
listOfChainDefs = []
for subChainDict in listOfChainDicts:
AFP = L2EFChain_afp(subChainDict)
listOfChainDefs += [AFP.generateHLTChainDef()]
if len(listOfChainDefs) > 1:
listOfChainDefs = [mergeChainDefs(listOfChainDefs)]
else:
listOfChainDefs = [listOfChainDefs[0]]
listOfChainDefs.reverse()
return listOfChainDefs
def generateChainDefs(chainDict):
listOfChainDicts = splitChainDict(chainDict)
listOfChainDefs = []
for subChainDict in listOfChainDicts:
electron_seq = EgammaSequence(subChainDict)
log.debug('Egamma Sequence: %s', electron_seq)
Electron = L2EFChain_e(subChainDict, electron_seq)
listOfChainDefs += [Electron.generateHLTChainDef()]
if len(listOfChainDefs) > 1:
theChainDef = mergeChainDefs(listOfChainDefs)
else:
theChainDef = listOfChainDefs[0]
if chainDict["topo"]:
theChainDef = _addTopoInfo(theChainDef, chainDict)
return theChainDef
def generateChainDefs(chainDict):
listOfChainDicts = splitChainDict(chainDict)
listOfChainDefs = []
for subChainDict in listOfChainDicts:
MissingET = L2EFChain_met(subChainDict)
listOfChainDefs += [MissingET.generateHLTChainDef()]
if "v6" in TriggerFlags.triggerMenuSetup(
) or "v5" in TriggerFlags.triggerMenuSetup():
if len(listOfChainDefs) > 1:
listOfChainDefs = [mergeChainDefs(listOfChainDefs)]
else:
listOfChainDefs = [listOfChainDefs[0]]
listOfChainDefs.reverse()
return listOfChainDefs
def generateChainDefs(chainDict):
"""Delegate the creation of ChainDef instnaces to JetDEf,
then add in the top information."""
jetgroup_chain = True
chainName = chainDict['chainName']
#print 'processing chain part 1 start', chainName
theChainDef = generateHLTChainDef(chainDict)
#print 'processing chain part 2 end', chainName
listOfChainDicts = splitChainDict(chainDict)
topoAlgs = []
for subCD in listOfChainDicts:
allTopoAlgs = subCD['chainParts']['topo']
for ta in allTopoAlgs:
topoAlgs.append(ta)
# test new jet algorithm and configuration PS 15/9/2016
# now use new jet algorthm TrigHLTJetHypo2 as standard,
# and have the test chains use th run 1 hypo for comaprison PS 04/10/2016
if ('muvtx' in topoAlgs) or ('llp' in topoAlgs):
logJet.info("Adding topo to jet chain")
try:
theChainDef = _addTopoInfo(theChainDef, chainDict, topoAlgs)
except Exception as e:
import traceback
tb = traceback.format_exc()
theChainDef = process_exception(e, tb, chainName)
jetgroup_chain = False
no_instantiation_flag = 'JETDEF_NO_INSTANTIATION' in os.environ
dump_chain = 'JETDEF_DEBUG2' in os.environ
if (not jetgroup_chain) and dump_chain:
dump_chaindef(chainDict, theChainDef, None, no_instantiation_flag)
return theChainDef
def setup_xeXX(self):
##EF only chain, run FEB or topo_cluster
##NoAlg at L2
##if at a certain point different steps are used at EF,
## we need a way to encode the information of the threshold at both the two steps
##could be a dict here, or adding something to the SignatureDictionary
threshold = int(self.chainPart['threshold'])
calibration = self.chainPart['calib']
jetCalib = self.chainPart['jetCalib']
L2recoAlg = self.chainPart['L2recoAlg']
EFrecoAlg = self.chainPart['EFrecoAlg']
EFmuon = self.chainPart['EFmuonCorr']
addInfo = self.chainPart["addInfo"]
# tcpufit is the run 3 name for pufit
if EFrecoAlg == "tcpufit":
EFrecoAlg = "pufit"
#--------------------------------------
#obtaining the muon sequences & signature:
#--------------------------------------
log.debug("Creating muon sequence")
chain = ['mu8', 'L1_MU6', [], ["Main"], ['RATE:SingleMuon', 'BW:Muon'], -1]
theDictFromChainName = DictFromChainName.DictFromChainName()
muonChainDict = theDictFromChainName.getChainDict(chain)
listOfChainDicts = splitChainDict(muonChainDict)
muDict = listOfChainDicts[0]
muDict['chainCounter'] = 9150
muonthing = L2EFChain_mu(muDict, False, ['8GeV'])
muonSeed = muonthing.EFsignatureList[-1][0][0]
for seq in muonthing.L2sequenceList:
self.L2sequenceList += [seq]
for seq in muonthing.EFsequenceList:
self.EFsequenceList += [seq]
########### Imports for hypos and fexes ###########
##L1 MET
theL2Fex = L2MissingET_Fex()
theL2MuonFex = L2TrigMissingETMuon_Fex()
mucorr= '_wMu' if EFmuon else ''
##MET with topo-cluster
if EFrecoAlg=='tc' or EFrecoAlg=='pueta' or EFrecoAlg=='pufit' or EFrecoAlg=='mht' or EFrecoAlg=='trkmht' or EFrecoAlg=='pufittrack' or EFrecoAlg=='trktc':
##Topo-cluster
if EFrecoAlg=='tc':
#MET fex
theEFMETFex = EFMissingET_Fex_topoClusters()
#Muon correction fex
theEFMETMuonFex = EFTrigMissingETMuon_Fex_topocl()
#TC hypo
#mucorr= '_wMu' if EFmuon else ''
if self.chainPart['trigType'] == "xs":
theEFMETHypo = EFMetHypoXS_2sided('EFMetHypo_xs_2sided_%i%s' % (threshold, mucorr),ef_thr=float(threshold)*0.1)
elif self.chainPart['trigType'] == "te":
theEFMETHypo = EFMetHypoTE('EFMetHypo_te%d' % threshold,ef_thr=float(threshold)*GeV)
else:
theEFMETHypo = EFMetHypoTCXE('EFMetHypo_TC_xe%s_tc%s%s'%(threshold,calibration,mucorr),ef_thr=float(threshold)*GeV)
if EFrecoAlg=='pufit':
doLArH11off=False
doLArH12off=False
LArTag=''
if "LArH11off" in addInfo:
doLArH11off = True
LArTag += '_LArH11off'
if "LArH12off" in addInfo:
doLArH12off = True
LArTag += '_LArH12off'
if "METphi" in addInfo:
LArTag += '_METphi'
jpt_thr = '-1'
if len(addInfo.split('Jpt'))==2: jpt_thr = addInfo.split('Jpt')[1]
if "Jpt" in addInfo:
LArTag += '_Jpt'+jpt_thr
#MET fex
theEFMETFex = EFMissingET_Fex_topoClustersPUC("EFMissingET_Fex_topoClustersPUC%s"%(addInfo),doLArH11off,doLArH12off,float(jpt_thr))
#Muon correction fex
theEFMETMuonFex = EFTrigMissingETMuon_Fex_topoclPUC()
mucorr= '_wMu' if EFmuon else ''
theEFMETHypo = EFMetHypoTCPUCXE('EFMetHypo_TCPUC'+LArTag+'_xe%s_tc%s%s'%(threshold,calibration,mucorr),ef_thr=float(threshold)*GeV,labelMET=addInfo)
if EFrecoAlg=='pufittrack':
calibCorr = ('_{0}'.format(calibration) if calibration != METChainParts_Default['calib'] else '') + ('_{0}'.format(jetCalib) if jetCalib != METChainParts_Default['jetCalib'] else '')
#MET fex
#print ("PUFITTRACK XXXXXXXXXX")
#print (calibCorr)
theEFMETFex = EFMissingET_Fex_topoClustersTracksPUC("EFMissingET_Fex_topoClustersTracksPUC{0}".format(calibCorr), extraCalib=calibCorr)
#print ("PUFITTRACK XXXXXXXXXX")
#print (theEFMETFex)
#Muon correction fex
theEFMETMuonFex = EFTrigMissingETMuon_Fex_topoclPUC()
#print (theEFMETMuonFex)
mucorr= '_wMu' if EFmuon else ''
#theEFMETHypo = EFMetHypoTCTrkPUCXE('EFMetHypo_TCTrkPUC_xe%s_tc%s%s'%(threshold,calibration,mucorr),ef_thr=float(threshold)*GeV)
theEFMETHypo = EFMetHypoTCTrkPUCXE('EFMetHypo_TCTrkPUC_xe%s_tc%s%s%s'%(threshold,jetCalib,calibration,mucorr),ef_thr=float(threshold)*GeV, extraCalib=calibCorr)
##MET based on trigger jets
if EFrecoAlg=='mht':
calibCorr = ('_{0}'.format(calibration) if calibration != METChainParts_Default['calib'] else '') + ('_{0}'.format(jetCalib) if jetCalib != METChainParts_Default['jetCalib'] else '')
#MET fex
theEFMETFex = EFMissingET_Fex_Jets("EFMissingET_Fex_Jets{0}".format(calibCorr), extraCalib=calibCorr )
#Muon correction fex
theEFMETMuonFex = EFTrigMissingETMuon_Fex_Jets("EFTrigMissingETMuon_Fex_Jets{0}".format(calibCorr) )
#mucorr= '_wMu' if EFmuon else ''
theEFMETHypo = EFMetHypoJetsXE('EFMetHypo_Jets_xe%s_tc%s%s%s'%(threshold,jetCalib,calibration,mucorr),ef_thr=float(threshold)*GeV, extraCalib=calibCorr)
##MET based on trigger jets
if EFrecoAlg=='trkmht':
#MET fex
theEFMETFex = EFMissingET_Fex_TrackAndJets()
#Muon correction fex
## this will be added later
theEFMETMuonFex = EFTrigMissingETMuon_Fex_Jets()
#mucorr= '_wMu' if EFmuon else ''
theEFMETHypo = EFMetHypoTrackAndJetsXE('EFMetHypo_TrackAndJets_xe%s_tc%s%s'%(threshold,calibration,mucorr),ef_thr=float(threshold)*GeV)
if EFrecoAlg=='trktc':
#MET fex
theEFMETFex = EFMissingET_Fex_TrackAndClusters()
#Muon correction fex
## this will never be used
theEFMETMuonFex = EFTrigMissingETMuon_Fex_topocl()
#mucorr= '_wMu' if EFmuon else ''
theEFMETHypo = EFMetHypoTrackAndClustersXE('EFMetHypo_TrackAndClusters_xe%s_tc%s%s'%(threshold,calibration,mucorr),ef_thr=float(threshold)*GeV)
##Topo-cluster with Pile-up suppression
if EFrecoAlg=='pueta':
#MET fex
theEFMETFex = EFMissingET_Fex_topoClustersPS()
#Muon correction fex
theEFMETMuonFex = EFTrigMissingETMuon_Fex_topoclPS()
theEFMETHypo = EFMetHypoTCPSXE('EFMetHypo_TCPS_xe%s_tc%s%s'%(threshold,calibration,mucorr),ef_thr=float(threshold)*GeV)
##2-SidedNoise Cell
elif EFrecoAlg=='cell':
#MET fex
theEFMETFex = EFMissingET_Fex_2sidednoiseSupp()
#Muon correction fex
theEFMETMuonFex = EFTrigMissingETMuon_Fex()
#Hypo
if self.chainPart['trigType'] == "xs":
theEFMETHypo = EFMetHypoXS_2sided('EFMetHypo_xs_2sided_%d%s' % (threshold, mucorr),ef_thr=float(threshold)*0.1)
elif self.chainPart['trigType'] == "te":
theEFMETHypo = EFMetHypoTE('EFMetHypo_te%d'% threshold,ef_thr=threshold*GeV)
else:
LArTag=''
if "LArH11off" in addInfo: LArTag += '_LArH11off'
if "LArH12off" in addInfo: LArTag += '_LArH12off'
if "METphi" in addInfo: LArTag += '_METphi'
theEFMETHypo = EFMetHypoXE('EFMetHypo'+LArTag+'_xe%s%s'%(threshold,mucorr),ef_thr=float(threshold)*GeV)
else:
log.warning("MET EF algorithm not recognised")
#----------------------------------------------------
# Obtaining the needed jet TEs from the jet code and b-jet code
#----------------------------------------------------
from TriggerJobOpts.TriggerFlags import TriggerFlags
from TriggerMenu.bjet.generateBjetChainDefs import generateChainDefs as generateBjetChainDefs
chain = ['j0_{0}_{1}'.format(calibration, jetCalib), '', [], ["Main"], ['RATE:SingleJet', 'BW:Jet'], -1]
theDictFromChainName = DictFromChainName.DictFromChainName()
jetChainDict = theDictFromChainName.getChainDict(chain)
jetChainDict['chainCounter'] = 9151
jetChainDef = generateHLTChainDef(jetChainDict)
#This is a dummy b-jet chain, with a threshold at 20 GeV at the uncalibrated scale. It computes the tracks within each jet RoI.
#Change the calibration by changing 'nojcalib' to the desired calibration scale.
#For pufittrack, we found that the performance was superior using uncalibrated jets.
dummy_bjet_chain = ['j20_{0}_{1}_boffperf_split'.format(calibration, jetCalib), '', [], ["Main"], ['RATE:SingleBJet', 'BW:BJet'], -1]
bjet_chain_dict = theDictFromChainName.getChainDict(dummy_bjet_chain)
bjet_chain_dict["chainCounter"] = 9152
bjet_chain_dict['topoThreshold'] = None
bjet_chain_def = generateBjetChainDefs(bjet_chain_dict)
#for i in range(3):
# m_input[i] = jetChainDef.sequenceList[i]['input']
# m_output[i]= jetChainDef.sequenceList[i]['output']
# m_algo[i] =jetChainDef.sequenceList[i]['algorithm']
#obtaining DummyUnseededAllTEAlgo/RoiCreator
input0=jetChainDef.sequenceList[0]['input']
output0 =jetChainDef.sequenceList[0]['output']
algo0 =jetChainDef.sequenceList[0]['algorithm']
#obtaing TrigCaloCellMaker/FS
input1=jetChainDef.sequenceList[1]['input']
output1 =jetChainDef.sequenceList[1]['output']
algo1 =jetChainDef.sequenceList[1]['algorithm']
#obtaining TrigCaloClusterMaker
input2=jetChainDef.sequenceList[2]['input']
output2 =jetChainDef.sequenceList[2]['output']
algo2 =jetChainDef.sequenceList[2]['algorithm']
#obtaining TrigHLTEnergyDensity
input3=jetChainDef.sequenceList[3]['input']
output3 =jetChainDef.sequenceList[3]['output']
algo3 =jetChainDef.sequenceList[3]['algorithm']
#obtaining TrigHLTJetRecFromCluster
input4=jetChainDef.sequenceList[4]['input']
output4 =jetChainDef.sequenceList[4]['output']
algo4 =jetChainDef.sequenceList[4]['algorithm']
#---End of obtaining jet TEs------------------------------
########### Sequences ###########
#Run L2-like algos only for l2fsperf and L2FS chains
if L2recoAlg=="l2fsperf" or L2recoAlg=="L2FS":
##L1 MET
self.L2sequenceList += [[ self.l2_input_tes, [theL2Fex], 'L2_xe_step1']]
##Moun Correction to L1 MET
self.L2sequenceList += [[ ['L2_xe_step1', muonSeed], [theL2MuonFex], 'L2_xe_step2']]
# --- EF ---
# cell preselection (v7 onwards only)
# First check if we're in a multipart chain (for now assume that we don't apply the preselection for these)
isMulitpartChain = self.chainPart['chainPartName'] != self.chainDict['chainName']
if EFrecoAlg != 'cell' and 'v6' not in TriggerFlags.triggerMenuSetup() and 'v5' not in TriggerFlags.triggerMenuSetup() and not isMulitpartChain:
# if EFrecoAlg != 'cell' and TriggerFlags.run2Config() != '2016' and not isMulitpartChain:
# a few parameters
cellPresel_minL1Threshold = 50
cellPresel_threshold = 50
# work out what the L1 threshold is
import re
match = re.match(r"L1_XE(\d+)", self.chainDict['L1item'])
if match:
if int(match.group(1) ) >= cellPresel_minL1Threshold:
cellPreselectionFex = EFMissingET_Fex_2sidednoiseSupp()
cellPreselectionMuonFex = EFTrigMissingETMuon_Fex()
cellPreselectionHypo = EFMetHypoXE('EFMetHypo_xe{0}_presel'.format(cellPresel_threshold), ef_thr = float(cellPresel_threshold) * GeV)
self.EFsequenceList += [[ [''], [cellPreselectionFex], 'EF_xe{0}_step1'.format(cellPresel_threshold) ]]
self.EFsequenceList += [[ ['EF_xe{0}_step1'.format(cellPresel_threshold), muonSeed], [cellPreselectionMuonFex, cellPreselectionHypo], 'EF_xe{0}_step2'.format(cellPresel_threshold) ]]
self.EFsignatureList += [ [['EF_xe{0}_step1'.format(cellPresel_threshold)]] ]
self.EFsignatureList += [ [['EF_xe{0}_step2'.format(cellPresel_threshold)]] ]
else:
log.info("Pure MET chain doesn't have an L1_XE seed! Will not apply the cell preselection")
#topocluster
if EFrecoAlg=='tc' or EFrecoAlg=='pueta' or EFrecoAlg=='pufit':
self.EFsequenceList +=[[ input0,algo0, output0 ]]
self.EFsequenceList +=[[ input1,algo1, output1 ]]
self.EFsequenceList +=[[ input2,algo2, output2 ]]
self.EFsequenceList +=[[ input3,algo3, output3 ]]
self.EFsequenceList +=[[ input4,algo4, output4 ]]
self.EFsequenceList +=[[ [output3,output4], [theEFMETFex], 'EF_xe_step1' ]]
self.EFsequenceList +=[[ ['EF_xe_step1',muonSeed], [theEFMETMuonFex, theEFMETHypo], 'EF_xe_step2' ]]
elif EFrecoAlg=='pufittrack':
def makelist(x):
return x if isinstance(x, list) else [x]
self.EFsequenceList += [ [ x['input'], makelist(x['algorithm']), x['output'] ] for x in bjet_chain_def.sequenceList[:-2] ]
# for x in bjet_chain_def.sequenceList[:-2]:
# print (x)
# print (self.EFsequenceList[4][2], "Clusters, output EF_FSTopoClusters")
# print (self.EFsequenceList[6][2], "Jets, output EF_8389636500743033767_jetrec_a4tclcwnojcalibFS")
# print (self.EFsequenceList[-1][2], "Tracks, output HLT_j20_eta_jsplit_IDTrig")
# print (self.EFsequenceList[-5][2], "Vertex, output HLT_superIDTrig_prmVtx")
# Fill the sequence with clusters, jets, tracks, vertices
self.EFsequenceList += [[ [self.EFsequenceList[4][2],self.EFsequenceList[6][2],self.EFsequenceList[-1][2],self.EFsequenceList[-5][2]], [theEFMETFex], 'EF_xe_step1' ]]
self.EFsequenceList += [[ ['EF_xe_step1',muonSeed], [theEFMETMuonFex, theEFMETHypo], 'EF_xe_step2' ]]
#trigger-jet based MET
elif EFrecoAlg=='mht':
self.EFsequenceList +=[[ input0,algo0, output0 ]]
self.EFsequenceList +=[[ input1,algo1, output1 ]]
self.EFsequenceList +=[[ input2,algo2, output2 ]]
self.EFsequenceList +=[[ input3,algo3, output3 ]]
self.EFsequenceList +=[[ input4,algo4, output4 ]]
self.EFsequenceList +=[[ [output4], [theEFMETFex], 'EF_xe_step1' ]]
self.EFsequenceList +=[[ ['EF_xe_step1',muonSeed], [theEFMETMuonFex, theEFMETHypo], 'EF_xe_step2' ]]
if "FStracks" in addInfo:
from TrigInDetConf.TrigInDetSequence import TrigInDetSequence
trk_algs = TrigInDetSequence("FullScan", "fullScan", "IDTrig", sequenceFlavour=["FTF"]).getSequence()
print (trk_algs[0])
dummyAlg = PESA__DummyUnseededAllTEAlgo("EF_DummyFEX_xe")
self.EFsequenceList +=[[ [''], [dummyAlg]+trk_algs[0], 'EF_xe_step3' ]]
elif EFrecoAlg=='trkmht':
self.EFsequenceList +=[[ input0,algo0, output0 ]]
self.EFsequenceList +=[[ input1,algo1, output1 ]]
self.EFsequenceList +=[[ input2,algo2, output2 ]]
self.EFsequenceList +=[[ input3,algo3, output3 ]]
self.EFsequenceList +=[[ input4,algo4, output4 ]]
#adding FullScan tracks
from TrigInDetConf.TrigInDetSequence import TrigInDetSequence
trk_algs = TrigInDetSequence("FullScan", "fullScan", "IDTrig", sequenceFlavour=["FTF"]).getSequence()
dummyAlg = PESA__DummyUnseededAllTEAlgo("EF_DummyFEX_xe")
self.EFsequenceList +=[[ [''], [dummyAlg]+trk_algs[0], 'EF_xe_step0' ]]
self.EFsequenceList +=[[ [output4,'EF_xe_step0',muonSeed], [theEFMETFex], 'EF_xe_step1' ]]
self.EFsequenceList +=[[ ['EF_xe_step1',muonSeed], [theEFMETMuonFex, theEFMETHypo], 'EF_xe_step2' ]]
elif EFrecoAlg=='trktc':
self.EFsequenceList +=[[ input0,algo0, output0 ]]
self.EFsequenceList +=[[ input1,algo1, output1 ]]
self.EFsequenceList +=[[ input2,algo2, output2 ]]
self.EFsequenceList +=[[ input3,algo3, output3 ]]
#self.EFsequenceList +=[[ input4,algo4, output4 ]]
##adding FullScan tracks
from TrigInDetConf.TrigInDetSequence import TrigInDetSequence
trk_algs = TrigInDetSequence("FullScan", "fullScan", "IDTrig", sequenceFlavour=["FTF"]).getSequence()
dummyAlg = PESA__DummyUnseededAllTEAlgo("EF_DummyFEX_xe")
self.EFsequenceList +=[[ [''], [dummyAlg]+trk_algs[0], 'EF_xe_step0' ]]
self.EFsequenceList +=[[ [output3,'EF_xe_step0',muonSeed], [theEFMETFex], 'EF_xe_step1' ]]
self.EFsequenceList +=[[ ['EF_xe_step1',muonSeed], [theEFMETMuonFex, theEFMETHypo], 'EF_xe_step2' ]]
#cell based MET
elif EFrecoAlg=='cell':
self.EFsequenceList +=[[ [''], [theEFMETFex], 'EF_xe_step1' ]]
self.EFsequenceList +=[[ ['EF_xe_step1',muonSeed], [theEFMETMuonFex, theEFMETHypo], 'EF_xe_step2' ]]
########### Signatures ###########
if L2recoAlg=="l2fsperf" or L2recoAlg=="L2FS" :
self.L2signatureList += [ [['L2_xe_step1']] ]
self.L2signatureList += [ [['L2_xe_step2']] ]
if EFrecoAlg=="trkmht" or EFrecoAlg=="trktc" :
self.EFsignatureList += [ [['EF_xe_step0']] ]
self.EFsignatureList += [ [['EF_xe_step1']] ]
self.EFsignatureList += [ [['EF_xe_step2']] ]
if "FStracks" in addInfo:
self.EFsignatureList += [ [['EF_xe_step3']] ]
########### TE renaming ###########
self.TErenamingDict = {}
if L2recoAlg=="l2fsperf" or L2recoAlg=="L2FS" :
self.TErenamingDict['L2_xe_step1']= mergeRemovingOverlap('L2_', self.sig_id_noMult+'_step1')
self.TErenamingDict['L2_xe_step2']= mergeRemovingOverlap('L2_', self.sig_id_noMult+'_step2')
if EFrecoAlg=='trkmht' or EFrecoAlg=='trktc':
self.TErenamingDict['EF_xe_step0']= mergeRemovingOverlap('EF_', self.sig_id_noMult+"_step0")
#if EFrecoAlg=='pufittrack':
# self.TErenamingDict['EF_xe_step0']= mergeRemovingOverlap('EF_', self.sig_id_noMult+"_step0")
self.TErenamingDict['EF_xe_step1']= mergeRemovingOverlap('EF_', self.sig_id_noMult+'_step1')
if "FStracks" in addInfo:
self.TErenamingDict['EF_xe_step2']= mergeRemovingOverlap('EF_', self.sig_id_noMult+"_step2")
self.TErenamingDict['EF_xe_step3']= mergeRemovingOverlap('EF_', self.sig_id_noMult)
else:
self.TErenamingDict['EF_xe_step2']= mergeRemovingOverlap('EF_', self.sig_id_noMult)
def generateChainDefs(chainDict, thisIsBphysChain=False):
listOfChainDicts = splitChainDict(chainDict)
listOfChainDefs = []
asymDiMuonChain = False
if (len(listOfChainDicts) > 1): asymDiMuonChain = True
else: asymDiMuonChain = False
asymMultiMuonChain = False
if (len(listOfChainDicts) > 1 and "noL1" not in chainDict["chainName"]
and sum(
map(int, [
subChainDict["chainParts"]["multiplicity"]
for subChainDict in listOfChainDicts
])) > 1):
asymMultiMuonChain = True
modifyNscanInputTE = False
modifyCalotagInputTE = False
for subChainDict in listOfChainDicts:
if "IdTest" in subChainDict["chainParts"]["addInfo"]:
Muon = L2EFChain_mu_IdTest(subChainDict, asymDiMuonChain)
else:
#If FS muon, needs total counts of muons in chain
if 'noL1' in subChainDict["chainParts"]["extra"]:
AllMuons = GetAllMuonThresholds(chainDict)
elif subChainDict["chainParts"][
"reccalibInfo"] == "btrk" or 'btrk' in subChainDict[
"chainParts"]["extra"]:
AllMuons = GetAllMuonThresholds(chainDict)
else:
AllMuons = []
Muon = L2EFChain_mu(subChainDict, asymDiMuonChain,
asymMultiMuonChain, AllMuons, thisIsBphysChain)
listOfChainDefs += [Muon.generateHLTChainDef()]
#only needed for nscan
if "nscan" in subChainDict["chainParts"]['FSinfo']:
modifyNscanInputTE = True
if "calotag" in subChainDict["chainParts"]['FSinfo']:
modifyCalotagInputTE = True
if len(listOfChainDefs) > 1:
if ('mergingStrategy' in chainDict.keys()):
theChainDef = mergeChainDefs(listOfChainDefs,
chainDict["mergingStrategy"],
chainDict["mergingOffset"])
else:
theChainDef = mergeChainDefs(listOfChainDefs)
else:
theChainDef = listOfChainDefs[0]
# needed for nscan to replace the placeholder TE with the L2TE of the other chain
if (modifyNscanInputTE == True):
theChainDef = _modifyTEinChainDef(theChainDef, chainDict)
if (modifyCalotagInputTE == True):
theChainDef = _modifyTEinChainDef(theChainDef, chainDict)
#if chainDict["topo"]:
# theChainDef = _addTopoInfo(theChainDef,chainDict)
if (len(listOfChainDicts) > 1):
nomucomb_asymmetric = True
for ii in range(len(listOfChainDicts)):
if listOfChainDicts[ii]['chainParts']['reccalibInfo'] != 'nomucomb':
nomucomb_asymmetric = False
if nomucomb_asymmetric == True:
theChainDef = _AsymmChainConfig(theChainDef, chainDict)
return theChainDef
def _AsymmChainConfig(theChainDef, chainDict):
maxL2SignatureIndex = -1
for signatureIndex, signature in enumerate(theChainDef.signatureList):
print "DEBUG1 : check0 : ", signature
if signature['listOfTriggerElements'][0][0:2] == "L2":
maxL2SignatureIndex = max(maxL2SignatureIndex, signatureIndex)
inputTEsL2 = theChainDef.signatureList[maxL2SignatureIndex][
'listOfTriggerElements']
inputTEsEF = theChainDef.signatureList[-1]['listOfTriggerElements']
idmultiArr = []
listOfChainDicts = splitChainDict(chainDict)
totalmulti = 0
for subChainDict in listOfChainDicts:
if subChainDict['chainParts']['reccalibInfo'] == "nomucomb":
totalmulti += int(subChainDict['chainParts']['multiplicity'])
idmultiArr += [
"%03i_AA_%03i" %
(int(subChainDict['chainParts']['threshold']),
int(subChainDict['chainParts']['multiplicity']))
]
idmultiArr.sort()
totalmulti_lowest = 0
totalmulti_2ndlow = 0
for ii in range(len(idmultiArr)):
multi = idmultiArr[ii].split("_AA_")[1]
totalmulti_lowest += int(multi)
if ii > 0: totalmulti_2ndlow += int(multi)
idmultiArr2 = []
for ii in range(len(idmultiArr)):
thre = idmultiArr[ii].split("_AA_")[0]
multi = idmultiArr[ii].split("_AA_")[1]
if ii == 0: idmultiArr2 += ["%ipt%i" % (totalmulti_lowest, int(thre))]
if ii == 1: idmultiArr2 += ["%ipt%i" % (totalmulti_2ndlow, int(thre))]
if ii == 2: idmultiArr2 += ["%ipt%i" % (int(multi), int(thre))]
if ii > 2: print "ERROR : not supported"
idmulti = "_".join(idmultiArr2)
from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonIDTrackMultiHypoConfig
theTrigMuonIDTrackMultiHypoConfig_FTF = TrigMuonIDTrackMultiHypoConfig(
idmulti, "FTF")
theTrigMuonIDTrackMultiHypoConfig_Muon = TrigMuonIDTrackMultiHypoConfig(
idmulti, "Muon")
L2TEname = "L2_idtrkmulti_" + idmulti + "_nomucomb_" + chainDict['L1item']
theChainDef.addSequence([theTrigMuonIDTrackMultiHypoConfig_FTF],
inputTEsL2, L2TEname)
theChainDef.addSignatureL2([L2TEname])
EFTEname = "EF_mutrkmulti_" + idmulti + "_nomucomb_" + chainDict['L1item']
theChainDef.addSequence([theTrigMuonIDTrackMultiHypoConfig_Muon],
inputTEsEF, EFTEname)
theChainDef.addSignature(
theChainDef.signatureList[-1]['signature_counter'] + 1, [EFTEname])
return theChainDef
def setup_xeXX(self):
##EF only chain, run FEB or topo_cluster
##NoAlg at L2
##if at a certain point different steps are used at EF,
## we need a way to encode the information of the threshold at both the two steps
##could be a dict here, or adding something to the SignatureDictionary
threshold = int(self.chainPart['threshold'])
calibration = self.chainPart['calib']
jetCalib = self.chainPart['jetCalib']
L2recoAlg = self.chainPart['L2recoAlg']
EFrecoAlg = self.chainPart['EFrecoAlg']
EFmuon = self.chainPart['EFmuonCorr']
addInfo = self.chainPart["addInfo"]
#--------------------------------------
#obtaining the muon sequences & signature:
#--------------------------------------
log.debug("Creating muon sequence")
chain = [
'mu8', 'L1_MU6', [], ["Main"], ['RATE:SingleMuon', 'BW:Muon'], -1
]
theDictFromChainName = DictFromChainName.DictFromChainName()
muonChainDict = theDictFromChainName.getChainDict(chain)
listOfChainDicts = splitChainDict(muonChainDict)
muDict = listOfChainDicts[0]
muDict['chainCounter'] = 9150
muonthing = L2EFChain_mu(muDict, False, ['8GeV'])
muonSeed = muonthing.EFsignatureList[-1][0][0]
for seq in muonthing.L2sequenceList:
self.L2sequenceList += [seq]
for seq in muonthing.EFsequenceList:
self.EFsequenceList += [seq]
########### Imports for hypos and fexes ###########
##L1 MET
theL2Fex = L2MissingET_Fex()
theL2MuonFex = L2TrigMissingETMuon_Fex()
mucorr = '_wMu' if EFmuon else ''
##MET with topo-cluster
if EFrecoAlg == 'tc' or EFrecoAlg == 'pueta' or EFrecoAlg == 'pufit' or EFrecoAlg == 'mht' or EFrecoAlg == 'trkmht':
##Topo-cluster
if EFrecoAlg == 'tc':
#MET fex
theEFMETFex = EFMissingET_Fex_topoClusters()
#Muon correction fex
theEFMETMuonFex = EFTrigMissingETMuon_Fex_topocl()
#TC hypo
#mucorr= '_wMu' if EFmuon else ''
if self.chainPart['trigType'] == "xs":
theEFMETHypo = EFMetHypoXS_2sided(
'EFMetHypo_xs_2sided_%i%s' % (threshold, mucorr),
ef_thr=float(threshold) * 0.1)
elif self.chainPart['trigType'] == "te":
theEFMETHypo = EFMetHypoTE('EFMetHypo_te%d' % threshold,
ef_thr=float(threshold) * GeV)
else:
theEFMETHypo = EFMetHypoTCXE(
'EFMetHypo_TC_xe%s_tc%s%s' %
(threshold, calibration, mucorr),
ef_thr=float(threshold) * GeV)
if EFrecoAlg == 'pufit':
#MET fex
theEFMETFex = EFMissingET_Fex_topoClustersPUC()
#Muon correction fex
theEFMETMuonFex = EFTrigMissingETMuon_Fex_topoclPUC()
mucorr = '_wMu' if EFmuon else ''
theEFMETHypo = EFMetHypoTCPUCXE(
'EFMetHypo_TCPUC_xe%s_tc%s%s' %
(threshold, calibration, mucorr),
ef_thr=float(threshold) * GeV)
##MET based on trigger jets
if EFrecoAlg == 'mht':
calibCorr = ('_{0}'.format(calibration) if
calibration != METChainParts_Default['calib'] else
'') + ('_{0}'.format(jetCalib) if jetCalib !=
METChainParts_Default['jetCalib'] else '')
#MET fex
theEFMETFex = EFMissingET_Fex_Jets(
"EFMissingET_Fex_Jets{0}".format(calibCorr),
extraCalib=calibCorr)
#Muon correction fex
theEFMETMuonFex = EFTrigMissingETMuon_Fex_Jets(
"EFTrigMissingETMuon_Fex_Jets{0}".format(calibCorr))
#mucorr= '_wMu' if EFmuon else ''
theEFMETHypo = EFMetHypoJetsXE(
'EFMetHypo_Jets_xe%s_tc%s%s%s' %
(threshold, jetCalib, calibration, mucorr),
ef_thr=float(threshold) * GeV,
extraCalib=calibCorr)
##MET based on trigger jets
if EFrecoAlg == 'trkmht':
#MET fex
if "FTK" in addInfo:
theEFMETFex = EFMissingET_Fex_FTKTrackAndJets()
else:
theEFMETFex = EFMissingET_Fex_TrackAndJets()
#Muon correction fex
## this will be added later
theEFMETMuonFex = EFTrigMissingETMuon_Fex_Jets()
#mucorr= '_wMu' if EFmuon else ''
if "FTK" in addInfo:
theEFMETHypo = EFMetHypoFTKTrackAndJetsXE(
'EFMetHypo_FTKTrackAndJets_xe%s_tc%s%s' %
(threshold, calibration, mucorr),
ef_thr=float(threshold) * GeV)
else:
theEFMETHypo = EFMetHypoTrackAndJetsXE(
'EFMetHypo_TrackAndJets_xe%s_tc%s%s' %
(threshold, calibration, mucorr),
ef_thr=float(threshold) * GeV)
##Topo-cluster with Pile-up suppression
if EFrecoAlg == 'pueta':
#MET fex
theEFMETFex = EFMissingET_Fex_topoClustersPS()
#Muon correction fex
theEFMETMuonFex = EFTrigMissingETMuon_Fex_topoclPS()
theEFMETHypo = EFMetHypoTCPSXE(
'EFMetHypo_TCPS_xe%s_tc%s%s' %
(threshold, calibration, mucorr),
ef_thr=float(threshold) * GeV)
##2-SidedNoise Cell
elif EFrecoAlg == 'cell':
#MET fex
theEFMETFex = EFMissingET_Fex_2sidednoiseSupp()
#Muon correction fex
theEFMETMuonFex = EFTrigMissingETMuon_Fex()
#Hypo
if self.chainPart['trigType'] == "xs":
theEFMETHypo = EFMetHypoXS_2sided(
'EFMetHypo_xs_2sided_%d%s' % (threshold, mucorr),
ef_thr=float(threshold) * 0.1)
elif self.chainPart['trigType'] == "te":
theEFMETHypo = EFMetHypoTE('EFMetHypo_te%d' % threshold,
ef_thr=threshold * GeV)
else:
theEFMETHypo = EFMetHypoXE('EFMetHypo_xe%s%s' %
(threshold, mucorr),
ef_thr=float(threshold) * GeV)
else:
log.warning("MET EF algorithm not recognised")
#----------------------------------------------------
# Obtaining the needed jet TEs from the jet code
#----------------------------------------------------
from TriggerJobOpts.TriggerFlags import TriggerFlags
chain = [
'j0_{0}_{1}'.format(calibration, jetCalib), '', [], ["Main"],
['RATE:SingleJet', 'BW:Jet'], -1
]
theDictFromChainName = DictFromChainName.DictFromChainName()
jetChainDict = theDictFromChainName.getChainDict(chain)
jetChainDict['chainCounter'] = 9151
jetChainDef = generateHLTChainDef(jetChainDict)
#for i in range(3):
# m_input[i] = jetChainDef.sequenceList[i]['input']
# m_output[i]= jetChainDef.sequenceList[i]['output']
# m_algo[i] =jetChainDef.sequenceList[i]['algorithm']
#obtaining DummyUnseededAllTEAlgo/RoiCreator
input0 = jetChainDef.sequenceList[0]['input']
output0 = jetChainDef.sequenceList[0]['output']
algo0 = jetChainDef.sequenceList[0]['algorithm']
#obtaing TrigCaloCellMaker/FS
input1 = jetChainDef.sequenceList[1]['input']
output1 = jetChainDef.sequenceList[1]['output']
algo1 = jetChainDef.sequenceList[1]['algorithm']
#obtaining TrigCaloClusterMaker
input2 = jetChainDef.sequenceList[2]['input']
output2 = jetChainDef.sequenceList[2]['output']
algo2 = jetChainDef.sequenceList[2]['algorithm']
#obtaining TrigHLTEnergyDensity
input3 = jetChainDef.sequenceList[3]['input']
output3 = jetChainDef.sequenceList[3]['output']
algo3 = jetChainDef.sequenceList[3]['algorithm']
#obtaining TrigHLTJetRecFromCluster
input4 = jetChainDef.sequenceList[4]['input']
output4 = jetChainDef.sequenceList[4]['output']
algo4 = jetChainDef.sequenceList[4]['algorithm']
#---End of obtaining jet TEs------------------------------
########### Sequences ###########
#Run L2-like algos only for l2fsperf and L2FS chains
if L2recoAlg == "l2fsperf" or L2recoAlg == "L2FS":
##L1 MET
self.L2sequenceList += [[
self.l2_input_tes, [theL2Fex], 'L2_xe_step1'
]]
##Moun Correction to L1 MET
self.L2sequenceList += [[['L2_xe_step1', muonSeed], [theL2MuonFex],
'L2_xe_step2']]
# --- EF ---
# cell preselection (v7 onwards only)
# First check if we're in a multipart chain (for now assume that we don't apply the preselection for these)
isMulitpartChain = self.chainPart['chainPartName'] != self.chainDict[
'chainName']
if EFrecoAlg != 'cell' and 'v6' not in TriggerFlags.triggerMenuSetup(
) and 'v5' not in TriggerFlags.triggerMenuSetup(
) and not isMulitpartChain:
# if EFrecoAlg != 'cell' and TriggerFlags.run2Config() != '2016' and not isMulitpartChain:
# a few parameters
cellPresel_minL1Threshold = 50
cellPresel_threshold = 50
# work out what the L1 threshold is
import re
match = re.match("L1_XE(\d+)", self.chainDict['L1item'])
if match:
if int(match.group(1)) >= cellPresel_minL1Threshold:
cellPreselectionFex = EFMissingET_Fex_2sidednoiseSupp()
cellPreselectionMuonFex = EFTrigMissingETMuon_Fex()
cellPreselectionHypo = EFMetHypoXE(
'EFMetHypo_xe{0}_presel'.format(cellPresel_threshold),
ef_thr=float(cellPresel_threshold) * GeV)
self.EFsequenceList += [[[''], [
cellPreselectionFex
], 'EF_xe{0}_step1'.format(cellPresel_threshold)]]
self.EFsequenceList += [[[
'EF_xe{0}_step1'.format(cellPresel_threshold), muonSeed
], [cellPreselectionMuonFex, cellPreselectionHypo
], 'EF_xe{0}_step2'.format(cellPresel_threshold)]]
self.EFsignatureList += [[[
'EF_xe{0}_step1'.format(cellPresel_threshold)
]]]
self.EFsignatureList += [[[
'EF_xe{0}_step2'.format(cellPresel_threshold)
]]]
else:
log.info(
"Pure MET chain doesn't have an L1_XE seed! Will not apply the cell preselection"
)
#topocluster
if EFrecoAlg == 'tc' or EFrecoAlg == 'pueta' or EFrecoAlg == 'pufit':
self.EFsequenceList += [[input0, algo0, output0]]
self.EFsequenceList += [[input1, algo1, output1]]
self.EFsequenceList += [[input2, algo2, output2]]
self.EFsequenceList += [[input3, algo3, output3]]
self.EFsequenceList += [[[output3], [theEFMETFex], 'EF_xe_step1']]
self.EFsequenceList += [[['EF_xe_step1', muonSeed],
[theEFMETMuonFex, theEFMETHypo],
'EF_xe_step2']]
#trigger-jet based MET
elif EFrecoAlg == 'mht':
self.EFsequenceList += [[input0, algo0, output0]]
self.EFsequenceList += [[input1, algo1, output1]]
self.EFsequenceList += [[input2, algo2, output2]]
self.EFsequenceList += [[input3, algo3, output3]]
self.EFsequenceList += [[input4, algo4, output4]]
self.EFsequenceList += [[[output4], [theEFMETFex], 'EF_xe_step1']]
self.EFsequenceList += [[['EF_xe_step1', muonSeed],
[theEFMETMuonFex, theEFMETHypo],
'EF_xe_step2']]
if "FStracks" in addInfo:
from TrigInDetConf.TrigInDetSequence import TrigInDetSequence
trk_algs = TrigInDetSequence("FullScan",
"fullScan",
"IDTrig",
sequenceFlavour=["FTF"
]).getSequence()
print "XXXXXXXXXXXXXXXXXX"
print trk_algs[0]
dummyAlg = PESA__DummyUnseededAllTEAlgo("EF_DummyFEX_xe")
self.EFsequenceList += [[[''], [dummyAlg] + trk_algs[0],
'EF_xe_step3']]
elif EFrecoAlg == 'trkmht':
self.EFsequenceList += [[input0, algo0, output0]]
self.EFsequenceList += [[input1, algo1, output1]]
self.EFsequenceList += [[input2, algo2, output2]]
self.EFsequenceList += [[input3, algo3, output3]]
self.EFsequenceList += [[input4, algo4, output4]]
##adding FTK tracks in the sequence,
##if not, adding FullScan tracks
if "FTK" in addInfo:
from TrigInDetConf.TrigInDetFTKSequence import TrigInDetFTKSequence
trk_algs = TrigInDetFTKSequence(
"FullScan", "fullScan",
sequenceFlavour=["FTKVtx"]).getSequence()
dummyAlg = PESA__DummyUnseededAllTEAlgo("EF_DummyFEX_xe")
self.EFsequenceList += [[[''], [dummyAlg] + trk_algs[0] +
trk_algs[1], 'EF_xe_step0']]
else:
from TrigInDetConf.TrigInDetSequence import TrigInDetSequence
trk_algs = TrigInDetSequence("FullScan",
"fullScan",
"IDTrig",
sequenceFlavour=["FTF"
]).getSequence()
dummyAlg = PESA__DummyUnseededAllTEAlgo("EF_DummyFEX_xe")
self.EFsequenceList += [[[''], [dummyAlg] + trk_algs[0],
'EF_xe_step0']]
self.EFsequenceList += [[[output4, 'EF_xe_step0', muonSeed],
[theEFMETFex], 'EF_xe_step1']]
self.EFsequenceList += [[['EF_xe_step1', muonSeed],
[theEFMETMuonFex, theEFMETHypo],
'EF_xe_step2']]
#cell based MET
elif EFrecoAlg == 'cell':
self.EFsequenceList += [[[''], [theEFMETFex], 'EF_xe_step1']]
self.EFsequenceList += [[['EF_xe_step1', muonSeed],
[theEFMETMuonFex, theEFMETHypo],
'EF_xe_step2']]
########### Signatures ###########
if L2recoAlg == "l2fsperf" or L2recoAlg == "L2FS":
self.L2signatureList += [[['L2_xe_step1']]]
self.L2signatureList += [[['L2_xe_step2']]]
if EFrecoAlg == "trkmht":
self.EFsignatureList += [[['EF_xe_step0']]]
self.EFsignatureList += [[['EF_xe_step1']]]
self.EFsignatureList += [[['EF_xe_step2']]]
if "FStracks" in addInfo:
self.EFsignatureList += [[['EF_xe_step3']]]
########### TE renaming ###########
self.TErenamingDict = {}
if L2recoAlg == "l2fsperf" or L2recoAlg == "L2FS":
self.TErenamingDict['L2_xe_step1'] = mergeRemovingOverlap(
'L2_', self.sig_id_noMult + '_step1')
self.TErenamingDict['L2_xe_step2'] = mergeRemovingOverlap(
'L2_', self.sig_id_noMult + '_step2')
if EFrecoAlg == 'trkmht':
self.TErenamingDict['EF_xe_step0'] = mergeRemovingOverlap(
'EF_', self.sig_id_noMult + "_step0")
self.TErenamingDict['EF_xe_step1'] = mergeRemovingOverlap(
'EF_', self.sig_id_noMult + '_step1')
if "FStracks" in addInfo:
self.TErenamingDict['EF_xe_step2'] = mergeRemovingOverlap(
'EF_', self.sig_id_noMult + "_step2")
self.TErenamingDict['EF_xe_step3'] = mergeRemovingOverlap(
'EF_', self.sig_id_noMult)
else:
self.TErenamingDict['EF_xe_step2'] = mergeRemovingOverlap(
'EF_', self.sig_id_noMult)
def generateChainDefs(chainDict):
#log.setLevel(0)
log.debug("In generateChainDefs")
chainDict_orig = deepcopy(chainDict)
# PrettyPrinter is rather expensive so make sure we don't invoke it unless in DEBUG
if log.isEnabledFor(logging.DEBUG):
log.debug("Initial b-jet chainDict: \n %s", pp.pformat(chainDict))
#----------------------------------------------------------------------------
# --- preparing the dictionary for jet chain generation ---
n_chainParts = len(chainDict['chainParts'])
if (n_chainParts > 1):
jetchainDict = _prepareJetChainDict(chainDict)
elif (n_chainParts == 1):
log.debug('Only one chain part dictionary for this chain.')
jetchainDict = chainDict
else:
raise RuntimeError('No chain parts found for chain %s' %
(chainDict['chainName']))
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
# --- obtain jet chain def used as inputTE for first btag sequence ---
thejThrChainDef = get_j35_ChainDef()
if ('j0_bperf' in chainDict['chainName']):
thejThrChainDef['L1item'] = 'L1_J10'
thejThrChainDef['chainName'] = 'j0'
for part in thejThrChainDef['chainParts']:
part['chainPartName'] = 'j0'
part['threshold'] = '0'
if ('L1MU10' in chainDict['chainName']):
thejThrChainDef['L1item'] = 'L1_MU10'
if ('L1RD0_EMPTY' in chainDict['chainName']):
thejThrChainDef['L1item'] = 'L1_RD0_EMPTY'
theBJChainDef = genJetChainDefs(thejThrChainDef)
log.debug("ChainDef for b-jet chain: \n %s", theBJChainDef)
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
# --- build the jet chain, then pass JetChainDef and bjetchainDictionaries to build bjet chains ---
log.debug("getting the Jet Chain Defs")
theAllJetChainDef = genJetChainDefs(jetchainDict)
log.debug("Jet ChainDef for b-jet chain: \n %s", theAllJetChainDef)
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
# --- now merge chain defs so that last TE is from jet serving as input to bjet seq ---
# DO NOT CHANGE THE MERGING ORDER PLEASE, OTHERWISE WRONG INPUT IS SELECTED
log.debug("Trying to merge chainDef for b-jet chain: \n ")
theJetChainDef = mergeChainDefs([theAllJetChainDef, theBJChainDef],
'serial', -1, False)
log.debug("Merged chainDef for b-jet chain: \n %s", theJetChainDef)
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
# --- filtering b-tagged jets chainParts ---
listofChainDicts = splitChainDict(chainDict_orig)
if log.isEnabledFor(logging.DEBUG):
log.debug("Split b-jet chainDict: \n %s", pp.pformat(listofChainDicts))
bjetchainDicts = [
cdict for cdict in listofChainDicts if cdict['chainParts']['bTag']
]
if log.isEnabledFor(logging.DEBUG):
log.debug("Final b-jet chainDict: \n %s", pp.pformat(bjetchainDicts))
#
# Basic properties of the chain, these are used to decide if we use the new AllTE configuration
#
isSplitChain = (not chainDict['chainName'].find("split") == -1)
isRunITagger = (not chainDict['chainName'].find("btight") == -1
or not chainDict['chainName'].find("bmedium") == -1
or not chainDict['chainName'].find("bloose") == -1)
is2015Tagger = (not chainDict['chainName'].find("bmv2c20") == -1
or not chainDict['chainName'].find("bperf") == -1)
isMuDr = (not chainDict['chainName'].find("mu") == -1
and not chainDict['chainName'].find("_dr") == -1)
isMuDz = (not chainDict['chainName'].find("mu") == -1
and not chainDict['chainName'].find("_dz") == -1)
isIsoLep = (not chainDict['chainName'].find("ivarmedium") == -1
or not chainDict['chainName'].find("ivarloose") == -1)
isSingleJet = ((len(chainDict['chainParts']) == 1)
and (int(chainDict['chainParts'][0]['multiplicity']) == 1))
#
# Only run the All TE on split chains
#
doAllTEConfig = isSplitChain
#
# Do not need to run AllTE on single jet chains
#
if isSingleJet: doAllTEConfig = False
#
# New AllTE config currently supported on new mv2c10 taggers
#
if isRunITagger or is2015Tagger: doAllTEConfig = False
#
# Need all the ouput bjet TEs to properly match to muons
# so dont use all TE here either
#
if isMuDz or isMuDr or isIsoLep: doAllTEConfig = False
if doAllTEConfig:
log.debug("Doing new buildBjetChainsAllTE")
theFinalChainDef = buildBjetChainsAllTE(theJetChainDef, bjetchainDicts)
else:
log.debug("Doing buildBjetChains")
theListOfChainDefs = []
for subChainDict in bjetchainDicts:
theJetChainDef1 = deepcopy(theJetChainDef)
theBjetChainDef = buildBjetChains(theJetChainDef1, subChainDict,
len(bjetchainDicts))
theListOfChainDefs += [theBjetChainDef]
if log.isEnabledFor(logging.DEBUG):
log.debug(
"----------------- Beginning of final individual chainDefs for b-jet chains printout -----------------"
)
for chainDef in theListOfChainDefs:
log.debug('%s', chainDef)
log.debug(
"----------------- End of final individual chainDefs for b-jet chains printout -----------------"
)
if len(theListOfChainDefs) > 1:
theFinalChainDef = mergeChainDefs(theListOfChainDefs,
strategy="parallel",
offset=-1,
preserveL2EFOrder=True,
removeDuplicateTEs=True,
noMergeBJet=True)
else:
theFinalChainDef = theListOfChainDefs[0]
log.debug(
"----------------- Beginning of final merged chainDefs for b-jet chains printout -----------------"
)
log.debug('%s', theFinalChainDef)
log.debug(
"----------------- End of final merged chainDefs for b-jet chains printout -----------------"
)
return theFinalChainDef
