SCTHitEffMonAlg Namespace Reference

Functions
	dedicatedTitle (i, isub)
	SCTHitEffMonAlgConfig (flags)

Detailed Description

@file SCTHitEffMonAlg.py
@author Ken Kreul
@date 2019-10-30
@brief Based on AthenaMonitoring/ExampleMonitorAlgorithm.py

Function Documentation

dedicatedTitle()

SCTHitEffMonAlg.dedicatedTitle	(		i,
			isub )

Definition at line 10 of file SCTHitEffMonAlg.py.

def dedicatedTitle(i, isub):
    m_element = i
    m_layerStr = i / 2
    m_region = isub
    if m_region == 1 :
        return "Layer " + str(m_layerStr) + " Side " + str((m_element % 2 + 1) % 2)
    else:
        return "Disk " + str(m_layerStr) + " Side " + str((m_element % 2 + 1) % 2)
 

SCTHitEffMonAlgConfig()

SCTHitEffMonAlg.SCTHitEffMonAlgConfig

(

flags

)

Function to configures some algorithms in the monitoring system.

Definition at line 19 of file SCTHitEffMonAlg.py.

def SCTHitEffMonAlgConfig(flags):
    '''Function to configures some algorithms in the monitoring system.'''
    
    from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
    result = ComponentAccumulator()
 
    # The following class will make a sequence, configure algorithms, and link
    # them to GenericMonitoringTools
    from AthenaMonitoring import AthMonitorCfgHelper
    helper = AthMonitorCfgHelper(flags, 'SCTHitEffMonCfg')
 
 
    
    from AthenaConfiguration.ComponentFactory import CompFactory
    from InDetConfig.InDetTrackHoleSearchConfig import (
        InDetTrackHoleSearchToolCfg)
    from InDetConfig.SiClusterOnTrackTool_SCTStripConfig import (
        InDetSCT_ClusterOnTrackToolCfg)
    from TrkConfig.TrkResidualPullCalculatorConfig import (
        ResidualPullCalculatorCfg)
 
    myMonAlg = helper.addAlgorithm(
        CompFactory.SCTHitEffMonAlg,
        'SCTHitEffMonAlg',
        HoleSearch = result.popToolsAndMerge(
            InDetTrackHoleSearchToolCfg(flags)),
        ROTCreator = result.popToolsAndMerge(
            InDetSCT_ClusterOnTrackToolCfg(flags)),
        ResPullCalc = result.popToolsAndMerge(
            ResidualPullCalculatorCfg(flags))
    )
 
    # # If for some really obscure reason you need to instantiate an algorithm
    # # yourself, the AddAlgorithm method will still configure the base 
    # # properties and add the algorithm to the monitoring sequence.
    # helper.AddAlgorithm(myExistingAlg)
 
 
    
    myMonAlg.TriggerChain = ''
 
    
 
    # set up geometry / conditions
    from LumiBlockComps.BunchCrossingCondAlgConfig import BunchCrossingCondAlgCfg
    result.merge(BunchCrossingCondAlgCfg(flags))
    from MagFieldServices.MagFieldServicesConfig import AtlasFieldCacheCondAlgCfg
    result.merge(AtlasFieldCacheCondAlgCfg(flags))
    from SCT_ConditionsAlgorithms.SCT_ConditionsAlgorithmsConfig import SCT_DetectorElementCondAlgCfg
    result.merge(SCT_DetectorElementCondAlgCfg(flags))
 
    # Add a generic monitoring tool (a "group" in old language). The returned 
    # object here is the standard GenericMonitoringTool.
 
    from ROOT import SCT_Monitoring as sctMon
 
    myMonGroup = [
        helper.addGroup(
            myMonAlg,
            "SCTHitEffMonitorEC",
            "SCT/SCTEC/"
        ),
        helper.addGroup(
            myMonAlg,
            "SCTHitEffMonitorB",
            "SCT/SCTB/"
        ),
        helper.addGroup(
            myMonAlg,
            "SCTHitEffMonitorEA",
            "SCT/SCTEA/"
        ),
        helper.addGroup(
            myMonAlg,
            "SCTHitEffMonitor",
            "SCT/GENERAL/"
        )
    ]
 
    
    
    # Conversion of ROOT.vector of ROOT.TString to list of str
    subDetName = []
    for i in range(len(sctMon.subDetName)):
        subDetName.append(sctMon.subDetName[i].Data())
 
    mapName = ["m_eff_", "eff_", "p_eff_"] 
    ineffmapName = ["ineffm_", "ineff_", "ineffp_"] 
 
    sumEff = ["summaryeffm", "summaryeff", "summaryeffp"]
    sumEffTitle = ["Summary Module Efficiency in Endcap C",
                   "Summary Module Efficiency in Barrel",
                   "Summary Module Efficiency in Endcap A"]
 
    limit = [sctMon.N_DISKS*2, sctMon.N_BARRELS*2, sctMon.N_DISKS*2]
 
    # GENERAL
    myMonGroup[sctMon.GENERAL_INDEX].defineHistogram(varname= "isub, eff;" + "SctTotalEff",
                                                     type= "TProfile",
                                                     title= "SCT Total Efficiency",
                                                     path="eff",
                                                     xbins=sctMon.N_REGIONS,
                                                     xmin=0.,
                                                     xmax=sctMon.N_REGIONS,
                                                     xlabels=subDetName,
                                                     opt='kAlwaysCreate')
 
    myMonGroup[sctMon.GENERAL_INDEX].defineHistogram(varname= "isub, eff;" + "SctTotalEffBCID",
                                                     type= "TProfile",
                                                     title= "SCT Total Efficiency for First BCID",
                                                     path="eff",
                                                     xbins=sctMon.N_REGIONS,
                                                     xmin=0.,
                                                     xmax=sctMon.N_REGIONS,
                                                     xlabels=subDetName,
                                                     cutmask="isFirstBCID",
                                                     opt='kAlwaysCreate')
 
    myMonGroup[sctMon.GENERAL_INDEX].defineHistogram(varname= "sideHash, eff;" + "effHashCode",
                                                     type= "TProfile",
                                                     title= "Efficiency vs module Hash code" + ";Module Hash Code;Efficiency",
                                                     path="eff",
                                                     xbins=sctMon.n_mod[sctMon.GENERAL_INDEX] * 2,
                                                     xmin=-0.5,
                                                     xmax=sctMon.n_mod[sctMon.GENERAL_INDEX] * 2 -0.5,
                                                     opt='kAlwaysCreate')
                
    myMonGroup[sctMon.GENERAL_INDEX].defineHistogram(varname= "LumiBlock, eff;" + "effLumiBlock",
                                                     type= "TProfile",
                                                     title= "Efficiency vs Luminosity block"+";;Efficiency",
                                                     path="eff",
                                                     xbins=sctMon.NBINS_LBs,
                                                     xmin=0.5,
                                                     xmax=sctMon.NBINS_LBs + 0.5,
                                                     opt='kAlwaysCreate')
 
    
 
    # SCTEC, SCTB, SCTEA
    for isub in range(sctMon.N_REGIONS):
        profileLabels = list(range(limit[isub]))
        for k in range(limit[isub]):
            profileLabels[k] = dedicatedTitle(k, isub)
        # Efficiency
        myMonGroup[isub].defineHistogram(varname= "layerPlusHalfSide, eff;" + sumEff[isub],
                                         type= "TProfile",
                                         title= sumEffTitle[isub]+ ";;Efficiency",
                                         path="eff",
                                         xbins=2*sctMon.n_layers[isub],
                                         xmin=0.,
                                         xmax=sctMon.n_layers[isub],
                                         xlabels=profileLabels,
                                         opt='kAlwaysCreate')
        # Efficiency for first BCIDs
        myMonGroup[isub].defineHistogram(varname= "layerPlusHalfSide, eff;" + sumEff[isub] + "BCID",
                                         type= "TProfile",
                                         title= sumEffTitle[isub]+" for First BC" + ";;Efficiency", 
                                         path="eff",
                                         xbins=2*sctMon.n_layers[isub],
                                         xmin=0.,
                                         xmax=sctMon.n_layers[isub],
                                         xlabels=profileLabels,
                                         cutmask="isFirstBCID",
                                         opt='kAlwaysCreate')
        # Efficiency as a function of LB
        myMonGroup[isub].defineHistogram(varname= "LumiBlock, eff;"+"effLumiBlock", #different names for fill
                                         type= "TProfile",
                                         title= "Efficiency vs Luminosity block in "+subDetName[isub]+";Luminosity block"+";Efficiency",
                                         path="eff",
                                         xbins=sctMon.NBINS_LBs,
                                         xmin=0.5,
                                         xmax=sctMon.NBINS_LBs + 0.5,
                                         opt='kAlwaysCreate')
 
        # Disks for SCTEC and SCTEA and layers for SCTB
        for layer_disk in range(sctMon.n_layers[isub]):
            for side in range(2):
                etaPhiSuffix = "_" + str(layer_disk) + "_" + str(side)
                effName = mapName[isub] + str(layer_disk) + "_" + str(side)
                ineffName = ineffmapName[isub] + str(layer_disk) + "_" + str(side)
                # Efficiency
                myMonGroup[isub].defineHistogram(varname="ieta" + etaPhiSuffix + ",iphi" + etaPhiSuffix + ",eff;" + effName,
                                                 type= "TProfile2D",
                                                 title="Hit efficiency of" + sctMon.layerName[isub].Data() + str(layer_disk) + " / side " + str(side) + " in " + subDetName[isub] + ";Index in the direction of #eta;Index in the direction of #phi",
                                                 path="eff",
                                                 xbins=sctMon.n_etabins[isub], xmin=sctMon.f_etabin[isub] - .5, xmax=sctMon.l_etabin[isub] + .5,
                                                 ybins=sctMon.n_phibins[isub], ymin=sctMon.f_phibin[isub] - .5, ymax=sctMon.l_phibin[isub] + .5,
                                                 opt='kAlwaysCreate')
                # Efficiency for first BCIDs
                myMonGroup[isub].defineHistogram(varname="ieta" + etaPhiSuffix + ",iphi" + etaPhiSuffix + ",eff;" + effName + "_bcid",
                                                 type= "TProfile2D",
                                                 title="Hit efficiency of" + sctMon.layerName[isub].Data() + str(layer_disk) + " / side " + str(side) + " in " + subDetName[isub] +  " for first BCID" + ";Index in the direction of #eta;Index in the direction of #phi",
                                                 path="eff",
                                                 xbins=sctMon.n_etabins[isub], xmin=sctMon.f_etabin[isub] - .5, xmax=sctMon.l_etabin[isub] + .5,
                                                 ybins=sctMon.n_phibins[isub], ymin=sctMon.f_phibin[isub] - .5, ymax=sctMon.l_phibin[isub] + .5,
                                                 cutmask="isFirstBCID",
                                                 opt='kAlwaysCreate')
                # Inefficiency
                myMonGroup[isub].defineHistogram(varname="ieta" + etaPhiSuffix + ",iphi" + etaPhiSuffix  + ",ineff;" + ineffName,
                                                 type= "TProfile2D",
                                                 title="Hit inefficiency of" + sctMon.layerName[isub].Data() + str(layer_disk) + " / side " + str(side) + " in " + subDetName[isub] + ";Index in the direction of #eta;Index in the direction of #phi",
                                                 path="eff",
                                                 xbins=sctMon.n_etabins[isub], xmin=sctMon.f_etabin[isub] - .5, xmax=sctMon.l_etabin[isub] + .5,
                                                 ybins=sctMon.n_phibins[isub], ymin=sctMon.f_phibin[isub] - .5, ymax=sctMon.l_phibin[isub] + .5,
                                                 opt='kAlwaysCreate')
 
    # Merge with result object and return
    result.merge(helper.result())
    return result