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 34 of file sysvar.py.

Member Function Documentation

__str__()

str __str__

(

self

)

Converts the object to a string.

Definition at line 154 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 102 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 85 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 123 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 92 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 74 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 168 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 57 of file sysvar.py.

column_names [2/2]

column_names

Names of the varied weight columns.

Definition at line 116 of file sysvar.py.

cov

np cov = None

static

Covariance matrix corresponds to the total uncertainty.

Definition at line 63 of file sysvar.py.

coverage

float coverage = None

static

Coverage of the user ntuple.

Definition at line 69 of file sysvar.py.

merged_table

pd merged_table .DataFrame

static

Merged table of the weights.

Definition at line 45 of file sysvar.py.

pdg_binning

dict pdg_binning

static

Kinematic binning of the weight table per particle.

Definition at line 48 of file sysvar.py.

plot_values

dict plot_values = None

static

Values for the plots.

Definition at line 72 of file sysvar.py.

prefix

str prefix

static

Prefix of the particle in the ntuple.

Definition at line 39 of file sysvar.py.

sys_seed

int sys_seed = None

static

Random seed for systematics.

Definition at line 60 of file sysvar.py.

syscorr

bool syscorr = True

static

When true assume systematics are 100% correlated.

Definition at line 66 of file sysvar.py.

type [1/2]

str type

static

Type of the particle (PID or FEI)

Definition at line 42 of file sysvar.py.

type [2/2]

type

Add the mcPDG code requirement for PID particle.

Definition at line 98 of file sysvar.py.

variable_aliases

dict variable_aliases

static

Variable aliases of the weight table.

Definition at line 51 of file sysvar.py.

weight_name

str weight_name

static

Weight column name that will be added to the ntuple.

Definition at line 54 of file sysvar.py.

---

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

• analysis/scripts/sysvar.py