FUCKROOT 0.0.0__tar.gz

fuckroot-0.0.0/FUCKROOT/HEP_PLOT/HepFigure.py

@@ -0,0 +1,395 @@
+from matplotlib.axes import Axes
+from matplotlib.projections import register_projection
+from matplotlib.ticker import AutoMinorLocator
+import matplotlib.pyplot as plt
+import numpy as np
+from tqdm import tqdm
+import matplotlib
+import warnings
+# matplotlib.use("tkAgg")  
+
+
+LHCB_FONT_FAMILY = "Times New Roman"
+LHCB_LINE_WIDTH = 1.0
+LHCB_TEXT_SIZE = 14
+LHCB_MAJOR_TICK_LENGTH = 8
+LHCB_MINOR_TICK_LENGTH = 4
+# Follow named ROOT color order: black, red, green, blue, yellow, magenta, cyan, purple.
+LHCB_COLOR_CYCLE = ["black", "red", "green", "blue", "yellow", "magenta", "cyan", "purple"]
+
+
+class HepAxes(Axes):
+    name = "hep"
+
+    def __init__(self, *args, **kwargs):
+        self._hep_font_family = LHCB_FONT_FAMILY
+        super().__init__(*args, **kwargs)
+        self._apply_lhcb_style()
+        self.hist_datas = []
+        self._hist_artists = []
+        self.grid(True)
+
+
+
+    def _apply_lhcb_style(self):
+        # ROOT lhcbStyle-like appearance, applied only to this projection.
+        self.set_facecolor("white")
+        self.figure.set_facecolor("white")
+
+        # Add both major and minor ticks on x/y axes.
+        self.xaxis.set_minor_locator(AutoMinorLocator())
+        self.yaxis.set_minor_locator(AutoMinorLocator())
+        self.minorticks_on()
+
+        self.tick_params(
+            axis="both",
+            which="major",
+            direction="in",
+            top=True,
+            right=True,
+            width=LHCB_LINE_WIDTH,
+            length=LHCB_MAJOR_TICK_LENGTH,
+            labelsize=LHCB_TEXT_SIZE,
+        )
+
+        self.tick_params(
+            axis="both",
+            which="minor",
+            direction="in",
+            top=True,
+            right=True,
+            width=0.8 * LHCB_LINE_WIDTH,
+            length=LHCB_MINOR_TICK_LENGTH,
+        )
+
+        for spine in self.spines.values():
+            spine.set_linewidth(LHCB_LINE_WIDTH)
+
+        self.set_prop_cycle(color=LHCB_COLOR_CYCLE)
+        self.title.set_fontsize(1.2 * LHCB_TEXT_SIZE)
+
+    def plot(self, *args, **kwargs):
+        # Match lhcbStyle defaults for line and marker appearance.
+        kwargs.setdefault("linestyle", "-")
+        kwargs.setdefault("linewidth", LHCB_LINE_WIDTH)
+        kwargs.setdefault("marker", "o")
+        kwargs.setdefault("markersize", 4)
+
+        return super().plot(*args, **kwargs)
+
+    def set_title(self, label, *args, **kwargs):
+        # Match lhcbStyle title size and weight.
+        kwargs.setdefault("fontsize", 1.5 * LHCB_TEXT_SIZE)
+        # kwargs.setdefault("fontweight", "bold")
+
+        return super().set_title(label, *args, **kwargs)
+
+    def set_xlabel(self, xlabel, *args, **kwargs):
+        # Put x label on the right end of the axis.
+        kwargs.setdefault("loc", "right")
+        kwargs.setdefault("fontsize", 1.1 * LHCB_TEXT_SIZE)
+
+        return super().set_xlabel(xlabel, *args, **kwargs)
+
+    def set_ylabel(self, ylabel, *args, **kwargs):
+        # Keep y label vertical and move it to the top of the axis.
+        kwargs.setdefault("loc", "top")
+        kwargs.setdefault("rotation", 90)
+        kwargs.setdefault("fontsize", 1.1 * LHCB_TEXT_SIZE)
+
+        return super().set_ylabel(ylabel, *args, **kwargs)
+    
+    def grid(self, visible=None, which="both", axis="both", **kwargs):
+        if visible is False:
+            if which in ("both", "major"):
+                super().grid(visible=False, which="major", axis=axis)
+            if which in ("both", "minor"):
+                super().grid(visible=False, which="minor", axis=axis)
+            return
+
+        if which in ("both", "major"):
+            major_kwargs = {
+                "linestyle": "-",
+                "linewidth": 0.8 * LHCB_LINE_WIDTH,
+                "alpha": 0.5,
+            }
+            major_kwargs.update(kwargs)
+            super().grid(visible=visible, which="major", axis=axis, **major_kwargs)
+
+        if which in ("both", "minor"):
+            minor_kwargs = {
+                "linestyle": "--",
+                "linewidth": 0.6 * LHCB_LINE_WIDTH,
+                "alpha": 0.25,
+            }
+            minor_kwargs.update(kwargs)
+            super().grid(visible=visible, which="minor", axis=axis, **minor_kwargs)
+
+
+    def hist(self, *args, stat=True, errors=True, **kwargs):
+        # Match lhcbStyle defaults for histogram appearance.
+        kwargs.setdefault("histtype", "step")
+        kwargs.setdefault("linewidth", LHCB_LINE_WIDTH)
+        label = kwargs.get("label", None)
+        if stat:
+            stat_text = self._format_hist_stat(args)
+            if label is None:
+                kwargs["label"] = stat_text
+            elif "$\\mu$=" not in label and "$\\sigma$=" not in label:
+                kwargs["label"] = f"{label} {stat_text}"
+
+        # remove stat and errors from kwargs before caching (will handle separately)
+        self.hist_datas.append({"args": args, "kwargs": kwargs.copy(), "errors": errors})
+
+        common_bins, common_range = self._get_common_hist_config()
+
+        # Remove old histogram artists before full redraw.
+        for artist in self._hist_artists:
+            if hasattr(artist, "remove"):
+                artist.remove()
+        self._hist_artists = []
+
+        # Reset property cycle so full redraw keeps stable color/marker order.
+        self.set_prop_cycle(color=LHCB_COLOR_CYCLE)
+
+        last_result = None
+        for hist_data in self.hist_datas:
+            draw_kwargs = hist_data["kwargs"].copy()
+            draw_kwargs["bins"] = common_bins
+            if common_range is not None:
+                draw_kwargs["range"] = common_range
+            else:
+                draw_kwargs.pop("range", None)
+
+            last_result = super().hist(*hist_data["args"], **draw_kwargs)
+            self._hist_artists.extend(self._flatten_artists(last_result[2]))
+            
+            # Add error bars if requested
+            errors_type = hist_data.get("errors", None)
+            if errors_type is not False and errors_type is not None and last_result is not []:
+                error_artists = self._draw_hist_errors(
+                    hist_data["args"], last_result, errors_type, **draw_kwargs
+                )
+                self._hist_artists.extend(error_artists)
+
+
+        self.set_title("Histogram")
+        self.set_ylabel("Entries")
+        # self.set_xlabel("Value")
+
+        return last_result
+
+
+    def twinx(self):
+        warnings.warn(
+
+            "\n\033[1;93m#### [NOT RECOMMENDED] HepAxes.twinx() have issues in current version ####\033[0m\n" \
+            "\033[1;93mtwin_ax do not share the same bin with the main ax, so histograms drawn on twin_ax will not be perfectly aligned with those on the main ax!!!\033[0m\n" \
+            "Will be fixed in future versions.",
+            UserWarning,
+            stacklevel=2,
+        )
+        # Create a twin axes with the same custom projection so hep-specific
+        # features (e.g. hist stat/errors kwargs) work on the right axis too.
+        twin = self._make_twin_axes(sharex=self, projection=self.name)
+        twin.yaxis.tick_right()
+        twin.yaxis.set_label_position('right')
+        twin.yaxis.set_offset_position('right')
+        twin.set_autoscalex_on(self.get_autoscalex_on())
+        self.yaxis.tick_left()
+        twin.xaxis.set_visible(False)
+        twin.patch.set_visible(False)
+        twin.xaxis.units = self.xaxis.units
+
+        twin._hep_font_family = self._hep_font_family
+        return twin
+
+    def _format_hist_stat(self, hist_args):
+        values = []
+        for dataset in self._extract_hist_datasets(hist_args):
+            finite = dataset[np.isfinite(dataset)]
+            if finite.size:
+                values.append(finite)
+
+        if not values:
+            return "(N=0), $\\mu$=nan, $\\sigma$=nan"
+
+        stacked = np.concatenate(values)
+        count = int(stacked.size)
+        mean = float(np.mean(stacked))
+        sigma = float(np.std(stacked))
+        return f"(N={count})\n$\\mu$={mean:.2g}, $\\sigma$={sigma:.2g}"
+
+    def _get_common_hist_config(self):
+        explicit_bins = None
+        explicit_range = None
+        for hist_data in self.hist_datas:
+            draw_kwargs = hist_data["kwargs"]
+            if "bins" in draw_kwargs:
+                explicit_bins = draw_kwargs["bins"]
+            if "range" in draw_kwargs:
+                explicit_range = draw_kwargs["range"]
+
+        bins = explicit_bins if explicit_bins is not None else 10
+        if explicit_range is not None:
+            return bins, explicit_range
+
+        values = []
+        for hist_data in self.hist_datas:
+            for dataset in self._extract_hist_datasets(hist_data["args"]):
+                finite = dataset[np.isfinite(dataset)]
+                if finite.size:
+                    values.append(finite)
+
+        if not values:
+            return bins, None
+
+        stacked = np.concatenate(values)
+        x_min = float(np.min(stacked))
+        x_max = float(np.max(stacked))
+        if x_min == x_max:
+            delta = 0.5 if x_min == 0.0 else abs(0.5 * x_min)
+            x_min -= delta
+            x_max += delta
+
+        return bins, (x_min, x_max)
+
+    def _extract_hist_datasets(self, hist_args):
+        if not hist_args:
+            return []
+
+        x = hist_args[0]
+        if isinstance(x, (list, tuple)):
+            if not x:
+                return []
+            if np.isscalar(x[0]):
+                return [np.asarray(x).ravel()]
+            return [np.asarray(dataset).ravel() for dataset in x]
+
+        x_array = np.asarray(x)
+        if x_array.ndim <= 1:
+            return [x_array.ravel()]
+
+        return [x_array[:, i].ravel() for i in range(x_array.shape[1])]
+
+    def _flatten_artists(self, maybe_nested):
+        if isinstance(maybe_nested, (list, tuple)):
+            artists = []
+            for item in maybe_nested:
+                artists.extend(self._flatten_artists(item))
+            return artists
+
+        return [maybe_nested]
+
+    def _draw_hist_errors(self, hist_args, hist_result, errors, **kwargs):
+        """Draw error bars on top of histogram. Returns list of artist objects."""
+        # bins = kwargs["bins"]
+        # data_range = kwargs["range"]
+        if errors is True:
+            errors_type = "stat"
+        elif type(errors) is np.ndarray:
+            errors_type = "custom"
+        else:
+            raise ValueError(f"Invalid errors argument: {errors}. Must be True, False, or array-like.")
+
+        # Extract histogram values and bin edges
+        hist_counts = hist_result[0]  # bin heights
+        bin_edges = hist_result[1]    # bin edges
+        
+        # Compute bin centers
+        bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2.0
+        bin_width = bin_edges[1] - bin_edges[0]
+        
+        # Compute errors based on type
+        if errors_type == "stat":
+            errors = np.sqrt(np.maximum(hist_counts, 0))
+            if "density" in kwargs and kwargs["density"]:
+                # For density histograms, propagate Poisson errors from raw bin counts:
+                # density_i = n_i / (N * bin_width_i), sigma_i = sqrt(n_i) / (N * bin_width_i)
+                data = np.asarray(hist_args[0]).ravel()
+                finite = data[np.isfinite(data)]
+                raw_counts, _ = np.histogram(finite, bins=bin_edges)
+                total = np.sum(raw_counts)
+                if total > 0:
+                    bin_widths = np.diff(bin_edges)
+                    errors = np.sqrt(raw_counts) / (total * bin_widths)
+                else:
+                    errors = np.zeros_like(hist_counts, dtype=float)
+        elif errors_type == "custom":
+            if len(errors) != len(hist_counts):
+                raise ValueError(f"Custom errors array length {len(errors)} does not match number of bins {len(hist_counts)}.")
+            errors = np.asarray(errors)
+        else:
+            raise ValueError(f"Unknown errors type: {errors_type}")
+
+
+
+        # Get current color from the last-drawn histogram line
+        color = None
+        for artist in self._flatten_artists(hist_result[2]):
+            if hasattr(artist, "get_edgecolor"):
+                color = artist.get_edgecolor()
+                break
+        
+        # Draw error bars
+        bin_width = bin_edges[1] - bin_edges[0]
+        errorbar_artists = self.errorbar(
+            bin_centers, hist_counts, yerr=errors, 
+            fmt=".", elinewidth=LHCB_LINE_WIDTH, 
+            color=color, alpha=0.7
+        )
+        artists = []
+
+        # 手动画 caps（用数据坐标）
+        cap_width = bin_width * 0.5  # 或者你想要的比例
+
+        for x, y, err in zip(bin_centers, hist_counts, errors):
+            cap_artistup = self.hlines(y + err, x - 0.5*cap_width, x + 0.5*cap_width,
+                    color=color, linewidth=LHCB_LINE_WIDTH)
+            cap_artistdown = self.hlines(y - err, x - 0.5*cap_width, x + 0.5*cap_width,
+                    color=color, linewidth=LHCB_LINE_WIDTH)
+
+            artists.append(cap_artistup)
+            artists.append(cap_artistdown)
+
+
+        # Return all artist objects from errorbar
+        if hasattr(errorbar_artists, '__iter__'):
+            artists.extend(self._flatten_artists(errorbar_artists))
+        else:
+            artists.append(errorbar_artists)
+        return artists
+
+
+    def draw(self, renderer, *args, **kwargs):
+        # Apply font only to text artists in this axes.
+        for text in self.findobj(match=lambda artist: hasattr(artist, "set_fontfamily")):
+            text.set_fontfamily(self._hep_font_family)
+
+        return super().draw(renderer, *args, **kwargs)
+
+
+# Register the projection at import time so pyplot can resolve "hep".
+register_projection(HepAxes)
+
+
+if __name__ == "__main__":
+
+
+    fig, ax = plt.subplots(subplot_kw={"projection": "hep"})
+    ax2 = ax.twinx()
+    # ax.plot([1, 2, 3], [1, 2, 3], label="Data 1")
+    # ax.plot([1, 2, 3], [4, 5, 6], label="Data 2")
+    ax.hist(np.random.randn(1000)**2, bins=100, histtype="step", label="Data 1", stat=True, errors=True)
+    ax2.hist(np.random.randn(1000)+3, bins=100, histtype="step", label="Data 2", stat=True, errors=np.linspace(5, 20, 100))
+    ax.set_xlabel("X-axis")
+    ax.set_ylabel("Y-axis")
+    ax.grid(True)
+
+    ax.legend()
+
+    ax.set_title("HepAxes Example")
+
+    plt.tight_layout()
+    plt.savefig("hep_axes_example.png", dpi=6000)
+    plt.show()

