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)
def	plot_coverage (self, fig=None, axs=None)

Public Attributes
	type
	Add the mcPDG code requirement for PID particle.
	column_names
	Names of the varied weight columns.

Static Public Attributes
str	prefix
	Prefix of the particle in the ntuple.
str	type
	Type of the particle (PID or FEI)
pd	merged_table .DataFrame
	Merged table of the weights.
dict	pdg_binning
	Kinematic binning of the weight table per particle.
dict	variable_aliases
	Variable aliases of the weight table.
str	weight_name
	Weight column name that will be added to the ntuple.
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 36 of file sysvar.py.

Member Function Documentation

__str__()

str __str__

(

self

)

Converts the object to a string.

Definition at line 156 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 104 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 87 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 125 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 94 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 76 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()

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

Plots the coverage of the ntuple.

Definition at line 170 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 [1/2]

list column_names = None

static

Internal list of the names of the weight columns.

Definition at line 59 of file sysvar.py.

column_names [2/2]

column_names

Names of the varied weight columns.

Definition at line 118 of file sysvar.py.

cov

np cov = None

static

Covariance matrix corresponds to the total uncertainty.

Definition at line 65 of file sysvar.py.

coverage

float coverage = None

static

Coverage of the user ntuple.

Definition at line 71 of file sysvar.py.

merged_table

pd merged_table .DataFrame

static

Merged table of the weights.

Definition at line 47 of file sysvar.py.

pdg_binning

dict pdg_binning

static

Kinematic binning of the weight table per particle.

Definition at line 50 of file sysvar.py.

plot_values

dict plot_values = None

static

Values for the plots.

Definition at line 74 of file sysvar.py.

prefix

str prefix

static

Prefix of the particle in the ntuple.

Definition at line 41 of file sysvar.py.

sys_seed

int sys_seed = None

static

Random seed for systematics.

Definition at line 62 of file sysvar.py.

syscorr

bool syscorr = True

static

When true assume systematics are 100% correlated.

Definition at line 68 of file sysvar.py.

type [1/2]

str type

static

Type of the particle (PID or FEI)

Definition at line 44 of file sysvar.py.

type [2/2]

type

Add the mcPDG code requirement for PID particle.

Definition at line 100 of file sysvar.py.

variable_aliases

dict variable_aliases

static

Variable aliases of the weight table.

Definition at line 53 of file sysvar.py.

weight_name

str weight_name

static

Weight column name that will be added to the ntuple.

Definition at line 56 of file sysvar.py.

---

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

• analysis/scripts/sysvar.py