Public Member Functions
	__init__ (self, filename, label=None, color_index=0, additional_information=None)

	get_figure_of_merits (self)

	get_figures_of_merit_latex (self)

	plot_efficiency_point (self)

	grouped_by_pt_data (self, mc_data=None)

	plot (self, data_x, data_y, loc=4, yerr=None)

	plot_finding_efficiency (self, data=None)

	plot_hit_efficiency (self, data=None)

	print_useful_information (self)

	append_to_dataframe (self, df)

Static Public Member Functions
	from_calculations (calculations, key="output_file_name", parameter_part=None)

Public Attributes
	filename = filename
	The root filename.

	pr_data = uproot.open(self.filename)["pr_tree/pr_tree"].arrays(library="pd")
	The pr data.

	mc_data = uproot.open(self.filename)["mc_tree/mc_tree"].arrays(library="pd")
	the mc data

	mc_prompts = self.mc_data[self.mc_data.is_prompt == 1]
	the mc prompt data

	pr_prompts = self.pr_data[self.pr_data.is_prompt == 1]
	the pr prompt data

	label = label
	the label

	color = colors[color_index % len(colors)]
	the color index

	finding_efficiency = None
	the finding efficiency

	hit_efficiency = None
	the hit efficiency

	fake_rate = None
	the fake rate

	clone_rate = None
	the clone rate

	additional_information = additional_information
	the additional information

Detailed Description

This class represents a loaded validation root file. It has methods for plotting the typically needed graphs.

Definition at line 15 of file root_handler.py.

Constructor & Destructor Documentation

◆ init()

__init__	(	self,
		filename,
		label = None,
		color_index = 0,
		additional_information = None )

Create a new validation result from the given filename.
   Additional options for plotting (e.g. color or label) can be given.

Definition at line 18 of file root_handler.py.

    def __init__(self, filename, label=None, color_index=0, additional_information=None):
        """Create a new validation result from the given filename.
           Additional options for plotting (e.g. color or label) can be given."""
        
        self.filename = filename
        
        self.pr_data = uproot.open(self.filename)["pr_tree/pr_tree"].arrays(library="pd")
        self.pr_data["is_prompt"] = (
            np.sqrt(self.pr_data.x_truth ** 2 + self.pr_data.y_truth ** 2) < 0.5) & (self.pr_data.is_primary == 1)
        
        self.mc_data = uproot.open(self.filename)["mc_tree/mc_tree"].arrays(library="pd")
        self.mc_data["is_prompt"] = (
            np.sqrt(self.mc_data.x_truth ** 2 + self.mc_data.y_truth ** 2) < 0.5) & (self.mc_data.is_primary == 1)
 
        self.mc_prompts = self.mc_data[self.mc_data.is_prompt == 1]
        
        self.pr_prompts = self.pr_data[self.pr_data.is_prompt == 1]
 
        import seaborn as sb
 
        colors = sb.color_palette()
 
        self.label = label
        
        self.color = colors[color_index % len(colors)]
 
        self.finding_efficiency = None
        
        self.hit_efficiency = None
        
        self.fake_rate = None
        
        self.clone_rate = None
        self.get_figure_of_merits()
 
        self.additional_information = additional_information

Member Function Documentation

◆ append_to_dataframe()

append_to_dataframe	(		self,
			df )

Append the main results to a already consisting dataframe.

Definition at line 179 of file root_handler.py.

    def append_to_dataframe(self, df):
        """Append the main results to a already consisting dataframe."""
        result = {"finding_efficiency": self.finding_efficiency,
                  "hit_efficiency": self.hit_efficiency,
                  "clone_rate": self.clone_rate,
                  "fake_rate": self.fake_rate,
                  "file_name": self.filename}
        if self.additional_information:
            result.update(self.additional_information)
        return df.append(result, ignore_index=True)

◆ from_calculations()

from_calculations	(	calculations,
		key = "output_file_name",
		parameter_part = None )

static

Create validation results from an ipython calculation.

Definition at line 60 of file root_handler.py.

    def from_calculations(calculations, key="output_file_name", parameter_part=None):
        """Create validation results from an ipython calculation."""
        if parameter_part:
            return [
                TrackingValidationResult(
                    c.get(key),
                    label=c.get_parameters()[parameter_part],
                    color_index=i) for i,
                c in enumerate(calculations)]
        else:
            return [
                TrackingValidationResult(
                    c.get(key),
                    label=c.get_parameters(),
                    color_index=i) for i,
                c in enumerate(calculations)]
 

