python.TrigEgammaFastCaloHypoTool Namespace Reference

Classes
class	TrigEgammaFastCaloHypoToolConfig

Functions
def	same (val, tool)
def	electronRingerFastCaloHypoConfig (flags, name, sequenceOut)
def	photonRingerFastCaloHypoConfig (flags, name, sequenceOut)
def	createTrigEgammaFastCaloHypoAlg (flags, name, sequenceOut)
def	TrigEgammaFastCaloHypoAlgCfg (flags, name, CaloClusters)
def	createTrigEgammaFastCaloHypoAlg_noringer (flags, name, sequenceOut)
def	treatPidName (pidname)
def	_IncTool (flags, name, monGroups, cpart, tool=None)
def	TrigEgammaFastCaloHypoToolFromDict (flags, chainDict, tool=None)
def	createTrigEgammaFastCaloElectronSelectors (flags, ConfigFilePath=None)
def	createTrigEgammaFastCaloPhotonSelectors (flags, ConfigFilePath=None)

Function Documentation

_IncTool()

def python.TrigEgammaFastCaloHypoTool._IncTool (   flags,   name,   monGroups,   cpart,   tool = None  )

private

Definition at line 325 of file TrigEgammaFastCaloHypoTool.py.

def _IncTool(flags, name, monGroups, cpart, tool=None):
  config = TrigEgammaFastCaloHypoToolConfig(flags, name, monGroups, cpart, tool=tool )
  config.compile(flags)
  return config.tool()
 
 

createTrigEgammaFastCaloElectronSelectors()

def python.TrigEgammaFastCaloHypoTool.createTrigEgammaFastCaloElectronSelectors	(		flags,
			ConfigFilePath = None
	)

Definition at line 338 of file TrigEgammaFastCaloHypoTool.py.

def createTrigEgammaFastCaloElectronSelectors(flags, ConfigFilePath=None):
 
    if not ConfigFilePath:
      ConfigFilePath = flags.Trigger.egamma.ringerVersion
 
  
    SelectorNames = {
            'tight'    : 'AsgElectronFastCaloRingerTightSelectorTool',
            'medium'   : 'AsgElectronFastCaloRingerMediumSelectorTool',
            'loose'    : 'AsgElectronFastCaloRingerLooseSelectorTool',
            'vloose'   : 'AsgElectronFastCaloRingerVeryLooseSelectorTool',
    }
        
 
    ToolConfigFile = {
          'tight'   :['ElectronRingerTightTriggerConfig.conf'    ],
          'medium'  :['ElectronRingerMediumTriggerConfig.conf'   ],
          'loose'   :['ElectronRingerLooseTriggerConfig.conf'    ],
          'vloose'  :['ElectronRingerVeryLooseTriggerConfig.conf'],
    }
    
    selectors = []    
 
    for pidname , name in SelectorNames.items():
      SelectorTool=CompFactory.Ringer.AsgRingerSelectorTool(name)
      SelectorTool.ConfigFiles = [ (ConfigFilePath+'/'+path) for path in ToolConfigFile[pidname] ]
      selectors.append(SelectorTool)
    return selectors
 
 
 

createTrigEgammaFastCaloHypoAlg()

def python.TrigEgammaFastCaloHypoTool.createTrigEgammaFastCaloHypoAlg	(		flags,
			name,
			sequenceOut
	)

Definition at line 50 of file TrigEgammaFastCaloHypoTool.py.

def createTrigEgammaFastCaloHypoAlg(flags, name, sequenceOut):
  if 'Electron' in name:
    return electronRingerFastCaloHypoConfig(flags, name, sequenceOut)
  elif 'Photon' in name:
    return photonRingerFastCaloHypoConfig(flags, name, sequenceOut)
 
 

createTrigEgammaFastCaloHypoAlg_noringer()

def python.TrigEgammaFastCaloHypoTool.createTrigEgammaFastCaloHypoAlg_noringer	(		flags,
			name,
			sequenceOut
	)