fuckroot-0.0.0/FUCKROOT/HEP_PLOT/__init__.py

@@ -0,0 +1,36 @@
+import matplotlib.pyplot as plt
+from .HepFigure import HepAxes
+
+__all__ = ["HepAxes", "enable_default_hep_subplots"]
+
+
+_ORIGINAL_SUBPLOTS = plt.subplots
+_HEP_DEFAULT_ENABLED = False
+
+
+def enable_default_hep_subplots(enable=True):
+	"""Enable or disable hep projection as the default for ``plt.subplots``.
+
+	When enabled, ``plt.subplots()`` will behave like:
+	``plt.subplots(subplot_kw={"projection": "hep"})`` unless the caller
+	explicitly provides a projection in ``subplot_kw``.
+	"""
+
+	global _HEP_DEFAULT_ENABLED
+
+	if enable and not _HEP_DEFAULT_ENABLED:
+		def _hep_default_subplots(*args, **kwargs):
+			subplot_kw = dict(kwargs.get("subplot_kw") or {})
+			subplot_kw.setdefault("projection", "hep")
+			kwargs["subplot_kw"] = subplot_kw
+			return _ORIGINAL_SUBPLOTS(*args, **kwargs)
+
+		plt.subplots = _hep_default_subplots
+		_HEP_DEFAULT_ENABLED = True
+	elif not enable and _HEP_DEFAULT_ENABLED:
+		plt.subplots = _ORIGINAL_SUBPLOTS
+		_HEP_DEFAULT_ENABLED = False
+
+
+# Default-on so users can call plt.subplots() directly after importing HEP_PLOT.
+enable_default_hep_subplots(True)

