diff --git a/include/aare/Chi2.hpp b/include/aare/Chi2.hpp
index 3b84567..b07fdbb 100644
--- a/include/aare/Chi2.hpp
+++ b/include/aare/Chi2.hpp
@@ -138,6 +138,12 @@ class Chi2Model1DGrad : public ROOT::Minuit2::FCNGradientBase {
 // ── Convenient aliases ──────────────────────────────────────────────
 
 using Chi2Gaussian = Chi2Model1DGrad<aare::model::Gaussian>;
+using Chi2GaussianErfcPlateau =
+    Chi2Model1DGrad<aare::model::GaussianErfcPlateau>;
+using Chi2GaussianChargeSharing =
+    Chi2Model1DGrad<aare::model::GaussianChargeSharing>;
+using Chi2GaussianChargeSharingKb =
+    Chi2Model1DGrad<aare::model::GaussianChargeSharingKb>;
 using Chi2RisingScurve = Chi2Model1DGrad<aare::model::RisingScurve>;
 using Chi2FallingScurve = Chi2Model1DGrad<aare::model::FallingScurve>;
 using Chi2Pol1 = Chi2Model1DGrad<aare::model::Pol1>;
diff --git a/include/aare/Models.hpp b/include/aare/Models.hpp
index 3c0e0cc..eee84e2 100644
--- a/include/aare/Models.hpp
+++ b/include/aare/Models.hpp
@@ -340,6 +340,510 @@ struct Gaussian {
     }
 };
 
