SCTHitEffMonAlg.py

Go to the documentation of this file.

#
#  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
#
'''@file SCTHitEffMonAlg.py
@author Ken Kreul
@date 2019-10-30
@brief Based on AthenaMonitoring/ExampleMonitorAlgorithm.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)
 
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
 
if __name__ == "__main__": 
    # Setup logs
    from AthenaCommon.Logging import log
    from AthenaCommon.Constants import INFO
    log.setLevel(INFO)
 
    # Set the Athena configuration flags
    from AthenaConfiguration.AllConfigFlags import initConfigFlags
    flags = initConfigFlags()
    flags.Input.Files = ["/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/RecExRecoTest/mc16_13TeV.361022.Pythia8EvtGen_A14NNPDF23LO_jetjet_JZ2W.recon.ESD.e3668_s3170_r10572_homeMade.pool.root"]
    flags.Input.isMC = True
    flags.Output.HISTFileName = 'SCTHitEffMonOutput.root'
    flags.GeoModel.Align.Dynamic = False
    flags.Detector.GeometryID = True
    flags.Detector.GeometryPixel = True
    flags.Detector.GeometrySCT = True
    flags.Detector.GeometryTRT = True
    flags.lock()
 
    # Initialize configuration object, add accumulator, merge, and run.
    from AthenaConfiguration.MainServicesConfig import MainServicesCfg 
    from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
    cfg = MainServicesCfg(flags)
    cfg.merge(PoolReadCfg(flags))
 
    cfg.merge(SCTHitEffMonAlgConfig(flags))
 
    cfg.run()