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)
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:
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:
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:
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:
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:
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, 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 getChainDef(self, chainDicts):
"""
== gets ChainDef object from the signature code
"""
# generation of ChainDef objects for each signature
if self.doMuonChains:
try:
import TriggerMenu.muon.generateMuonChainDefs
except:
log.error(
'Problems when importing MuonDef.py, disabling muon chains.'
)
log.info(traceback.print_exc())
self.doMuonChains = False
if self.doBphysicsChains:
try:
import TriggerMenu.bphysics.generateBPhysicsChainDefs
except:
log.error(
'Problems when importing BphysicsDef.py, disabling Bphysics chains.'
)
log.info(traceback.print_exc())
self.doBphysicsChains = False
if self.doMETChains:
try:
import TriggerMenu.met.generateMETChainDefs
except:
log.error(
'Problems when importing MissingETDef.py, disabling MET chains.'
)
log.info(traceback.print_exc())
self.doMETChains = False
if self.doTauChains:
try:
import TriggerMenu.tau.generateTauChainDefs
except:
log.error(
'Problems when importing TauDef.py, disabling tau chains.')
log.info(traceback.print_exc())
self.doTauChains = False
if self.doEgammaChains:
try:
import TriggerMenu.egamma.generateElectronChainDefs
import TriggerMenu.egamma.generatePhotonChainDefs
except:
log.error(
'Problems when importing EgammaDef.py or PhotonDef.py, disabling egamma chains.'
)
log.info(traceback.print_exc())
self.doEgammaChains = False
if self.doJetChains:
try:
import TriggerMenu.jet.generateJetChainDefs
except:
log.error(
'Problems when importing JetDef.py or JetDef_HT.py, disabling jet chains.'
)
log.info(traceback.print_exc())
self.doJetChains = False
if self.doBjetChains:
try:
import TriggerMenu.bjet.generateBjetChainDefs
except:
log.error(
'Problems when importing BjetDef.py disabling bjet chains.'
)
log.info(traceback.print_exc())
self.doBjetChains = False
if self.doAFPChains:
try:
import TriggerMenu.afp.generateAFPChainDefs
except:
log.error(
'Problems when importing AFP.py, disabling AFP chains.')
log.info(traceback.print_exc())
self.doAFPChains = False
if self.doMinBiasChains:
try:
import TriggerMenu.minbias.generateMinBiasChainDefs
except:
log.error(
'Problems when importing MinBiasDef.py, disabling MinBias chains.'
)
log.info(traceback.print_exc())
self.doMinBiasChains = False
if self.doHeavyIonChains:
try:
import TriggerMenu.heavyion.generateHeavyIonChainDefs
except:
log.error(
'Problems when importing HeavyIonDef.py, disabling HeavyIon chains.'
)
log.info(traceback.print_exc())
self.doHeavyIonChains = False
if self.doCosmicChains:
try:
import TriggerMenu.calibcosmicmon.generateCosmicChainDefs
except:
log.error(
'Problems when importing CosmicDef.py, disabling cosmic chains.'
)
log.info(traceback.print_exc())
self.doCosmicChains = False
if self.doCalibrationChains:
try:
import TriggerMenu.calibcosmicmon.generateCalibChainDefs
except:
log.error(
'Problems when importing CalibDef.py, disabling calibration chains.'
)
log.info(traceback.print_exc())
self.doCalibrationChains = False
if self.doStreamingChains:
try:
import TriggerMenu.calibcosmicmon.generateStreamingChainDefs
except:
log.error(
'Problems when importing Streaming.py, disabling streaming chains.'
)
log.info(traceback.print_exc())
self.doStreamingChains = False
if self.doMonitorChains:
try:
import TriggerMenu.calibcosmicmon.generateMonitoringChainDefs
except:
log.error(
'Problems when importing Monitor.py, disabling monitoring chains.'
)
log.info(traceback.print_exc())
self.doMonitorChains = False
if self.doBeamspotChains:
try:
import TriggerMenu.calibcosmicmon.generateBeamspotChainDefs
except:
log.error(
'Problems when importing Beamspot.py, disabling beamspot chains.'
)
log.info(traceback.print_exc())
self.doBeamspotChains = False
if self.doEnhancedBiasChains:
try:
import TriggerMenu.calibcosmicmon.generateEnhancedBiasChainDefs
except:
log.error(
'Problems when importing EnhancedBias.py, disabling EnhancedBias chains.'
)
log.info(traceback.print_exc())
self.doEnhancedBiasChains = False
if self.doTestChains:
try:
import TriggerMenu.test.generateTestChainDefs
except:
log.error(
'Problems when importing Test.py, disabling Test chains.')
log.info(traceback.print_exc())
self.doTestChains = False
if self.doCombinedChains:
try:
import TriggerMenu.combined.generateCombinedChainDefs
except:
log.error(
'Problems when importing generateCombinedChainDefs.py, disabling Topo on combined chains.'
)
log.info(traceback.print_exc())
self.doCombinedChains = False
#allowedSignatures = ["jet","egamma","muon", "electron", "photon","met","tau", "afp",
# "minbias", "heavyion", "cosmic", "calibration", "streaming", "monitoring", "ht", 'bjet','eb']
listOfChainDefs = []
log.debug("\n chainDicts1 %s ", chainDicts)
chainDicts = splitInterSignatureChainDict(chainDicts)
log.debug("\n chainDicts2 %s", chainDicts)
#print 'doEgammaChains, doMuonChains', self.doEgammaChains, self.doMuonChains
for chainDict in chainDicts:
chainDefs = None
# print 'checking chainDict for chain %s %s %r' %(chainDict['chainName'],chainDict["signature"], self.doEnhancedBiasChains)
if (chainDict["signature"] == "Jet" or chainDict["signature"]
== "HT") and (self.doJetChains or self.doBjetChains):
bjetchain = False
for chainpart in chainDict["chainParts"]:
if chainpart['bTag']: bjetchain = True
if (bjetchain == True) and self.doBjetChains:
try:
chainDefs = TriggerMenu.bjet.generateBjetChainDefs.generateChainDefs(
chainDict)
except:
log.error(
'Problems creating ChainDef for bjet chain %s ' %
(chainDict['chainName']))
log.info(traceback.print_exc())
continue
elif self.doJetChains:
try:
chainDefs = TriggerMenu.jet.generateJetChainDefs.generateChainDefs(
chainDict)
except:
log.error('Problems creating ChainDef for chain %s ' %
(chainDict['chainName']))
log.info(traceback.print_exc())
continue
elif chainDict["signature"] == "Muon" and self.doMuonChains:
try:
chainDefs = TriggerMenu.muon.generateMuonChainDefs.generateChainDefs(
chainDict)
except:
log.error('Problems creating ChainDef for chain %s ' %
(chainDict['chainName']))
log.info(traceback.print_exc())
continue
elif chainDict["signature"] == "Bphysics" and self.doBphysicsChains:
try:
chainDefs = TriggerMenu.bphysics.generateBPhysicsChainDefs.generateChainDefs(
chainDict)
except:
log.error('Problems creating ChainDef for chain %s ' %
(chainDict['chainName']))
log.info(traceback.print_exc())
continue
elif chainDict["signature"] == "Electron" and self.doEgammaChains:
try:
chainDefs = TriggerMenu.egamma.generateElectronChainDefs.generateChainDefs(
chainDict)
except:
log.error('Problems creating ChainDef for chain %s ' %
(chainDict['chainName']))
log.info(traceback.print_exc())
continue
elif chainDict["signature"] == "Photon" and self.doEgammaChains:
try:
chainDefs = TriggerMenu.egamma.generatePhotonChainDefs.generateChainDefs(
chainDict)
except:
log.error('Problems creating ChainDef for chain %s ' %
(chainDict['chainName']))
log.info(traceback.print_exc())
continue
elif (chainDict["signature"] == "MET"
or chainDict["signature"] == "XS"
or chainDict["signature"] == "TE") and self.doMETChains:
try:
chainDefs = TriggerMenu.met.generateMETChainDefs.generateChainDefs(
chainDict)
except:
log.error('Problems creating ChainDef for chain %s ' %
(chainDict['chainName']))
log.info(traceback.print_exc())
continue
elif chainDict["signature"] == "Tau" and self.doTauChains:
try:
chainDefs = TriggerMenu.tau.generateTauChainDefs.generateChainDefs(
chainDict)
except:
log.error('Problems creating ChainDef for chain %s ' %
(chainDict['chainName']))
log.info(traceback.print_exc())
continue
elif chainDict["signature"] == "AFP" and self.doAFPChains:
try:
chainDefs = TriggerMenu.afp.generateAFPChainDefs.generateChainDefs(
chainDict)
except:
log.error('Problems creating ChainDef for chain %s ' %
(chainDict['chainName']))
log.info(traceback.print_exc())
continue
elif chainDict["signature"] == "MinBias" and self.doMinBiasChains:
try:
chainDefs = TriggerMenu.minbias.generateMinBiasChainDefs.generateChainDefs(
chainDict)
except:
log.error('Problems creating ChainDef for chain %s ' %
(chainDict['chainName']))
log.info(traceback.print_exc())
continue
elif chainDict["signature"] == "HeavyIon" and self.doHeavyIonChains:
try:
chainDefs = TriggerMenu.heavyion.generateHeavyIonChainDefs.generateChainDefs(
chainDict)
except:
log.error('Problems creating ChainDef for chain %s ' %
(chainDict['chainName']))
log.info(traceback.print_exc())
continue
elif chainDict["signature"] == "Cosmic" and self.doCosmicChains:
try:
chainDefs = TriggerMenu.calibcosmicmon.generateCosmicChainDefs.generateChainDefs(
chainDict)
except:
log.error('Problems creating ChainDef for chain %s ' %
(chainDict['chainName']))
log.info(traceback.print_exc())
continue
elif chainDict[
"signature"] == "Calibration" and self.doCalibrationChains:
try:
chainDefs = TriggerMenu.calibcosmicmon.generateCalibChainDefs.generateChainDefs(
chainDict)
except:
log.error('Problems creating ChainDef for chain %s ' %
(chainDict['chainName']))
log.info(traceback.print_exc())
continue
elif chainDict[
"signature"] == "Streaming" and self.doStreamingChains:
try:
chainDefs = TriggerMenu.calibcosmicmon.generateStreamingChainDefs.generateChainDefs(
chainDict)
except:
log.error('Problems creating ChainDef for chain %s ' %
(chainDict['chainName']))
log.info(traceback.print_exc())
continue
elif chainDict[
"signature"] == "Monitoring" and self.doMonitorChains:
try:
chainDefs = TriggerMenu.calibcosmicmon.generateMonitoringChainDefs.generateChainDefs(
chainDict)
except:
log.error('Problems creating ChainDef for chain %s ' %
(chainDict['chainName']))
log.info(traceback.print_exc())
continue
elif chainDict["signature"] == "Beamspot" and self.doBeamspotChains:
try:
chainDefs = TriggerMenu.calibcosmicmon.generateBeamspotChainDefs.generateChainDefs(
chainDict)
except:
log.error('Problems creating ChainDef for chain %s ' %
(chainDict['chainName']))
log.info(traceback.print_exc())
continue
elif chainDict[
"signature"] == "EnhancedBias" and self.doEnhancedBiasChains:
try:
chainDefs = TriggerMenu.calibcosmicmon.generateEnhancedBiasChainDefs.generateChainDefs(
chainDict)
except:
log.error('Problems creating ChainDef for chain %s ' %
(chainDict['chainName']))
log.info(traceback.print_exc())
continue
elif chainDict["signature"] == "Test" and self.doTestChains:
try:
chainDefs = TriggerMenu.test.generateTestChainDefs.generateChainDefs(
chainDict)
except:
log.error('Problems creating ChainDef for chain %s ' %
(chainDict['chainName']))
log.info(traceback.print_exc())
continue
else:
log.error(
'Chain %s ignored - either because the trigger signature ("slice") has been turned off or because the corresponding chain dictionary cannot be read.'
% (chainDict['chainName']))
log.debug('Chain dictionary of failed chain is %s.', chainDict)
log.debug(' ChainDef %s ' % chainDefs)
from ChainDef import ErrorChainDef, ChainDef
if not isinstance(chainDefs, list):
chainDefs = [chainDefs]
for chainDef in chainDefs:
if isinstance(chainDef, ErrorChainDef):
self.listOfErrorChainDefs.append(chainDict['chainName'])
continue
elif isinstance(chainDef, ChainDef):
listOfChainDefs.append(chainDef)
doTopo = self.CheckIntraSignatureTopo(chainDicts) and chainDict["topo"]
if len(listOfChainDefs
) == 0: # or not (len(listOfChainDefs)==len(chainDicts)):
return False
elif len(listOfChainDefs) > 1:
if ("mergingStrategy" in chainDicts[0].keys()):
theChainDef = mergeChainDefs(
listOfChainDefs,
chainDicts[0]["mergingStrategy"],
chainDicts[0]["mergingOffset"],
preserveL2EFOrder=chainDicts[0]
["mergingPreserveL2EFOrder"],
doTopo=doTopo,
chainDicts=chainDicts
) #, noTEreplication = chainDicts[0]["mergingNoTEreplication"])
else:
log.error(
"No merging strategy specified for combined chain %s" %
chainDicts[0]['chainName'])
else:
theChainDef = listOfChainDefs[0]
#Do TOPO on Combined chains
if self.doCombinedChains:
if doTopo:
theChainDef = TriggerMenu.combined.generateCombinedChainDefs._addTopoInfo(
theChainDef, chainDicts, listOfChainDefs)
return theChainDef
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