+// _____________________________________________________________________
+//
+// GaussianErfcPlateau
+// _____________________________________________________________________
+
+/**
+ * @brief Gaussian peak plus a falling error-function plateau.
+ *
+ * Equivalent to the ROOT-style expression:
+ *
+ *   [0] * exp(-0.5 * ((x - [2])/[3])^2)
+ * + [1] * (1 - erf((x - [2]) / ([3] * sqrt(2)))) / 2
+ *
+ * f(x) = A * exp(-(x - mu)^2 / (2*sigma^2))
+ *      + S * 0.5 * (1 - erf((x - mu) / (sqrt(2)*sigma)))
+ *
+ * Parameters:
+ *   par[0] = A      (Gaussian amplitude)
+ *   par[1] = S      (left plateau height)
+ *   par[2] = mu     (shared Gaussian center / step inflection point)
+ *   par[3] = sigma  (shared Gaussian width / step width, must be > 0)
+ *
+ * Analytic partial derivatives:
+ *   Let dx = x - mu
+ *       z  = dx / (sqrt(2)*sigma)
+ *       E  = exp(-z^2)
+ *       H  = 0.5 * (1 - erf(z))
+ *
+ *   df/dA     = E
+ *   df/dS     = H
+ *   df/dmu    = A*E*dx/sigma^2 + S*E/(sqrt(2*pi)*sigma)
+ *   df/dsigma = A*E*dx^2/sigma^3 + S*E*dx/(sqrt(2*pi)*sigma^2)
+ */
+struct GaussianErfcPlateau {
+    static constexpr std::size_t npar = 4;
+
+    static constexpr std::array<ParamInfo, npar> param_info = {{
+        {"A", -no_bound, no_bound},
+        {"S", -no_bound, no_bound},
+        {"mu", -no_bound, no_bound},
+        {"sigma", 1e-12, no_bound},
+    }};
+
+    static double eval(double x, const std::vector<double> &par) {
+        const double A = par[0];
+        const double S = par[1];
+        const double mu = par[2];
+        const double sig = par[3];
+
+        const double dx = x - mu;
+        const double z = dx * inv_sqrt2 / sig;
+
+        const double e = std::exp(-z * z);
+        const double step = 0.5 * (1.0 - fast_erf(z));
+
+        return A * e + S * step;
+    }
+
+    static void eval_and_grad(double x, const std::vector<double> &par,
+                              double &f, std::array<double, npar> &g) {
+        const double A = par[0];
+        const double S = par[1];
+        const double mu = par[2];
+        const double sig = par[3];
+
+        const double dx = x - mu;
+        const double z = dx * inv_sqrt2 / sig;
+
+        const double e = std::exp(-z * z);
+        const double step = 0.5 * (1.0 - fast_erf(z));
+
+        f = A * e + S * step;
+
+        const double inv_sig = 1.0 / sig;
+        const double inv_sig2 = inv_sig * inv_sig;
+        const double inv_sig3 = inv_sig2 * inv_sig;
+
+        g[0] = e;    // df/dA
+        g[1] = step; // df/dS
+
+        g[2] = A * e * dx * inv_sig2 + S * inv_sqrt_2pi * e * inv_sig; // df/dmu
+
+        g[3] = A * e * dx * dx * inv_sig3 +
+               S * inv_sqrt_2pi * e * dx * inv_sig2; // df/dsigma
+    }
+
+    /** @brief Reject degenerate or negative width. */
+    static bool is_valid(const std::vector<double> &par) {
+        return par[3] > 0.0;
+    }
+
+    /**
+     * @brief Data-driven initial parameter estimates.
+     *
+     * Assumes x is sorted ascending and the plateau is on the left.
+     *
+     * S      ~ average of first 10% of y values
+     * mu     ~ x at maximum y
+     * A      ~ y_max - 0.5*S
+     * sigma  ~ right-side half-width of the peak, fallback to 10% x-range
+     */
+    static std::array<double, npar> estimate_par(NDView<double, 1> x,
+                                                 NDView<double, 1> y) {
+        const ssize_t n = y.size();
+
+        const auto max_it = std::max_element(y.begin(), y.end());
+        const ssize_t i_max = std::distance(y.begin(), max_it);
+
+        const double y_max = *max_it;
+
+        const double x_range = std::max(x[n - 1] - x[0], 1e-9);
+
+        const ssize_t tail = std::min<ssize_t>(std::max<ssize_t>(n / 10, 2), n);
+
+        double left_mean = 0.0;
+        double right_mean = 0.0;
+
+        for (ssize_t i = 0; i < tail; ++i)
+            left_mean += y[i];
+        left_mean /= tail;
+
+        for (ssize_t i = n - tail; i < n; ++i)
+            right_mean += y[i];
+        right_mean /= tail;
+
+        const double S = left_mean;
+        const double mu = x[i_max];
+
+        // At x = mu, the erfc step contributes roughly S/2.
+        const double A = y_max - 0.5 * S;
+
+        // Estimate sigma from the right half-width of the peak.
+        // This avoids the left plateau biasing the FWHM estimate.
+        const double half = right_mean + 0.5 * (y_max - right_mean);
+
+        double sig = 0.1 * x_range;
+        for (ssize_t i = i_max; i < n; ++i) {
+            if (y[i] <= half) {
+                const double half_width = std::abs(x[i] - mu);
+                if (half_width > 1e-12) {
+                    sig = half_width / 1.1774100225154747; // sqrt(2*ln(2))
+                }
+                break;
+            }
+        }
+
+        sig = std::max(sig, 1e-6);
+
+        return {A, S, mu, sig};
+    }
+
+    static void compute_steps(const std::array<double, npar> &start,
+                              double x_range, double y_range,
+                              double /*slope_scale*/,
+                              std::array<double, npar> &steps) {
+        steps[0] = std::max(0.1 * std::abs(start[0]), 0.1 * y_range);
+        steps[1] = std::max(0.1 * std::abs(start[1]), 0.1 * y_range);
+        steps[2] = 0.05 * x_range;
+        steps[3] = 0.05 * x_range;
+    }
+};
+
+// _____________________________________________________________________
+//
+// GaussianChargeSharing
+// _____________________________________________________________________
+
+/**
+ * @brief Gaussian peak with erfc charge-sharing tail and linear pedestal.
+ *
+ * Equivalent to the old ROOT energyCalibration function:
+ *
+ *   gaussChargeSharing(x, par)
+ *
+ * for sign = +1:
+ *
+ *   f(x) = p0 - p1*x
+ *        + N * [ G(x; mu, sigma) + C * H(x; mu, sigma) ]
+ *
+ * where:
+ *
+ *   G = exp(-0.5 * ((x - mu)/sigma)^2)
+ *   H = 0.5 * erfc((x - mu)/(sqrt(2)*sigma))
+ *
+ * Parameters:
+ *   par[0] = p0     background pedestal
+ *   par[1] = p1     background slope, ROOT convention uses p0 - p1*x
+ *   par[2] = mu     peak position
+ *   par[3] = sigma  noise RMS / Gaussian width
+ *   par[4] = N      number of photons / global amplitude
+ *   par[5] = C      charge-sharing pedestal
+ */
+struct GaussianChargeSharing {
+    static constexpr std::size_t npar = 6;
+
+    static constexpr std::array<ParamInfo, npar> param_info = {{
+        {"p0", -no_bound, no_bound},
+        {"p1", -no_bound, no_bound},
+        {"mu", -no_bound, no_bound},
+        {"sigma", 1e-12, no_bound},
+        {"N", -no_bound, no_bound},
+        {"C", -no_bound, no_bound},
+    }};
+
+    static double eval(double x, const std::vector<double> &par) {
+        const double p0 = par[0];
+        const double p1 = par[1];
+        const double mu = par[2];
+        const double sig = par[3];
+        const double N = par[4];
+        const double C = par[5];
+
+        const double dx = x - mu;
+        const double u = dx / sig;
+
+        const double G = std::exp(-0.5 * u * u);
+        const double H = 0.5 * (1.0 - fast_erf(u * inv_sqrt2));
+
+        return p0 - p1 * x + N * (G + C * H);
+    }
+
+    static void eval_and_grad(double x, const std::vector<double> &par,
+                              double &f, std::array<double, npar> &g) {
+        const double p0 = par[0];
+        const double p1 = par[1];
+        const double mu = par[2];
+        const double sig = par[3];
+        const double N = par[4];
+        const double C = par[5];
+
+        const double dx = x - mu;
+        const double u = dx / sig;
+
+        const double G = std::exp(-0.5 * u * u);
+        const double H = 0.5 * (1.0 - fast_erf(u * inv_sqrt2));
+
+        f = p0 - p1 * x + N * (G + C * H);
+
+        const double inv_sig = 1.0 / sig;
+        const double inv_sig2 = inv_sig * inv_sig;
+        const double inv_sig3 = inv_sig2 * inv_sig;
+
+        const double dG_dmu = G * dx * inv_sig2;
+        const double dG_dsig = G * dx * dx * inv_sig3;
+
+        const double dH_dmu = inv_sqrt_2pi * G * inv_sig;
+        const double dH_dsig = inv_sqrt_2pi * G * dx * inv_sig2;
+
+        g[0] = 1.0;
+        g[1] = -x;
+        g[2] = N * (dG_dmu + C * dH_dmu);
+        g[3] = N * (dG_dsig + C * dH_dsig);
+        g[4] = G + C * H;
+        g[5] = N * H;
+    }
+
+    static bool is_valid(const std::vector<double> &par) {
+        return par[3] > 0.0;
+    }
+
+    static std::array<double, npar> estimate_par(NDView<double, 1> x,
+                                                 NDView<double, 1> y) {
+        const ssize_t n = y.size();
+
+        const auto max_it = std::max_element(y.begin(), y.end());
+        const ssize_t i_max = std::distance(y.begin(), max_it);
+
+        const double x_range = std::max(x[n - 1] - x[0], 1e-9);
+
+        const ssize_t tail = std::min<ssize_t>(std::max<ssize_t>(n / 10, 2), n);
+
+        double left_mean = 0.0;
+        double right_mean = 0.0;
+
+        for (ssize_t i = 0; i < tail; ++i)
+            left_mean += y[i];
+        left_mean /= tail;
+
+        for (ssize_t i = n - tail; i < n; ++i)
+            right_mean += y[i];
+        right_mean /= tail;
+
+        const double p0 = right_mean;
+        const double p1 = 0.0;
+        const double mu = x[i_max];
+
+        const double N = std::max(*max_it - right_mean, 1e-9);
+
+        // Left plateau excess is roughly N*C.
+        const double C = (left_mean - right_mean) / N;
+
+        double sigma = 0.1 * x_range;
+        const double half = right_mean + 0.5 * ((*max_it) - right_mean);
+
+        for (ssize_t i = i_max; i < n; ++i) {
+            if (y[i] <= half) {
+                const double half_width = std::abs(x[i] - mu);
+                if (half_width > 1e-12)
+                    sigma = half_width / 1.1774100225154747; // sqrt(2*ln(2))
+                break;
+            }
+        }
+
+        sigma = std::max(sigma, 1e-6);
+
+        return {p0, p1, mu, sigma, N, C};
+    }
+
+    static void compute_steps(const std::array<double, npar> &start,
+                              double x_range, double y_range,
+                              double slope_scale,
+                              std::array<double, npar> &steps) {
+        steps[0] = std::max(0.1 * std::abs(start[0]), 0.1 * y_range);
+        steps[1] = 0.1 * slope_scale;
+        steps[2] = 0.05 * x_range;
+        steps[3] = 0.05 * x_range;
+        steps[4] = std::max(0.1 * std::abs(start[4]), 0.1 * y_range);
+        steps[5] = std::max(0.1 * std::abs(start[5]), 0.01);
+    }
+};
+
+// _____________________________________________________________________
+//
+// GaussianChargeSharingKb
+// _____________________________________________________________________
+
+/**
+ * @brief Double-Gaussian Kα/Kβ spectrum with erfc charge-sharing tails.
+ *
+ * Equivalent to the old ROOT energyCalibration function:
+ *
+ *   gaussChargeSharingKb(x, par)
+ *
+ * for sign = +1:
+ *
+ *   mu_b = r * mu
+ *
+ *   f(x) = p0 - p1*x
+ *        + N * [
+ *              G(x; mu, sigma)
+ *            + C * H(x; mu, sigma)
+ *            + q * G(x; mu_b, sigma)
+ *            + q * C * H(x; mu_b, sigma)
+ *          ]
+ *
+ * Parameters:
+ *   par[0] = p0      background pedestal
+ *   par[1] = p1      background slope, ROOT convention uses p0 - p1*x
+ *   par[2] = mu      Kα peak position
+ *   par[3] = sigma   shared width / noise RMS
+ *   par[4] = N       global amplitude / number of photons
+ *   par[5] = C       charge-sharing pedestal
+ *   par[6] = r       Kβ mean ratio, mu_Kb = r * mu
+ *   par[7] = q       Kβ fraction
+ */
+struct GaussianChargeSharingKb {
+    static constexpr std::size_t npar = 8;
+
+    static constexpr std::array<ParamInfo, npar> param_info = {{
+        {"p0", -no_bound, no_bound},
+        {"p1", -no_bound, no_bound},
+        {"mu", -no_bound, no_bound},
+        {"sigma", 1e-12, no_bound},
+        {"N", -no_bound, no_bound},
+        {"C", -no_bound, no_bound},
+        {"kb_mean", -no_bound, no_bound},
+        {"kb_frac", -no_bound, no_bound},
+    }};
+
+    static double eval(double x, const std::vector<double> &par) {
+        const double p0 = par[0];
+        const double p1 = par[1];
+        const double mu = par[2];
+        const double sig = par[3];
+        const double N = par[4];
+        const double C = par[5];
+        const double r = par[6];
+        const double q = par[7];
+
+        const double mu_b = r * mu;
+
+        const double dx = x - mu;
+        const double dxb = x - mu_b;
+
+        const double u = dx / sig;
+        const double ub = dxb / sig;
+
+        const double G = std::exp(-0.5 * u * u);
+        const double Gb = std::exp(-0.5 * ub * ub);
+
+        const double H = 0.5 * (1.0 - fast_erf(u * inv_sqrt2));
+        const double Hb = 0.5 * (1.0 - fast_erf(ub * inv_sqrt2));
+
+        const double ka = G + C * H;
+        const double kb = Gb + C * Hb;
+
+        return p0 - p1 * x + N * (ka + q * kb);
+    }
+
+    static void eval_and_grad(double x, const std::vector<double> &par,
+                              double &f, std::array<double, npar> &g) {
+        const double p0 = par[0];
+        const double p1 = par[1];
+        const double mu = par[2];
+        const double sig = par[3];
+        const double N = par[4];
+        const double C = par[5];
+        const double r = par[6];
+        const double q = par[7];
+
+        const double mu_b = r * mu;
+
+        const double dx = x - mu;
+        const double dxb = x - mu_b;
+
+        const double u = dx / sig;
+        const double ub = dxb / sig;
+
+        const double G = std::exp(-0.5 * u * u);
+        const double Gb = std::exp(-0.5 * ub * ub);
+
+        const double H = 0.5 * (1.0 - fast_erf(u * inv_sqrt2));
+        const double Hb = 0.5 * (1.0 - fast_erf(ub * inv_sqrt2));
+
+        const double ka = G + C * H;
+        const double kb = Gb + C * Hb;
+
+        f = p0 - p1 * x + N * (ka + q * kb);
+
+        const double inv_sig = 1.0 / sig;
+        const double inv_sig2 = inv_sig * inv_sig;
+        const double inv_sig3 = inv_sig2 * inv_sig;
+
+        const double dG_dmu = G * dx * inv_sig2;
+        const double dG_dsig = G * dx * dx * inv_sig3;
+        const double dH_dmu = inv_sqrt_2pi * G * inv_sig;
+        const double dH_dsig = inv_sqrt_2pi * G * dx * inv_sig2;
+
+        const double dGb_dmu_b = Gb * dxb * inv_sig2;
+        const double dGb_dsig = Gb * dxb * dxb * inv_sig3;
+        const double dHb_dmu_b = inv_sqrt_2pi * Gb * inv_sig;
+        const double dHb_dsig = inv_sqrt_2pi * Gb * dxb * inv_sig2;
+
+        const double dka_dmu = dG_dmu + C * dH_dmu;
+        const double dka_dsig = dG_dsig + C * dH_dsig;
+
+        const double dkb_dmu_b = dGb_dmu_b + C * dHb_dmu_b;
+        const double dkb_dsig = dGb_dsig + C * dHb_dsig;
+
+        g[0] = 1.0;
+        g[1] = -x;
+
+        // mu_b = r * mu, so dmu_b/dmu = r
+        g[2] = N * (dka_dmu + q * r * dkb_dmu_b);
+
+        g[3] = N * (dka_dsig + q * dkb_dsig);
+
+        g[4] = ka + q * kb;
+
+        g[5] = N * (H + q * Hb);
+
+        // mu_b = r * mu, so dmu_b/dr = mu
+        g[6] = N * q * mu * dkb_dmu_b;
+
+        g[7] = N * kb;
+    }
+
+    static bool is_valid(const std::vector<double> &par) {
+        return par[3] > 0.0;
+    }
+
+    static std::array<double, npar> estimate_par(NDView<double, 1> x,
+                                                 NDView<double, 1> y) {
+        const auto base = GaussianChargeSharing::estimate_par(x, y);
+
+        const double p0 = base[0];
+        const double p1 = base[1];
+        const double mu = base[2];
+        const double sigma = base[3];
+        const double N = base[4];
+        const double C = base[5];
+
+        // Good generic starting values for Cu Kβ relative to Kα.
+        const double kb_mean = 1.10;
+        const double kb_frac = 0.10;
+
+        return {p0, p1, mu, sigma, N, C, kb_mean, kb_frac};
+    }
+
+    static void compute_steps(const std::array<double, npar> &start,
+                              double x_range, double y_range,
+                              double slope_scale,
+                              std::array<double, npar> &steps) {
+        steps[0] = std::max(0.1 * std::abs(start[0]), 0.1 * y_range);
+        steps[1] = 0.1 * slope_scale;
+        steps[2] = 0.05 * x_range;
+        steps[3] = 0.05 * x_range;
+        steps[4] = std::max(0.1 * std::abs(start[4]), 0.1 * y_range);
+        steps[5] = std::max(0.1 * std::abs(start[5]), 0.01);
+        steps[6] = std::max(0.01 * std::abs(start[6]), 1e-3);
+        steps[7] = std::max(0.1 * std::abs(start[7]), 0.01);
+    }
+};
+
 // _____________________________________________________________________
 //
 // RisingScurve
