DAPHNE_randomTrigger_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26248767",
   "metadata": {},
   "outputs": [],
   "source": [
    "### note this notebook is based off of one I found on one of the DAQ machines at CERN\n",
    "\n",
    "# define some functions\n",
    "\n",
    "from oei import *\n",
    "from tqdm.notebook import trange, tqdm\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import warnings\n",
    "import time\n",
    "\n",
    "class readwave:\n",
    "    def __init__(self, ep=100, afe=0, ch=0,plot=False):\n",
    "        thing = OEI(f\"10.73.137.{ep}\")\n",
    "        thing.write(0x2000,[1234])\n",
    "        wf=[]\n",
    "        for i in range (20):\n",
    "            doutrec = thing.read(0x40000000+(0x100000 * afe)+(0x10000 * ch)+i*50,50)[2:]\n",
    "            for word in doutrec:\n",
    "                wf.append(word)\n",
    "        #print(len(wf))\n",
    "        x = np.linspace(0.0, len(wf) * 16e-9, num=len(wf))\n",
    "        if plot:\n",
    "            plt.figure()\n",
    "            plt.plot(x,wf,linewidth=0.6,label=f' \\t rms={np.round(np.mean(wf),2)}')\n",
    "            plt.show()\n",
    "        self.wf=np.array(wf)\n",
    "        self.afe=afe\n",
    "        self.ch=ch\n",
    "        self.ep=ep\n",
    "        thing.close()\n",
    "\n",
    "        \n",
    "class fft:\n",
    "    def __init__(self, sig, dt=16e-9, plot=False):\n",
    "        np.seterr(divide = 'ignore') \n",
    "        if dt is None:\n",
    "            dt = 1\n",
    "            t = np.arange(0, sig.shape[-1])\n",
    "            xLabel = \"samples\"\n",
    "        else:\n",
    "            t = np.arange(0, sig.shape[-1]) * dt\n",
    "            xLabel = \"freq [Hz]\"\n",
    "\n",
    "        if sig.shape[0] % 2 != 0:\n",
    "            warnings.warn(\"signal preferred to be even in size, autoFixing it...\")\n",
    "            t = t[:-1]\n",
    "            sig = sig[:-1]\n",
    "\n",
    "        sigFFT = np.fft.fft(sig) / t.shape[0] \n",
    "\n",
    "        freq = np.fft.fftfreq(t.shape[0], d=dt)\n",
    "\n",
    "        firstNegInd = np.argmax(freq < 0)\n",
    "        freqAxisPos = freq[:firstNegInd]\n",
    "        sigFFTPos = 2 * sigFFT[:firstNegInd] \n",
    "\n",
    "        if plot:\n",
    "            plt.figure()\n",
    "            plt.plot(freqAxisPos, 20*np.log10(np.abs(sigFFTPos)/2**14))\n",
    "            plt.ylim([-140, -80])\n",
    "            plt.xscale(\"log\")\n",
    "            plt.xlabel(xLabel)\n",
    "            plt.ylabel(\"U.A.\")\n",
    "            plt.title(\"Analytic FFT plot\")\n",
    "            plt.show()\n",
    "\n",
    "        self.x = freqAxisPos /10e5\n",
    "        self.y = 20*np.log10(np.abs(sigFFTPos)/2**14)\n",
    "#wf=readwave(plot=True).wf\n",
    "#f=fft   (wf,dt=None,plot=True)     \n",
    "        \n",
    "class mean_fft:\n",
    "    def __init__(self, data,label=None,plot=False):\n",
    "        np.seterr(divide = 'ignore') \n",
    "        fft_list_x=[]\n",
    "        fft_list_y=[]\n",
    "        std_list=[]\n",
    "        for k in range(len(data)):\n",
    "            fft_list_x.append(fft(data[k]).x)\n",
    "            fft_list_y.append(fft(data[k]).y)\n",
    "            std_list.append(np.std(data[k],axis=0))\n",
    "        self.x=np.mean(fft_list_x,axis=0) \n",
    "        self.y=np.mean(fft_list_y,axis=0)\n",
    "        self.stdx=np.mean(std_list,axis=0)\n",
    "        if plot:\n",
    "            plt.rcParams[\"figure.figsize\"] = (10,7)\n",
    "            plt.figure()\n",
    "            plt.plot(self.x,self.y,linewidth=1,label=f'{label} \\t rms={np.round(self.stdx,2)}'.expandtabs())\n",
    "            plt.ylim([min(self.y)-10, -80])\n",
    "            #plt.xscale(\"log\")\n",
    "            # plt.xlim([0.2, 3])\n",
    "            plt.legend()\n",
    "            plt.ylabel(\"dBFS\")\n",
    "            plt.xlabel(\"MHz\")\n",
    "            plt.title(\"FFT\")\n",
    "            plt.tight_layout()\n",
    "\n",
    "def calculate_rms_deviation(array):\n",
    "    mean = np.mean(array)\n",
    "    deviations = array - mean\n",
    "    squared_deviations = deviations ** 2\n",
    "    mean_squared_deviation = np.mean(squared_deviations)\n",
    "    rms_deviation = np.sqrt(mean_squared_deviation)\n",
    "    return rms_deviation\n",
    "\n",
    "from init import write_and_read\n",
    "\n",
    "def tune_offset(thing, i, afe, tolerance=50, target_pedestal=8192):\n",
    "    #thing = OEI(f\"10.73.137.{i}\")\n",
    "    print(\"DAPHNE firmware version %0X\" % thing.read(0x9000,1)[2])\n",
    "    print(f'DAPHNE ip address = 10.73.137.{i}')\n",
    "    channels=[4,5,6,7]\n",
    "    for ch in channels:\n",
    "        thing.write(0x2000, [1234]) # software trigger, all spy buffers capture\n",
    "        a=np.average(thing.read(0x40000000+(afe*0x100000)+(ch*0x10000),50)[40:])\n",
    "        #print (a)\n",
    "        offset=1118\n",
    "        pedestal=target_pedestal\n",
    "        while tolerance<=abs(pedestal-a):\n",
    "            offset=offset+((pedestal-a)/abs(pedestal-a))\n",
    "            write_and_read(thing, f'WR OFFSET CH {afe*8+ch} V {offset}',get_response=True) \n",
    "            thing.write(0x2000, [1234]) # software trigger, all spy buffers capture\n",
    "            a=np.average(thing.read(0x40000000+(afe*0x100000)+(ch*0x10000),50)[40:])\n",
    "\n",
    "            print (a) \n",
    "        print(\"AFE%d[%d]: \" % (afe,ch),end=\"\")\n",
    "        for x in thing.read(0x40000000+(afe*0x100000)+(ch*0x10000),15)[3:]:\n",
    "            print(\"%04X \" % x,end=\"\")\n",
    "        print()\n",
    "    print()\n",
    "           \n",
    "    thing.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07166141",
   "metadata": {},
   "outputs": [],
   "source": [
    "### take data at multiple VGAIN values and calculate RMS and FFT\n",
    "\n",
    "# make a list of VGAIN settings to try\n",
    "VGAIN_SETTINGS = [0]\n",
    "i = 100 # ip endpoint\n",
    "\n",
    "channel = 0\n",
    "AFE = 0\n",
    "nWvfms = 1000\n",
    "\n",
    "FFT_data = []\n",
    "RMS_data = []\n",
    "ADC_data = []\n",
    "\n",
    "turn_on_OIs = False\n",
    "set_VGAIN = True\n",
    "tune_offset = False\n",
    "\n",
    "# try each VGAIN value and take data with each setting\n",
    "for VGAIN in VGAIN_SETTINGS:\n",
    "    thing = OEI(f\"10.73.137.{i}\")\n",
    "    \n",
    "    if turn_on_OIs:\n",
    "        # turn on offset integrators, should tune offset also to close to 8196\n",
    "        write_and_read(thing, 'WR AFE '+ str(int(AFE)) + ' REG 52 V 16896', get_response=True)\n",
    "        write_and_read(thing, 'WR AFE '+ str(int(AFE)) + ' REG 51 V 0', get_response=True)\n",
    "\n",
    "    if set_VGAIN:\n",
    "        write_and_read(thing, 'WR AFE '+ str(int(AFE)) + f' VGAIN V {VGAIN}', get_response=True)\n",
    "        \n",
    "    if tune_offset:\n",
    "        tune_offset(thing, i, AFE, target_pedestal=8196, tolerance=100)\n",
    "    \n",
    "    progress=trange(nWvfms, unit='waveforms',desc = f'Reading from endpoint {i}:')\n",
    "    d = [readwave(ep=i, ch=channel,afe=AFE).wf for _ in progress ]\n",
    "    RMS_data.append(calculate_rms_deviation(np.array(d).flatten()))\n",
    "    FFT_data.append(mean_fft(d))\n",
    "    ADC_data.append(np.array(d).flatten())\n",
    "    \n",
    "for RMS in RMS_data:\n",
    "    print(f'RMS value: {RMS:.3f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9d638aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# optionally save FFT, RMS, and ADC data to npz file for later analysis\n",
    "BIAS=47\n",
    "np.savez(f'FFT_RMS_ADC_data_ch{channel}_afe{AFE}_March12024_VGAIN{VGAIN_SETTINGS[0]}_BOTHOffsetIntegratorsOFF.npz', FFT_data=np.array(FFT_data), RMS_data=np.array(RMS_data), ADC_data=np.array(ADC_data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dc905c8c",
   "metadata": {},
   "outputs": [],
   "source": [
    "### example of loading npz data\n",
    "\n",
    "#np.load('FFT_RMS_ADC_data_ch0_afe0_variousVGAIN_offsetIntegratorsOn.npz',allow_pickle=True)['ADC_data']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eaf6fb12",
   "metadata": {},
   "outputs": [],
   "source": [
    "VGAIN_SETTINGS = [600]\n",
    "i = 100\n",
    "AFEs = [0,1,2,3,4]\n",
    "\n",
    "VGAIN=VGAIN_SETTINGS[0]\n",
    "# to set VGAIN on each AFE\n",
    "thing = OEI(f\"10.73.137.{i}\")\n",
    "for AFE in AFEs:\n",
    "    write_and_read(thing, 'WR AFE '+ str(int(AFE)) + f' VGAIN V {VGAIN}', get_response=True)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b787142",
   "metadata": {},
   "outputs": [],
   "source": [
    "thing = OEI(f\"10.73.137.{i}\")\n",
    "AFEs=[0]\n",
    "for AFE in AFEs:\n",
    "    # first turn on offset integrators\n",
    "    #write_and_read(thing, 'WR AFE '+ str(int(AFE)) + ' REG 52 V 16896', get_response=True)\n",
    "    #write_and_read(thing, 'WR AFE '+ str(int(AFE)) + ' REG 51 V 0', get_response=True)\n",
    "    #write_and_read(thing, 'WR AFE '+ str(int(AFE)) + ' REG 52 V 21056', get_response=True)\n",
    "    #write_and_read(thing, 'WR AFE '+ str(int(AFE)) + ' REG 51 V 16', get_response=True)\n",
    "    write_and_read(thing, 'WR AFE '+ str(int(AFE)) + ' REG 52 V 20992', get_response=True)\n",
    "    write_and_read(thing, 'WR AFE '+ str(int(AFE)) + ' REG 51 V 16', get_response=True)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1f18e94",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "### plot FFTs\n",
    "\n",
    "np.seterr(divide = 'ignore') \n",
    "plt.rcParams[\"figure.figsize\"] = (10,7)\n",
    "plt.figure()\n",
    "\n",
    "for j in range(len(VGAIN_SETTINGS)):\n",
    "    plt.plot(FFT_data[j].x,FFT_data[j].y,linewidth=1,label=f'VGAIN = {VGAIN_SETTINGS[j]}')\n",
    "plt.legend()\n",
    "\n",
    "plt.ylim([-115, -80])\n",
    "plt.ylabel(\"dBFS\")\n",
    "plt.xlabel(\"MHz\")\n",
    "#plt.xlim(0, 3.5)\n",
    "plt.title(f'CSU DAPHNE FFT, channel {channel}, AFE {AFE}')\n",
    "#plt.title(f\"Noise tests on DAPHNE V2A ch {Channel+AFE[]*8}\")\n",
    "plt.grid(axis='x',color=\"0.95\")\n",
    "plt.tight_layout()\n",
    "#plt.savefig(f'FFTs_ch{channel}_afe{AFE}_variousVGAIN_offsetIntegratorsOn.pdf')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd886c00",
   "metadata": {},
   "outputs": [],
   "source": [
    "### plot RMS data points (particularly useful for multiple VGAIN values)\n",
    "\n",
    "np.seterr(divide = 'ignore') \n",
    "plt.rcParams[\"figure.figsize\"] = (10,7)\n",
    "plt.figure()\n",
    "\n",
    "plt.scatter(VGAIN_SETTINGS, RMS_data, linewidth=1)\n",
    "plt.legend()\n",
    "#plt.ylim([-115, -87])\n",
    "plt.ylabel(\"ADC RMS\")\n",
    "plt.xlabel(\"VGAIN\")\n",
    "plt.title(f'CSU DAPHNE Waveform RMS, channel {channel}, AFE {AFE} (offset integrators OFF)')\n",
    "#plt.title(f\"Noise tests on DAPHNE V2A ch {Channel+AFE[]*8}\")\n",
    "#plt.grid(axis='x',color=\"0.95\")\n",
    "plt.tight_layout()\n",
    "#plt.savefig(f'RMS_plot_ch{channel}_afe{AFE}_variousVGAIN_offsetIntegratorsOn.pdf')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4a24479",
   "metadata": {},
   "outputs": [],
   "source": [
    "### plot histograms of ADC data for each VGAIN value\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "np.seterr(divide='ignore') \n",
    "plt.rcParams[\"figure.figsize\"] = (10, 6)\n",
    "\n",
    "# Determine the number of rows and columns for subplots\n",
    "num_plots = len(VGAIN_SETTINGS)\n",
    "num_cols = 4  # Adjust the number of columns as needed\n",
    "num_rows = (num_plots + num_cols - 1) // num_cols\n",
    "\n",
    "fig, axes = plt.subplots(num_rows, num_cols, figsize=(14, 3*num_rows))\n",
    "\n",
    "# Flatten axes if it's a single row or column\n",
    "if num_rows == 1:\n",
    "    axes = axes.reshape(1, -1)\n",
    "if num_cols == 1:\n",
    "    axes = axes.reshape(-1, 1)\n",
    "\n",
    "for j, ax in enumerate(axes.flat):\n",
    "    if j < num_plots:\n",
    "        ax.hist(ADC_data[j].astype('int'), range=(np.min(ADC_data[j]), np.max(ADC_data[j])), bins=np.max(ADC_data[j])-np.min(ADC_data[j]), label=f'VGAIN = {VGAIN_SETTINGS[j]}', alpha=0.5)\n",
    "        ax.legend(fontsize='small')\n",
    "        if j == 0:\n",
    "            nticks=10\n",
    "        elif j == 1:\n",
    "            nticks=10\n",
    "        elif j==2:\n",
    "            nticks=10\n",
    "        else:\n",
    "            nticks=5\n",
    "        ax.set_xticks(np.arange(np.min(ADC_data[j]), np.max(ADC_data[j]), nticks))\n",
    "        ax.set_ylabel(\"Counts\")\n",
    "        ax.set_xlabel(\"ADCs\")\n",
    "        \n",
    "#ax.set_title(f'CSU DAPHNE ADC Histogram, channel {channel}, AFE {AFE} (offset integrators ON)')\n",
    "ax.set_rasterization_zorder(2)\n",
    "# Hide any unused subplots\n",
    "for j in range(num_plots, num_rows * num_cols):\n",
    "    axes.flat[j].axis('off')\n",
    "fig.suptitle(f'CSU DAPHNE ADC Histograms, channel {channel}, AFE {AFE} (offset integrators ON)')\n",
    "plt.tight_layout()\n",
    "#plt.savefig(f'ADC_histograms_ch{channel}_afe{AFE}_variousVGAIN_offsetIntegratorsOn.pdf')\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c4418082",
   "metadata": {},
   "outputs": [],
   "source": [
    "### define function for converting h5 to csv\n",
    "\n",
    "import h5py\n",
    "import numpy as np\n",
    "start_index = 1000\n",
    "stop_index = 2000\n",
    "#filename = \"daphne_fnal_data/config4/daphne_fnal_LED_config4_VGAIN900\"\n",
    "def convert_h5py_to_csv(h5py_filename, csv_filename):\n",
    "    with h5py.File(h5py_filename, 'r') as f:\n",
    "        # Load all waveforms into memory\n",
    "        waveforms_data = np.array(f['waveforms']['adc'][:], dtype='i4')\n",
    "        waveforms_data = waveforms_data[:, start_index:stop_index]\n",
    "    # Reshape the waveforms_data array to have each waveform in a column\n",
    "    reshaped_data = waveforms_data\n",
    "\n",
    "    # Write the reshaped data into a CSV file\n",
    "    output_filename = csv_filename\n",
    "    np.savetxt(output_filename, reshaped_data, delimiter=',', fmt='%d')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f8e04e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "### convert multiple files to csv from h5\n",
    "\n",
    "import os\n",
    "import fnmatch\n",
    "\n",
    "def get_files_in_directory(directory, pattern):\n",
    "    file_list = []\n",
    "    for root, dirs, files in os.walk(directory):\n",
    "        for filename in files:\n",
    "            if fnmatch.fnmatch(filename, pattern):\n",
    "                file_list.append(os.path.join(root, filename).replace('\\\\', '/'))\n",
    "    return file_list\n",
    "\n",
    "# Example usage:\n",
    "directory = 'daphne_fnal_data'\n",
    "pattern = 'daphne_fnal_config5*.h5'  # Example pattern to match all files ending with '.txt'\n",
    "\n",
    "matching_files = get_files_in_directory(directory, pattern)\n",
    "for file in matching_files:\n",
    "    print(file)\n",
    "    convert_h5py_to_csv(file, f\"{file.split('.h5')[0]}.csv\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c60609e",
   "metadata": {},
   "outputs": [],
   "source": [
    "channel=0\n",
    "AFE=0\n",
    "VGAIN=900\n",
    "data_OI_BOTH_OFF = np.load(f'FFT_RMS_ADC_data_ch{channel}_afe{AFE}_March12024_VGAIN0_BOTHOffsetIntegratorsOFF.npz',allow_pickle=True)\n",
    "data_OI_BOTH_ON = np.load(f'FFT_RMS_ADC_data_ch{channel}_afe{AFE}_March12024_VGAIN0_BothOffsetIntegratorsON.npz',allow_pickle=True)\n",
    "data_OI_PGA_ON = np.load(f'FFT_RMS_ADC_data_ch{channel}_afe{AFE}_March12024_VGAIN0_OnlyPGAOffsetIntegratorsON.npz',allow_pickle=True)\n",
    "data_OI_LNA_ON = np.load(f'FFT_RMS_ADC_data_ch{channel}_afe{AFE}_March12024_VGAIN0_OnlyLNAOffsetIntegratorsON.npz',allow_pickle=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa7b13f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "plt.rcParams[\"figure.figsize\"] = (8,6)\n",
    "plt.figure()\n",
    "\n",
    "plt.plot(data_OI_BOTH_OFF['FFT_data'][0].x,data_OI_BOTH_OFF['FFT_data'][0].y,linewidth=1,label='Both Offset Integrators OFF')\n",
    "plt.plot(data_OI_BOTH_ON['FFT_data'][0].x,data_OI_BOTH_ON['FFT_data'][0].y,linewidth=1,label='Both Offset Integrators ON')\n",
    "plt.plot(data_OI_PGA_ON['FFT_data'][0].x,data_OI_PGA_ON['FFT_data'][0].y,linewidth=1,label='Only PGA Offset Integrator ON')\n",
    "plt.plot(data_OI_LNA_ON['FFT_data'][0].x,data_OI_LNA_ON['FFT_data'][0].y,linewidth=1,label='Only LNA Offset Integrator ON')\n",
    "plt.legend()\n",
    "\n",
    "plt.ylim([-115, -80])\n",
    "plt.ylabel(\"dBFS\")\n",
    "plt.xlabel(\"MHz\")\n",
    "#plt.xlim(0, 3.5)\n",
    "plt.title(f'CSU DAPHNE FFT, channel {channel}, AFE {AFE}, March 1 2024 Offset Integrator Test')\n",
    "#plt.title(f\"Noise tests on DAPHNE V2A ch {Channel+AFE[]*8}\")\n",
    "plt.grid(axis='x',color=\"0.95\")\n",
    "plt.tight_layout()\n",
    "#plt.savefig(f'FFTs_ch{channel}_afe{AFE}_variousVGAIN_offsetIntegratorsOn.pdf')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e4aa6f3",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "%matplotlib notebook\n",
    "plt.rcParams[\"figure.figsize\"] = (12,2)\n",
    "\n",
    "plot_one = False\n",
    "\n",
    "if plot_one:\n",
    "    plt.figure()\n",
    "    ADC_data_OI_BOTH_ON = (data_OI_BOTH_ON['ADC_data'][0] - int(np.mean(data_OI_BOTH_ON['ADC_data'][0]))).astype('int')\n",
    "    plt.hist(ADC_data_OI_BOTH_ON.astype('int'), range=(np.min(ADC_data_OI_BOTH_ON), np.max(ADC_data_OI_BOTH_ON)), bins=np.max(ADC_data_OI_BOTH_ON)-np.min(ADC_data_OI_BOTH_ON), label=f'Both Offset Integrators ON', alpha=0.5)\n",
    "    ADC_data_OI_BOTH_OFF = (data_OI_BOTH_OFF['ADC_data'][0] - int(np.mean(data_OI_BOTH_OFF['ADC_data'][0]))).astype('int')\n",
    "    plt.hist(ADC_data_OI_BOTH_OFF.astype('int'), range=(np.min(ADC_data_OI_BOTH_OFF), np.max(ADC_data_OI_BOTH_OFF)), bins=np.max(ADC_data_OI_BOTH_OFF)-np.min(ADC_data_OI_BOTH_OFF), label=f'Both Offset Integrators OFF', alpha=0.5)\n",
    "    ADC_data_OI_PGA_ON = (data_OI_PGA_ON['ADC_data'][0] - int(np.mean(data_OI_PGA_ON['ADC_data'][0]))).astype('int')\n",
    "    plt.hist(ADC_data_OI_PGA_ON.astype('int'), range=(np.min(ADC_data_OI_PGA_ON), np.max(ADC_data_OI_PGA_ON)), bins=np.max(ADC_data_OI_PGA_ON)-np.min(ADC_data_OI_PGA_ON), label=f'Only PGA Offset Integrator', alpha=0.5)\n",
    "    ADC_data_OI_LNA_ON = (data_OI_LNA_ON['ADC_data'][0] - int(np.mean(data_OI_LNA_ON['ADC_data'][0]))).astype('int')\n",
    "    plt.hist(ADC_data_OI_LNA_ON.astype('int'), range=(np.min(ADC_data_OI_LNA_ON), np.max(ADC_data_OI_LNA_ON)), bins=np.max(ADC_data_OI_LNA_ON)-np.min(ADC_data_OI_LNA_ON), label=f'Only LNA Offset Integrator ON', alpha=0.5)\n",
    "    \n",
    "    plt.legend()\n",
    "    plt.xlabel('ADC - mean ADC')\n",
    "    plt.ylabel('counts')\n",
    "    plt.title(f'VGAIN = {VGAIN}')\n",
    "else:\n",
    "    fig, axes = plt.subplots(1, 4, figsize=(15, 4))\n",
    "    ADC_data_OI_BOTH_ON = (data_OI_BOTH_ON['ADC_data'][0]).astype('int')\n",
    "    axes[0].hist(ADC_data_OI_BOTH_ON.astype('int'), range=(np.min(ADC_data_OI_BOTH_ON), np.max(ADC_data_OI_BOTH_ON)), bins=np.max(ADC_data_OI_BOTH_ON)-np.min(ADC_data_OI_BOTH_ON), label=f'Both Offset Integrators ON', alpha=0.5)\n",
    "    ADC_data_OI_BOTH_OFF = (data_OI_BOTH_OFF['ADC_data'][0]).astype('int')\n",
    "    axes[1].hist(ADC_data_OI_BOTH_OFF.astype('int'), range=(np.min(ADC_data_OI_BOTH_OFF), np.max(ADC_data_OI_BOTH_OFF)), bins=np.max(ADC_data_OI_BOTH_OFF)-np.min(ADC_data_OI_BOTH_OFF), label=f'Both Offset Integrators OFF', alpha=0.5)\n",
    "    ADC_data_OI_PGA_ON = (data_OI_PGA_ON['ADC_data'][0]).astype('int')\n",
    "    axes[2].hist(ADC_data_OI_PGA_ON.astype('int'), range=(np.min(ADC_data_OI_PGA_ON), np.max(ADC_data_OI_PGA_ON)), bins=np.max(ADC_data_OI_PGA_ON)-np.min(ADC_data_OI_PGA_ON), label=f'Only PGA Offset Integrator', alpha=0.5)\n",
    "    ADC_data_OI_LNA_ON = (data_OI_LNA_ON['ADC_data'][0]).astype('int')\n",
    "    axes[3].hist(ADC_data_OI_LNA_ON.astype('int'), range=(np.min(ADC_data_OI_LNA_ON), np.max(ADC_data_OI_LNA_ON)), bins=np.max(ADC_data_OI_LNA_ON)-np.min(ADC_data_OI_LNA_ON), label=f'Only LNA Offset Integrator ON', alpha=0.5)\n",
    "    \n",
    "    axes[0].set_xlabel('ADC')\n",
    "    axes[1].set_xlabel('ADC')\n",
    "    axes[0].set_ylabel('counts')\n",
    "    #axes[1].set_ylabel('counts')\n",
    "    axes[0].set_title(f'Both Offset Integrators ON', fontsize=9)\n",
    "    axes[1].set_title(f'Both Offset Integrators OFF', fontsize=9)\n",
    "    axes[2].set_title('Only PGA Offset Integrator ON', fontsize=9)\n",
    "    axes[3].set_title('Only LNA Offset Integrator ON', fontsize=9)\n",
    "    #plt.savefig('daphne_offset_integrator_test.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "963a48b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"RMS offset integrators off = {data_OI_OFF['RMS_data'][0]:.3f}\")\n",
    "print(f\"RMS offset integrators on = {data_OI_ON['RMS_data'][0]:.3f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6bed3482",
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}