fuckroot-0.0.0/FUCKROOT/HEP_PLOT/lhcbStyle.C

@@ -0,0 +1,195 @@
+// all users - please change the name of this file to lhcbStyle.C
+// Commits to lhcbdocs svn of .C files are not allowed
+{
+
+  // define names for colours
+  Int_t black  = 1;
+  Int_t red    = 2;
+  Int_t green  = 3;
+  Int_t blue   = 4;
+  Int_t yellow = 5; 
+  Int_t magenta= 6;
+  Int_t cyan   = 7;
+  Int_t purple = 9;
+  
+
+////////////////////////////////////////////////////////////////////
+// PURPOSE:
+//
+// This macro defines a standard style for (black-and-white) 
+// "publication quality" LHCb ROOT plots. 
+//
+// USAGE:
+//
+// Include the lines
+//   gROOT->ProcessLine(".L lhcbstyle.C");
+//   lhcbStyle();
+// at the beginning of your root macro.
+//
+// Example usage is given in myPlot.C
+//
+// COMMENTS:
+//
+// Font:
+// 
+// The font is chosen to be 132, this is Times New Roman (like the text of
+//  your document) with precision 2.
+//
+// "Landscape histograms":
+//
+// The style here is designed for more or less square plots.
+// For longer histograms, or canvas with many pads, adjustements are needed. 
+// For instance, for a canvas with 1x5 histograms:
+//  TCanvas* c1 = new TCanvas("c1", "L0 muons", 600, 800);
+//  c1->Divide(1,5);
+//  Adaptions like the following will be needed:
+//  gStyle->SetTickLength(0.05,"x");
+//  gStyle->SetTickLength(0.01,"y");
+//  gStyle->SetLabelSize(0.15,"x");
+//  gStyle->SetLabelSize(0.1,"y");
+//  gStyle->SetStatW(0.15);
+//  gStyle->SetStatH(0.5);
+//
+// Authors: Thomas Schietinger, Andrew Powell, Chris Parkes, Niels Tuning
+// Maintained by Editorial board member (currently Niels)
+///////////////////////////////////////////////////////////////////
+
+  // Use times new roman, precision 2 
+  Int_t lhcbFont        = 132;  // Old LHCb style: 62;
+  // Line thickness
+  Double_t lhcbWidth    = 2.00; // Old LHCb style: 3.00;
+  // Text size
+  Double_t lhcbTSize    = 0.06; 
+  
+  // use plain black on white colors
+  gROOT->SetStyle("Plain"); 
+  TStyle *lhcbStyle= new TStyle("lhcbStyle","LHCb plots style");
+  
+  //lhcbStyle->SetErrorX(0); //  don't suppress the error bar along X
+
+  lhcbStyle->SetFillColor(1);
+  lhcbStyle->SetFillStyle(1001);   // solid
+  lhcbStyle->SetFrameFillColor(0);
+  lhcbStyle->SetFrameBorderMode(0);
+  lhcbStyle->SetPadBorderMode(0);
+  lhcbStyle->SetPadColor(0);
+  lhcbStyle->SetCanvasBorderMode(0);
+  lhcbStyle->SetCanvasColor(0);
+  lhcbStyle->SetStatColor(0);
+  lhcbStyle->SetLegendBorderSize(0);
+
+  // If you want the usual gradient palette (blue -> red)
+  lhcbStyle->SetPalette(1);
+  // If you want colors that correspond to gray scale in black and white:
+  int colors[8] = {0,5,7,3,6,2,4,1};
+  lhcbStyle->SetPalette(8,colors);
+
+  // set the paper & margin sizes
+  lhcbStyle->SetPaperSize(20,26);
+  lhcbStyle->SetPadTopMargin(0.05);
+  lhcbStyle->SetPadRightMargin(0.05); // increase for colz plots
+  lhcbStyle->SetPadBottomMargin(0.16);
+  lhcbStyle->SetPadLeftMargin(0.14);
+  
+  // use large fonts
+  lhcbStyle->SetTextFont(lhcbFont);
+  lhcbStyle->SetTextSize(lhcbTSize);
+  lhcbStyle->SetLabelFont(lhcbFont,"x");
+  lhcbStyle->SetLabelFont(lhcbFont,"y");
+  lhcbStyle->SetLabelFont(lhcbFont,"z");
+  lhcbStyle->SetLabelSize(lhcbTSize,"x");
+  lhcbStyle->SetLabelSize(lhcbTSize,"y");
+  lhcbStyle->SetLabelSize(lhcbTSize,"z");
+  lhcbStyle->SetTitleFont(lhcbFont);
+  lhcbStyle->SetTitleFont(lhcbFont,"x");
+  lhcbStyle->SetTitleFont(lhcbFont,"y");
+  lhcbStyle->SetTitleFont(lhcbFont,"z");
+  lhcbStyle->SetTitleSize(1.2*lhcbTSize,"x");
+  lhcbStyle->SetTitleSize(1.2*lhcbTSize,"y");
+  lhcbStyle->SetTitleSize(1.2*lhcbTSize,"z");
+
+  // use medium bold lines and thick markers
+  lhcbStyle->SetLineWidth(lhcbWidth);
+  lhcbStyle->SetFrameLineWidth(lhcbWidth);
+  lhcbStyle->SetHistLineWidth(lhcbWidth);
+  lhcbStyle->SetFuncWidth(lhcbWidth);
+  lhcbStyle->SetGridWidth(lhcbWidth);
+  lhcbStyle->SetLineStyleString(2,"[12 12]"); // postscript dashes
+  lhcbStyle->SetMarkerStyle(20);
+  lhcbStyle->SetMarkerSize(1.0);
+
+  // label offsets
+  lhcbStyle->SetLabelOffset(0.010,"X");
+  lhcbStyle->SetLabelOffset(0.010,"Y");
+
+  // by default, do not display histogram decorations:
+  //lhcbStyle->SetOptStat(0);  
+  lhcbStyle->SetOptStat("emr");  // show only nent -e , mean - m , rms -r
+  // full opts at http://root.cern.ch/root/html/TStyle.html#TStyle:SetOptStat
+  lhcbStyle->SetStatFormat("6.3g"); // specified as c printf options
+  lhcbStyle->SetOptTitle(0);
+  lhcbStyle->SetOptFit(0);
+  //lhcbStyle->SetOptFit(1011); // order is probability, Chi2, errors, parameters
+  //titles
+  lhcbStyle->SetTitleOffset(0.95,"X");
+  lhcbStyle->SetTitleOffset(0.95,"Y");
+  lhcbStyle->SetTitleOffset(1.2,"Z");
+  lhcbStyle->SetTitleFillColor(0);
+  lhcbStyle->SetTitleStyle(0);
+  lhcbStyle->SetTitleBorderSize(0);
+  lhcbStyle->SetTitleFont(lhcbFont,"title");
+  lhcbStyle->SetTitleX(0.0);
+  lhcbStyle->SetTitleY(1.0); 
+  lhcbStyle->SetTitleW(1.0);
+  lhcbStyle->SetTitleH(0.05);
+  
+  // look of the statistics box:
+  lhcbStyle->SetStatBorderSize(0);
+  lhcbStyle->SetStatFont(lhcbFont);
+  lhcbStyle->SetStatFontSize(0.05);
+  lhcbStyle->SetStatX(0.9);
+  lhcbStyle->SetStatY(0.9);
+  lhcbStyle->SetStatW(0.25);
+  lhcbStyle->SetStatH(0.15);
+
+  // put tick marks on top and RHS of plots
+  lhcbStyle->SetPadTickX(1);
+  lhcbStyle->SetPadTickY(1);
+
+  // histogram divisions: only 5 in x to avoid label overlaps
+  lhcbStyle->SetNdivisions(505,"x");
+  lhcbStyle->SetNdivisions(510,"y");
+  
+  gROOT->SetStyle("lhcbStyle");
+  gROOT->ForceStyle();
+/*
+  // add LHCb label
+  lhcbName = new TPaveText(gStyle->GetPadLeftMargin() + 0.05,
+                           0.87 - gStyle->GetPadTopMargin(),
+                           gStyle->GetPadLeftMargin() + 0.20,
+                           0.95 - gStyle->GetPadTopMargin(),
+                           "BRNDC");
+  lhcbName->AddText("LHCb");
+  lhcbName->SetFillColor(0);
+  lhcbName->SetTextAlign(12);
+  lhcbName->SetBorderSize(0);
+*/
+  TText *lhcbLabel = new TText();
+  lhcbLabel->SetTextFont(lhcbFont);
+  lhcbLabel->SetTextColor(1);
+  lhcbLabel->SetTextSize(lhcbTSize);
+  lhcbLabel->SetTextAlign(12);
+
+  TLatex *lhcbLatex = new TLatex();
+  lhcbLatex->SetTextFont(lhcbFont);
+  lhcbLatex->SetTextColor(1);
+  lhcbLatex->SetTextSize(lhcbTSize);
+  lhcbLatex->SetTextAlign(12);
+
+  //std::cout << "-------------------------" << std::endl;  
+  //std::cout << "Set LHCb Style - Feb 2012" << std::endl;
+  //std::cout << "-------------------------" << std::endl;  
+  
+}
+
+

