IV Analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a1ad193a-103a-4065-bf6c-b614d7451448",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import mplhep as hep\n",
    "from scipy.optimize import curve_fit\n",
    "import matplotlib.dates as mdates\n",
    "from datetime import datetime, timezone, timedelta\n",
    "import os\n",
    "import scipy\n",
    "import pandas as pd\n",
    "import re\n",
    "import scipy.ndimage\n",
    "from matplotlib.backends.backend_pdf import PdfPages\n",
    "\n",
    "hep.style.use(hep.style.CMS)\n",
    "\n",
    "def linear(x, a, b):\n",
    "    return a*x + b\n",
    "\n",
    "def quad(x, a, b, c):\n",
    "    return a*x**2 + b*x + c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4b8422bf-58fb-4f7f-8fff-7375746bb9ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "directory = 'Sipm_RadTest/Davis'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e017a340-d116-4019-bccb-8ee8cf33aba7",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Processing FlowerBoard Irradiated\n",
      "Processing FlowerBoard IV_PreIrradiation\n",
      "Making plots for this type...\n",
      "\n",
      "Processing S13_6050 Irradiated\n",
      "Processing S13_6050 IV_PreIrradiation\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_354/937874038.py:84: RuntimeWarning: invalid value encountered in sqrt\n",
      "  breakV = (-fit[1] + np.sqrt(fit[1]**2 - 4 * fit[0] * (fit[2] - baseline))) / 2 / fit[0]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Making plots for this type...\n",
      "\n",
      "Processing S14_3010 Irradiated\n",
      "Processing S14_3010 IV_PreIrradiation\n",
      "Making plots for this type...\n",
      "\n",
      "Processing S14_3015 Irradiated\n",
      "Processing S14_3015 IV_PreIrradiation\n",
      "Making plots for this type...\n",
      "\n",
      "Processing S14_6015 Irradiated\n",
      "Processing S14_6015 IV_PreIrradiation\n",
      "Making plots for this type...\n",
      "\n",
      "Processing S14_6050 Irradiated\n",
      "Processing S14_6050 IV_PreIrradiation\n",
      "Making plots for this type...\n",
      "\n"
     ]
    }
   ],
   "source": [
    "sipm_type = os.listdir(directory)\n",
    "\n",
    "for type in sipm_type:\n",
    "    if type == \"JF_3015\" or type == \"JF_6015\":\n",
    "        continue\n",
    "    \n",
    "    sipm_test = os.listdir(directory + os.sep + type)\n",
    "    Current = []\n",
    "    Voltage = []\n",
    "    time = []\n",
    "    sipm_id = []\n",
    "    status = []\n",
    "    Breakdown = []\n",
    "    fluence = []\n",
    "    darkI = []\n",
    "    for test in sipm_test:\n",
    "        if test == \"bad_runs\" or test == \"short_runs\":\n",
    "            continue\n",
    "        \n",
    "        print('Processing ' + type + ' ' + test, flush=True)\n",
    "        datasheet = 53 if type.split('_')[0] == 'S13' else 38\n",
    "        datasheet_error = 5 if type.split('_')[0] == 'S13' else 3\n",
    "        files = sorted(os.listdir(directory + os.sep + type + os.sep + test))\n",
    "        if len(files) == 0:\n",
    "            continue\n",
    "        BV = []\n",
    "        BV1 = []\n",
    "        BV2 = []\n",
    "        BV3 = []\n",
    "        BV4 = []\n",
    "        BV5 = []\n",
    "        BV6 = []\n",
    "        avgBV = []\n",
    "        for i in enumerate(files):\n",
    "            if i[1] == '.ipynb_checkpoints':\n",
    "                pass\n",
    "            f = i[1]\n",
    "            id = str(f.split('_')[0])\n",
    "            if test == 'Irradiated':\n",
    "                fluence.append(float(re.split('_|[A-Z]+',id)[-1]))\n",
    "            else:\n",
    "                fluence.append(0)\n",
    "            sipm_id.append(id.split('_')[0])\n",
    "            timestamp = f.split('UTC_')[1].split('.txt')[0]\n",
    "            status.append(test)\n",
    "            with open(directory + os.sep + type + os.sep + test + os.sep + f,'r') as file:\n",
    "                lines = file.read().split(',')\n",
    "            voltage = lines[::2]\n",
    "            current = lines[1::2]\n",
    "            \n",
    "            voltage = np.array(list(map(float, voltage[1:])))\n",
    "            current = np.array(list(map(float, current[1:])))\n",
    "            Voltage.append(voltage)\n",
    "            Current.append(current)\n",
    "            \n",
    "            yyyymmdd = list(timestamp.split('__')[0])\n",
    "            month = yyyymmdd[4]+yyyymmdd[5]\n",
    "            day = yyyymmdd[6]+yyyymmdd[7]\n",
    "            hour = f.split('UTC_')[1].split('.txt')[0].split('__')[1].split('_')[0]\n",
    "            minute = f.split('UTC_')[1].split('.txt')[0].split('__')[1].split('_')[1]   \n",
    "            \n",
    "            time.append(datetime(2024, int(month), int(day), int(hour), int(minute), tzinfo=timezone.utc))\n",
    "            \n",
    "            breakdown = 0\n",
    "            \n",
    "            plt.title(f'{test} {f}')\n",
    "            plt.xlabel('Voltage (V)')\n",
    "            plt.ylabel('Current (A)')\n",
    "            \n",
    "            plt.plot(voltage,current,label='Raw Data')\n",
    "\n",
    "            index = 0\n",
    "            for vol in enumerate(voltage):\n",
    "                if (51 if type.split('_')[0] == 'S13' else 37) - vol[1] > 0:\n",
    "                    index += 1\n",
    "\n",
    "            cutoff = index-10\n",
    "            fit, cov = curve_fit(quad, voltage[cutoff:], current[cutoff:], sigma=current[cutoff:])\n",
    "            #plt.plot(voltage,quad(np.array(voltage), *fit),label='Quadratic Fit')\n",
    "            \n",
    "            baseline = sum(current[1:index])/len(current[1:index])\n",
    "            #plt.axhline(baseline,label='Baseline',c='g')\n",
    "            \n",
    "            breakV = (-fit[1] + np.sqrt(fit[1]**2 - 4 * fit[0] * (fit[2] - baseline))) / 2 / fit[0]\n",
    "            \n",
    "            BV4.append(breakV)\n",
    "            #plt.scatter(breakV, quad(breakV, *fit), label=f'Breakdown Voltage: {breakV:.2f}')\n",
    "            breakdown += breakV\n",
    "\n",
    "            breakV = -fit[1]/2/fit[0]\n",
    "            BV5.append(breakV)\n",
    "            #plt.scatter(-fit[1]/2/fit[0], quad(-fit[1]/2/fit[0], *fit), label=f'Breakdown Voltage: {-fit[1]/2/fit[0]:.2f}')\n",
    "            breakdown += breakV\n",
    "            \n",
    "            dIdV = (current[1:]-current[:-1])/(voltage[1:]-voltage[:-1])/((current[1:]+current[:-1])/2)\n",
    "            #dIdV = (current[1:]-current[:-1])/(voltage[1]-voltage[0])/((current[1:]+current[:-1])/2)\n",
    "            #dIdV = scipy.ndimage.gaussian_filter(dIdV,1)\n",
    "            breakV = voltage[np.argmax(dIdV)]/2+voltage[np.argmax(dIdV)+1]/2\n",
    "            BV.append(breakV)\n",
    "            #plt.plot((voltage[1:]+voltage[:-1])/2,dIdV/1E8,label=r'Method $\\frac{\\frac{dI}{dV}}{I}$')\n",
    "            breakdown += breakV\n",
    "\n",
    "            dIdV = (current[1:]-current[:-1])/(voltage[1:]-voltage[:-1])/((current[1:]+current[:-1])/2)**2\n",
    "            breakV = voltage[np.argmax(dIdV)]/2+voltage[np.argmax(dIdV)+1]/2\n",
    "            BV1.append(breakV)\n",
    "            #plt.plot((voltage[1:]+voltage[:-1])/2,dIdV/1E16,label=r'Method $\\frac{\\frac{dI}{dV}}{I^2}$')\n",
    "            breakdown += breakV\n",
    "\n",
    "            dIdV = (current[1:]-current[:-1])/(voltage[1:]-voltage[:-1])/((current[1:]+current[:-1])/2)**5\n",
    "            breakV = voltage[np.argmax(dIdV)]/2+voltage[np.argmax(dIdV)+1]/2\n",
    "            BV2.append(breakV)\n",
    "            #plt.plot((voltage[1:]+voltage[:-1])/2,dIdV/1E39,label=r'Method $\\frac{\\frac{dI}{dV}}{I^5}$')\n",
    "            breakdown += breakV\n",
    "\n",
    "            current_smooth = scipy.ndimage.gaussian_filter(current,5)\n",
    "            dIdV = (current_smooth[1:]-current_smooth[:-1])/(voltage[1:]-voltage[:-1])/((current_smooth[1:]+current_smooth[:-1])/2)**5\n",
    "            breakV = voltage[np.argmax(dIdV)]/2+voltage[np.argmax(dIdV)+1]/2\n",
    "            BV3.append(breakV)\n",
    "            #plt.plot((voltage[1:]+voltage[:-1])/2,dIdV/1E39,label=r'Method Gaussian Smoothed Current + $\\frac{\\frac{dI}{dV}}{I^5}$')\n",
    "            breakdown += breakV\n",
    "            \n",
    "            current_1 = scipy.ndimage.gaussian_filter(current,1)\n",
    "            dIdV = (np.log(current_1[1:])-np.log(current_1[:-1]))/(voltage[1:]-voltage[:-1])\n",
    "            #plt.plot((voltage[1:]+voltage[:-1])/2,dIdV/1E12,label=r'Method $\\frac{d(log(I))}{dV}$')\n",
    "            breakV = voltage[np.argmax(dIdV)]/2+voltage[np.argmax(dIdV)+1]/2\n",
    "            BV6.append(breakV)\n",
    "            plt.axvline(breakV,c='black',label=f'Breakdown Voltage: {breakV:.2f} V')\n",
    "            \n",
    "            breakdown = breakdown / 6\n",
    "\n",
    "            avgBV.append(breakdown)\n",
    "            \n",
    "            plt.axvline(breakdown,c='r',label=f'Breakdown Voltage: {breakdown:.2f} V')\n",
    "            \n",
    "            plt.legend()\n",
    "            plt.yscale('log')\n",
    "\n",
    "            #if os.path.isfile(directory + os.sep + type + os.sep + test + os.sep + f + '.png'):\n",
    "                #pass\n",
    "            #else:\n",
    "                #plt.savefig(directory + os.sep + type + os.sep + test + os.sep + f + '.png')\n",
    "\n",
    "            #if(type==\"S14_6050\"):\n",
    "                #plt.show()    ### Single IV with various methods of determining breakdown voltage\n",
    "            plt.close()\n",
    "\n",
    "            OV_I = []\n",
    "            for j in range(10):\n",
    "                index = 0\n",
    "                \n",
    "                for vol in enumerate(voltage):\n",
    "                    if ((breakV if test == 'Irradiated' else breakdown) + j*0.5 - 1.5) - vol[1] > 0:\n",
    "                        index += 1\n",
    "                OV_I.append(current[index])\n",
    "            darkI.append(OV_I)\n",
    "            Breakdown.append((breakV if test == 'Irradiated' else breakdown))\n",
    "\n",
    "        plt.title(f'{type} {test}') # with method $\\frac{\\frac{dI}{dV}}{I}$\n",
    "        '''\n",
    "        plt.plot(np.linspace(0,len(BV),len(BV)),BV,marker='o',label=r'$\\frac{\\frac{dI}{dV}}{I}$')\n",
    "        plt.plot(np.linspace(0,len(BV1),len(BV)),BV1,marker='o',label=r'$\\frac{\\frac{dI}{dV}}{I^2}$')\n",
    "        plt.plot(np.linspace(0,len(BV2),len(BV)),BV2,marker='o',label=r'$\\frac{\\frac{dI}{dV}}{I^5}$')\n",
    "        plt.plot(np.linspace(0,len(BV3),len(BV)),BV3,marker='o',label=r'Gaussian Smoothed Current + $\\frac{\\frac{dI}{dV}}{I^5}$')\n",
    "        plt.plot(np.linspace(0,len(BV4),len(BV)),BV4,marker='o',label=r'Quadratic Fit + Baseline')\n",
    "        plt.plot(np.linspace(0,len(BV5),len(BV)),BV5,marker='o',label=r'Quadratic Fit Derivative = 0')\n",
    "        plt.plot(np.linspace(0,len(BV6),len(BV)),BV6,marker='o',label=r'$\\frac{d(log(I))}{dV}$')\n",
    "       '''\n",
    "        plt.plot(np.linspace(0,len(avgBV),len(BV)),avgBV,marker='o',label=r'Breakdown Voltage')\n",
    "        plt.axhspan(datasheet-datasheet_error,datasheet+datasheet_error,facecolor='grey',label=rf\"Datasheet\", alpha=0.5)\n",
    "        \n",
    "        plt.ylim(0,60)\n",
    "        plt.xlabel('SiPM number')\n",
    "        plt.ylabel('Breakdown Voltage (V)')\n",
    "        plt.legend()\n",
    "        #plt.show()    #### Breakdown voltage per sipm with other methods\n",
    "        plt.close()\n",
    "\n",
    "    ###---\n",
    "    print(\"Making plots for this type...\\n\")\n",
    "        \n",
    "    ###----\n",
    "    ### IV curve per sipm with different data-taking time -- log y scale\n",
    "    outfile_name = f'Sipm_RadTest/plots/IV_time_{type}.pdf'\n",
    "    pp1 = PdfPages(outfile_name)\n",
    "    for id in set(sipm_id):\n",
    "        plt.title(id+' Fluence = 10^'+re.split('_|[A-Z]',id)[-1]+r' $N_{{p^+}}$')\n",
    "        plt.ylabel(r'Current ($\\mu$A)')\n",
    "        plt.xlabel('Voltage (V)')\n",
    "        starttime = datetime(2024, 5, 14, 17, 0, tzinfo=timezone.utc)\n",
    "        plt.plot(np.array(Voltage)[(np.array(sipm_id)==id)][-1],\n",
    "                 (np.array(Current)[(np.array(sipm_id)==id)][-1])*1e6,c='black',label='Pre-Irradiation')\n",
    "        for i in range(len(np.array(Voltage)[(np.array(sipm_id)==id)])-1):\n",
    "            ts = np.array(time)[(np.array(sipm_id)==id)][i] - starttime\n",
    "            tdelta = ''\n",
    "            if ts.days == 0:\n",
    "                tdelta = f'{ts.seconds//3600} Hours'\n",
    "            else: \n",
    "                tdelta = f'{ts.days} Day'\n",
    "            plt.plot(np.array(Voltage)[(np.array(sipm_id)==id)][i],\n",
    "                     (np.array(Current)[(np.array(sipm_id)==id)][i])*1e6,label=tdelta)\n",
    "        plt.yscale('log')\n",
    "        plt.legend()\n",
    "        #plt.show()\n",
    "        \n",
    "        #Figure Output\n",
    "        fig = plt.gcf()\n",
    "        fig.set_size_inches(18.5/2, 10.5/2)\n",
    "        fig.savefig(pp1, format='pdf')\n",
    "        \n",
    "        plt.close()\n",
    "        \n",
    "    #Close output pdf\n",
    "    pp1.close()\n",
    "    \n",
    "    ###----\n",
    "    ### IV curve per sipm with different data-taking time -- linear y scale\n",
    "    outfile_name = f'Sipm_RadTest/plots/IV_time_linear_{type}.pdf'\n",
    "    pp1 = PdfPages(outfile_name)\n",
    "    for id in set(sipm_id):\n",
    "        plt.title(id+' Fluence = 10^'+re.split('_|[A-Z]',id)[-1]+r' $N_{{p^+}}$')\n",
    "        plt.ylabel(r'Current ($\\mu$A)')\n",
    "        plt.xlabel('Voltage (V)')\n",
    "        starttime = datetime(2024, 5, 14, 17, 0, tzinfo=timezone.utc)\n",
    "        plt.plot(np.array(Voltage)[(np.array(sipm_id)==id)][-1],\n",
    "                 (np.array(Current)[(np.array(sipm_id)==id)][-1])*1e6,c='black',label='Pre-Irradiation')\n",
    "        for i in range(len(np.array(Voltage)[(np.array(sipm_id)==id)])-1):\n",
    "            ts = np.array(time)[(np.array(sipm_id)==id)][i] - starttime\n",
    "            tdelta = ''\n",
    "            if ts.days == 0:\n",
    "                tdelta = f'{ts.seconds//3600} Hours'\n",
    "            else: \n",
    "                tdelta = f'{ts.days} Day'\n",
    "            plt.plot(np.array(Voltage)[(np.array(sipm_id)==id)][i],\n",
    "                     (np.array(Current)[(np.array(sipm_id)==id)][i])*1e6,label=tdelta)\n",
    "        #plt.yscale('log')\n",
    "        plt.legend()\n",
    "        #plt.show()\n",
    "        \n",
    "        #Figure Output\n",
    "        fig = plt.gcf()\n",
    "        fig.set_size_inches(18.5/2, 10.5/2)\n",
    "        fig.savefig(pp1, format='pdf')\n",
    "        \n",
    "        plt.close()\n",
    "        \n",
    "    #Close output pdf\n",
    "    pp1.close()\n",
    "\n",
    "    ###----\n",
    "    ### All irradiated IV curves for each type of sipm\n",
    "    outfile_name = f'Sipm_RadTest/plots/IV_irradiated_{type}.pdf'\n",
    "    pp1 = PdfPages(outfile_name)\n",
    "    starttime = datetime(2024, 5, 14, 17, 0, tzinfo=timezone.utc)\n",
    "    \n",
    "    #Get irradiated Sipms and sort based on fluence\n",
    "    sipm_rad = np.array(sipm_id)[np.char.find(status,'Irradiated')==0]\n",
    "    time_rad = np.array(time)[np.char.find(status,'Irradiated')==0]\n",
    "    Voltage_rad = np.array(Voltage)[np.char.find(status,'Irradiated')==0]\n",
    "    Current_rad = np.array(Current)[np.char.find(status,'Irradiated')==0]\n",
    "    Breakdown_rad = np.array(Breakdown)[np.char.find(status,'Irradiated')==0]\n",
    "    fluence_rad = np.array(fluence)[np.char.find(status,'Irradiated')==0]\n",
    "    \n",
    "    sipm_rad = sipm_rad[fluence_rad.argsort()]\n",
    "    time_rad = time_rad[fluence_rad.argsort()]\n",
    "    Voltage_rad = Voltage_rad[fluence_rad.argsort()]\n",
    "    Current_rad = Current_rad[fluence_rad.argsort()]\n",
    "    Breakdown_rad = Breakdown_rad[fluence_rad.argsort()]\n",
    "    \n",
    "    fluence_print = np.power(10,np.sort(fluence_rad))\n",
    "    \n",
    "    for id in enumerate(sipm_rad):\n",
    "        ts = time_rad[id[0]] - starttime\n",
    "        tdelta = ''\n",
    "        if ts.days == 0:\n",
    "            tdelta = f'{ts.seconds//3600} Hours'\n",
    "        else: \n",
    "            tdelta = f'{ts.days} Day'\n",
    "        label = f'{fluence_print[id[0]]:.2e} $N_{{p^+}}$ : {tdelta} : BV = {Breakdown_rad[id[0]]:.2f} V'\n",
    "        plt.plot(Voltage_rad[id[0]],np.array(Current_rad[id[0]])*1e6,label=label)\n",
    "    plt.title(f'{type} Irradiated IV')\n",
    "    plt.xlabel('Voltage (V)')\n",
    "    plt.ylabel(r'Current ($\\mu$A)')\n",
    "    plt.legend()\n",
    "    #plt.yscale('log')\n",
    "    #plt.show()\n",
    "    \n",
    "    #Figure Output\n",
    "    fig = plt.gcf()\n",
    "    fig.set_size_inches(18.5/2, 10.5/2)\n",
    "    fig.savefig(pp1, format='pdf')\n",
    "    \n",
    "    plt.close()\n",
    "    \n",
    "    #Close output pdf\n",
    "    pp1.close()\n",
    "        \n",
    "    ###----\n",
    "    ### Averaged dark current per fluence\n",
    "    outfile_name = f'Sipm_RadTest/plots/I_fluence_{type}.pdf'\n",
    "    pp1 = PdfPages(outfile_name)\n",
    "    for i in range(10):\n",
    "        fluences = []\n",
    "        avgI = []\n",
    "        errI = []\n",
    "        for j in sorted(set(fluence)):\n",
    "            fluences.append(j)\n",
    "            avg = np.array(darkI)[np.array(fluence)==j][:,i]\n",
    "            avgI.append(sum(avg)/len(avg))\n",
    "            errI.append(np.std(avg))\n",
    "        \n",
    "        if( (i*0.5 - 1.5) > 0 ):\n",
    "            plt.errorbar(fluences,np.array(avgI)*1e6,yerr=np.array(errI)*1e6,\n",
    "                         label=fr'$V_{{OV}}$ = {i*0.5 - 1.5} V',fmt='-o')\n",
    "        else:\n",
    "            plt.errorbar(fluences,np.array(avgI)*1e6,yerr=np.array(errI)*1e6,\n",
    "                         label=fr'$V_{{OV}}$ = {i*0.5 - 1.5} V',fmt='-s',fillstyle='none')\n",
    "            \n",
    "    plt.legend()\n",
    "    plt.xlabel(r'log(Fluence) (log($N_{p^+}$/$cm^2$))')\n",
    "    plt.ylabel(r'Dark Current ($\\mu$A)')\n",
    "    plt.title(type)\n",
    "    plt.yscale('log')\n",
    "    #plt.show()\n",
    "    \n",
    "    #Figure Output\n",
    "    fig = plt.gcf()\n",
    "    fig.set_size_inches(18.5/2, 10.5/2)\n",
    "    fig.savefig(pp1, format='pdf')\n",
    "    \n",
    "    plt.close()\n",
    "    \n",
    "    #Close output pdf\n",
    "    pp1.close()\n",
    "\n",
    "    ###----\n",
    "    ### Fluence vs. breakdown voltage \n",
    "    outfile_name = f'Sipm_RadTest/plots/BV_fluence_{type}.pdf'\n",
    "    pp1 = PdfPages(outfile_name)\n",
    "    flu_i = []\n",
    "    flu = []\n",
    "    flu_err = []\n",
    "    for i in sorted(set(fluence)):\n",
    "        flu_i.append(i)\n",
    "        condition = np.array(fluence)==i\n",
    "        flu.append(sum(np.array(Breakdown)[condition])/len(np.array(Breakdown)[condition]))\n",
    "        flu_err.append(np.std(np.array(Breakdown)[condition]))\n",
    "    \n",
    "    plt.errorbar(flu_i,flu,yerr=flu_err,fmt='-o',label=f'{type}')\n",
    "    plt.axhspan(datasheet-datasheet_error,datasheet+datasheet_error,facecolor='grey',label=rf\"Datasheet\", alpha=0.5)\n",
    "    plt.xlabel(r'log(Fluence) (log($N_{p^+}$/$cm^2$))')\n",
    "    plt.ylabel(r'Breakdown Voltage (V)')\n",
    "    plt.ylim(30,60)\n",
    "    plt.legend()\n",
    "    #plt.show()\n",
    "    \n",
    "    #Figure Output\n",
    "    fig = plt.gcf()\n",
    "    fig.set_size_inches(18.5/2, 10.5/2)\n",
    "    fig.savefig(pp1, format='pdf')\n",
    "    \n",
    "    plt.close()\n",
    "    \n",
    "    #Close output pdf\n",
    "    pp1.close()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81316e3c",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}