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 327 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 340 of file TrigEgammaFastCaloHypoTool.py.

def createTrigEgammaFastCaloElectronSelectors(flags, ConfigFilePath=None):
 
    if not ConfigFilePath:
      ConfigFilePath = flags.Trigger.egamma.ringerVersion
 
  
    SelectorNames = collections.OrderedDict({
            'tight'    : 'AsgElectronFastCaloRingerTightSelectorTool',
            'medium'   : 'AsgElectronFastCaloRingerMediumSelectorTool',
            'loose'    : 'AsgElectronFastCaloRingerLooseSelectorTool',
            'vloose'   : 'AsgElectronFastCaloRingerVeryLooseSelectorTool',
            })
        
 
    ToolConfigFile = collections.OrderedDict({
          '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 52 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 68 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 371 of file TrigEgammaFastCaloHypoTool.py.

def createTrigEgammaFastCaloPhotonSelectors(flags, ConfigFilePath=None):
 
    if not ConfigFilePath:
      ConfigFilePath = flags.Trigger.egamma.photonRingerVersion
 
  
    SelectorNames = collections.OrderedDict({
            'tight'    : 'AsgPhotonFastCaloRingerTightSelectorTool',
            'medium'   : 'AsgPhotonFastCaloRingerMediumSelectorTool',
            'loose'    : 'AsgPhotonFastCaloRingerLooseSelectorTool',
            })
        
 
    ToolConfigFile = collections.OrderedDict({
          '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 19 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 36 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 12 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 89 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 59 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 333 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)