Var vs var

def __eq__(self, other: VarVsVar) -> bool:
    """Handles a == check with the class.

    Parameters
    ----------
    other : VarVsVar
        Other VarVsVar that this class is tested against

    Returns
    -------
    bool
        If this VarVsVar and the other are equal
    """
    if isinstance(other, self.__class__):
        return (
            np.all(self.x_var == other.x_var)
            and np.all(self.y_var_mean == other.y_var_mean)
            and np.all(self.y_var_std == other.y_var_std)
            and self.key == other.key
        )
    return False

def divide(
    self,
    other: VarVsVar,
    inverse: bool = False,
    method: str = "divide",
) -> tuple[np.ndarray, np.ndarray]:
    """Calculate ratio between two class objects.

    Parameters
    ----------
    other : VarVsVar
        Second VarVsVar object to calculate ratio with
    inverse : bool, optional
        If False the ratio is calculated `this / other`,
        if True the inverse is calculated. By default False.
    method : str, optional
        Define which method is used for ratio calculation. By default "divide".
        Other possibility is "root_square_diff" and "subtract".

    Returns
    -------
    tuple[np.ndarray, np.ndarray]
        Ratio and ratio error
        Ratio error

    Raises
    ------
    ValueError
        If binning is not identical between 2 objects
    """
    # Check that both x variables match
    if not np.array_equal(self.x_var, other.x_var):
        raise ValueError("The x variables of the two given objects do not match.")

    # Get the nominator/denominator + uncertainty
    nom, nom_err = self.y_var_mean, self.y_var_std
    denom, denom_err = other.y_var_mean, other.y_var_std

    # Calculate the ratio/difference between the the actual and other VarVsVar object
    ratio, ratio_err = hist_ratio(
        numerator=denom if inverse else nom,
        denominator=nom if inverse else denom,
        numerator_unc=denom_err if inverse else nom_err,
        step=False,
        method=method,
    )
    return (ratio, ratio_err)

def add(self, curve: VarVsVar, key: str | None = None, reference: bool = False) -> None:
    """Adding VarVsVar object to figure.

    Parameters
    ----------
    curve : VarVsVar
        VarVsVar curve
    key : str | None, optional
        Unique identifier for VarVsVar curve, by default None
    reference : bool, optional
        If VarVsVar is used as reference for ratio calculation, by default False

    Raises
    ------
    KeyError
        If unique identifier key is used twice
    """
    key = cast(str, key if key is not None else f"{len(self.plot_objects) + 1}")

    if key in self.plot_objects:
        raise KeyError(f"Duplicated key {key} already used for unique identifier.")

    self.plot_objects[key] = curve
    self.add_order.append(key)
    # set linestyle
    if curve.linestyle is None:
        curve.linestyle = "-"
    # set colours
    if curve.colour is None:
        curve.colour = get_good_colours()[len(self.plot_objects) - 1]
    # set alpha
    if curve.alpha is None:
        curve.alpha = 0.8
    # set linewidth
    if curve.linewidth is None:
        curve.linewidth = 1.6

    if curve.is_marker is True:
        if curve.marker is None:
            curve.marker = get_good_markers()[len(self.plot_objects)]
        # Set markersize
        if curve.markersize is None:
            curve.markersize = 8
        if curve.markeredgewidth is None:
            curve.markeredgewidth = 2

    # set min and max edges
    if curve.x_var_widths is not None:
        left_edge = curve.x_var - curve.x_var_widths / 2
        right_edge = curve.x_var + curve.x_var_widths / 2
    else:
        left_edge = curve.x_var
        right_edge = curve.x_var
    self.x_var_min = min(self.x_var_min, np.sort(left_edge)[0])
    self.x_var_max = max(self.x_var_max, np.sort(right_edge)[-1])

    if reference:
        logger.debug("Setting roc %s as reference.", key)
        self.set_reference(key)