diff --git a/python/aare/__init__.py b/python/aare/__init__.py
index 0145f37..f4bddda 100644
--- a/python/aare/__init__.py
+++ b/python/aare/__init__.py
@@ -17,7 +17,7 @@ from .ClusterFinder import ClusterFinder, ClusterCollector, ClusterFinderMT, Clu
 from .ClusterVector import ClusterVector
 from .Cluster import Cluster
 
-from ._aare import Gaussian, RisingScurve, FallingScurve, Pol1, Pol2
+from ._aare import Gaussian, RisingScurve, FallingScurve, Pol1, Pol2, GaussianErfcPlateau, GaussianChargeSharing, GaussianChargeSharingKb
 from ._aare import fit
 from ._aare import fit_gaus, fit_pol1, fit_scurve, fit_scurve2
 from ._aare import Interpolator
diff --git a/python/src/fit.hpp b/python/src/fit.hpp
index 1101415..f045d43 100644
--- a/python/src/fit.hpp
+++ b/python/src/fit.hpp
@@ -679,6 +679,11 @@ void define_fit_bindings(py::module &m) {
 
     // ── Bind model classes ──────────────────────────────────────────
     bind_fit_model<aare::model::Gaussian>(m, "Gaussian");
+    bind_fit_model<aare::model::GaussianErfcPlateau>(m, "GaussianErfcPlateau");
+    bind_fit_model<aare::model::GaussianChargeSharing>(m,
+                                                       "GaussianChargeSharing");
+    bind_fit_model<aare::model::GaussianChargeSharingKb>(
+        m, "GaussianChargeSharingKb");
     bind_fit_model<aare::model::RisingScurve>(m, "RisingScurve");
     bind_fit_model<aare::model::FallingScurve>(m, "FallingScurve");
     bind_fit_model<aare::model::Pol1>(m, "Pol1");
@@ -716,6 +721,38 @@ void define_fit_bindings(py::module &m) {
                     mdl, x, y, y_err_obj, n_threads);
             }
 
