ReweighterParticle Class Reference

Public Member Functions
str	get_varname (self, str varname)
list	get_binning_variables (self)
list	get_pdg_variables (self)
None	generate_variations (self, int n_variations, np.ndarray rho_sys=None, np.ndarray rho_stat=None)
np.ndarray	get_covariance (self, int n_variations, np.ndarray rho_sys=None, np.ndarray rho_stat=None)
str	__str__ (self)
	plot_coverage (self, fig=None, axs=None)

Public Attributes
	variable_aliases
	Variable aliases of the weight table.
	prefix = self.variable_aliases[varname]
	Prefix of the particle in the ntuple.
str	type = "PID":
	Add the mcPDG code requirement for PID particle.
	weight_name = weights.T
	Weight column name that will be added to the ntuple.
	pdg_binning
	Kinematic binning of the weight table per particle.

Static Public Attributes
pd	merged_table .DataFrame
	Type of the particle (PID or FEI)
list	column_names = None
	Internal list of the names of the weight columns.
int	sys_seed = None
	Random seed for systematics.
np	cov = None
	Covariance matrix corresponds to the total uncertainty.
bool	syscorr = True
	When true assume systematics are 100% correlated.
float	coverage = None
	Coverage of the user ntuple.
dict	plot_values = None
	Values for the plots.

Detailed Description

Class that stores the information of a particle.

Definition at line 45 of file sysvar.py.

Member Function Documentation

__str__()

str __str__

(

self

)

Converts the object to a string.

Definition at line 169 of file sysvar.py.

    def __str__(self) -> str:
        """
        Converts the object to a string.
        """
        separator = '------------------'
        title = 'ReweighterParticle'
        prefix_str = f'Type: {self.type} Prefix: {self.prefix}'
        columns = _weight_cols
        merged_table_str = f'Merged table:\n{self.merged_table[columns].describe()}'
        pdg_binning_str = 'PDG binning:\n'
        for pdgs in self.pdg_binning:
            pdg_binning_str += f'{pdgs}: {self.pdg_binning[pdgs]}\n'
        return '\n'.join([separator, title, prefix_str, merged_table_str, pdg_binning_str]) + separator
 

generate_variations()

None generate_variations	(		self,
		int	n_variations,
		np.ndarray	rho_sys = None,
		np.ndarray	rho_stat = None )

Generates variations of weights according to the uncertainties

Definition at line 117 of file sysvar.py.

                            rho_stat: np.ndarray = None) -> None:
        """
        Generates variations of weights according to the uncertainties
        """
        self.merged_table['stat_error'] = self.merged_table[["data_MC_uncertainty_stat_up",
                                                             "data_MC_uncertainty_stat_dn"]].max(axis=1)
        self.merged_table['sys_error'] = self.merged_table[["data_MC_uncertainty_sys_up",
                                                            "data_MC_uncertainty_sys_dn"]].max(axis=1)
        self.merged_table["error"] = np.sqrt(self.merged_table["stat_error"] ** 2 + self.merged_table["sys_error"] ** 2)
        means = self.merged_table["data_MC_ratio"].values
        
        self.column_names = [f"{self.weight_name}_{i}" for i in range(n_variations)]
        cov = self.get_covariance(n_variations, rho_sys, rho_stat)
        weights = cov + means
        self.merged_table[self.weight_name] = self.merged_table["data_MC_ratio"]
        self.merged_table[self.column_names] = weights.T
        self.column_names.insert(0, self.weight_name)
 

get_binning_variables()

list get_binning_variables

(

self

)

Returns the list of variables that are used for the binning

Definition at line 100 of file sysvar.py.

    def get_binning_variables(self) -> list:
        """
        Returns the list of variables that are used for the binning
        """
        variables = set(sum([list(d.keys()) for d in self.pdg_binning.values()], []))
        return [f'{self.get_varname(var)}' for var in variables]
 

get_covariance()

np.ndarray get_covariance	(		self,
		int	n_variations,
		np.ndarray	rho_sys = None,
		np.ndarray	rho_stat = None )

Returns the covariance matrix of the weights

Definition at line 138 of file sysvar.py.

                       rho_stat: np.ndarray = None) -> np.ndarray:
        """
        Returns the covariance matrix of the weights
        """
        len_means = len(self.merged_table["data_MC_ratio"])
        zeros = np.zeros(len_means)
        if self.cov is None:
            if rho_sys is None:
                if self.syscorr:
                    rho_sys = np.ones((len_means, len_means))
                else:
                    rho_sys = np.identity(len_means)
            if rho_stat is None:
                rho_stat = np.identity(len_means)
            sys_cov = np.matmul(
                np.matmul(np.diag(self.merged_table['sys_error']), rho_sys), np.diag(self.merged_table['sys_error'])
            )
            stat_cov = np.matmul(
                np.matmul(np.diag(self.merged_table['stat_error']), rho_stat), np.diag(self.merged_table['stat_error'])
            )
            np.random.seed(self.sys_seed)
            sys = np.random.multivariate_normal(zeros, sys_cov, n_variations)
            np.random.seed(None)
            stat = np.random.multivariate_normal(zeros, stat_cov, n_variations)
            return sys + stat
        errors = np.random.multivariate_normal(zeros, self.cov, n_variations)
        return errors
 