def draw(
    self,
    labelpad: int | None = None,
):
    """Draw figure.

    Parameters
    ----------
    labelpad : int | None, optional
        Spacing in points from the axes bounding box including
        ticks and tick labels, by default "ratio"
    """
    self.set_xlim(
        self.x_var_min if self.xmin is None else self.xmin,
        self.x_var_max if self.xmax is None else self.xmax,
    )
    plt_handles = self.plot()
    if self.n_ratio_panels == 1:
        self.plot_ratios()
    self.set_title()
    self.set_log()
    self.set_y_lim()
    self.set_xlabel()
    self.set_tick_params()
    self.set_ylabel(self.axis_top)

    if self.n_ratio_panels > 0:
        assert isinstance(self.ylabel_ratio, list)
        self.set_ylabel(
            self.ratio_axes[0],
            self.ylabel_ratio[0],
            align="center",
            labelpad=labelpad,
        )
    self.make_legend(plt_handles, ax_mpl=self.axis_top)
    self.plotting_done = True
    if self.apply_atlas_style is True:
        self.atlasify()

def draw_hline(self, y_val: float):
    """Draw hline in top plot panel.

    Parameters
    ----------
    y_val : float
        y value of the horizontal line
    """
    self.axis_top.hlines(
        y=y_val,
        xmin=self.x_var_min,
        xmax=self.x_var_max,
        colors="black",
        linestyle="dotted",
        alpha=0.5,
    )

def get_reference_name(self, var_object: VarVsVar) -> VarVsVar | None:
    """Get reference VarVsVar object from list of references.

    Parameters
    ----------
    var_object : VarVsVar
        VarVsVar we want to calculate the ratio for

    Returns
    -------
    reference_name : VarVsVar | None
        Corresponding reference VarVsVar

    Raises
    ------
    ValueError
        If no reference VarVsVar was found or multiple matches.
    """
    matches = 0
    reference_name = None

    for key in self.reference_object:
        reference_candidate = self.plot_objects[key]
        if var_object.ratio_group is not None:
            if var_object.ratio_group == reference_candidate.ratio_group:
                matches += 1
                reference_name = reference_candidate
        else:
            matches += 1
            reference_name = reference_candidate

    if matches != 1:
        raise ValueError(
            f"Found {matches} matching reference candidates, but only one match is allowed."
        )

    logger.debug("Reference var_object for '%s' is '%s'", var_object.key, reference_name.key)

    return reference_name

def plot(self, **kwargs: Any) -> mpl.lines.Line2D:
    """Plotting curves.

    Parameters
    ----------
    **kwargs: Any
        Keyword arguments passed to plt.axis.errorbar

    Returns
    -------
    mpl.lines.Line2D
        matplotlib Line2D object
    """
    logger.debug("Plotting curves")
    plt_handles = []
    for key in self.add_order:
        elem = self.plot_objects[key]
        error_bar = self.axis_top.errorbar(
            elem.x_var,
            elem.y_var_mean,
            xerr=elem.x_var_widths / 2 if elem.x_var_widths is not None else None,
            yerr=(elem.y_var_std if elem.plot_y_std else np.zeros_like(elem.x_var)),
            color=elem.colour,
            fmt="none",
            label=elem.label,
            alpha=elem.alpha,
            linewidth=elem.linewidth,
            ms=elem.markersize,
            **kwargs,
        )
        # # set linestyle for errorbar
        error_bar[-1][0].set_linestyle(elem.linestyle)
        # Draw markers
        if elem.is_marker is True:
            self.axis_top.scatter(
                x=elem.x_var,
                y=elem.y_var_mean,
                marker=elem.marker,
                s=elem.markersize**2,
                color=elem.colour,
            )
        if elem.x_var_widths is not None and elem.fill:
            for x_pos, y_pos, width, height in zip(
                elem.x_var,
                elem.y_var_mean,
                elem.x_var_widths,
                2 * elem.y_var_std,
                strict=False,
            ):
                self.axis_top.add_patch(
                    Rectangle(
                        xy=(
                            x_pos - width / 2,
                            y_pos - height / 2,
                        ),
                        width=width,
                        height=height,
                        linewidth=0,
                        color=elem.colour,
                        alpha=0.3,
                        zorder=1,
                    )
                )
        plt_handles.append(
            mpl.lines.Line2D(
                [],
                [],
                color=elem.colour,
                label=elem.label,
                linestyle=elem.linestyle,
                marker=elem.marker,
                markersize=elem.markersize,
            )
        )
    return plt_handles