Definition at line 66 of file TrigEgammaFastCaloHypoTool.py.

def createTrigEgammaFastCaloHypoAlg_noringer(flags, name, sequenceOut):
  
  # make the Hypo
  theFastCaloHypo = CompFactory.TrigEgammaFastCaloHypoAlg(name)
  theFastCaloHypo.CaloClusters = sequenceOut
 
  # Just for electrons
  theFastCaloHypo.PidNames = []
  theFastCaloHypo.RingerNNSelectorTools = []
 
 
  monTool = GenericMonitoringTool(flags, "MonTool_"+name,
                                  HistPath = 'FastCaloL2EgammaHypo/'+name)
  monTool.defineHistogram('TIME_exec', type='TH1F', path='EXPERT', title="Fast Calo Hypo Algtime; time [ us ] ; Nruns", xbins=80, xmin=0.0, xmax=8000.0)
  monTool.defineHistogram('TIME_NN_exec', type='TH1F', path='EXPERT', title="Fast Calo Hypo NN Algtime; time [ us ] ; Nruns", xbins=20, xmin=0.0, xmax=1000.0)
 
  theFastCaloHypo.MonTool=monTool
  return theFastCaloHypo
 
 
 

createTrigEgammaFastCaloPhotonSelectors()

def python.TrigEgammaFastCaloHypoTool.createTrigEgammaFastCaloPhotonSelectors	(		flags,
			ConfigFilePath = None
	)

Definition at line 369 of file TrigEgammaFastCaloHypoTool.py.

def createTrigEgammaFastCaloPhotonSelectors(flags, ConfigFilePath=None):
 
    if not ConfigFilePath:
      ConfigFilePath = flags.Trigger.egamma.photonRingerVersion
 
  
    SelectorNames = {
            'tight'    : 'AsgPhotonFastCaloRingerTightSelectorTool',
            'medium'   : 'AsgPhotonFastCaloRingerMediumSelectorTool',
            'loose'    : 'AsgPhotonFastCaloRingerLooseSelectorTool',
    }
        
 
    ToolConfigFile = {
          'tight'   :['PhotonRingerTightTriggerConfig.conf'    ],
          'medium'  :['PhotonRingerMediumTriggerConfig.conf'   ],
          'loose'   :['PhotonRingerLooseTriggerConfig.conf'    ],
    }
    
    selectors = []    
 
    for pidname , name in SelectorNames.items():
      SelectorTool=CompFactory.Ringer.AsgRingerSelectorTool(name)
      SelectorTool.UseTansigOutput = True # FIXME: Should be removed in the next round
      SelectorTool.ConfigFiles = [ (ConfigFilePath+'/'+path) for path in ToolConfigFile[pidname] ]
      selectors.append(SelectorTool)
    return selectors

electronRingerFastCaloHypoConfig()

def python.TrigEgammaFastCaloHypoTool.electronRingerFastCaloHypoConfig	(		flags,
			name,
			sequenceOut
	)

Definition at line 17 of file TrigEgammaFastCaloHypoTool.py.

def electronRingerFastCaloHypoConfig(flags, name, sequenceOut):
  # make the Hypo
  theFastCaloHypo = CompFactory.TrigEgammaFastCaloHypoAlg(name)
  theFastCaloHypo.CaloClusters = sequenceOut
  theFastCaloHypo.PidNames = ["tight", "medium", "loose", "vloose"]
  theFastCaloHypo.RingerNNSelectorTools = createTrigEgammaFastCaloElectronSelectors(flags)
 
  monTool = GenericMonitoringTool(flags, "MonTool_"+name, HistPath = 'FastCaloL2EgammaHypo/'+name)
  monTool.defineHistogram('TIME_exec', type='TH1F', path='EXPERT', title="Fast Calo Hypo Algtime; time [ us ] ; Nruns", xbins=80, xmin=0.0, xmax=8000.0)
  monTool.defineHistogram('TIME_NN_exec', type='TH1F', path='EXPERT', title="Fast Calo Hypo NN Algtime; time [ us ] ; Nruns", xbins=50, xmin=0.0, xmax=50)
 
  theFastCaloHypo.MonTool=monTool
  return theFastCaloHypo
 