get_pdg_variables()

list get_pdg_variables

(

self

)

Returns the list of variables that are used for the PDG codes

Definition at line 107 of file sysvar.py.

    def get_pdg_variables(self) -> list:
        """
        Returns the list of variables that are used for the PDG codes
        """
        pdg_vars = ['PDG']
        
        if self.type == "PID":
            pdg_vars += ['mcPDG']
        return [f'{self.get_varname(var)}' for var in pdg_vars]
 

get_varname()

str get_varname	(		self,
		str	varname )

Returns the variable name with the prefix and use alias if defined.

Definition at line 89 of file sysvar.py.

    def get_varname(self, varname: str) -> str:
        """
        Returns the variable name with the prefix and use alias if defined.
        """
        name = varname
        if self.variable_aliases and varname in self.variable_aliases:
            name = self.variable_aliases[varname]
        if name.startswith(self.prefix):
            return name
        return f'{self.prefix}{name}'
 

plot_coverage()

plot_coverage	(		self,
			fig = None,
			axs = None )

Plots the coverage of the ntuple.

Definition at line 183 of file sysvar.py.

    def plot_coverage(self, fig=None, axs=None):
        """
        Plots the coverage of the ntuple.
        """
        if self.plot_values is None:
            return
        vars = set(sum([list(d.keys()) for d in self.plot_values.values()], []))
        if fig is None:
            fig, axs = plt.subplots(len(self.plot_values), len(vars), figsize=(5*len(vars), 3*len(self.plot_values)), dpi=120)
        axs = np.array(axs)
        if len(axs.shape) < 1:
            axs = axs.reshape(len(self.plot_values), len(vars))
        bin_plt = {'linewidth': 3, 'linestyle': '--', 'color': '0.5'}
        fig.suptitle(f'{self.type} particle {self.prefix.strip("_")}')
        for (reco_pdg, mc_pdg), ax_row in zip(self.plot_values, axs):
            for var, ax in zip(self.plot_values[(reco_pdg, mc_pdg)], ax_row):
                ymin = 0
                ymax = self.plot_values[(reco_pdg, mc_pdg)][var][1].max()*1.1
                # Plot binning
                if self.type == 'PID':
                    ax.vlines(self.pdg_binning[(reco_pdg, mc_pdg)][var], ymin, ymax,
                              label='Binning',
                              alpha=0.8,
                              **bin_plt)
                elif self.type == 'FEI':
                    values = np.array([int(val[4:]) for val in self.pdg_binning[(reco_pdg, mc_pdg)][var]])
                    ax.bar(values+0.5,
                           np.ones(len(values))*ymax,
                           width=1,
                           alpha=0.5,
                           label='Binning',
                           **bin_plt)
                    rest = np.setdiff1d(self.plot_values[(reco_pdg, mc_pdg)][var][0], values)
                    ax.bar(rest+0.5,
                           np.ones(len(rest))*ymax,
                           width=1,
                           alpha=0.2,
                           label='Rest category',
                           **bin_plt)
                # Plot values
                widths = (self.plot_values[(reco_pdg, mc_pdg)][var][0][1:] - self.plot_values[(reco_pdg, mc_pdg)][var][0][:-1])
                centers = self.plot_values[(reco_pdg, mc_pdg)][var][0][:-1] + widths/2
                ax.bar(centers,
                       self.plot_values[(reco_pdg, mc_pdg)][var][1],
                       width=widths,
                       label='Values',
                       alpha=0.8)
                ax.set_title(f'True {pdg.to_name(mc_pdg)} to reco {pdg.to_name(reco_pdg)} coverage')
                ax.set_xlabel(var)
        axs[-1][-1].legend()
        fig.tight_layout()
        return fig, axs
 
 

Member Data Documentation

column_names

list column_names = None

static

Internal list of the names of the weight columns.

Definition at line 72 of file sysvar.py.

cov

np cov = None

static

Covariance matrix corresponds to the total uncertainty.

Definition at line 78 of file sysvar.py.

coverage

float coverage = None

static

Coverage of the user ntuple.

Definition at line 84 of file sysvar.py.

merged_table

pd merged_table .DataFrame

static

Type of the particle (PID or FEI)

Merged table of the weights

Definition at line 57 of file sysvar.py.

pdg_binning

pdg_binning

Kinematic binning of the weight table per particle.

Definition at line 179 of file sysvar.py.

plot_values

plot_values = None

static

Values for the plots.

Definition at line 87 of file sysvar.py.

prefix

prefix = self.variable_aliases[varname]

Prefix of the particle in the ntuple.

Definition at line 96 of file sysvar.py.

sys_seed

sys_seed = None

static

Random seed for systematics.

Definition at line 75 of file sysvar.py.

syscorr

bool syscorr = True

static

When true assume systematics are 100% correlated.

Definition at line 81 of file sysvar.py.

type

str type = "PID":

Add the mcPDG code requirement for PID particle.

Definition at line 113 of file sysvar.py.

variable_aliases

variable_aliases

Variable aliases of the weight table.

Definition at line 94 of file sysvar.py.

weight_name

weight_name = weights.T

Weight column name that will be added to the ntuple.

Definition at line 136 of file sysvar.py.

---

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

• analysis/scripts/sysvar.py