def plot_ratios(self):
    """Plotting ratio curves.

    Raises
    ------
    ValueError
        If no reference curve is defined
    """
    if self.reference_object is None:
        raise ValueError("Please specify a reference curve.")
    for key in self.add_order:
        elem = self.plot_objects[key]
        ratio, ratio_err = elem.divide(
            other=self.get_reference_name(elem),
            method=self.ratio_method,
        )
        error_bar = self.ratio_axes[0].errorbar(
            elem.x_var,
            ratio,
            xerr=elem.x_var_widths / 2 if elem.x_var_widths is not None else None,
            yerr=ratio_err if elem.plot_y_std else np.zeros_like(elem.x_var),
            color=elem.colour,
            fmt="none",
            alpha=elem.alpha,
            linewidth=elem.linewidth,
            ms=elem.markersize,
        )
        # set linestyle for errorbar
        error_bar[-1][0].set_linestyle(elem.linestyle)
        # draw markers
        if elem.is_marker is True:
            self.ratio_axes[0].scatter(
                x=elem.x_var,
                y=ratio,
                marker=elem.marker,
                color=elem.colour,
                s=elem.markersize**2,
            )
        if elem.x_var_widths is not None and elem.fill:
            for x_pos, y_pos, width, height in zip(
                elem.x_var, ratio, elem.x_var_widths, 2 * ratio_err, strict=False
            ):
                self.ratio_axes[0].add_patch(
                    Rectangle(
                        xy=(
                            x_pos - width / 2,
                            y_pos - height / 2,
                        ),
                        width=width,
                        height=height,
                        linewidth=0,
                        color=elem.colour,
                        alpha=0.3,
                        zorder=1,
                    )
                )

def set_reference(self, key: str):
    """Setting the reference VarVsVar curves used in the ratios.

    Parameters
    ----------
    key : str
        Unique identifier of roc object
    """
    if self.reference_object is None:
        self.reference_object = [key]
    else:
        self.reference_object.append(key)
    logger.debug("Adding '%s' to reference VarVsVar(s)", key)

def efficiency(
    self,
    arr: np.ndarray,
    cut: float | np.ndarray,
    weights: np.ndarray | None = None,
) -> tuple[float, float] | tuple[np.ndarray, np.ndarray]:
    """Calculate efficiency and the associated error.

    Parameters
    ----------
    arr : np.ndarray
        Array with discriminants
    cut : float | np.ndarray
        Cut value. If you want to use PCFT, two values are provided.
        The lower and the upper cut.
    weights : np.ndarray | None, optional
        Weights to use for the array. Must be same length as arr!
        When None is given, equal weights are used. By default None

    Returns
    -------
    float | np.ndarray
        Efficiency
    float | np.ndarray
        Efficiency error

    Raises
    ------
    TypeError
        If the cut parameter type is not supported
    """
    # If no values are given, return 0 for eff and eff_err
    if len(arr) == 0:
        return 0.0, 0.0

    # Fall back if no weights are used
    if weights is None:
        weights = np.ones_like(arr, dtype=float)

    # If the cut is a single value, this is a non-PCFT WP
    if isinstance(cut, (int, float, np.integer, np.floating)):
        # Check for the inverse cut
        mask = arr < cut if self.inverse_cut else arr > cut

    # If the cut is an array, this is a PCFT-style two-sided cut
    # Keep values between cut[1] and cut[0]
    elif isinstance(cut, np.ndarray):
        mask = (arr < cut[0]) & (arr > cut[1])

    # Else return an error that this type of cut is not supported
    else:
        raise TypeError(
            f"cut parameter type {type(cut)} is not supported! Must be float or np.ndarray"
        )

    # With the given mask, calculate the sum of the weights
    numerator = float(weights[mask].sum())
    denominator = float(weights.sum())

    # Check if the denominator is > 0
    # If not, return 0 as eff and eff_err
    if denominator <= 0:
        return 0.0, 0.0

    # Calculate the efficiency and the error
    eff = save_divide(numerator=numerator, denominator=denominator)

    # Use effective sample size for proper weighted binomial uncertainty:
    # N_eff = (sum w)^2 / sum(w^2). For uniform weights, N_eff = N.
    n_eff = float(weights.sum()) ** 2 / float((weights**2).sum())
    eff_error = calculate_efficiency_error(eff, n_eff)

    return eff, eff_error

