ClusterEfficiency Class Reference

Inheritance diagram for ClusterEfficiency:

Public Member Functions
	initialize (self)
	terminate (self)
	fill_truehits (self, phi, p, truehits)
	event (self)

Public Attributes
	rfile = ROOT.TFile("ClusterEfficiency.root", "RECREATE")
	Output file to store all plots.
list	profiles = []
	flat list of all profiles for easy access
dict	eff = {}
	layer/momentum hierarchy of all profiles

Detailed Description

Plot Efficiency to find a U and V cluster for each given truehit.

Definition at line 36 of file ClusterEfficiency.py.

Member Function Documentation

event()

event

(

self

)

Update the efficiencies by iterating over all primary particles

Definition at line 151 of file ClusterEfficiency.py.

    def event(self):
        """
        Update the efficiencies by iterating over all primary particles
        """
        mcparticles = Belle2.PyStoreArray("MCParticles")
        for mcp in mcparticles:
            # we only look at primary particles
            if not mcp.hasStatus(1):
                continue
 
            # let's get the momentum and determine which of the ones we wanted
            # to generate it is
            p = mcp.getMomentum()
            p_gen = None
            for i in momenta:
                if abs(p.R() - i) < 0.05:
                    p_gen = i
                    break
 
            # meh, something strange with the momentum, ignore this one
            if p_gen is None:
                b2.B2WARNING(f"Strange particle momentum: {p.R():f}, expected one of {', '.join('' for p in momenta)}")
                continue
 
            # and check all truehits
            pxdtruehits = mcp.getRelationsTo("PXDTrueHits")
            self.fill_truehits(math.degrees(p.Phi()), p_gen, pxdtruehits)
            svdtruehits = mcp.getRelationsTo("SVDTrueHits")
            self.fill_truehits(math.degrees(p.Phi()), p_gen, svdtruehits)
 
 
# Now let's create a path to simulate our events. We need a bit of statistics but
# that's not too bad since we only simulate single muons

fill_truehits()

fill_truehits	(		self,
			phi,
			p,
			truehits )

Loop over all truehits for a track with the given angle phi and momentum
p and update the efficiency profiles.

Definition at line 110 of file ClusterEfficiency.py.

    def fill_truehits(self, phi, p, truehits):
        """
        Loop over all truehits for a track with the given angle phi and momentum
        p and update the efficiency profiles.
        """
        # iterate over all truehits and look for the clusters
        for i, truehit in enumerate(truehits):
            # we ignore all truehits which have an negative weight
            if truehits.weight(i) < 0:
                continue
 
            # get layer number and a list of all clusters related to the truehit
            layer = truehit.getSensorID().getLayerNumber()
            if isinstance(truehit, Belle2.SVDTrueHit):
                is_pxd = False
                clusters = truehit.getRelationsFrom("SVDClusters")
            else:
                is_pxd = True
                clusters = truehit.getRelationsFrom("PXDClusters")
 
            # now check if we find a cluster
            has_cluster = {False: 0, True: 0}
            for j, cls in enumerate(clusters):
                # we ignore all clusters where less then 100 electrons come from
                # our truehit
                if clusters.weight(j) < 100:
                    continue
 
                if is_pxd:
                    # for pxt we always have both directions so set efficiency
                    # for this TrueHit to 1
                    has_cluster[True] = 1
                    has_cluster[False] = 1
                else:
                    # for SVD we remember that we set the efficiency for the
                    # direction of the cluster
                    has_cluster[cls.isUCluster()] = 1
 
            # and we fill the profile
            self.eff[layer][p].Fill(phi, has_cluster[True] & has_cluster[False])
 

initialize()

initialize

(

self

)

Create ROOT TProfiles for all layers and momenta.

Definition at line 41 of file ClusterEfficiency.py.

    def initialize(self):
        """
        Create ROOT TProfiles for all layers and momenta.
        """
 
        # let's create a root file to store all profiles
        
        self.rfile = ROOT.TFile("ClusterEfficiency.root", "RECREATE")
        self.rfile.cd()
        
        self.profiles = []
        
        self.eff = {}
 
        def profile(name, title, text, contact):
            """small helper function to create a phi profile and set the names
            and descriptions"""
            prof = ROOT.TProfile(name, title, 60, -180, 180)
            prof.GetListOfFunctions().Add(ROOT.TNamed("Description", text))
            prof.GetListOfFunctions().Add(ROOT.TNamed("Contact", contact))
            prof.GetListOfFunctions().Add(ROOT.TNamed("Check", "Should be close to 1 everywhere"))
            # make a list of all profiles
            self.profiles.append(prof)
            return prof
 
        # name, title and description templates
        prof_name = "ClusterEfficiency_layer{layer}_{p:.1f}GeV"
        prof_title = "Cluster Efficiency in #phi, layer={layer}, "\
            + "p={p:.1f} GeV;#phi in degrees;efficiency"
        prof_text = "Efficiency to find a U and V cluster for any given truehit "\
            + "in layer {layer} when simulation muons with p={p:.1f} GeV uniformly "\
            + "in phi and theta={theta[0]}+-{theta[1]} degree. phi is the angle "\
            + "of the generated particle, not the truehit position."
        # contact person for PXD (layer<3 = True) or SVD (layer<3 = False)
        prof_contact = {
            True: "Benjamin Schwenker <Benjamin.Schwenker@phys.uni-goettingen.de>",
            False: "Andrzej Bozek <bozek@belle2.ifj.edu.pl>",
        }
 
        # create all profiles
        for layer in range(1, 7):
            self.eff[layer] = {}
            for p in momenta:
                name = prof_name.format(p=p, layer=layer)
                title = prof_title.format(p=p, layer=layer)
                text = prof_text.format(p=p, layer=layer, theta=theta_params)
                self.eff[layer][p] = profile(name, title, text, prof_contact[layer < 3])
 

terminate()

terminate

(

self

)

Format all profiles and write the ROOT file.

Definition at line 89 of file ClusterEfficiency.py.

    def terminate(self):
        """
        Format all profiles and write the ROOT file.
        """
        # determine min value in all profiles to set all profiles to a common
        # range. We always want to show at least the range from 0.9
        minVal = 0.9
        for prof in self.profiles:
            minBin = prof.GetMinimumBin()
            # minimum value is bin content - error and a 5% margin
            minVal = min(minVal, (prof.GetBinContent(minBin) - prof.GetBinError(minBin)) * 0.95)
 
        # no let's set the range of all profiles to be equal
        for prof in self.profiles:
            prof.SetMinimum(max(0, minVal))
            prof.SetMaximum(1.02)
            prof.SetStats(False)
 
        self.rfile.Write()
        self.rfile.Close()
 

Member Data Documentation

eff

dict eff = {}

layer/momentum hierarchy of all profiles

Definition at line 53 of file ClusterEfficiency.py.

profiles

list profiles = []

flat list of all profiles for easy access

Definition at line 51 of file ClusterEfficiency.py.

rfile

rfile = ROOT.TFile("ClusterEfficiency.root", "RECREATE")

Output file to store all plots.

Definition at line 48 of file ClusterEfficiency.py.

---

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

• vxd/validation/ClusterEfficiency.py