#
# For photons
#

photonRingerFastCaloHypoConfig()

def python.TrigEgammaFastCaloHypoTool.photonRingerFastCaloHypoConfig	(		flags,
			name,
			sequenceOut
	)

Definition at line 34 of file TrigEgammaFastCaloHypoTool.py.

def photonRingerFastCaloHypoConfig(flags, name, sequenceOut):
    # make the Hypo
  theFastCaloHypo = CompFactory.TrigEgammaFastCaloHypoAlg(name)
  theFastCaloHypo.CaloClusters = sequenceOut
  theFastCaloHypo.PidNames = ["tight", "medium", "loose"]
  theFastCaloHypo.RingerNNSelectorTools = createTrigEgammaFastCaloPhotonSelectors(flags)
 
  monTool = GenericMonitoringTool(flags, "MonTool_"+name, HistPath = 'FastCaloL2EgammaHypo/'+name)
  monTool.defineHistogram('TIME_exec', type='TH1F', path='EXPERT', title="Fast Calo Hypo Algtime; time [ us ] ; Nruns", xbins=80, xmin=0.0, xmax=8000.0)
  monTool.defineHistogram('TIME_NN_exec', type='TH1F', path='EXPERT', title="Fast Calo Hypo NN Algtime; time [ us ] ; Nruns", xbins=50, xmin=0.0, xmax=50)
 
  theFastCaloHypo.MonTool=monTool
  return theFastCaloHypo
 
 
 

same()

def python.TrigEgammaFastCaloHypoTool.same	(		val,
			tool
	)

Definition at line 10 of file TrigEgammaFastCaloHypoTool.py.

def same( val , tool):
  return [val]*( len( tool.EtaBins ) - 1 )
 
 
#
# For electrons
#

treatPidName()

def python.TrigEgammaFastCaloHypoTool.treatPidName

(

pidname

)

Definition at line 87 of file TrigEgammaFastCaloHypoTool.py.

def treatPidName(pidname):
  if 'tight' in pidname:
    return 'tight'
  elif 'medium' in pidname:
    return 'medium'
  # this should be before loose to works
  elif 'vloose' in pidname:
    return 'vloose'
  else:
    return 'loose'
 
#
# For electron and photons
#

TrigEgammaFastCaloHypoAlgCfg()

def python.TrigEgammaFastCaloHypoTool.TrigEgammaFastCaloHypoAlgCfg	(		flags,
			name,
			CaloClusters
	)

Definition at line 57 of file TrigEgammaFastCaloHypoTool.py.

def TrigEgammaFastCaloHypoAlgCfg(flags, name, CaloClusters):
  acc = ComponentAccumulator()
  acc.addEventAlgo(createTrigEgammaFastCaloHypoAlg(flags, name=name, sequenceOut=CaloClusters))
  return acc
 
#
# For photons only
# NOTE: For future, ringer will be applied at the fast photon step
#

TrigEgammaFastCaloHypoToolFromDict()

def python.TrigEgammaFastCaloHypoTool.TrigEgammaFastCaloHypoToolFromDict	(		flags,
			chainDict,
			tool = None
	)

Use menu decoded chain dictionary to configure the tool 

Definition at line 331 of file TrigEgammaFastCaloHypoTool.py.

def TrigEgammaFastCaloHypoToolFromDict(flags, chainDict , tool=None):
    """ Use menu decoded chain dictionary to configure the tool """
    cparts = [i for i in chainDict['chainParts'] if ((i['signature']=='Electron') or (i['signature']=='Photon'))]
    return _IncTool( flags, chainDict['chainName'], chainDict['monGroups'], cparts[0], tool=tool)