Inheritance diagram for PXDHotPixelMaskCalibrationChecker:

Public Member Functions
	__init__ (self)

	define_graphs (self)

	fill_graphs (self)

	draw_plots (self)

	initialize (self, checker_list=[])

	valid (self)

	beginRun (self)

	terminate (self)

Public Attributes
	hotdead_graphs = get_sensor_graphs("Hot/Dead pixels [%]")
	Dictionary to save TGraphs of hot/dead pixel fractions with sensor id as key.

	occupancy_masked_graphs = get_sensor_graphs("Occupancy (With Mask) [%]")
	Dictionary to save TGraph of module occupancy (with mask)

	occupancy_no_mask_graphs = get_sensor_graphs("Occupancy (No Mask) [%]")
	Dictionary to save TGraph of module occupancy (without mask)

dict	sum_graphs = {}
	Dictionary of summary TGraphs and their TLegend.

dict	condition_checkers = {}
	condition checkers which are associated to this calibration.

Detailed Description

Checker for PXDHotPixelMaskCalibration

Definition at line 117 of file calibration_checker.py.

Constructor & Destructor Documentation

◆ init()

__init__ ( self )

Initial with related condition db object types

Definition at line 122 of file calibration_checker.py.

    def __init__(self):
        """
        Initial with related condition db object types
        """
        super().__init__(objType_list=[
            Belle2.PXDMaskedPixelPar,
            Belle2.PXDDeadPixelPar,
            Belle2.PXDOccupancyInfoPar,
        ])
 

Member Function Documentation

◆ beginRun()

beginRun ( self )

inherited

function to be executed at the beginning of a run

Definition at line 97 of file calibration_checker.py.

    def beginRun(self):
        """
        function to be executed at the beginning of a run
        """
        # \cond false positive doxygen warning
        if self.valid:
            self.fill_graphs()
        # \endcond
 

◆ define_graphs()

define_graphs ( self )

Define TGraphs for filling

Reimplemented from CalibrationCheckerBase.

Definition at line 132 of file calibration_checker.py.

    def define_graphs(self):
        """
        Define TGraphs for filling
        """
        
        self.hotdead_graphs = get_sensor_graphs("Hot/Dead pixels [%]")
        
        self.occupancy_masked_graphs = get_sensor_graphs("Occupancy (With Mask) [%]")
        
        self.occupancy_no_mask_graphs = get_sensor_graphs("Occupancy (No Mask) [%]")
        
        self.sum_graphs = {}
        # TLegend
        legsum = ROOT.TLegend(0.75, 0.65, 0.90, 0.85)
        legsum.SetFillStyle(0)
        legsum.SetBorderSize(0)
        legsum.SetTextFont(43)
        legsum.SetTextSize(18)
        legocc = deepcopy(legsum)
        self.sum_graphs["TLegends"] = {"sum": legsum, "occ": legocc}
 
        for category, style_dict in plot_type_dict.items():
            agraph = ROOT.TGraph()
            agraph.SetLineColor(style_dict["color"])
            agraph.SetMarkerColor(style_dict["color"])
            agraph.SetMarkerStyle(20)
            if category == "hot_dead":
                agraph.GetYaxis().SetTitle('Total Hot/Dead pixels [%]')
                agraph.SetMaximum(style_dict["max"])
            elif category == "occ_no_mask":
                agraph.GetYaxis().SetTitle('Average occupancy [%]')
                agraph.SetMaximum(style_dict["max"])
            agraph.GetXaxis().SetTitle('run #')
            agraph.GetYaxis().SetTitleOffset(0.9)
            agraph.SetMinimum(0.0)
            self.sum_graphs[category] = agraph
 

◆ draw_plots()

draw_plots ( self )

Generate summary plots from TGraphs of all condition checkers

Reimplemented from CalibrationCheckerBase.