fuckroot-0.0.0/FUCKROOT/ROOT_BASE/ROOT.py

@@ -0,0 +1,106 @@
+import time
+
+import numpy as np
+import uproot
+from matplotlib import pyplot as plt
+
+from .Tree import Tree
+from ..HEP_PLOT import HepAxes  # noqa: F401
+
+class ROOT:
+    def __init__(self, filename=None):
+        self.rt_file = None
+        self.load(filename=filename)
+
+    def __str__(self):
+        rt_info = ""
+        if self.rt_file is None:
+            return "No ROOT file is currently loaded"
+        else:
+            rt_info += f"File: {self.filename} is opened\n"
+
+        rt_info += self._directory_tree()
+
+        return rt_info
+
+    def __getitem__(self, key):
+
+        return Tree(self.rt_file[key])
+
+    def _directory_tree(self, max_depth=None):
+        """Return a pretty string of the ROOT file structure; limit depth with max_depth (None = no limit)."""
+        if self.rt_file is None:
+            return "No ROOT file loaded"
+
+        lines = []
+
+        def _recurse(directory, prefix="", level=0):
+            if max_depth is not None and level >= max_depth:
+                return
+            items = list(directory.items(recursive=False))
+            for idx, (key, obj) in enumerate(items):
+                name = key.split(";")[0]
+                connector = "├── " if idx < len(items) - 1 else "└── "
+                
+                lines.append(f"{prefix}{connector}{name}")
+                
+                if isinstance(obj, uproot.reading.ReadOnlyDirectory):
+                    child_prefix = prefix + ("│   " if idx < len(items) - 1 else "    ")
+                    _recurse(obj, child_prefix, level + 1)
+
+        _recurse(self.rt_file)
+        return "\n".join(lines) if lines else "(empty file)"
+
+    def load(self, filename):
+        self.filename = filename
+        try:
+            print(f"Loading ROOT file: {filename}")
+            self.rt_file = uproot.open(filename)
+            print(self.rt_file)
+        except Exception as e:
+            print(f"Error loading file: {e}")
+            self.rt_file = None
+
+
+
+
+
+
+
+
+
+if __name__ == "__main__":
+    # rt = ROOT("/home/easonfu/pyproj/FUCKROOT/large_10G.root")
+    rt = ROOT("/home/easonfu/pyproj/FUCKROOT/tuple_reco_baseline.root")
+    print(rt)
+
+    rt_layer1 = rt["FakeClusteringUP_46bab5f1/layer0;1"]
+    # rt_layer1 = rt["tree"]
+
+
+    print(rt_layer1)
+    print(rt_layer1.keys())
+
+    fig, ax = plt.subplots(subplot_kw={"projection": "hep"})
+
+    # ax2 = ax.twinx()
+    # normalize
+    # rt_layer1.hist1d("var_1", errors=True, ax=ax)
+    # rt_layer1.hist1d("x", errors=True, ax=ax)
+    # rt_layer1.hist1d("y", errors=True, ax=ax)
+    rt_layer1.hist1d("z", errors=True, ax=ax, bins=100)
+
+    ax.set_xlabel("X Label")
+    # ax.set_ylabel("Y Label")
+
+    plt.show()
+
+    # for I in range(10):
+    #     t0 = time.time()
+    #     print(f"Time taken: {time.time() - t0:.2f} seconds")
+
+
+
+
+
+