◆ get_figure_of_merits()

get_figure_of_merits ( self )

Return the figures of merit from the file. Mostly used for internal setting of the properties.

Definition at line 77 of file root_handler.py.

    def get_figure_of_merits(self):
        """Return the figures of merit from the file. Mostly used for internal setting of the properties."""
        if self.finding_efficiency is None:
            overview = uproot.open(
                self.filename)["ExpertMCSideTrackingValidationModule_overview_figures_of_merit"].arrays(
                library="pd")
            self.finding_efficiency = overview.finding_efficiency[0]
            self.hit_efficiency = overview.hit_efficiency[0]
 
            overview = uproot.open(
                self.filename)["ExpertPRSideTrackingValidationModule_overview_figures_of_merit"].arrays(
                library="pd")
            self.clone_rate = overview.clone_rate[0]
            self.fake_rate = overview.fake_rate[0]
 
        return dict(finding_efficiency=self.finding_efficiency,
                    hit_efficiency=self.hit_efficiency,
                    clone_rate=self.clone_rate,
                    fake_rate=self.fake_rate)
 

◆ get_figures_of_merit_latex()

get_figures_of_merit_latex ( self )

Print out the figures of merit as a LaTeX-ready table.

Definition at line 97 of file root_handler.py.

    def get_figures_of_merit_latex(self):
        """Print out the figures of merit as a LaTeX-ready table."""
        results = self.get_figure_of_merits()
 
        latex_string = r'\begin{table}' + "\n"
        latex_string += r'  \begin{tabular}{cc} \toprule' + "\n"
        latex_string += r'    & \\ \midrule' + "\n"
        latex_string += r'    Finding Efficiency & ' + f"{100 * results['finding_efficiency']:.2f}" + r' \% \\' + "\n"
        latex_string += r'    Hit Efficiency & ' + f"{100 * results['hit_efficiency']:.2f}" + r' \% \\' + "\n"
        latex_string += r'    Fake Rate & ' + f"{100 * results['fake_rate']:.2f}" + r' \% \\' + "\n"
        latex_string += r'    Clone Rate & ' + f"{100 * results['clone_rate']:.2f}" + r' \% \\ \bottomrule' + "\n"
        latex_string += r'  \end{tabular}' + "\n"
        latex_string += r'\end{table}'
 
        return latex_string
 

◆ grouped_by_pt_data()

grouped_by_pt_data	(		self,
			mc_data = None )

Convenience function to return the input data (or the internal mc_data) grouped by pt.

Definition at line 120 of file root_handler.py.

    def grouped_by_pt_data(self, mc_data=None):
        """Convenience function to return the input data (or the internal mc_data) grouped by pt."""
        if mc_data is None:
            mc_data = self.mc_data
 
        pt_values = pd.cut(mc_data.pt_truth, np.linspace(mc_data.pt_truth.min(), mc_data.pt_truth.max(), 10))
        grouped = mc_data.groupby(pt_values)
 
        return grouped
 

◆ plot()

plot	(	self,
		data_x,
		data_y,
		loc = 4,
		yerr = None )

Plot data_y over data_x with the correct settings for this result. Mostly used internally.

Definition at line 130 of file root_handler.py.

    def plot(self, data_x, data_y, loc=4, yerr=None):
        """Plot data_y over data_x with the correct settings for this result. Mostly used internally."""
        import matplotlib.pyplot as plt
        if yerr is not None:
            plt.errorbar(data_x, data_y, ls="-", marker="o",
                         color=self.color, label=self.label, yerr=yerr, lw=4)
        else:
            plt.plot(data_x, data_y, ls="-", marker="o",
                     color=self.color, label=self.label, lw=4)
 
        if self.label is not None:
            plt.legend(loc=loc, frameon=True)
 

◆ plot_efficiency_point()

plot_efficiency_point ( self )

Plot a point in the finding-efficiency/hit-efficiency plane.

Definition at line 113 of file root_handler.py.

    def plot_efficiency_point(self):
        """Plot a point in the finding-efficiency/hit-efficiency plane."""
        import matplotlib.pyplot as plt
        self.plot(100 * self.finding_efficiency, 100 * self.hit_efficiency, loc=3)
        plt.xlabel("finding efficiency")
        plt.ylabel("hit efficiency")
 

◆ plot_finding_efficiency()

plot_finding_efficiency	(		self,
			data = None )