Definition at line 233 of file calibration_checker.py.

    def draw_plots(self):
        """
        Generate summary plots from TGraphs of all condition checkers
        """
 
        # Reuse masker checker and replace its graphs
        # checker = deepcopy(self.condition_checkers[PXDMaskedPixelPar])
        # checker.tfile = self.condition_checkers[PXDMaskedPixelPar].tfile
        checker = self.condition_checkers[PXDMaskedPixelPar]
 
        # Create a TCanvas under the file folder
        checker.tfile.cd()
        canvas = ROOT.TCanvas('c_pxd', 'c_pxd', 1000, 400)
        # canvas.SetLeftMargin(0.09)
        # canvas.SetRightMargin(0.05)
 
        # Hot/dead pixel masking
        checker.graphs = self.hotdead_graphs
        checker.draw_plots(
            canvas=canvas, cname="PXDHotnDeadPixel", ymin=0., ymax=plot_type_dict["hot_dead"]["max"])
        checker.draw_plots(canvas=canvas, cname="PXDHotnDeadPixel", ymin=0., ymax=None, logy=True)
        canvas.Write()
        # Occupancy with/without Mask
        checker.graphs = self.occupancy_masked_graphs
        checker.draw_plots(
            canvas=canvas, cname="PXDOccupancyWithMask", ymin=0., ymax=plot_type_dict["occ_masked"]["max"])
        checker.draw_plots(canvas=canvas, cname="PXDOccupancyWithMask", ymin=0., ymax=None, logy=True)
        canvas.Write()
        checker.graphs = self.occupancy_no_mask_graphs
        checker.draw_plots(
            canvas=canvas, cname="PXDOccupancyNoMask", ymin=0., ymax=plot_type_dict["occ_no_mask"]["max"])
        checker.draw_plots(canvas=canvas, cname="PXDOccupancyNoMask", ymin=0., ymax=None, logy=True)
        canvas.Write()
 
        # checker.save_canvas(canvas, "PXDHotnDeadPixel")
 
        # Summary plots
        #   Total Masking plots
        canvas.Clear()
        g1 = self.sum_graphs["hot_dead"]
        g2 = self.sum_graphs["hot"]
        g3 = self.sum_graphs["dead"]
        leg = self.sum_graphs["TLegends"]["sum"]
        g1.Draw("AP")
        g2.Draw("P same")
        g3.Draw("P same")
        leg.AddEntry(g1, 'Hot+Dead pixels', 'p')
        leg.AddEntry(g2, 'Hot pixels', 'p')
        leg.AddEntry(g3, 'Dead pixels', 'p')
        leg.Draw()
        checker.save_canvas(canvas, "PXDTotalHotnDeadPixel", logy=True)
        canvas.Write()
        checker.save_canvas(canvas, "PXDTotalHotnDeadPixel", logy=False)
        #   Average Occupancy plots
        canvas.Clear()
        g1 = self.sum_graphs["occ_no_mask"]
        g2 = self.sum_graphs["occ_masked"]
        leg = self.sum_graphs["TLegends"]["occ"]
        g1.Draw("AP")
        g2.Draw("P same")
        leg.AddEntry(g1, 'No Mask', 'p')
        leg.AddEntry(g2, 'With Mask', 'p')
        leg.Draw()
        checker.save_canvas(canvas, "PXDTotalOccupancy", logy=True)
        canvas.Write()
        checker.save_canvas(canvas, "PXDTotalOccupancy", logy=False)

◆ fill_graphs()

fill_graphs ( self )

Fill TGraphs, will be executed for each run

Reimplemented from CalibrationCheckerBase.

Definition at line 169 of file calibration_checker.py.

    def fill_graphs(self):
        """
        Fill TGraphs, will be executed for each run
        """
        dead_checker = self.condition_checkers[PXDDeadPixelPar]
        masked_graphs = self.condition_checkers[PXDMaskedPixelPar].graphs
        dead_graphs = self.condition_checkers[PXDDeadPixelPar].graphs
        occ_graphs = self.condition_checkers[PXDOccupancyInfoPar].graphs
 
        current_run = dead_checker.run
        saved_run = -1  # to be updated
        saved_run_occ = -1  # to be updated
        sum_hotfraction = 0.
        sum_deadfraction = 0.
        sum_hotdeadfraction = 0.
        sum_occupancymasked = 0.
        sum_occupancynomask = 0.
        for sensorID in sensorID_list:
            numID = sensorID.getID()
            # This function is executed just after filling the condition checker graphs, so we don't need a python loop!
            g1 = masked_graphs[numID]
            g2 = dead_graphs[numID]
            g3 = occ_graphs[numID]
            # If two runs have the same constants, only results from the 1st run will be saved.
            hotfraction = g1.GetPointY(g1.GetN() - 1)
            deadfraction = g2.GetPointY(g2.GetN() - 1)
            occupancymasked = g3.GetPointY(g3.GetN() - 1)
            occupancynomask = 0.
            # Masked hot pixels and dead pixels could be updated for different runs.
            saved_run = max(g1.GetPointX(g1.GetN() - 1), g2.GetPointX(g2.GetN() - 1))
            saved_run_occ = max(saved_run, g3.GetPointX(g3.GetN() - 1))
            if current_run == saved_run:
                self.hotdead_graphs[numID].append(current_run, hotfraction + deadfraction)
                sum_hotfraction += hotfraction
                sum_deadfraction += deadfraction
                sum_hotdeadfraction += hotfraction + deadfraction
            if current_run == saved_run_occ:
                # occupancy correction (it's overestiamting occ_masked?)
                # By default, both occ and fractions are in percentage.
                if deadfraction != 100.:
                    occupancynomask = (occupancymasked + hotfraction) / (1. - deadfraction / 100)
                    occupancymasked = occupancymasked / (1. - deadfraction / 100)
                self.occupancy_no_mask_graphs[numID].append(current_run, occupancynomask)
                self.occupancy_masked_graphs[numID].append(current_run, occupancymasked)
                sum_occupancymasked += occupancymasked
                sum_occupancynomask += occupancynomask
            # print(f"hotfraction:{hotfraction}, deadfraction: {deadfraction}")
            # print(f"occ:{occupancymasked}, occ_no_mask:{occupancynomask}")
            # rawOcc = self.condition_checkers[PXDOccupancyInfoPar].dbObj.getOccupancy(numID)
            # print(f"Raw occ: {rawOcc}")
            # print(f"sum_hotfraction:{sum_hotfraction}, sum_deadfraction: {sum_deadfraction}")
            # print(f"sum_occ:{sum_occupancymasked}, sum_occ_no_mask:{sum_occupancynomask}")
 
        nSensors = len(sensorID_list)
        if current_run == saved_run:
            self.sum_graphs["hot"].append(current_run, sum_hotfraction / nSensors)
            self.sum_graphs["dead"].append(current_run, sum_deadfraction / nSensors)
            self.sum_graphs["hot_dead"].append(current_run, sum_hotdeadfraction / nSensors)
 
        nSensors = nSensors - len(dead_checker.dbObj.getDeadSensorMap())
        if current_run == saved_run_occ and nSensors > 0:
            self.sum_graphs["occ_masked"].append(current_run, sum_occupancymasked / nSensors)
            self.sum_graphs["occ_no_mask"].append(current_run, sum_occupancynomask / nSensors)
 