fuckroot-0.0.0/FUCKROOT/ROOT_BASE/Tree.py

@@ -0,0 +1,79 @@
+import time
+
+import pandas   as pd
+from ..HEP_PLOT import HepAxes  # noqa: F401
+import matplotlib.pyplot as plt
+
+class Tree:
+    def __init__(self, rt):
+        self.rt = rt
+        self._rt_cache = {}
+        self._keys = rt.keys()
+
+        self.data_len = rt.num_entries if hasattr(rt, "num_entries") else 0
+        if self.data_len < 1000:
+            self._rt_df = rt.arrays(library="pd")
+        else:
+            self._rt_df = pd.concat([
+                rt.arrays(entry_start=0, entry_stop=500, library="pd"),
+                rt.arrays(entry_start=self.data_len-500, entry_stop=self.data_len, library="pd")
+            ])
+
+    def __str__(self):
+        return str(self._rt_df)
+
+
+    def keys(self):
+        return self._keys
+
+
+    def hist1d(self, keys, histtype="step", bins=40, label=None, stat=True, errors=True, **kwargs):
+        '''
+        :param keys:
+        :param kwargs:
+        :return:
+        '''
+        if keys not in self._keys:
+            raise KeyError(f"Key ['{keys}'] not in the tree.")
+
+
+        if keys in self._rt_cache:
+            data = self._rt_cache[keys]
+        else:
+            data = self.rt[keys].array(library="np")
+            self._rt_cache[keys] = data
+
+
+        kwargs.setdefault("histtype", histtype)
+        kwargs.setdefault("bins", bins)
+        kwargs.setdefault("label", label or keys)
+
+        fig, ax = plt.subplots()
+        ax.hist(data, stat=stat, errors=errors, **kwargs)
+        ax.set_xlabel(keys)
+        ax.set_ylabel("Entries")
+        ax.grid(True)
+        ax.legend()
+        ax.set_title(f"Histogram of {keys}")
+        plt.tight_layout()
+        plt.show(block=False)
+
+
+        return fig
+    
+    def __getitem__(self, key):
+        if key not in self._keys:
+            raise KeyError(f"Key ['{key}'] not in the tree.")
+        
+        if key in self._rt_cache:
+            return self._rt_cache[key]
+        else:
+            data = self.rt[key].array(library="np")
+            self._rt_cache[key] = data
+            return data
+
+
+
+
+if __name__ == "__main__":
+    pass

