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)
int	get_seed (self, str component)
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 only (legacy, prefer seed)
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.
int	seed = None
	Base seed for all variations, see get_seed.

Detailed Description

Class that stores the information of a particle.

Definition at line 94 of file sysvar.py.

Member Function Documentation

__str__()

str __str__

(

self

)

Converts the object to a string.

Definition at line 243 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 169 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 152 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 203 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'])
            )
            if self.seed is not None:
                # Local generators, so the caller's global RNG state is left untouched
                sys = np.random.default_rng(self.get_seed('sys')).multivariate_normal(zeros, sys_cov, n_variations)
                stat = np.random.default_rng(self.get_seed('stat')).multivariate_normal(zeros, stat_cov, n_variations)
                return sys + stat
            # Legacy sys_seed behaviour
            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
        # Total covariance: a single draw covers sys and stat
        if self.seed is not None:
            return np.random.default_rng(self.get_seed('total')).multivariate_normal(zeros, self.cov, n_variations)
        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 159 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_seed()

int get_seed	(		self,
		str	component )

Returns the seed for one component of the variations: 'sys', 'stat', or 'total'
for the combined draw when cov is set.

Derived from seed, the table identity and the component, so a table gives the
same variations in every dataframe it is applied to, while different tables and
components are independent.

Definition at line 190 of file sysvar.py.

    def get_seed(self, component: str) -> int:
        """
        Returns the seed for one component of the variations: 'sys', 'stat', or 'total'
        for the combined draw when cov is set.
 
        Derived from seed, the table identity and the component, so a table gives the
        same variations in every dataframe it is applied to, while different tables and
        components are independent.
        """
        if self.seed is None:
            return None
        return _derive_seed(self.seed, f'{component}:{_table_key(self.merged_table)}')
 

get_varname()

str get_varname	(		self,
		str	varname )

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

Definition at line 141 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 257 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) < 2:
            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 121 of file sysvar.py.

cov

cov = None

static

Covariance matrix corresponds to the total uncertainty.

Definition at line 127 of file sysvar.py.

coverage

float coverage = None

static

Coverage of the user ntuple.

Definition at line 133 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 106 of file sysvar.py.

pdg_binning

pdg_binning

Kinematic binning of the weight table per particle.

Definition at line 253 of file sysvar.py.

plot_values

plot_values = None

static

Values for the plots.

Definition at line 136 of file sysvar.py.

prefix

prefix = self.variable_aliases[varname]

Prefix of the particle in the ntuple.

Definition at line 148 of file sysvar.py.

seed

seed = None

static

Base seed for all variations, see get_seed.

None falls back to sys_seed

Definition at line 139 of file sysvar.py.

sys_seed

sys_seed = None

static

Random seed for systematics only (legacy, prefer seed)

Definition at line 124 of file sysvar.py.

syscorr

bool syscorr = True

static

When true assume systematics are 100% correlated.

Definition at line 130 of file sysvar.py.

type

str type = "PID":

Add the mcPDG code requirement for PID particle.

Definition at line 165 of file sysvar.py.

variable_aliases

variable_aliases

Variable aliases of the weight table.

Definition at line 146 of file sysvar.py.

weight_name

weight_name = weights.T

Weight column name that will be added to the ntuple.

Definition at line 188 of file sysvar.py.

---

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

• analysis/scripts/sysvar.py