def get(self, mode: str, inverse_cut: bool = False):
    """Wrapper around rejection and efficiency functions.

    Parameters
    ----------
    mode : str
        Can be "sig_eff", "bkg_eff", "sig_rej", "bkg_rej", or
        "bkg_eff_sig_err"
    inverse_cut : bool, optional
        Inverts the discriminant cut, which will yield the efficiency or rejection
        of the jets not passing the working point, by default False

    Returns
    -------
    np.ndarray
        Rejection or efficiency depending on `mode` value
    np.ndarray
        Rejection or efficiency error depending on `mode` value

    Raises
    ------
    ValueError
        If mode not supported
    """
    if mode in VarVsEffPlot.mode_options:
        name = "normal" if inverse_cut is False else "inverse"
        return (
            self.results[name][mode]["y_value"],
            self.results[name][mode]["y_error"],
        )
    raise ValueError(
        f"The selected mode {mode} is not supported. Use one of the following:"
        f" {VarVsEffPlot.mode_options}."
    )

def rejection(
    self,
    arr: np.ndarray,
    cut: float | np.ndarray,
    weights: np.ndarray | None = None,
) -> tuple[float, float] | tuple[np.ndarray, np.ndarray]:
    """Calculate rejection and the associated error.

    Parameters
    ----------
    arr : np.ndarray
        Array with discriminants
    cut : float | np.ndarray
        Cut value used for the given working point. Ndarray
        when PCFT-style cuts are used
    weights : np.ndarray | None, optional
        Weights to use for the array. Must be same length as arr!
        When None is given, equal weights are used. By default None

    Returns
    -------
    float | np.ndarray
        Rejection
    float | np.ndarray
        Rejection error

    Raises
    ------
    TypeError
        If the cut parameter type is not supported
    """
    # If no values are given, return 0 for eff and eff_err
    if len(arr) == 0:
        return 0.0, 0.0

    # Fall back if no weights are used
    if weights is None:
        weights = np.ones_like(arr, dtype=float)

    # Get the denominator from the total sum of weights
    denominator = float(weights.sum())

    # Return NaN if total weights is <= 0
    if denominator <= 0:
        logger.warning("Total weight in bin is <= 0. Setting rejection to NaN.")
        return np.nan, np.nan

    # If the cut is a single value, this is a non-PCFT WP
    if isinstance(cut, (int, float, np.integer, np.floating)):
        # Check for the inverse cut
        mask = arr < cut if self.inverse_cut else arr > cut

    # If the cut is an array, this is a PCFT-style two-sided cut
    # Keep values between cut[1] and cut[0]
    elif isinstance(cut, np.ndarray):
        mask = (arr < cut[0]) & (arr > cut[1])

    # Else return an error that this type of cut is not supported
    else:
        raise TypeError(
            f"cut parameter type {type(cut)} is not supported! Must be float or np.ndarray"
        )

    # Get the total weight for passing jets
    numerator = float(weights[mask].sum())

    # Calculate the rejection by using the inverse of the efficiency (1 / eff)
    # To do so with less calculation, flip numerator and denominator
    rej = save_divide(numerator=denominator, denominator=numerator, default=np.inf)

    # If the rejection is infinite, print a warning and return NaN
    if rej == np.inf:
        logger.warning("Your rejection is infinity -> setting it to np.nan.")
        return np.nan, np.nan

    # Use effective sample size for proper weighted binomial uncertainty:
    # N_eff = (sum w)^2 / sum(w^2). For uniform weights, N_eff = N.
    n_eff = denominator**2 / float((weights**2).sum())
    rej_error = calculate_rejection_error(rej, n_eff)
    return rej, rej_error