fuckroot-0.0.0/FUCKROOT/ROOT_BASE/__init__.py

@@ -0,0 +1,4 @@
+from .ROOT import ROOT
+from .Tree import Tree
+
+__all__ = ["ROOT", "Tree"]

fuckroot-0.0.0/FUCKROOT/__init__.py

@@ -0,0 +1,4 @@
+from .HEP_PLOT import HepAxes
+from .ROOT_BASE import ROOT, Tree
+
+__all__ = ["ROOT", "Tree", "HepAxes"]

fuckroot-0.0.0/FUCKROOT.egg-info/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: FUCKROOT
+Version: 0.0.0
+Summary: FUCKROOT toolkit for ROOT I/O and HEP-style plotting
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: matplotlib>=3.8
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Requires-Dist: uproot>=5.0
+Requires-Dist: tqdm>=4.65
+
+# FUCKROOT
+
+FUCKROOT 是一个面向高能物理（HEP）分析场景的小工具包，提供两类核心能力：
+
+- ROOT 文件读取与树结构访问（基于 `uproot`）
+- Matplotlib 的 HEP 风格绘图投影（`projection="hep"`）
+
+当前版本：`0.1.1`
+
+## Features
+
+- `ROOT` 类：打开 ROOT 文件并打印目录树结构
+- `Tree` 类：
+	- 缓存分支数据，支持 `tree["branch"]` 直接取 NumPy 数组
+	- 快速查看分支名 `tree.keys()`
+	- `hist1d(...)` 一键绘制 1D 直方图
+- `HepAxes` 自定义投影：
+	- LHCb 风格默认样式（刻度、线宽、配色、字体）
+	- `ax.hist(..., stat=True, errors=True)` 自动统计文本与误差棒
+	- 多次 `hist` 自动使用统一 bin/range，便于叠图比较
+	- 支持 `twinx()`（当前版本有已知对齐限制，见下方注意事项）
+
+## Installation
+
+要求：Python `>= 3.10`
+
+推荐在虚拟环境中安装：
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+```
+
+项目依赖（由 `pyproject.toml` 管理）：
+
+- `matplotlib>=3.8`
+- `numpy>=1.24`
+- `pandas>=2.0`
+- `uproot>=5.0`
+- `tqdm>=4.65`
+
+## Quick Start
+
+### 1) 打开 ROOT 文件并查看目录
+
+```python
+from FUCKROOT import ROOT
+
+rt = ROOT("your_file.root")
+print(rt)  # 打印 ROOT 目录树
+```
+
+### 2) 访问树并读取分支
+
+```python
+tree = rt["tree"]
+print(tree.keys())
+
+x = tree["var_0"]  # 返回 numpy.ndarray
+print(x.shape)
+```
+
+### 3) 画 HEP 风格直方图
+
+```python
+import matplotlib.pyplot as plt
+
+fig, ax = plt.subplots(subplot_kw={"projection": "hep"})
+ax.hist(x, bins=60, label="var_0", stat=True, errors=True)
+ax.set_xlabel("var_0")
+ax.set_ylabel("Entries")
+ax.legend()
+plt.show()
+```
+
+说明：导入 `FUCKROOT.HEP_PLOT` 后，`plt.subplots()` 默认会启用 `projection="hep"`。
+
+## Public API
+
+`FUCKROOT/__init__.py` 暴露以下对象：
+
+- `ROOT`
+- `Tree`
+- `HepAxes`
+
+你可以直接：
+
+```python
+from FUCKROOT import ROOT, Tree, HepAxes
+```
+
+## Notes And Caveats
+
+- `Tree.__init__` 在数据量较大时只预取前 500 和后 500 条用于快速预览；实际分支数据在 `tree["branch"]` 时按需读取并缓存。
+- `Tree.hist1d(...)` 当前实现会内部创建新的 `figure/axes` 并直接显示（`plt.show(block=False)`）。
+- `HepAxes.twinx()` 会给出 warning：双轴直方图在当前版本下可能存在 bin 对齐问题，不建议用于严格对齐比较。
+
+## Package Layout
+
+```text
+FUCKROOT/
+	HEP_PLOT/
+		HepFigure.py   # HepAxes 实现与投影注册
+		lhcbStyle.C    # ROOT 风格参考文件
+	ROOT_BASE/
+		ROOT.py        # ROOT 文件包装
+		Tree.py        # 树数据与绘图辅助
+```
+
+## Development
+
+本地开发安装：
+
+```bash
+pip install -e .
+```
+
+构建分发包：
+
+```bash
+python -m build
+```

fuckroot-0.0.0/FUCKROOT.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+FUCKROOT/__init__.py
+FUCKROOT.egg-info/PKG-INFO
+FUCKROOT.egg-info/SOURCES.txt
+FUCKROOT.egg-info/dependency_links.txt
+FUCKROOT.egg-info/requires.txt
+FUCKROOT.egg-info/top_level.txt
+FUCKROOT/HEP_PLOT/HepFigure.py
+FUCKROOT/HEP_PLOT/__init__.py
+FUCKROOT/HEP_PLOT/lhcbStyle.C
+FUCKROOT/ROOT_BASE/ROOT.py
+FUCKROOT/ROOT_BASE/Tree.py
+FUCKROOT/ROOT_BASE/__init__.py

fuckroot-0.0.0/FUCKROOT.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fuckroot-0.0.0/FUCKROOT.egg-info/requires.txt

@@ -0,0 +1,5 @@
+matplotlib>=3.8
+numpy>=1.24
+pandas>=2.0
+uproot>=5.0
+tqdm>=4.65

fuckroot-0.0.0/FUCKROOT.egg-info/top_level.txt

@@ -0,0 +1 @@
+FUCKROOT

fuckroot-0.0.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: FUCKROOT
+Version: 0.0.0
+Summary: FUCKROOT toolkit for ROOT I/O and HEP-style plotting
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: matplotlib>=3.8
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Requires-Dist: uproot>=5.0
+Requires-Dist: tqdm>=4.65
+
+# FUCKROOT
+
+FUCKROOT 是一个面向高能物理（HEP）分析场景的小工具包，提供两类核心能力：
+
+- ROOT 文件读取与树结构访问（基于 `uproot`）
+- Matplotlib 的 HEP 风格绘图投影（`projection="hep"`）
+
+当前版本：`0.1.1`
+
+## Features
+
+- `ROOT` 类：打开 ROOT 文件并打印目录树结构
+- `Tree` 类：
+	- 缓存分支数据，支持 `tree["branch"]` 直接取 NumPy 数组
+	- 快速查看分支名 `tree.keys()`
+	- `hist1d(...)` 一键绘制 1D 直方图
+- `HepAxes` 自定义投影：
+	- LHCb 风格默认样式（刻度、线宽、配色、字体）
+	- `ax.hist(..., stat=True, errors=True)` 自动统计文本与误差棒
+	- 多次 `hist` 自动使用统一 bin/range，便于叠图比较
+	- 支持 `twinx()`（当前版本有已知对齐限制，见下方注意事项）
+
+## Installation
+
+要求：Python `>= 3.10`
+
+推荐在虚拟环境中安装：
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+```
+
+项目依赖（由 `pyproject.toml` 管理）：
+
+- `matplotlib>=3.8`
+- `numpy>=1.24`
+- `pandas>=2.0`
+- `uproot>=5.0`
+- `tqdm>=4.65`
+
+## Quick Start
+
+### 1) 打开 ROOT 文件并查看目录
+
+```python
+from FUCKROOT import ROOT
+
+rt = ROOT("your_file.root")
+print(rt)  # 打印 ROOT 目录树
+```
+
+### 2) 访问树并读取分支
+
+```python
+tree = rt["tree"]
+print(tree.keys())
+
+x = tree["var_0"]  # 返回 numpy.ndarray
+print(x.shape)
+```
+
+### 3) 画 HEP 风格直方图
+
+```python
+import matplotlib.pyplot as plt
+
+fig, ax = plt.subplots(subplot_kw={"projection": "hep"})
+ax.hist(x, bins=60, label="var_0", stat=True, errors=True)
+ax.set_xlabel("var_0")
+ax.set_ylabel("Entries")
+ax.legend()
+plt.show()
+```
+
+说明：导入 `FUCKROOT.HEP_PLOT` 后，`plt.subplots()` 默认会启用 `projection="hep"`。
+
+## Public API
+
+`FUCKROOT/__init__.py` 暴露以下对象：
+
+- `ROOT`
+- `Tree`
+- `HepAxes`
+
+你可以直接：
+
+```python
+from FUCKROOT import ROOT, Tree, HepAxes
+```
+
+## Notes And Caveats
+
+- `Tree.__init__` 在数据量较大时只预取前 500 和后 500 条用于快速预览；实际分支数据在 `tree["branch"]` 时按需读取并缓存。
+- `Tree.hist1d(...)` 当前实现会内部创建新的 `figure/axes` 并直接显示（`plt.show(block=False)`）。
+- `HepAxes.twinx()` 会给出 warning：双轴直方图在当前版本下可能存在 bin 对齐问题，不建议用于严格对齐比较。
+
+## Package Layout
+
+```text
+FUCKROOT/
+	HEP_PLOT/
+		HepFigure.py   # HepAxes 实现与投影注册
+		lhcbStyle.C    # ROOT 风格参考文件
+	ROOT_BASE/
+		ROOT.py        # ROOT 文件包装
+		Tree.py        # 树数据与绘图辅助
+```
+
+## Development
+
+本地开发安装：
+
+```bash
+pip install -e .
+```
+
+构建分发包：
+
+```bash
+python -m build
+```