Plot the finding efficiency over pt.

Definition at line 143 of file root_handler.py.

    def plot_finding_efficiency(self, data=None):
        """Plot the finding efficiency over pt."""
        import matplotlib.pyplot as plt
        grouped = self.grouped_by_pt_data(data)
 
        self.plot(grouped.median().pt_truth, grouped.mean().is_matched, yerr=1 / np.sqrt(grouped.count().is_matched))
        plt.xlabel(r"$p_T$ of the MC tracks (in GeV)")
        plt.ylabel("Finding Efficiency")
 

◆ plot_hit_efficiency()

plot_hit_efficiency	(		self,
			data = None )

Plot the hit efficiency over pt.

Definition at line 152 of file root_handler.py.

    def plot_hit_efficiency(self, data=None):
        """Plot the hit efficiency over pt."""
        import matplotlib.pyplot as plt
        grouped = self.grouped_by_pt_data(data)
 
        self.plot(grouped.median().pt_truth, grouped.mean().hit_efficiency, yerr=1 / np.sqrt(grouped.sum().mc_number_of_hits))
        plt.xlabel(r"$p_T$ of the MC tracks (in GeV)")
        plt.ylabel("Hit Efficiency")
 

◆ print_useful_information()

print_useful_information ( self )

Print mostfully useful information about this result.

Definition at line 161 of file root_handler.py.

    def print_useful_information(self):
        """Print mostfully useful information about this result."""
        pr_data = self.pr_data
        mc_data = self.mc_data
        primaries = pr_data[self.pr_data.is_prompt == 1]
        primaries_mc = mc_data[self.mc_data.is_prompt == 1]
 
        print(self.label)
        print("Fake", 100 * primaries.is_fake.mean(), 100 * pr_data.is_fake.mean())
        print("Clone", 100 * primaries.is_clone.mean(), 100 * pr_data.is_clone.mean())
        print("Ghost", 100 * primaries.is_ghost.mean(), 100 * pr_data.is_ghost.mean())
        print("Fitted", 100 * primaries.is_fitted.mean(), 100 * pr_data.is_fitted.mean())
        print("Found", 100 * primaries_mc.is_matched.mean(), 100 * mc_data.is_matched.mean())
        print("Found2", 100.0 - 100 * primaries_mc.is_missing.mean(), 100.0 - 100 * mc_data.is_missing.mean())
        print("Merged", 100 * primaries_mc.is_merged.mean(), 100 * mc_data.is_merged.mean())
        print("Hit-Eff", 100 * primaries_mc.hit_efficiency.mean(), 100 * mc_data.hit_efficiency.mean())
        print("Wrong Hits", primaries.number_of_wrong_hits.mean(), pr_data.number_of_wrong_hits.mean())
 

Member Data Documentation

◆ additional_information

additional_information = additional_information

the additional information

Definition at line 57 of file root_handler.py.

◆ clone_rate

clone_rate = None

the clone rate

Definition at line 53 of file root_handler.py.

◆ color

color = colors[color_index % len(colors)]

the color index

Definition at line 44 of file root_handler.py.

◆ fake_rate

fake_rate = None

the fake rate

Definition at line 51 of file root_handler.py.

◆ filename

filename = filename

The root filename.

Definition at line 22 of file root_handler.py.

◆ finding_efficiency

finding_efficiency = None

the finding efficiency

Definition at line 47 of file root_handler.py.

◆ hit_efficiency

hit_efficiency = None

the hit efficiency

Definition at line 49 of file root_handler.py.

◆ label

label = label

the label

Definition at line 42 of file root_handler.py.

◆ mc_data

mc_data = uproot.open(self.filename)["mc_tree/mc_tree"].arrays(library="pd")

the mc data

Definition at line 28 of file root_handler.py.

◆ mc_prompts

mc_prompts = self.mc_data[self.mc_data.is_prompt == 1]

the mc prompt data

Definition at line 33 of file root_handler.py.

◆ pr_data

pr_data = uproot.open(self.filename)["pr_tree/pr_tree"].arrays(library="pd")

The pr data.

Definition at line 24 of file root_handler.py.

◆ pr_prompts

pr_prompts = self.pr_data[self.pr_data.is_prompt == 1]

the pr prompt data

Definition at line 35 of file root_handler.py.

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

tracking/scripts/tracking/ipython_tools/root_handler.py

Public Member Functions

Static Public Member Functions

Public Attributes