python.TrigEgammaFastCaloHypoTool Namespace Reference

Classes
class	TrigEgammaFastCaloHypoToolConfig

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

Function Documentation

_IncTool()

_IncTool ( flags, name, monGroups, cpart, tool = None )

protected

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()

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()

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()

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()

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()

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()

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()

same	(		val,
			tool )

Definition at line 10 of file TrigEgammaFastCaloHypoTool.py.

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

treatPidName()

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()

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()

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)