fuckroot-0.0.0/README.md

@@ -0,0 +1,123 @@
+# FUCKROOT
+
+FUCKROOT 是一个面向高能物理（HEP）分析场景的小工具包，提供两类核心能力：
+
+- ROOT 文件读取与树结构访问（基于 `uproot`）
+- Matplotlib 的 HEP 风格绘图投影（`projection="hep"`）
+
+当前版本：`0.1.1`
+
+## Features
+
+- `ROOT` 类：打开 ROOT 文件并打印目录树结构
+- `Tree` 类：
+	- 缓存分支数据，支持 `tree["branch"]` 直接取 NumPy 数组
+	- 快速查看分支名 `tree.keys()`
+	- `hist1d(...)` 一键绘制 1D 直方图
+- `HepAxes` 自定义投影：
+	- LHCb 风格默认样式（刻度、线宽、配色、字体）
+	- `ax.hist(..., stat=True, errors=True)` 自动统计文本与误差棒
+	- 多次 `hist` 自动使用统一 bin/range，便于叠图比较
+	- 支持 `twinx()`（当前版本有已知对齐限制，见下方注意事项）
+
+## Installation
+
+要求：Python `>= 3.10`
+
+推荐在虚拟环境中安装：
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+```
+
+项目依赖（由 `pyproject.toml` 管理）：
+
+- `matplotlib>=3.8`
+- `numpy>=1.24`
+- `pandas>=2.0`
+- `uproot>=5.0`
+- `tqdm>=4.65`
+
+## Quick Start
+
+### 1) 打开 ROOT 文件并查看目录
+
+```python
+from FUCKROOT import ROOT
+
+rt = ROOT("your_file.root")
+print(rt)  # 打印 ROOT 目录树
+```
+
+### 2) 访问树并读取分支
+
+```python
+tree = rt["tree"]
+print(tree.keys())
+
+x = tree["var_0"]  # 返回 numpy.ndarray
+print(x.shape)
+```
+
+### 3) 画 HEP 风格直方图
+
+```python
+import matplotlib.pyplot as plt
+
+fig, ax = plt.subplots(subplot_kw={"projection": "hep"})
+ax.hist(x, bins=60, label="var_0", stat=True, errors=True)
+ax.set_xlabel("var_0")
+ax.set_ylabel("Entries")
+ax.legend()
+plt.show()
+```
+
+说明：导入 `FUCKROOT.HEP_PLOT` 后，`plt.subplots()` 默认会启用 `projection="hep"`。
+
+## Public API
+
+`FUCKROOT/__init__.py` 暴露以下对象：
+
+- `ROOT`
+- `Tree`
+- `HepAxes`
+
+你可以直接：
+
+```python
+from FUCKROOT import ROOT, Tree, HepAxes
+```
+
+## Notes And Caveats
+
+- `Tree.__init__` 在数据量较大时只预取前 500 和后 500 条用于快速预览；实际分支数据在 `tree["branch"]` 时按需读取并缓存。
+- `Tree.hist1d(...)` 当前实现会内部创建新的 `figure/axes` 并直接显示（`plt.show(block=False)`）。
+- `HepAxes.twinx()` 会给出 warning：双轴直方图在当前版本下可能存在 bin 对齐问题，不建议用于严格对齐比较。
+
+## Package Layout
+
+```text
+FUCKROOT/
+	HEP_PLOT/
+		HepFigure.py   # HepAxes 实现与投影注册
+		lhcbStyle.C    # ROOT 风格参考文件
+	ROOT_BASE/
+		ROOT.py        # ROOT 文件包装
+		Tree.py        # 树数据与绘图辅助
+```
+
+## Development
+
+本地开发安装：
+
+```bash
+pip install -e .
+```
+
+构建分发包：
+
+```bash
+python -m build
+```

fuckroot-0.0.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "FUCKROOT"
+version = "0.0.0"
+description = "FUCKROOT toolkit for ROOT I/O and HEP-style plotting"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+  "matplotlib>=3.8",
+  "numpy>=1.24",
+  "pandas>=2.0",
+  "uproot>=5.0",
+  "tqdm>=4.65",
+]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["FUCKROOT*"]
+exclude = ["zdelete*"]
+
+[tool.setuptools.package-data]
+"FUCKROOT.HEP_PLOT" = ["*.C"]

fuckroot-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+