5_gen_plot_for_paper.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load lib\n",
    "import ROOT\n",
    "import os, sys\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import nlfir\n",
    "from matplotlib import pyplot as plt\n",
    "import numba as nb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Applying ATLAS style settings...\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# load style\n",
    "from ROOT import gROOT\n",
    "\n",
    "path = '/Users/yy/cernbox/'\n",
    "# path = '/eos/user/y/youyou/'\n",
    "gROOT.SetMacroPath(path+\"atlasstyle/\")\n",
    "gROOT.LoadMacro(\"AtlasLabels.C\")\n",
    "gROOT.LoadMacro(\"AtlasStyle.C\")\n",
    "gROOT.LoadMacro(\"AtlasUtils.C\")\n",
    "from ROOT import SetAtlasStyle, ATLASLabel, myText, myMarkerText\n",
    "SetAtlasStyle()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def data_reader(data_folder, data_folder_of):\n",
    "    pulse = np.loadtxt(data_folder+'/ideal_output_sequence.txt')\n",
    "    adc = np.loadtxt(data_folder+'/digits_out_sequence_eT.txt')\n",
    "    signal = np.loadtxt(data_folder+'/hit_eT_sig_sequence.txt')\n",
    "    pileup = np.loadtxt(data_folder+'/hit_eT_bck_sequence.txt')\n",
    "    \n",
    "    of_out = np.loadtxt(data_folder_of+'/digits_out_sequence_eT.txt')\n",
    "    of_coeff = np.loadtxt(data_folder_of+'/configuration.txt')\n",
    "\n",
    "    return pulse, adc, signal, pileup, of_coeff, of_out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [],
   "source": [
    "def error_bar(pred, adc, h):\n",
    "    difference = pred - adc\n",
    "    # noise_variance = np.mean(difference**2)\n",
    "    # denominator = np.dot(h, np.conj(h))\n",
    "\n",
    "    return np.sqrt(np.std(difference) / sum(h**2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimal(of_out, of_coeff, to_cut=int(1e6)):\n",
    "    of_out = of_out[5+to_cut: 5-to_cut]\n",
    "\n",
    "    return of_out, of_coeff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "def all_les_mat(adc, signal, pileup, jl=30, jr=8, ncut=10000, thresh=1.5, adjusted=0):\n",
    "    npad=len(adc)-len(pileup)\n",
    "\n",
    "    signal=np.hstack([signal,np.zeros(npad)])\n",
    "    pileup=np.hstack([pileup,np.zeros(npad)])\n",
    "\n",
    "    nn=jl+jr+2\n",
    "    mat=np.zeros([len(adc),nn])  \n",
    "    mm=np.zeros([len(adc)-2*ncut,nn])\n",
    "    for i in range(nn-1):\n",
    "        mm[:,i]=adc[ncut-jl+i:-ncut-jl+i]\n",
    "    mm[:,-1]=1\n",
    "    mm_quad=np.hstack([mm,mm[:,:-1]**2])\n",
    "    mm_cub=np.hstack([mm,mm[:,:-1]**2,mm[:,:-1]**3])\n",
    "\n",
    "    def _matrix_mult(mm):\n",
    "        ss=(signal+pileup)[ncut:-ncut]\n",
    "\n",
    "        lhs=mm.T@mm\n",
    "        rhs=mm.T@ss\n",
    "        coeffs=np.linalg.inv(lhs)@rhs\n",
    "        pred=mm@coeffs\n",
    "    \n",
    "        return pred, coeffs\n",
    "\n",
    "    if adjusted:\n",
    "        error = ss - pred1\n",
    "        mask = np.abs(error) > thresh\n",
    "        poly_coeffs = np.polyfit(pred1[mask], error[mask], deg=1)\n",
    "        pred1[mask] = np.polyval(poly_coeffs, pred1[mask])\n",
    "\n",
    "    return _matrix_mult(mm), _matrix_mult(mm_quad), _matrix_mult(mm_cub)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lin_les_fft(adc, signal, pileup, jl=30, jr=8, to_cut=int(1e6), thresh=1.5):\n",
    "    s=signal+pileup\n",
    "    k1=to_cut  #k1/k2 define the stretch of data we'll use\n",
    "    k2=-k1\n",
    "\n",
    "    ones=0.0*adc+1.0\n",
    "    mat=nlfir.FIRmat(ones,0,0,k1,k2) #initialize the matrix with the constant offset term\n",
    "    mat.add_vec(adc,jl,jr)  #include the linear part of the response to the ADCs\n",
    "    mat.get_fts() #do this once you've added everything you want\n",
    "    mat.get_coeffs(s)\n",
    "    pred=mat.get_pred()\n",
    "\n",
    "    mat.set_adjust(s,thresh)\n",
    "    pred_adjust=mat.get_pred(adjust=True)[to_cut: -to_cut]\n",
    "\n",
    "    h = np.fft.rfft(mat.coeffs)\n",
    "\n",
    "    return pred_adjust, h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quad_les_fft(adc, signal, pileup, jl=30, jr=8, to_cut=int(1e6), thresh=1.5):\n",
    "    s=signal+pileup\n",
    "    k1=to_cut  #k1/k2 define the stretch of data we'll use\n",
    "    k2=-k1\n",
    "\n",
    "    ones=0.0*adc+1.0\n",
    "\n",
    "    nlmat=nlfir.FIRmat(ones,0,0,k1,k2) #initialize the matrix with the constant offset term\n",
    "    nlmat.add_vec(adc,jl,jr)  #include the linear part of the response to the ADCs\n",
    "    nlmat.add_vec(adc**2,jl,jr)  #we can add the nonlinear part now\n",
    "    nlmat.get_fts() #do this once you've added everything you want\n",
    "    nlmat.get_coeffs(s)\n",
    "    nlpred=nlmat.get_pred()\n",
    "\n",
    "    nlmat.set_adjust(s,thresh)\n",
    "    nlpred_adjust=nlmat.get_pred(adjust=True)[to_cut: -to_cut]\n",
    "\n",
    "    h = np.fft.rfft(nlmat.coeffs)\n",
    "\n",
    "    return nlpred_adjust, h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cub_les_fft(adc, signal, pileup, jl=30, jr=8, to_cut=int(1e6), thresh=1.5):\n",
    "    s=signal+pileup\n",
    "    k1=to_cut  #k1/k2 define the stretch of data we'll use\n",
    "    k2=-k1\n",
    "\n",
    "    ones=0.0*adc+1.0\n",
    "\n",
    "    nlmat=nlfir.FIRmat(ones,0,0,k1,k2) #initialize the matrix with the constant offset term\n",
    "    nlmat.add_vec(adc,jl,jr)  #include the linear part of the response to the ADCs\n",
    "    nlmat.add_vec(adc**2,jl,jr)  #we can add the nonlinear part now\n",
    "    nlmat.add_vec(adc**3,jl,jr) \n",
    "    nlmat.get_fts() #do this once you've added everything you want\n",
    "    nlmat.get_coeffs(s)\n",
    "    nlpred=nlmat.get_pred()\n",
    "\n",
    "    nlmat.set_adjust(s,thresh)\n",
    "    nlpred_adjust=nlmat.get_pred(adjust=True)[to_cut: -to_cut]\n",
    "\n",
    "    h = np.fft.rfft(nlmat.coeffs)\n",
    "\n",
    "    return nlpred_adjust, h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "@nb.njit(parallel=True)\n",
    "def indices_gen(e_true):\n",
    "    bins = np.linspace(np.min(e_true), np.max(e_true), 11)\n",
    "    bin_indices = np.digitize(e_true, bins)\n",
    "    indices, x = [], []\n",
    "    \n",
    "    for j in range(1, len(bins)):\n",
    "        x.append((bins[j-1] + bins[j]) / 2)\n",
    "        indices.append(np.where(bin_indices == j)[0])\n",
    "\n",
    "    return indices, x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "@nb.njit(parallel=True)\n",
    "def arr_generator(e_diff, true_signal, indices):\n",
    "    n_indices = len(indices)\n",
    "    \n",
    "    # Pre-allocate numpy arrays for the output to avoid using Python lists\n",
    "    mean = np.empty(n_indices)\n",
    "    std = np.empty(n_indices)\n",
    "    median = np.empty(n_indices)\n",
    "    lower_98 = np.empty(n_indices)\n",
    "    higher_98 = np.empty(n_indices)\n",
    "    scale_mean = np.empty(n_indices)\n",
    "    scale_std = np.empty(n_indices)\n",
    "\n",
    "    # Calculate the scales array once\n",
    "    scales = e_diff / true_signal\n",
    "    \n",
    "    for i in nb.prange(n_indices):\n",
    "        i_arr = indices[i]\n",
    "        # Use np array indexing instead of list comprehension\n",
    "        data = e_diff[i_arr]\n",
    "\n",
    "        mean[i] = data.mean()\n",
    "        std[i] = data.std()\n",
    "        \n",
    "        # Use the pre-computed scales array\n",
    "        scale_data = scales[i_arr]\n",
    "        scale_mean[i] = scale_data.mean()\n",
    "        scale_std[i] = scale_data.std()\n",
    "        \n",
    "        # Use the built-in np.percentile function to calculate quantiles directly\n",
    "        lower, upper = np.percentile(data, [1, 99])\n",
    "        # Use np's boolean indexing to filter the signal\n",
    "        filtered_signal = data[(data >= lower) & (data <= upper)]\n",
    "        \n",
    "        median[i] = np.median(filtered_signal)\n",
    "        lower_98[i] = lower\n",
    "        higher_98[i] = upper\n",
    "    \n",
    "    return mean, std, median, lower_98, higher_98, scale_mean, scale_std\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mean_hist_gen(x, mean_of, std_of, mean_lin, std_lin, mean_quad, std_quad, mean_cub, std_cub, y_min, y_max):\n",
    "    shift_x = x[-1]/100\n",
    "\n",
    "    graph1 = ROOT.TGraphErrors(len(x), np.array(x, 'd')+shift_x, np.array(mean_of, 'd'), np.zeros(len(x)), np.array(std_of, 'd'))\n",
    "    graph1.SetMarkerStyle(22)\n",
    "    graph1.SetMarkerSize(1.5)\n",
    "    graph1.SetLineColorAlpha(ROOT.kRed, 0.8)\n",
    "    graph1.SetLineWidth(2)\n",
    "    graph1.SetMarkerColorAlpha(ROOT.kRed, 0.8)\n",
    "\n",
    "    graph2 = ROOT.TGraphErrors(len(x), np.array(x, 'd'), np.array(mean_quad, 'd'), np.zeros(len(x)), np.array(std_quad, 'd'))\n",
    "    graph2.SetMarkerStyle(20)\n",
    "    graph2.SetMarkerSize(1.5)\n",
    "    graph2.SetLineColorAlpha(ROOT.kBlue, 0.8)\n",
    "    graph2.SetMarkerColorAlpha(ROOT.kBlue, 0.8)\n",
    "    graph2.SetLineWidth(2)\n",
    "\n",
    "    graph3 = ROOT.TGraphErrors(len(x), np.array(x, 'd')-shift_x, np.array(mean_lin, 'd'), np.zeros(len(x)), np.array(std_lin, 'd'))\n",
    "    graph3.SetMarkerStyle(23)\n",
    "    graph3.SetMarkerSize(1.5)\n",
    "    graph3.SetLineColorAlpha(ROOT.kOrange+1, 0.9)\n",
    "    graph3.SetMarkerColorAlpha(ROOT.kOrange+1, 0.9)\n",
    "    graph3.SetLineWidth(2)\n",
    "\n",
    "    graph4 = ROOT.TGraphErrors(len(x), np.array(x, 'd')+2*shift_x, np.array(mean_cub, 'd'), np.zeros(len(x)), np.array(std_cub, 'd'))\n",
    "    graph4.SetMarkerStyle(21)\n",
    "    graph4.SetMarkerSize(1.4)\n",
    "    graph4.SetLineColorAlpha(ROOT.kSpring-8, 0.9)\n",
    "    graph4.SetMarkerColorAlpha(ROOT.kSpring-8, 0.9)\n",
    "    graph4.SetLineWidth(2)\n",
    "\n",
    "    graph1.GetXaxis().SetTitle(\"E_{true} = (E_{sig}+E_{PU}) [GeV]\")\n",
    "    graph1.GetYaxis().SetTitle(\"mean of \\DeltaE [GeV]\")\n",
    "    graph1.GetYaxis().SetRangeUser(y_min, y_max)\n",
    "\n",
    "    legend = ROOT.TLegend(0.6, 0.75, 0.95, 0.95)\n",
    "    legend.AddEntry(graph1, \"E_{reco} with OF\", \"lep\")\n",
    "    legend.AddEntry(graph3, \"E_{reco} with Linear Filter\", \"lep\")\n",
    "    legend.AddEntry(graph2, \"E_{reco} with Quadratic Filter\", \"lep\")\n",
    "    legend.AddEntry(graph4, \"E_{reco} with Cubic Filter\", \"lep\")\n",
    "\n",
    "    return graph1, graph2, graph3, graph4, legend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [],
   "source": [
    "def std_hist_gen(x, indices, std_of, std_lin, std_quad, std_cub, y_min, y_max):\n",
    "    shift_x = x[-1]/100\n",
    "\n",
    "    n = np.array([len(i) for  i in indices])\n",
    "\n",
    "    y = np.array(std_of)\n",
    "    uncertainty_y = y / np.sqrt(2 * n-2)\n",
    "    y[0] = 0.65\n",
    "    y[1] = 0.65\n",
    "    graph1 = ROOT.TGraphErrors(len(x), np.array(x, 'd')-shift_x, np.array(y, 'd'), np.zeros(len(x)), np.array(uncertainty_y, 'd'))\n",
    "    graph1.SetMarkerStyle(22)\n",
    "    graph1.SetMarkerSize(1.5)\n",
    "    graph1.SetLineColorAlpha(ROOT.kRed, 0.8)\n",
    "    graph1.SetLineWidth(2)\n",
    "    graph1.SetMarkerColorAlpha(ROOT.kRed, 0.8)\n",
    "\n",
    "    y = np.array(std_quad)\n",
    "    uncertainty_y = y / np.sqrt(2 * n-2)\n",
    "\n",
    "    graph2 = ROOT.TGraphErrors(len(x), np.array(x, 'd')+shift_x, np.array(y, 'd'), np.zeros(len(x)), np.array(uncertainty_y, 'd'))\n",
    "    graph2.SetMarkerStyle(20)\n",
    "    graph2.SetMarkerSize(1.5)\n",
    "    graph2.SetLineColorAlpha(ROOT.kBlue, 0.8)\n",
    "    graph2.SetMarkerColorAlpha(ROOT.kBlue, 0.8)\n",
    "    graph2.SetLineWidth(2)\n",
    "\n",
    "    y = np.array(std_lin)\n",
    "    uncertainty_y = y / np.sqrt(2 * n-2)\n",
    "    y[0] = 0.65\n",
    "    graph3 = ROOT.TGraphErrors(len(x), np.array(x, 'd'), np.array(y, 'd'), np.zeros(len(x)), np.array(uncertainty_y, 'd'))\n",
    "    graph3.SetMarkerStyle(20)\n",
    "    graph3.SetMarkerSize(1.5)\n",
    "    graph3.SetLineColorAlpha(ROOT.kOrange+1, 0.9)\n",
    "    graph3.SetMarkerColorAlpha(ROOT.kOrange+1, 0.9)\n",
    "    graph3.SetLineWidth(2)\n",
    "\n",
    "    y = np.array(std_cub)\n",
    "    uncertainty_y = y / np.sqrt(2 * n-2)\n",
    "\n",
    "    graph4 = ROOT.TGraphErrors(len(x), np.array(x, 'd')+2*shift_x, np.array(y, 'd'), np.zeros(len(x)), np.array(uncertainty_y, 'd'))\n",
    "    graph4.SetMarkerStyle(21)\n",
    "    graph4.SetMarkerSize(1.4)\n",
    "    graph4.SetLineColorAlpha(ROOT.kSpring-8, 0.9)\n",
    "    graph4.SetMarkerColorAlpha(ROOT.kSpring-8, 0.9)\n",
    "    graph4.SetLineWidth(2)\n",
    "\n",
    "\n",
    "    graph1.GetXaxis().SetTitle(\"E_{true} = (E_{sig}+E_{PU}) [GeV]\")\n",
    "    graph1.GetYaxis().SetTitle(\"\\sigma_{\\DeltaE}  [GeV]\")\n",
    "    graph1.GetYaxis().SetRangeUser(y_min, y_max)\n",
    "\n",
    "    legend = ROOT.TLegend(0.6, 0.75, 0.95, 0.95)\n",
    "    legend.AddEntry(graph1, \"E_{reco} with OF\", \"lep\")\n",
    "    legend.AddEntry(graph3, \"E_{reco} with Linear Filter\", \"lep\")\n",
    "    legend.AddEntry(graph2, \"E_{reco} with Quadratic Filter\", \"lep\")\n",
    "    legend.AddEntry(graph4, \"E_{reco} with Cubic Filter\", \"lep\")\n",
    "\n",
    "    return graph1, graph2, graph3, graph4, legend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [],
   "source": [
    "def median_hist_gen(x, median_of, lower_98_of, higher_98_of, median_quad, lower_98_quad, higher_98_quad, median_lin, lower_98_lin, higher_98_lin, median_cub, lower_98_cub, higher_98_cub, y_min, y_max):\n",
    "\n",
    "    shift_x = x[-1]/100\n",
    "\n",
    "    y = np.array(median_of, 'd')\n",
    "    lower_error = np.array(lower_98_of, 'd')  \n",
    "    upper_error = np.array(higher_98_of, 'd')  \n",
    "\n",
    "    graph1 = ROOT.TGraphAsymmErrors(len(x), np.array(x, 'd')-shift_x, y, np.zeros(len(x)), np.zeros(len(x)), y-lower_error, upper_error-y)\n",
    "    graph1.SetMarkerStyle(22)\n",
    "    graph1.SetMarkerSize(1.5)\n",
    "    graph1.SetLineColorAlpha(ROOT.kRed, 0.8)\n",
    "    graph1.SetLineWidth(2)\n",
    "    graph1.SetMarkerColorAlpha(ROOT.kRed, 0.8)\n",
    "\n",
    "    y = np.array(median_quad, 'd')\n",
    "    lower_error = np.array(lower_98_quad, 'd')  \n",
    "    upper_error = np.array(higher_98_quad, 'd')  \n",
    "\n",
    "    graph2 = ROOT.TGraphAsymmErrors(len(x), np.array(x, 'd')+shift_x, y, np.zeros(len(x)), np.zeros(len(x)), y-lower_error, upper_error-y)\n",
    "    graph2.SetMarkerStyle(20)\n",
    "    graph2.SetMarkerSize(1.5)\n",
    "    graph2.SetLineColorAlpha(ROOT.kOrange+1, 0.9)\n",
    "    graph2.SetMarkerColorAlpha(ROOT.kOrange+1, 0.9)\n",
    "    graph2.SetLineWidth(2)\n",
    "\n",
    "\n",
    "    y = np.array(median_lin, 'd')\n",
    "    lower_error = np.array(lower_98_lin, 'd')  \n",
    "    upper_error = np.array(higher_98_lin, 'd')  \n",
    "    graph3 = ROOT.TGraphAsymmErrors(len(x), np.array(x, 'd'), y, np.zeros(len(x)), np.zeros(len(x)), y-lower_error, upper_error-y)\n",
    "    graph3.SetMarkerStyle(20)\n",
    "    graph3.SetMarkerSize(1.5)\n",
    "    graph3.SetLineColorAlpha(ROOT.kBlue, 0.8)\n",
    "    graph3.SetMarkerColorAlpha(ROOT.kBlue, 0.8)\n",
    "    graph3.SetLineWidth(2)\n",
    "\n",
    "\n",
    "    y = np.array(median_cub, 'd')\n",
    "    lower_error = np.array(lower_98_cub, 'd')  \n",
    "    upper_error = np.array(higher_98_cub, 'd')  \n",
    "    graph4 = ROOT.TGraphAsymmErrors(len(x), np.array(x, 'd')+2*shift_x, y, np.zeros(len(x)), np.zeros(len(x)), y-lower_error, upper_error-y)\n",
    "    graph4.SetMarkerStyle(21)\n",
    "    graph4.SetMarkerSize(1.4)\n",
    "    graph4.SetLineColorAlpha(ROOT.kSpring-8, 0.9)\n",
    "    graph4.SetMarkerColorAlpha(ROOT.kSpring-8, 0.9)\n",
    "    graph4.SetLineWidth(2)\n",
    "\n",
    "\n",
    "    graph1.GetXaxis().SetTitle(\"E_{true} = (E_{sig}+E_{PU}) [GeV]\")\n",
    "    graph1.GetYaxis().SetTitle(\"(\\Delta E)_{1/2} with 98% [GeV]\")\n",
    "    graph1.GetYaxis().SetRangeUser(y_min, y_max)\n",
    "\n",
    "    legend = ROOT.TLegend(0.6, 0.75, 0.95, 0.95)\n",
    "    legend.AddEntry(graph1, \"E_{reco} with OF\", \"lep\")\n",
    "    legend.AddEntry(graph3, \"E_{reco} with Linear Filter\", \"lep\")\n",
    "    legend.AddEntry(graph2, \"E_{reco} with Quadratic Filter\", \"lep\")\n",
    "    legend.AddEntry(graph4, \"E_{reco} with Cubic Filter\", \"lep\")\n",
    "\n",
    "\n",
    "    return graph1, graph2, graph3, graph4, legend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rela_std_hist_gen(x, indices, scale_std_of, scale_std_lin, scale_std_quad, scale_std_cub, y_min, y_max):\n",
    "\n",
    "    shift_x = x[-1]/100\n",
    "\n",
    "    n = np.array([len(i) for  i in indices])\n",
    "\n",
    "    y = np.array(scale_std_of)\n",
    "    uncertainty_y = y / np.sqrt(2 * n-2)\n",
    "    y[0] = y_max\n",
    "    y[1] = y_max\n",
    "    graph1 = ROOT.TGraphErrors(len(x), np.array(x, 'd')-shift_x, np.array(y, 'd'), np.zeros(len(x)), np.array(uncertainty_y, 'd'))\n",
    "    graph1.SetMarkerStyle(22)\n",
    "    graph1.SetMarkerSize(1.5)\n",
    "    graph1.SetLineColorAlpha(ROOT.kRed, 0.8)\n",
    "    graph1.SetLineWidth(2)\n",
    "    graph1.SetMarkerColorAlpha(ROOT.kRed, 0.8)\n",
    "\n",
    "    y = np.array(scale_std_quad)\n",
    "    y[0] = y_max\n",
    "    uncertainty_y = y / np.sqrt(2 * n-2)\n",
    "    graph2 = ROOT.TGraphErrors(len(x), np.array(x, 'd')+shift_x, np.array(y, 'd'), np.zeros(len(x)), np.array(uncertainty_y, 'd'))\n",
    "    graph2.SetMarkerStyle(20)\n",
    "    graph2.SetMarkerSize(1.5)\n",
    "    graph2.SetLineColorAlpha(ROOT.kBlue, 0.8)\n",
    "    graph2.SetMarkerColorAlpha(ROOT.kBlue, 0.8)\n",
    "    graph2.SetLineWidth(2)\n",
    "\n",
    "    y = np.array(scale_std_lin)\n",
    "    y[0] = y_max\n",
    "    y[1] = y_max\n",
    "    uncertainty_y = y / np.sqrt(2 * n-2)\n",
    "    graph3 = ROOT.TGraphErrors(len(x), np.array(x, 'd'), np.array(y, 'd'), np.zeros(len(x)), np.array(uncertainty_y, 'd'))\n",
    "    graph3.SetMarkerStyle(20)\n",
    "    graph3.SetMarkerSize(1.5)\n",
    "    graph3.SetLineColorAlpha(ROOT.kOrange+1, 0.9)\n",
    "    graph3.SetMarkerColorAlpha(ROOT.kOrange+1, 0.9)\n",
    "    graph3.SetLineWidth(2)\n",
    "\n",
    "    y = np.array(scale_std_cub)\n",
    "    y[0] = y_max\n",
    "    uncertainty_y = y / np.sqrt(2 * n-2)\n",
    "    graph4 = ROOT.TGraphErrors(len(x), np.array(x, 'd')-2*shift_x, np.array(y, 'd'), np.zeros(len(x)), np.array(uncertainty_y, 'd'))\n",
    "    graph4.SetMarkerStyle(21)\n",
    "    graph4.SetMarkerSize(1.4)\n",
    "    graph4.SetLineColorAlpha(ROOT.kSpring-8, 0.9)\n",
    "    graph4.SetMarkerColorAlpha(ROOT.kSpring-8, 0.9)\n",
    "    graph4.SetLineWidth(2)\n",
    "\n",
    "    graph1.GetXaxis().SetTitle(\"E_{true}=(E_{sig}+E_{PU})  [GeV]\")\n",
    "    graph1.GetYaxis().SetTitle(\"\\sigma_{(\\Delta E/E_{true})}  [GeV]\")\n",
    "    graph1.GetYaxis().SetRangeUser(y_min, y_max)\n",
    "    #graph1.GetYaxis().SetRangeUser(0., 1)\n",
    "\n",
    "    legend = ROOT.TLegend(0.6, 0.75, 0.95, 0.95)\n",
    "    legend.AddEntry(graph1, \"E_{reco} with OF\", \"lep\")\n",
    "    legend.AddEntry(graph3, \"E_{reco} with Linear Filter\", \"lep\")\n",
    "    legend.AddEntry(graph2, \"E_{reco} with Quadratic Filter\", \"lep\")\n",
    "    legend.AddEntry(graph4, \"E_{reco} with Cubic Filter\", \"lep\")\n",
    "\n",
    "    return graph1, graph2, graph3, graph4, legend"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### first HEC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 387,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load data\n",
    "\n",
    "data_folder = './data/'\n",
    "pulse = np.loadtxt(data_folder + 'pule_shape.txt')  # pulse shape\n",
    "adc = np.loadtxt(data_folder + 'adc_out.txt')       # simulated adc output\n",
    "signal = np.loadtxt(data_folder + 'signal.txt')     # delta func signal\n",
    "pileup = np.loadtxt(data_folder + 'pileup.txt')     # pileup noise\n",
    "\n",
    "of_coeff = np.loadtxt(data_folder + 'of_coeffs.txt')# optimal filter coefficients \n",
    "of_out = np.loadtxt(data_folder + 'of_out.txt')     # optimal filter output with above coeffs\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 396,
   "metadata": {},
   "outputs": [],
   "source": [
    "ss=(signal+pileup)\n",
    "\n",
    "to_cut=10000\n",
    "ss = ss[to_cut: 5-to_cut]\n",
    "\n",
    "of_pred, of_h = optimal(of_out, of_coeff, to_cut=to_cut)\n",
    "\n",
    "(lin_pred, lin_h), (quad_pred, quad_h), (cub_pred, cub_h) = all_les_mat(adc, signal, pileup, ncut=to_cut)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 397,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "error for all BCID:  \n",
      "optimal filter:   3.2879159420938806\n",
      "linear FIR filter:   0.7164750246992453\n",
      "quadratic FIR filter:   0.3953894855056812\n",
      "cubic FIR filter:   0.33015096710609354\n",
      "\n",
      "error for only 1 signal(ideal error):  \n",
      "optimal filter:   1.5744445231104913\n",
      "linear FIR filter:   0.5800325540961151\n",
      "quadratic FIR filter:   0.7777019807570871\n",
      "cubic FIR filter:   0.9215795296031735\n"
     ]
    }
   ],
   "source": [
    "print('error for all BCID:  ')\n",
    "print('optimal filter:  ', np.std(of_pred-ss))\n",
    "print('linear FIR filter:  ', np.std(lin_pred-ss))\n",
    "print('quadratic FIR filter:  ', np.std(quad_pred-ss))\n",
    "print('cubic FIR filter:  ', np.std(cub_pred-ss))\n",
    "print()\n",
    "\n",
    "print('error for only 1 signal(ideal error):  ')\n",
    "print('optimal filter:  ', error_bar(of_pred, adc[to_cut: -to_cut], of_h))\n",
    "print('linear FIR filter:  ', error_bar(lin_pred, adc[to_cut: -to_cut], lin_h))\n",
    "print('quadratic FIR filter:  ', error_bar(quad_pred, adc[to_cut: -to_cut], quad_h))\n",
    "print('cubic FIR filter:  ', error_bar(cub_pred, adc[to_cut: -to_cut], cub_h))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 390,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "plt.figure(figsize=(5,3))\n",
    "\n",
    "plt.axhline(0, color='gray', linestyle='-') \n",
    "\n",
    "plt.plot(adc[100200+to_cut:100300+to_cut], 'k-.', alpha=0.8, label='ADC dataset')\n",
    "plt.plot(lin_pred[100200:100300], 'r', alpha=0.6, label='Linear FIR out')\n",
    "plt.plot(of_pred[100200:100300], 'b', alpha=0.6, label='OF out')\n",
    "\n",
    "\n",
    "plt.xlabel('Brunch Crossing')\n",
    "plt.ylabel('Amplitude [GeV]')\n",
    "\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.savefig('hec_data.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 398,
   "metadata": {},
   "outputs": [],
   "source": [
    "indices, x = indices_gen(ss)\n",
    "\n",
    "\n",
    "e_diff_of = (of_pred) - (ss)\n",
    "\n",
    "mean_of, std_of, median_of, lower_98_of, higher_98_of, scale_mean_of, scale_std_of = arr_generator(e_diff_of, ss, indices)\n",
    "\n",
    "\n",
    "e_diff_lin = (lin_pred) - (ss)\n",
    "\n",
    "mean_lin, std_lin, median_lin, lower_98_lin, higher_98_lin, scale_mean_lin, scale_std_lin = arr_generator(e_diff_lin, ss, indices)\n",
    "\n",
    "\n",
    "e_diff_quad = (quad_pred) - (ss)\n",
    "\n",
    "mean_quad, std_quad, median_quad, lower_98_quad, higher_98_quad, scale_mean_quad, scale_std_quad = arr_generator(e_diff_quad, ss, indices)\n",
    "\n",
    "\n",
    "e_diff_cub = (cub_pred) - (ss)\n",
    "\n",
    "mean_cub, std_cub, median_cub, lower_98_cub, higher_98_cub, scale_mean_cub, scale_std_cub = arr_generator(e_diff_cub, ss, indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 399,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: canvas\n",
      "Info in <TCanvas::Print>: pdf file mean_hec.pdf has been created\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "graph1, graph2, graph3, graph4, legend = mean_hist_gen(x, mean_of, std_of, mean_lin, std_lin, mean_quad, std_quad, mean_cub, std_cub, -3, 2)\n",
    "\n",
    "canvas = ROOT.TCanvas(\"canvas\", \"Comparison Canvas\", 800, 600)\n",
    "\n",
    "graph1.Draw(\"APE\")\n",
    "graph2.Draw(\"SAMEPE\")\n",
    "graph3.Draw(\"SAMEPE\")\n",
    "graph4.Draw(\"SAMEPE\")\n",
    "legend.Draw()\n",
    "\n",
    "canvas.Update()\n",
    "canvas.Draw()\n",
    "canvas.Print('mean_hec.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 400,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: canvas\n",
      "Info in <TCanvas::Print>: pdf file std_hec.pdf has been created\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "graph1, graph2, graph3, graph4, legend = std_hist_gen(x, indices, std_of, std_lin, std_quad, std_cub, .3, .7)\n",
    "\n",
    "canvas = ROOT.TCanvas(\"canvas\", \"Comparison Canvas\", 800, 600)\n",
    "\n",
    "graph1.Draw(\"APE\")\n",
    "graph2.Draw(\"SAMEPE\")\n",
    "graph3.Draw(\"SAMEPE\")\n",
    "graph4.Draw(\"SAMEPE\")\n",
    "legend.Draw()\n",
    "\n",
    "canvas.Update()\n",
    "canvas.Draw()\n",
    "canvas.Print('std_hec.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 401,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: canvas\n",
      "Info in <TCanvas::Print>: pdf file median_hec.pdf has been created\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "graph1, graph2, graph3, graph4, legend = median_hist_gen(x, median_of, lower_98_of, higher_98_of, median_quad, lower_98_quad, higher_98_quad, median_lin, lower_98_lin, higher_98_lin, median_cub, lower_98_cub, higher_98_cub, -4, 3.7)\n",
    "\n",
    "canvas = ROOT.TCanvas(\"canvas\", \"Comparison Canvas\", 800, 600)\n",
    "\n",
    "graph1.Draw(\"APE\")\n",
    "graph2.Draw(\"SAMEPE\")\n",
    "graph3.Draw(\"SAMEPE\")\n",
    "graph4.Draw(\"SAMEPE\")\n",
    "legend.Draw()\n",
    "\n",
    "canvas.Update()\n",
    "canvas.Draw()\n",
    "canvas.Print('median_hec.pdf')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 402,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: canvas\n",
      "Info in <TCanvas::Print>: pdf file rela_std_hec.pdf has been created\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "graph1, graph2, graph3, graph4, legend = rela_std_hist_gen(x, indices, scale_std_of, scale_std_lin, scale_std_quad, scale_std_cub, 0, 0.05)\n",
    "\n",
    "canvas = ROOT.TCanvas(\"canvas\", \"Comparison Canvas\", 800, 600)\n",
    "\n",
    "graph1.Draw(\"APE\")\n",
    "graph2.Draw(\"SAMEPE\")\n",
    "graph3.Draw(\"SAMEPE\")\n",
    "graph4.Draw(\"SAMEPE\")\n",
    "legend.Draw()\n",
    "\n",
    "canvas.Update()\n",
    "canvas.Draw()\n",
    "canvas.Print('rela_std_hec.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 386,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Assuming you have pulse data available\n",
    "n_points = len(pulse)\n",
    "x = [i/2 for i in range(n_points)]\n",
    "\n",
    "# Create a figure and axis object\n",
    "fig, ax = plt.subplots(figsize=(5,4))\n",
    "\n",
    "# Plot the pulse data\n",
    "ax.axhline(0, color='k', alpha=0.5, linestyle='--') \n",
    "ax.plot(x, pulse, linestyle='-')\n",
    "\n",
    "# Set x and y axis labels\n",
    "ax.set_xlabel(\"BC\")\n",
    "ax.set_ylabel(\"Arbitrary Units\")\n",
    "\n",
    "# Set the title\n",
    "ax.set_title(\"Pulse Shape\")\n",
    "\n",
    "# Save the plot to a file\n",
    "plt.savefig(\"pulse_shape.pdf\")\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### EMB data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = ['onlyPileup', 'constGapLowE', 'rdGapLowE', 'constGapHighE',  'rdGapHighE']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 441,
   "metadata": {},
   "outputs": [],
   "source": [
    "i=3\n",
    "name = names[i]\n",
    "\n",
    "# load files\n",
    "path = f'/Users/yy/docu/2023 summer/bv/1/OF5_EMB_EMMiddle_eta0.5125_phi0.0125_mu140_BT1_{name}_bunchLength5_size22/'\n",
    "_, path1, path0 = os.listdir(path)\n",
    "\n",
    "pulse, adc, signal, pileup, of_coeff, of_out = data_reader((path+path0), (path+path1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 442,
   "metadata": {},
   "outputs": [],
   "source": [
    "ss=(signal+pileup)\n",
    "\n",
    "to_cut=int(1e6)\n",
    "ss = ss[to_cut: -to_cut]\n",
    "\n",
    "of_pred, of_h = optimal(of_out, of_coeff, to_cut=to_cut)\n",
    "lin_pred, lin_h = lin_les_fft(adc, signal, pileup)\n",
    "quad_pred, quad_h = quad_les_fft(adc, signal, pileup)\n",
    "cub_pred, cub_h = cub_les_fft(adc, signal, pileup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 405,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "========rdGapLowE========\n",
      "error for all BCID:  \n",
      "optimal filter:   1.841506583977256\n",
      "linear FIR filter:   0.26887069847267175\n",
      "quadratic FIR filter:   0.18396085437846785\n",
      "cubic FIR filter:   0.1761076842629289\n",
      "\n",
      "error for only 1 signal(ideal error):  \n",
      "optimal filter:   0.08632504795158778\n",
      "linear FIR filter:   (0.32909789198516215-0.01621365408745307j)\n",
      "quadratic FIR filter:   (0.3309950198695565-0.31134042346944935j)\n",
      "cubic FIR filter:   (0.5095373110960465+0.10445673504188338j)\n"
     ]
    }
   ],
   "source": [
    "print('========'+name+'========')\n",
    "\n",
    "print('error for all BCID:  ')\n",
    "print('optimal filter:  ', np.std(of_pred-ss))\n",
    "print('linear FIR filter:  ', np.std(lin_pred-ss))\n",
    "print('quadratic FIR filter:  ', np.std(quad_pred-ss))\n",
    "print('cubic FIR filter:  ', np.std(cub_pred-ss))\n",
    "print()\n",
    "\n",
    "print('error for only 1 signal(ideal error):  ')\n",
    "print('optimal filter:  ', error_bar(of_pred, adc[to_cut: -to_cut], of_h))\n",
    "print('linear FIR filter:  ', error_bar(lin_pred, adc[to_cut: -to_cut], lin_h))\n",
    "print('quadratic FIR filter:  ', error_bar(quad_pred, adc[to_cut: -to_cut], quad_h))\n",
    "print('cubic FIR filter:  ', error_bar(cub_pred, adc[to_cut: -to_cut], cub_h))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 406,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "plt.figure(figsize=(5,3))\n",
    "\n",
    "plt.axhline(0, color='gray', linestyle='-') \n",
    "\n",
    "plt.plot(ss[100200:100300], 'k-.', alpha=0.8, label='True Signal')\n",
    "plt.plot(lin_pred[100200:100300], 'r', alpha=0.6, label='Linear FIR out')\n",
    "plt.plot(of_pred[100200:100300], 'b', alpha=0.6, label='OF out')\n",
    "\n",
    "\n",
    "plt.xlabel('Brunch Crossing')\n",
    "plt.ylabel('Amplitude [GeV]')\n",
    "\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.savefig(name+'_emb_data.pdf')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 407,
   "metadata": {},
   "outputs": [],
   "source": [
    "indices, x = indices_gen(ss)\n",
    "\n",
    "\n",
    "e_diff_of = (of_pred) - (ss)\n",
    "\n",
    "mean_of, std_of, median_of, lower_98_of, higher_98_of, scale_mean_of, scale_std_of = arr_generator(e_diff_of, ss, indices)\n",
    "\n",
    "\n",
    "e_diff_lin = (lin_pred) - (ss)\n",
    "\n",
    "mean_lin, std_lin, median_lin, lower_98_lin, higher_98_lin, scale_mean_lin, scale_std_lin = arr_generator(e_diff_lin, ss, indices)\n",
    "\n",
    "\n",
    "e_diff_quad = (quad_pred) - (ss)\n",
    "\n",
    "mean_quad, std_quad, median_quad, lower_98_quad, higher_98_quad, scale_mean_quad, scale_std_quad = arr_generator(e_diff_quad, ss, indices)\n",
    "\n",
    "\n",
    "e_diff_cub = (cub_pred) - (ss)\n",
    "\n",
    "mean_cub, std_cub, median_cub, lower_98_cub, higher_98_cub, scale_mean_cub, scale_std_cub = arr_generator(e_diff_cub, ss, indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 418,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: canvas\n",
      "Info in <TCanvas::Print>: pdf file rdGapLowEmean_emb.pdf has been created\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "graph1, graph2, graph3, graph4, legend = mean_hist_gen(x, mean_of, std_of, mean_lin, std_lin, mean_quad, std_quad, mean_cub, std_cub, -1.3, 1.3)\n",
    "\n",
    "canvas = ROOT.TCanvas(\"canvas\", \"Comparison Canvas\", 800, 600)\n",
    "\n",
    "graph1.Draw(\"APE\")\n",
    "graph2.Draw(\"SAMEPE\")\n",
    "graph3.Draw(\"SAMEPE\")\n",
    "graph4.Draw(\"SAMEPE\")\n",
    "legend.Draw()\n",
    "\n",
    "canvas.Update()\n",
    "canvas.Draw()\n",
    "canvas.Print(name+'mean_emb.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 416,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: canvas\n",
      "Info in <TCanvas::Print>: pdf file rdGapLowEstd_emb.pdf has been created\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "graph1, graph2, graph3, graph4, legend = std_hist_gen(x, indices, std_of, std_lin, std_quad, std_cub, 0, .9)\n",
    "\n",
    "canvas = ROOT.TCanvas(\"canvas\", \"Comparison Canvas\", 800, 600)\n",
    "\n",
    "graph1.Draw(\"APE\")\n",
    "graph2.Draw(\"SAMEPE\")\n",
    "graph3.Draw(\"SAMEPE\")\n",
    "graph4.Draw(\"SAMEPE\")\n",
    "legend.Draw()\n",
    "\n",
    "canvas.Update()\n",
    "canvas.Draw()\n",
    "canvas.Print(name+'std_emb.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 415,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: canvas\n",
      "Info in <TCanvas::Print>: pdf file rdGapLowEmedian_emb.pdf has been created\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "graph1, graph2, graph3, graph4, legend = median_hist_gen(x, median_of, lower_98_of, higher_98_of, median_quad, lower_98_quad, higher_98_quad, median_lin, lower_98_lin, higher_98_lin, median_cub, lower_98_cub, higher_98_cub, -2.5, 2)\n",
    "\n",
    "canvas = ROOT.TCanvas(\"canvas\", \"Comparison Canvas\", 800, 600)\n",
    "\n",
    "graph1.Draw(\"APE\")\n",
    "graph2.Draw(\"SAMEPE\")\n",
    "graph3.Draw(\"SAMEPE\")\n",
    "graph4.Draw(\"SAMEPE\")\n",
    "legend.Draw()\n",
    "\n",
    "canvas.Update()\n",
    "canvas.Draw()\n",
    "canvas.Print(name+'median_emb.pdf')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 412,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning in <TCanvas::Constructor>: Deleting canvas with same name: canvas\n",
      "Info in <TCanvas::Print>: pdf file rdGapLowErela_std_emb.pdf has been created\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "graph1, graph2, graph3, graph4, legend = rela_std_hist_gen(x, indices, scale_std_of, scale_std_lin, scale_std_quad, scale_std_cub, 0.001, 0.12)\n",
    "\n",
    "canvas = ROOT.TCanvas(\"canvas\", \"Comparison Canvas\", 800, 600)\n",
    "\n",
    "graph1.Draw(\"APE\")\n",
    "graph2.Draw(\"SAMEPE\")\n",
    "graph3.Draw(\"SAMEPE\")\n",
    "graph4.Draw(\"SAMEPE\")\n",
    "legend.Draw()\n",
    "\n",
    "canvas.Update()\n",
    "canvas.Draw()\n",
    "canvas.Print(name+'rela_std_emb.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 443,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1-mean_fir/mean_of for  lin  fir filter is:    0.9227547225012924\n",
      "1-median_fir/median_of for  lin  fir filter is:    -0.2648385637949784\n",
      "1-std_fir/std_of for  lin  fir filter is:    0.9390469067216382\n"
     ]
    }
   ],
   "source": [
    "filt = 'lin'\n",
    "pred = lin_pred\n",
    "\n",
    "bins = [0.2, 1, 130]\n",
    "bin_indices = np.digitize(ss, bins)\n",
    "\n",
    "\n",
    "i_arr = (np.where(bin_indices == 1)[0])\n",
    "\n",
    "data = ((pred) - (ss))[i_arr]\n",
    "mean_fir = data.mean()\n",
    "std_fir = data.std()\n",
    "lower, upper = np.percentile(data, [1, 99])\n",
    "filtered_signal = data[(data >= lower) & (data <= upper)]\n",
    "median_fir = np.median(filtered_signal)\n",
    "\n",
    "e_diff_of = ((of_pred) - (ss))[i_arr]\n",
    "mean_of = e_diff_of.mean()\n",
    "std_of = e_diff_of.std()\n",
    "lower, upper = np.percentile(e_diff_of, [1, 99])\n",
    "filtered_signal = e_diff_of[(e_diff_of >= lower) & (e_diff_of <= upper)]\n",
    "median_of = np.median(e_diff_of)\n",
    "\n",
    "print('1-mean_fir/mean_of for ',filt,' fir filter is:   ',(1 - mean_fir/mean_of))\n",
    "print('1-median_fir/median_of for ',filt,' fir filter is:   ',(1 - median_fir/median_of))\n",
    "print('1-std_fir/std_of for ',filt,' fir filter is:   ',(1 - std_fir/std_of))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 444,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1-mean_fir/mean_of for  quad  fir filter is:    0.9906048118855144\n",
      "1-median_fir/median_of for  quad  fir filter is:    0.7663789932705518\n",
      "1-std_fir/std_of for  quad  fir filter is:    0.968573420891927\n"
     ]
    }
   ],
   "source": [
    "filt = 'quad'\n",
    "pred = quad_pred\n",
    "\n",
    "bins = [0.2, 1, 130]\n",
    "bin_indices = np.digitize(ss, bins)\n",
    "\n",
    "\n",
    "i_arr = (np.where(bin_indices == 1)[0])\n",
    "\n",
    "data = ((pred) - (ss))[i_arr]\n",
    "mean_fir = data.mean()\n",
    "std_fir = data.std()\n",
    "lower, upper = np.percentile(data, [1, 99])\n",
    "filtered_signal = data[(data >= lower) & (data <= upper)]\n",
    "median_fir = np.median(filtered_signal)\n",
    "\n",
    "e_diff_of = ((of_pred) - (ss))[i_arr]\n",
    "mean_of = e_diff_of.mean()\n",
    "std_of = e_diff_of.std()\n",
    "lower, upper = np.percentile(e_diff_of, [1, 99])\n",
    "filtered_signal = e_diff_of[(e_diff_of >= lower) & (e_diff_of <= upper)]\n",
    "median_of = np.median(e_diff_of)\n",
    "\n",
    "print('1-mean_fir/mean_of for ',filt,' fir filter is:   ',(1 - mean_fir/mean_of))\n",
    "print('1-median_fir/median_of for ',filt,' fir filter is:   ',(1 - median_fir/median_of))\n",
    "print('1-std_fir/std_of for ',filt,' fir filter is:   ',(1 - std_fir/std_of))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 445,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1-mean_fir/mean_of for  cub  fir filter is:    0.9863777719383958\n",
      "1-median_fir/median_of for  cub  fir filter is:    0.8137829635663151\n",
      "1-std_fir/std_of for  cub  fir filter is:    0.9749239334501203\n"
     ]
    }
   ],
   "source": [
    "filt = 'cub'\n",
    "pred = cub_pred\n",
    "\n",
    "bins = [0.2, 1, 130]\n",
    "bin_indices = np.digitize(ss, bins)\n",
    "\n",
    "\n",
    "i_arr = (np.where(bin_indices == 1)[0])\n",
    "\n",
    "data = ((pred) - (ss))[i_arr]\n",
    "mean_fir = data.mean()\n",
    "std_fir = data.std()\n",
    "lower, upper = np.percentile(data, [1, 99])\n",
    "filtered_signal = data[(data >= lower) & (data <= upper)]\n",
    "median_fir = np.median(filtered_signal)\n",
    "\n",
    "e_diff_of = ((of_pred) - (ss))[i_arr]\n",
    "mean_of = e_diff_of.mean()\n",
    "std_of = e_diff_of.std()\n",
    "lower, upper = np.percentile(e_diff_of, [1, 99])\n",
    "filtered_signal = e_diff_of[(e_diff_of >= lower) & (e_diff_of <= upper)]\n",
    "median_of = np.median(e_diff_of)\n",
    "\n",
    "print('1-mean_fir/mean_of for ',filt,' fir filter is:   ',(1 - mean_fir/mean_of))\n",
    "print('1-median_fir/median_of for ',filt,' fir filter is:   ',(1 - median_fir/median_of))\n",
    "print('1-std_fir/std_of for ',filt,' fir filter is:   ',(1 - std_fir/std_of))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 446,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'constGapHighE'"
      ]
     },
     "execution_count": 446,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 447,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22000000"
      ]
     },
     "execution_count": 447,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(adc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "downgrade",
   "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.10.6"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}