◆ initialize()

initialize	(		self,
			checker_list = [] )

inherited

Initialize condition_checker according to condition objType
Parameters:
  checker_list (list): list of objType checkers

Definition at line 50 of file calibration_checker.py.

    def initialize(self, checker_list=[]):
        """
        Initialize condition_checker according to condition objType
        Parameters:
          checker_list (list): list of objType checkers
        """
        checker = None
        for checker in checker_list:
            for objType in self.condition_checkers.keys():
                if objType == checker.objType:
                    self.condition_checkers[objType] = checker
        # \cond false positive doxygen warning
        if self.valid:
            checker.tfile.cd()
            print(f"root file path: {checker.tfile}")
            self.define_graphs()
        # \endcond
 

◆ terminate()

terminate ( self )

inherited

Execute when terminating a basf2 module.
All required TGraphs should be ready at this stage.

Definition at line 106 of file calibration_checker.py.

    def terminate(self):
        """
        Execute when terminating a basf2 module.
        All required TGraphs should be ready at this stage.
        """
        # \cond false positive doxygen warning
        if self.valid:
            self.draw_plots()
        # \endcond
 
 

◆ valid()

valid ( self )

inherited

valid flag

Definition at line 69 of file calibration_checker.py.

    def valid(self):
        """
        valid flag
        """
        if None in self.condition_checkers.values():
            # do nothing if any of the condition checkers is missing
            return False
        else:
            return True
 

Member Data Documentation

◆ condition_checkers

dict condition_checkers = {}

inherited

condition checkers which are associated to this calibration.

Parameters:
  objType_list (list): a list of db objects used as keys to their checker.
    e.g., [Belle2.PXDMaskedPixelPar, Belle2.PXDDeadPixelPar]

Definition at line 46 of file calibration_checker.py.

◆ hotdead_graphs

hotdead_graphs = get_sensor_graphs("Hot/Dead pixels [%]")

Dictionary to save TGraphs of hot/dead pixel fractions with sensor id as key.

Definition at line 137 of file calibration_checker.py.

◆ occupancy_masked_graphs

occupancy_masked_graphs = get_sensor_graphs("Occupancy (With Mask) [%]")

Dictionary to save TGraph of module occupancy (with mask)

Definition at line 139 of file calibration_checker.py.

◆ occupancy_no_mask_graphs

occupancy_no_mask_graphs = get_sensor_graphs("Occupancy (No Mask) [%]")

Dictionary to save TGraph of module occupancy (without mask)

Definition at line 141 of file calibration_checker.py.

◆ sum_graphs

dict sum_graphs = {}

Dictionary of summary TGraphs and their TLegend.

Definition at line 143 of file calibration_checker.py.

The documentation for this class was generated from the following file:

pxd/scripts/pxd/calibration/calibration_checker.py

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ beginRun()

◆ define_graphs()

◆ draw_plots()

◆ fill_graphs()

◆ initialize()

◆ terminate()

◆ valid()

Member Data Documentation

◆ condition_checkers

◆ hotdead_graphs

◆ occupancy_masked_graphs

◆ occupancy_no_mask_graphs

◆ sum_graphs

◆ init()