+            // ── GaussianErfcPlateau ───────
+            if (py::isinstance<aare::FitModel<GaussianErfcPlateau>>(
+                    model_obj)) {
+                const auto &mdl =
+                    model_obj
+                        .cast<const aare::FitModel<GaussianErfcPlateau> &>();
+                return fit_dispatch<GaussianErfcPlateau,
+                                    Chi2GaussianErfcPlateau>(
+                    mdl, x, y, y_err_obj, n_threads);
+            }
+
+            // ── GaussianChargeSharing ───────
+            if (py::isinstance<aare::FitModel<GaussianChargeSharing>>(
+                    model_obj)) {
+                const auto &mdl =
+                    model_obj
+                        .cast<const aare::FitModel<GaussianChargeSharing> &>();
+                return fit_dispatch<GaussianChargeSharing,
+                                    Chi2GaussianChargeSharing>(
+                    mdl, x, y, y_err_obj, n_threads);
+            }
+
+            // ── GaussianChargeSharingKb ───────
+            if (py::isinstance<aare::FitModel<GaussianChargeSharingKb>>(
+                    model_obj)) {
+                const auto &mdl = model_obj.cast<
+                    const aare::FitModel<GaussianChargeSharingKb> &>();
+                return fit_dispatch<GaussianChargeSharingKb,
+                                    Chi2GaussianChargeSharingKb>(
+                    mdl, x, y, y_err_obj, n_threads);
+            }
+
             // ── Rising Scurve ───────
             if (py::isinstance<aare::FitModel<RisingScurve>>(model_obj)) {
                 const auto &mdl =
diff --git a/python/tests/GaussainErfcPlateau.ipynb b/python/tests/GaussainErfcPlateau.ipynb
new file mode 100644
index 0000000..c189e09
--- /dev/null
+++ b/python/tests/GaussainErfcPlateau.ipynb
@@ -0,0 +1,367 @@
+{
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "id": "fbdc2fb9",
+            "metadata": {},
+            "source": [
+                "# Test `GaussianErfcPlateau` Python bindings\n",
+                "\n",
+                "Minimal check for the Aare Minuit2 object API against a SciPy `curve_fit` reference.\n",
+                "\n",
+                "Model:\n",
+                "\n",
+                "\\[\n",
+                "f(x) =\n",
+                "A \\exp\\left[-\\frac{1}{2}\\left(\\frac{x-\\mu}{\\sigma}\\right)^2\\right]\n",
+                "+\n",
+                "\\frac{S}{2}\\left[\n",
+                "1 - \\operatorname{erf}\\left(\n",
+                "\\frac{x-\\mu}{\\sqrt{2}\\sigma}\n",
+                "\\right)\n",
+                "\\right]\n",
+                "\\]\n",
+                "\n",
+                "Parameter order:\n",
+                "\n",
+                "```text\n",
+                "[A, S, mu, sigma]\n",
+                "```"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 1,
+            "id": "2835b05b",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import time\n",
+                "import numpy as np\n",
+                "np.set_printoptions(suppress=True, precision=6)\n",
+                "\n",
+                "import matplotlib.pyplot as plt\n",
+                "from scipy.special import erf\n",
+                "from scipy.optimize import curve_fit\n",
+                "from pprint import pprint\n",
+                "\n",
+                "import sys\n",
+                "sys.path.insert(0, \"/home/ferjao_k/sw/aare/build\")\n",
+                "\n",
+                "try:\n",
+                "    from aare import GaussianErfcPlateau\n",
+                "except ImportError:\n",
+                "    import aare\n",
+                "    print(\"Could not import GaussianErfcPlateau directly.\")\n",
+                "    print(\"Available Gaussian/Erf/Plateau-like names:\")\n",
+                "    pprint([name for name in dir(aare)\n",
+                "            if any(token.lower() in name.lower()\n",
+                "                   for token in (\"gauss\", \"erf\", \"plateau\"))])\n",
+                "    raise"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 2,
+            "id": "feb3872d",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "def gaussian_erfc_plateau(x, p):\n",
+                "    A, S, mu, sigma = p\n",
+                "    z = (x - mu) / (np.sqrt(2.0) * sigma)\n",
+                "    return A * np.exp(-0.5 * ((x - mu) / sigma)**2) + 0.5 * S * (1.0 - erf(z))\n",
+                "\n",
+                "def gaussian_erfc_plateau_curve_fit(x, A, S, mu, sigma):\n",
+                "    return gaussian_erfc_plateau(x, np.array([A, S, mu, sigma], dtype=float))"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 3,
+            "id": "4e10fc29",
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "image/png":
+                            "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",
+                        "text/plain": [
+                            "<Figure size 800x400 with 1 Axes>"
+                        ]
+                    },
+                    "metadata": {},
+                    "output_type": "display_data"
+                }
+            ],
+            "source": [
+                "# Synthetic data\n",
+                "rng = np.random.default_rng(42)\n",
+                "\n",
+                "x = np.linspace(-4.0, 6.0, 251)\n",
+                "\n",
+                "p_true = np.array([\n",
+                "    1.20,  # A: Gaussian amplitude\n",
+                "    1.00,  # S: left plateau height\n",
+                "    1.00,  # mu: shared center / step position\n",
+                "    0.65,  # sigma: shared width\n",
+                "])\n",
+                "\n",
+                "noise_sigma = 0.035\n",
+                "\n",
+                "y_true = gaussian_erfc_plateau(x, p_true)\n",
+                "y = y_true + rng.normal(0.0, noise_sigma, size=x.shape)\n",
+                "y_err = np.full_like(x, noise_sigma)\n",
+                "\n",
+                "plt.figure(figsize=(8, 4))\n",
+                "plt.plot(x, y_true, label=\"true\")\n",
+                "plt.scatter(x, y, s=10, label=\"noisy data\")\n",
+                "plt.xlabel(\"x\")\n",
+                "plt.ylabel(\"y\")\n",
+                "plt.title(\"Synthetic Gaussian + erfc plateau data\")\n",
+                "plt.legend()\n",
+                "plt.grid(True, alpha=0.3)\n",
+                "plt.show()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 4,
+            "id": "20571047",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "True params :  [1.2  1.   1.   0.65]\n",
+                        "SciPy params:  [1.19916  1.000479 1.005638 0.64249 ]\n",
+                        "SciPy abs error: [0.00084  0.000479 0.005638 0.00751 ]\n"
+                    ]
+                }
+            ],
+            "source": [
+                "# SciPy reference fit\n",
+                "p0_ref = np.array([1.0, 0.8, 0.5, 0.8])\n",
+                "\n",
+                "bounds_ref = (\n",
+                "    [-np.inf, -np.inf, -np.inf, 1e-12],\n",
+                "    [ np.inf,  np.inf,  np.inf, np.inf],\n",
+                ")\n",
+                "\n",
+                "p_scipy, cov_scipy = curve_fit(\n",
+                "    gaussian_erfc_plateau_curve_fit,\n",
+                "    x,\n",
+                "    y,\n",
+                "    p0=p0_ref,\n",
+                "    sigma=y_err,\n",
+                "    absolute_sigma=True,\n",
+                "    bounds=bounds_ref,\n",
+                "    maxfev=20_000,\n",
+                ")\n",
+                "\n",
+                "print(\"True params : \", p_true)\n",
+                "print(\"SciPy params: \", p_scipy)\n",
+                "print(\"SciPy abs error:\", np.abs(p_scipy - p_true))"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 5,
+            "id": "60ae684f",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "Parameter list:\n",
+                        "['A', 'S', 'mu', 'sigma']\n",
+                        "n_par: 4\n",
+                        "\n",
+                        "== Tuned fit settings ==\n",
+                        "max_calls      : 1000\n",
+                        "tolerance      : 0.01\n",
+                        "compute_errors : True\n",
+                        "\n",
+                        "== Aare / Minuit2 result ==\n",
+                        "{'par': array([1.199158, 1.000478, 1.00564 , 0.642494]),\n",
+                        " 'par_err': array([0.008525, 0.003768, 0.005623, 0.005163]),\n",
+                        " 'chi2': array([218.22232])}\n",
+                        "\n",
+                        "True params     :  [1.2  1.   1.   0.65]\n",
+                        "SciPy params    :  [1.19916  1.000479 1.005638 0.64249 ]\n",
+                        "Aare params     :  [1.199158 1.000478 1.00564  0.642494]\n",
+                        "SciPy abs error :  [0.00084  0.000479 0.005638 0.00751 ]\n",
+                        "Aare abs error  :  [0.000842 0.000478 0.00564  0.007506]\n"
+                    ]
+                }
+            ],
+            "source": [
+                "# Aare / Minuit2 object API fit\n",
+                "model = GaussianErfcPlateau()\n",
+                "\n",
+                "print(\"Parameter list:\")\n",
+                "print(model.par_names)\n",
+                "print(\"n_par:\", model.n_par)\n",
+                "print()\n",
+                "\n",
+                "# Optional: provide explicit starts close enough to avoid relying only on estimate_par().\n",
+                "model.SetParameter(\"A\", 1.0)\n",
+                "model.SetParameter(\"S\", 0.8)\n",
+                "model.SetParameter(\"mu\", 0.5)\n",
+                "model.SetParameter(\"sigma\", 0.8)\n",
+                "\n",
+                "# Optional fit settings\n",
+                "model.compute_errors = True\n",
+                "model.max_calls = 1000\n",
+                "model.tolerance = 0.01\n",
+                "\n",
+                "print(\"== Tuned fit settings ==\")\n",
+                "print(f\"max_calls      : {model.max_calls}\")\n",
+                "print(f\"tolerance      : {model.tolerance}\")\n",
+                "print(f\"compute_errors : {model.compute_errors}\")\n",
+                "print()\n",
+                "\n",
+                "res_aare = model.fit(x, y, y_err)\n",
+                "\n",
+                "print(\"== Aare / Minuit2 result ==\")\n",
+                "pprint(res_aare, sort_dicts=False)\n",
+                "\n",
+                "p_aare = np.array(res_aare[\"par\"], dtype=float)\n",
+                "\n",
+                "print()\n",
+                "print(\"True params     : \", p_true)\n",
+                "print(\"SciPy params    : \", p_scipy)\n",
+                "print(\"Aare params     : \", p_aare)\n",
+                "print(\"SciPy abs error : \", np.abs(p_scipy - p_true))\n",
+                "print(\"Aare abs error  : \", np.abs(p_aare - p_true))"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 26,
+            "id": "3f1f13e0",
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "image/png":
+                            "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",
+                        "text/plain": [
+                            "<Figure size 800x400 with 1 Axes>"
+                        ]
+                    },
+                    "metadata": {},
+                    "output_type": "display_data"
+                }
+            ],
+            "source": [
+                "plt.figure(figsize=(8, 4))\n",
+                "\n",
+                "# plt.plot(x, y_true, label=\"true\")\n",
+                "plt.scatter(x, y, s=10, label=\"data\", color=\"tab:blue\")\n",
+                "plt.plot(x, gaussian_erfc_plateau(x, p_scipy), linewidth=4.0, label=\"SciPy curve_fit\", color=\"tab:red\")\n",
+                "plt.plot(x, model(x, p_aare), linewidth=1.0, label=\"Aare Minuit2\", color=\"tab:cyan\")\n",
+                "\n",
+                "plt.xlabel(\"x\")\n",
+                "plt.ylabel(\"y\")\n",
+                "plt.title(\"Gaussian + erfc plateau fit comparison\")\n",
+                "plt.legend()\n",
+                "plt.grid(True, alpha=0.3)\n",
+                "plt.show()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 27,
+            "id": "1359c6b6",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "SciPy curve_fit : 3.746 ms\n",
+                        "Aare Minuit2    : 0.355 ms\n",
+                        "\n",
+                        "SciPy bench params: [1.19916  1.000479 1.005638 0.64249 ]\n",
+                        "Aare bench params : [1.199158 1.000478 1.00564  0.642494]\n"
+                    ]
+                }
+            ],
+            "source": [
+                "def bench(fn, n_repeats=200):\n",
+                "    for _ in range(3):\n",
+                "        fn()\n",
+                "\n",
+                "    t0 = time.perf_counter()\n",
+                "    for _ in range(n_repeats):\n",
+                "        res = fn()\n",
+                "    t1 = time.perf_counter()\n",
+                "\n",
+                "    return res, (t1 - t0) / n_repeats\n",
+                "\n",
+                "def fit_scipy_once():\n",
+                "    return curve_fit(\n",
+                "        gaussian_erfc_plateau_curve_fit,\n",
+                "        x,\n",
+                "        y,\n",
+                "        p0=p0_ref,\n",
+                "        sigma=y_err,\n",
+                "        absolute_sigma=True,\n",
+                "        bounds=bounds_ref,\n",
+                "        maxfev=20_000,\n",
+                "    )[0]\n",
+                "\n",
+                "def fit_aare_once():\n",
+                "    m = GaussianErfcPlateau()\n",
+                "    m.SetParameter(\"A\", 1.0)\n",
+                "    m.SetParameter(\"S\", 0.8)\n",
+                "    m.SetParameter(\"mu\", 0.5)\n",
+                "    m.SetParameter(\"sigma\", 0.8)\n",
+                "    m.max_calls = 1000\n",
+                "    m.tolerance = 0.01\n",
+                "    return m.fit(x, y, y_err)[\"par\"]\n",
+                "\n",
+                "p_scipy_bench, t_scipy = bench(fit_scipy_once, n_repeats=200)\n",
+                "p_aare_bench, t_aare = bench(fit_aare_once, n_repeats=200)\n",
+                "\n",
+                "print(f\"SciPy curve_fit : {1e3*t_scipy:.3f} ms\")\n",
+                "print(f\"Aare Minuit2    : {1e3*t_aare:.3f} ms\")\n",
+                "print()\n",
+                "print(\"SciPy bench params:\", p_scipy_bench)\n",
+                "print(\"Aare bench params :\", p_aare_bench)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "f6c02fe0-c642-470b-965a-f6931ac74726",
+            "metadata": {},
+            "outputs": [],
+            "source": []
+        }
+    ],
+    "metadata": {
+        "kernelspec": {
+            "display_name": "Python 3 (ipykernel)",
+            "language": "python",
+            "name": "python3"
+        },
+        "language_info": {
+            "codemirror_mode": {
+                "name": "ipython",
+                "version": 3
+            },
+            "file_extension": ".py",
+            "mimetype": "text/x-python",
+            "name": "python",
+            "nbconvert_exporter": "python",
+            "pygments_lexer": "ipython3",
+            "version": "3.12.5"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 5
+}
diff --git a/python/tests/GaussianChargeSharingKb.ipynb b/python/tests/GaussianChargeSharingKb.ipynb
new file mode 100644
index 0000000..4ae15fc
--- /dev/null
+++ b/python/tests/GaussianChargeSharingKb.ipynb
@@ -0,0 +1,404 @@
+{
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "id": "bb29ae9f",
+            "metadata": {},
+            "source": [
+                "# Test `GaussianChargeSharingKb` Python bindings\n",
+                "\n",
+                "This notebook tests and benchmarks the Aare Minuit2 object API for the 8-parameter Kα/Kβ charge-sharing model.\n",
+                "\n",
+                "\\[\n",
+                "f(x)=p_0-p_1x+N\\left[\n",
+                "G_\\alpha(x)+qG_\\beta(x)+C H_\\alpha(x)+qC H_\\beta(x)\n",
+                "\\right]\n",
+                "\\]\n",
+                "\n",
+                "with\n",
+                "\n",
+                "\\[\n",
+                "\\mu_\\beta = r\\mu_\\alpha\n",
+                "\\]\n",
+                "\n",
+                "Parameter order:\n",
+                "\n",
+                "```text\n",
+                "[p0, p1, mu, sigma, N, C, kb_mean, kb_frac]\n",
+                "```\n",
+                "\n",
+                "where:\n",
+                "\n",
+                "```text\n",
+                "kb_mean = r\n",
+                "kb_frac = q\n",
+                "```"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 1,
+            "id": "e6de205a",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import time\n",
+                "import numpy as np\n",
+                "np.set_printoptions(suppress=True, precision=6)\n",
+                "\n",
+                "import matplotlib.pyplot as plt\n",
+                "from scipy.special import erf\n",
+                "from scipy.optimize import curve_fit\n",
+                "from pprint import pprint\n",
+                "\n",
+                "import sys\n",
+                "sys.path.insert(0, \"/home/ferjao_k/sw/aare/build\")\n",
+                "\n",
+                "from aare import GaussianChargeSharingKb"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 2,
+            "id": "4ad6bc4a",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "def gaussian_charge_sharing_kb(x, p):\n",
+                "    p0, p1, mu, sigma, N, C, kb_mean, kb_frac = p\n",
+                "\n",
+                "    mu_b = kb_mean * mu\n",
+                "\n",
+                "    u = (x - mu) / sigma\n",
+                "    ub = (x - mu_b) / sigma\n",
+                "\n",
+                "    G = np.exp(-0.5 * u**2)\n",
+                "    Gb = np.exp(-0.5 * ub**2)\n",
+                "\n",
+                "    H = 0.5 * (1.0 - erf(u / np.sqrt(2.0)))\n",
+                "    Hb = 0.5 * (1.0 - erf(ub / np.sqrt(2.0)))\n",
+                "\n",
+                "    return p0 - p1 * x + N * (G + kb_frac * Gb + C * H + kb_frac * C * Hb)\n",
+                "\n",
+                "def gaussian_charge_sharing_kb_curve_fit(x, p0, p1, mu, sigma, N, C, kb_mean, kb_frac):\n",
+                "    return gaussian_charge_sharing_kb(\n",
+                "        x,\n",
+                "        np.array([p0, p1, mu, sigma, N, C, kb_mean, kb_frac], dtype=float),\n",
+                "    )"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 13,
+            "id": "93e4550c",
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "image/png":
+                            "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",
+                        "text/plain": [
+                            "<Figure size 900x500 with 1 Axes>"
+                        ]
+                    },
+                    "metadata": {},
+                    "output_type": "display_data"
+                }
+            ],
+            "source": [
+                "rng = np.random.default_rng(123)\n",
+                "\n",
+                "x = np.linspace(0.0, 140.0, 281)\n",
+                "\n",
+                "p_true = np.array([\n",
+                "    14.0,   # p0\n",
+                "    0.010,  # p1, model uses p0 - p1*x\n",
+                "    62.0,   # mu: K-alpha position\n",
+                "    2.0,    # sigma\n",
+                "    180.0,  # N\n",
+                "    0.10,   # C: charge-sharing plateau\n",
+                "    1.105,  # kb_mean: K-beta mean ratio\n",
+                "    0.3,   # kb_frac: K-beta fraction\n",
+                "])\n",
+                "\n",
+                "noise_sigma = 1.5\n",
+                "y_true = gaussian_charge_sharing_kb(x, p_true)\n",
+                "y = y_true + rng.normal(0.0, noise_sigma, size=x.shape)\n",
+                "y_err = np.full_like(x, noise_sigma)\n",
+                "\n",
+                "plt.figure(figsize=(9, 5))\n",
+                "plt.plot(x, y_true, label=\"true\")\n",
+                "plt.scatter(x, y, s=10, label=\"noisy data\")\n",
+                "plt.xlabel(\"x\")\n",
+                "plt.ylabel(\"y\")\n",
+                "plt.title(\"Synthetic GaussianChargeSharingKb data\")\n",
+                "plt.legend()\n",
+                "plt.grid(True, alpha=0.3)\n",
+                "plt.show()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 4,
+            "id": "2133a34c",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "True params     : [ 14.      0.01   62.      2.    180.      0.1     1.105   0.3  ]\n",
+                        "SciPy params    : [ 14.534234   0.015155  62.003314   1.998024 180.396284   0.098433\n",
+                        "   1.104748   0.302732]\n",
+                        "SciPy abs error : [0.534234 0.005155 0.003314 0.001976 0.396284 0.001567 0.000252 0.002732]\n"
+                    ]
+                }
+            ],
+            "source": [
+                "# SciPy reference fit\n",
+                "p0_ref = np.array([12.0, 0.0, 60.0, 6.0, 150.0, 0.20, 1.10, 0.10])\n",
+                "\n",
+                "bounds_ref = (\n",
+                "    [-np.inf, -np.inf, 0.0, 1e-12, 0.0, -np.inf, 1.02, 0.0],\n",
+                "    [ np.inf,  np.inf, 140.0, 50.0, np.inf,  np.inf, 1.40, 1.00],\n",
+                ")\n",
+                "\n",
+                "p_scipy, cov_scipy = curve_fit(\n",
+                "    gaussian_charge_sharing_kb_curve_fit,\n",
+                "    x,\n",
+                "    y,\n",
+                "    p0=p0_ref,\n",
+                "    sigma=y_err,\n",
+                "    absolute_sigma=True,\n",
+                "    bounds=bounds_ref,\n",
+                "    maxfev=50_000,\n",
+                ")\n",
+                "\n",
+                "print(\"True params     :\", p_true)\n",
+                "print(\"SciPy params    :\", p_scipy)\n",
+                "print(\"SciPy abs error :\", np.abs(p_scipy - p_true))"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 5,
+            "id": "2a563865",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "Parameter list:\n",
+                        "['p0', 'p1', 'mu', 'sigma', 'N', 'C', 'kb_mean', 'kb_frac']\n",
+                        "n_par: 8\n",
+                        "\n",
+                        "{'par': array([ 14.534164,   0.015155,  62.003317,   1.99802 , 180.396621,\n",
+                        "         0.098433,   1.104748,   0.302733]),\n",
+                        " 'par_err': array([0.564971, 0.005172, 0.009856, 0.008685, 0.698493, 0.00188 ,\n",
+                        "       0.000509, 0.003632]),\n",
+                        " 'chi2': array([262.404385])}\n",
+                        "\n",
+                        "True params     : [ 14.      0.01   62.      2.    180.      0.1     1.105   0.3  ]\n",
+                        "SciPy params    : [ 14.534234   0.015155  62.003314   1.998024 180.396284   0.098433\n",
+                        "   1.104748   0.302732]\n",
+                        "Aare params     : [ 14.534164   0.015155  62.003317   1.99802  180.396621   0.098433\n",
+                        "   1.104748   0.302733]\n",
+                        "SciPy abs error : [0.534234 0.005155 0.003314 0.001976 0.396284 0.001567 0.000252 0.002732]\n",
+                        "Aare abs error  : [0.534164 0.005155 0.003317 0.00198  0.396621 0.001567 0.000252 0.002733]\n",
+                        "Aare - SciPy    : [-0.00007  -0.        0.000003 -0.000004  0.000337 -0.       -0.\n",
+                        "  0.000001]\n"
+                    ]
+                }
+            ],
+            "source": [
+                "# Aare / Minuit2 object API fit\n",
+                "model = GaussianChargeSharingKb()\n",
+                "\n",
+                "print(\"Parameter list:\")\n",
+                "print(model.par_names)\n",
+                "print(\"n_par:\", model.n_par)\n",
+                "print()\n",
+                "\n",
+                "model.SetParameter(\"p0\", 12.0)\n",
+                "model.SetParameter(\"p1\", 0.0)\n",
+                "model.SetParameter(\"mu\", 58.0)\n",
+                "model.SetParameter(\"sigma\", 4.0)\n",
+                "model.SetParameter(\"N\", 150.0)\n",
+                "model.SetParameter(\"C\", 0.10)\n",
+                "model.SetParameter(\"kb_mean\", 1.20)\n",
+                "model.SetParameter(\"kb_frac\", 0.40)\n",
+                "\n",
+                "model.SetParLimits(\"kb_mean\", 1.02, 1.40)\n",
+                "model.SetParLimits(\"kb_frac\", 0.0, 1.00)\n",
+                "\n",
+                "model.compute_errors = True\n",
+                "model.max_calls = 4000\n",
+                "model.tolerance = 0.01\n",
+                "\n",
+                "res_aare = model.fit(x, y, y_err)\n",
+                "pprint(res_aare, sort_dicts=False)\n",
+                "\n",
+                "p_aare = np.array(res_aare[\"par\"], dtype=float)\n",
+                "\n",
+                "print()\n",
+                "print(\"True params     :\", p_true)\n",
+                "print(\"SciPy params    :\", p_scipy)\n",
+                "print(\"Aare params     :\", p_aare)\n",
+                "print(\"SciPy abs error :\", np.abs(p_scipy - p_true))\n",
+                "print(\"Aare abs error  :\", np.abs(p_aare - p_true))\n",
+                "print(\"Aare - SciPy    :\", p_aare - p_scipy)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 12,
+            "id": "fc217c0e",
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "image/png":
+                            "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",
+                        "text/plain": [
+                            "<Figure size 1000x500 with 1 Axes>"
+                        ]
+                    },
+                    "metadata": {},
+                    "output_type": "display_data"
+                }
+            ],
+            "source": [
+                "plt.figure(figsize=(10, 5))\n",
+                "# plt.plot(x, y_true, label=\"true\")\n",
+                "plt.scatter(x, y, s=10, label=\"data\")\n",
+                "plt.plot(x, gaussian_charge_sharing_kb(x, p_scipy), linewidth=3.0, label=\"SciPy curve_fit\", color=\"tab:orange\")\n",
+                "plt.plot(x, model(x, p_aare), linewidth=1.5, label=\"Aare Minuit2\", color=\"tab:cyan\")\n",
+                "plt.xlabel(\"x\")\n",
+                "plt.ylabel(\"y\")\n",
+                "plt.title(\"GaussianChargeSharingKb fit comparison\")\n",
+                "plt.legend()\n",
+                "plt.grid(True, alpha=0.3)\n",
+                "plt.show()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 9,
+            "id": "a4a6aec0",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "SciPy curve_fit : 17.591 ms\n",
+                        "Aare Minuit2    : 1.888 ms\n",
+                        "\n",
+                        "SciPy bench params: [ 14.534234   0.015155  62.003314   1.998024 180.396284   0.098433\n",
+                        "   1.104748   0.302732]\n",
+                        "Aare bench params : [ 32.421516   0.162626  62.154113   2.413067 169.643047   0.05319\n",
+                        "   1.271962   0.      ]\n"
+                    ]
+                }
+            ],
+            "source": [
+                "def bench(fn, n_repeats=200):\n",
+                "    for _ in range(3):\n",
+                "        fn()\n",
+                "\n",
+                "    t0 = time.perf_counter()\n",
+                "    for _ in range(n_repeats):\n",
+                "        res = fn()\n",
+                "    t1 = time.perf_counter()\n",
+                "\n",
+                "    return res, (t1 - t0) / n_repeats\n",
+                "\n",
+                "def fit_scipy_once():\n",
+                "    return curve_fit(\n",
+                "        gaussian_charge_sharing_kb_curve_fit,\n",
+                "        x,\n",
+                "        y,\n",
+                "        p0=p0_ref,\n",
+                "        sigma=y_err,\n",
+                "        absolute_sigma=True,\n",
+                "        bounds=bounds_ref,\n",
+                "        maxfev=50_000,\n",
+                "    )[0]\n",
+                "\n",
+                "def fit_aare_once():\n",
+                "    m = GaussianChargeSharingKb()\n",
+                "    m.SetParameter(\"p0\", 10.0)\n",
+                "    m.SetParameter(\"p1\", 0.0)\n",
+                "    m.SetParameter(\"mu\", 50.0)\n",
+                "    m.SetParameter(\"sigma\", 5.0)\n",
+                "    m.SetParameter(\"N\", 150.0)\n",
+                "    m.SetParameter(\"C\", 0.10)\n",
+                "    m.SetParameter(\"kb_mean\", 1.20)\n",
+                "    m.SetParameter(\"kb_frac\", 0.40)\n",
+                "    \n",
+                "    m.SetParLimits(\"kb_mean\", 1.02, 1.40)\n",
+                "    m.SetParLimits(\"kb_frac\", 0.0, 1.00)\n",
+                "    m.max_calls = 4000\n",
+                "    m.tolerance = 0.01\n",
+                "    return np.array(m.fit(x, y, y_err)[\"par\"], dtype=float)\n",
+                "\n",
+                "p_scipy_bench, t_scipy = bench(fit_scipy_once, n_repeats=200)\n",
+                "p_aare_bench, t_aare = bench(fit_aare_once, n_repeats=200)\n",
+                "\n",
+                "print(f\"SciPy curve_fit : {1e3*t_scipy:.3f} ms\")\n",
+                "print(f\"Aare Minuit2    : {1e3*t_aare:.3f} ms\")\n",
+                "print()\n",
+                "print(\"SciPy bench params:\", p_scipy_bench)\n",
+                "print(\"Aare bench params :\", p_aare_bench)"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "77a15aea",
+            "metadata": {},
+            "source": [
+                "## No-Kβ sanity check\n",
+                "\n",
+                "For no-Kβ data, prefer `GaussianChargeSharing`.\n",
+                "\n",
+                "You can also use this 8-parameter model and fix:\n",
+                "\n",
+                "```python\n",
+                "model.FixParameter(\"kb_frac\", 0.0)\n",
+                "```\n",
+                "\n",
+                "but the 6-parameter model is cleaner and usually better conditioned."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "4abba19d-f4ca-4a41-adf8-1d0f4946086a",
+            "metadata": {},
+            "outputs": [],
+            "source": []
+        }
+    ],
+    "metadata": {
+        "kernelspec": {
+            "display_name": "Python 3 (ipykernel)",
+            "language": "python",
+            "name": "python3"
+        },
+        "language_info": {
+            "codemirror_mode": {
+                "name": "ipython",
+                "version": 3
+            },
+            "file_extension": ".py",
+            "mimetype": "text/x-python",
+            "name": "python",
+            "nbconvert_exporter": "python",
+            "pygments_lexer": "ipython3",
+            "version": "3.12.5"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 5
+}