pedestal_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Raw data analysis\n",
    "Plots summary of channel ADC values and trigger rates\n",
    "\n",
    "## Paths\n",
    "Set ``geometrypath`` to point to the larpix-geometry yaml file you'd like to use to plot x,y positions of pixels\n",
    "Set ``datapath`` to point to the directory containing datafiles you'd like to look at"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ipywidgets as widgets\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as ticker\n",
    "import matplotlib.colors as colors\n",
    "import os\n",
    "import glob\n",
    "import h5py\n",
    "from collections import defaultdict\n",
    "import time\n",
    "import yaml\n",
    "from matplotlib import cm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "geometrypath = '/global/project/projectdirs/dune/users/pmadigan/larpix/larpix-software/larpix-geometry/larpixgeometry/layouts/layout-2.4.0.yaml'\n",
    "\n",
    "# datapath = '/global/project/projectdirs/dune/data/larpix/raw_data/raw_20_10_12/500_V_cm'\n",
    "# datapath = '/global/project/projectdirs/dune/data/module_0/tile_10x10/'\n",
    "\n",
    "datapath = '/global/project/projectdirs/dune/www/data/Module0-HV/LArPix/dataRuns/rawData/'\n",
    "# datapath = '/global/project/projectdirs/dune/www/data/Module0-HV/LArPix/pedestalRuns/'\n",
    "# datapath = '/global/project/projectdirs/dune/www/data/Module0-HV/LArPix/leakageCurrent/'\n",
    "\n",
    "# datapath = '/global/project/projectdirs/dune/www/data/Bern-singlecube/LArPix/dataRuns/rawData' # data runs\n",
    "# datapath = '/global/project/projectdirs/dune/www/data/Bern-singlecube/LArPix/pedestalRuns' # pedestal runs\n",
    "# datapath = '/global/project/projectdirs/dune/www/data/Bern-singlecube/LArPix/leakageCurrent' # pedestal runs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(geometrypath) as fi:\n",
    "    geo = yaml.full_load(fi)\n",
    "chip_pix = dict([(chip_id, pix) for chip_id,pix in geo['chips']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## XY hit map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_cache = dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e113ffeb90f44ed1a03f01ba875db55f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='File', options=('datalog_2020_12_01_08_39_46_CET_.h5', 'data…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib widget\n",
    "files = sorted([os.path.basename(path) for path in glob.glob(datapath+'/*_.h5')])\n",
    "\n",
    "def unique_channel_id(d):\n",
    "    return ((d['io_group'].astype(int)*256 + d['io_channel'].astype(int))*256 \\\n",
    "            + d['chip_id'].astype(int))*64 + d['channel_id'].astype(int)\n",
    "def unique_channel_id_2_str(unique_id,*args,**kwargs):\n",
    "    return (unique_id//(256*256*64)).astype(int).astype(str) \\\n",
    "        + '-' + ((unique_id//(256*64))%256).astype(int).astype(str) \\\n",
    "        + '-' + ((unique_id//64)%256).astype(int).astype(str) \\\n",
    "        + '-' + (unique_id%64).astype(int).astype(str)\n",
    "def unique_chip_id(d):\n",
    "    return (d['io_group'].astype(int)*256 + d['io_channel'].astype(int))*256 \\\n",
    "            + d['chip_id'].astype(int)\n",
    "\n",
    "@widgets.interact\n",
    "def display(filenames=widgets.SelectMultiple(options=list(reversed(sorted(files))), rows=10, \n",
    "                                             description=\"File\")\n",
    "           ):   \n",
    "    plt.close('all')\n",
    "    fig1 = None\n",
    "    for filename in filenames:\n",
    "        if not filename in data_cache:\n",
    "            print('opening',filename,'...')\n",
    "            f = h5py.File(os.path.join(datapath,filename),'r')\n",
    "            unixtime = f['packets']['timestamp'][f['packets']['packet_type'] == 4]\n",
    "            livetime = np.max(unixtime) - np.min(unixtime)\n",
    "\n",
    "            data_mask = f['packets']['packet_type'] == 0\n",
    "            data_mask = np.logical_and(f['packets']['valid_parity'], data_mask)\n",
    "            dataword = f['packets']['dataword'][data_mask]\n",
    "            \n",
    "            if 'configs' in f.keys():\n",
    "                configs_unique_chip_id = unique_chip_id(f['configs'])\n",
    "            else:\n",
    "                configs_unique_chip_id = np.zeros((1,))-1\n",
    "            \n",
    "            unique_id = unique_channel_id(f['packets'][data_mask])\n",
    "            unique_id_set = np.unique(unique_id)\n",
    "            d = defaultdict(dict)\n",
    "            last = time.time()\n",
    "            for i,id in enumerate(unique_id_set):\n",
    "                if time.time() > last + 1:\n",
    "                    print('{}/{} {}'.format(i+1,len(unique_id_set),unique_channel_id_2_str(id)),end='\\r')\n",
    "                    last = time.time()\n",
    "                id_mask = unique_id == id\n",
    "                config_mask = configs_unique_chip_id == id//64\n",
    "                if np.sum(id_mask) < 3:\n",
    "                    continue\n",
    "                masked_dataword = dataword[id_mask]\n",
    "                if np.any(config_mask):\n",
    "                    d[id]['trim'] = f['configs']['registers'][config_mask,id%64][-1]\n",
    "                    d[id]['threshold'] = f['configs']['registers'][config_mask,64][-1]\n",
    "                    d[id]['threshold_88K_mV'] = d[id]['threshold']*1800/256 + 465 + 2.34 * d[id]['trim']\n",
    "                    d[id]['threshold_300K_mV'] = d[id]['threshold']*1800/256 + 210 + 1.45 * d[id]['trim']\n",
    "                else:\n",
    "                    d[id]['trim'] = 0\n",
    "                    d[id]['threshold'] = 0\n",
    "                    d[id]['threshold_88K_mV'] = 0\n",
    "                    d[id]['threshold_300K_mV'] = 0\n",
    "                d[id]['min'] = np.min(masked_dataword)\n",
    "                d[id]['mean'] = np.mean(masked_dataword)\n",
    "                d[id]['med'] = np.median(masked_dataword)\n",
    "                d[id]['std'] = np.std(masked_dataword)\n",
    "                d[id]['rate'] = len(masked_dataword) / (livetime + 1e-9)\n",
    "                pix = chip_pix[(id//64)%256][id%64] if (id//64)%256 in chip_pix else None\n",
    "                if pix:\n",
    "                    d[id]['x'] = geo['pixels'][pix][1]\n",
    "                    d[id]['y'] = geo['pixels'][pix][2]\n",
    "                else:\n",
    "                    d[id]['x'] = 0.\n",
    "                    d[id]['y'] = 0.\n",
    "            data_cache[filename] = d\n",
    "        else:\n",
    "            print('loading',filename,'from cache')\n",
    "            d = data_cache[filename]\n",
    "\n",
    "        if not fig1:\n",
    "            fig1,axes = plt.subplots(3,1,sharex='col',num='summary 1',figsize=(8,6))\n",
    "        else:\n",
    "            fig1 = plt.figure('summary 1')\n",
    "            axes = fig1.axes\n",
    "        axes[0].scatter([key for key in d if 'mean' in d[key]],\n",
    "                        [d[key]['mean'] for key in d if 'mean' in d[key]],\n",
    "                        marker='.',alpha=0.5)\n",
    "        axes[1].scatter([key for key in d if 'std' in d[key]],\n",
    "                        [d[key]['std'] for key in d if 'std' in d[key]],\n",
    "                        marker='.',alpha=0.5)\n",
    "        axes[2].scatter([key for key in d if 'rate' in d[key]],\n",
    "                        [d[key]['rate'] for key in d if 'rate' in d[key]],\n",
    "                        marker='.',alpha=0.5)\n",
    "        axes[2].set(xlabel='unique channel')\n",
    "        axes[0].set(ylabel='mean ADC')\n",
    "        axes[1].set(ylabel='std ADC')\n",
    "        axes[2].set(ylabel='rate [Hz]')\n",
    "        for ax in axes:\n",
    "            ax.grid(1)\n",
    "        axes[2].set_yscale('log')\n",
    "\n",
    "        ax2 = axes[0].secondary_xaxis('top', functions=(lambda x: x, lambda x: x))\n",
    "        ax2.xaxis.set_major_formatter(ticker.FuncFormatter(unique_channel_id_2_str))\n",
    "        ax2.set(xlabel='channel key')\n",
    "        plt.legend(range(len(filenames)))\n",
    "        plt.tight_layout()\n",
    "\n",
    "        fig2, axes = plt.subplots(3,1,sharex='col',sharey='col',num='summary 2 {}'.format(filename),\n",
    "                                  figsize=(6,12))\n",
    "        x = np.array([d[key]['x'] for key in d if 'x' in d[key]])\n",
    "        y = np.array([d[key]['y'] for key in d if 'y' in d[key]])\n",
    "        c0 = fig2.colorbar(axes[0].scatter(x,y,c=[d[key]['mean'] for key in d if 'mean' in d[key]], \n",
    "                                           marker='.', alpha=0.5*2), ax=axes[0])\n",
    "        c1 = fig2.colorbar(axes[1].scatter(x,y,c=[d[key]['std'] for key in d if 'std' in d[key]], \n",
    "                                           marker='.', norm=colors.LogNorm(), alpha=0.5*2), ax=axes[1])\n",
    "        c2 = fig2.colorbar(axes[2].scatter(x,y,c=[d[key]['rate'] for key in d if 'rate' in d[key]], \n",
    "                                           marker='.', norm=colors.LogNorm(), alpha=0.5*2), ax=axes[2])\n",
    "        axes[2].set(xlabel='x [mm]')\n",
    "        axes[0].set(ylabel='y [mm]',title=filename)\n",
    "        c0.set_label('mean ADC')\n",
    "        axes[1].set(ylabel='y [mm]')\n",
    "        c1.set_label('std ADC')\n",
    "        axes[2].set(ylabel='y [mm]')\n",
    "        c2.set_label('rate [Hz]')\n",
    "\n",
    "        ax2 = axes[0].secondary_xaxis('top', functions=(lambda x: x, lambda x: x))\n",
    "        ax2.set(xlabel='x [mm]')\n",
    "        plt.tight_layout()\n",
    "        \n",
    "        rates = np.array([d[key]['rate'] for key in d if 'rate' in d[key]])\n",
    "        keys = np.array([key for key in d if 'rate' in d[key]])\n",
    "        idx_sorted = np.argsort(rates)\n",
    "        for i in idx_sorted[-10:]:\n",
    "            print(unique_channel_id_2_str(keys[i]),'trigger rate',rates[i])\n",
    "        \n",
    "        if any(['threshold_88K_mV' in d[key] for key in d]):\n",
    "            fig3, axes = plt.subplots(3,1,sharex='col',sharey='col',num='summary 3 {}'.format(filename),\n",
    "                                      figsize=(6,12))\n",
    "            x = np.array([d[key]['x'] for key in d if 'x' in d[key]])\n",
    "            y = np.array([d[key]['y'] for key in d if 'y' in d[key]])\n",
    "            c0 = fig3.colorbar(axes[0].scatter(x,y,c=[d[key]['trim'] for key in d if 'trim' in d[key]], \n",
    "                                               marker='.', alpha=0.5*2), ax=axes[0])\n",
    "            c1 = fig3.colorbar(axes[1].scatter(x,y,c=[d[key]['threshold'] for key in d \n",
    "                                                      if 'threshold' in d[key]], \n",
    "                                               marker='.', #norm=colors.LogNorm(), \n",
    "                                               alpha=0.5*2), ax=axes[1])\n",
    "            c2 = fig3.colorbar(axes[2].scatter(x,y,c=[d[key]['threshold_88K_mV'] for key in d \n",
    "                                                      if 'threshold_88K_mV' in d[key]], \n",
    "                                               marker='.', #norm=colors.LogNorm(), \n",
    "                                               alpha=0.5*2), ax=axes[2])\n",
    "            axes[2].set(xlabel='x [mm]')\n",
    "            axes[0].set(ylabel='y [mm]',title=filename)\n",
    "            c0.set_label('pixel trim')\n",
    "            axes[1].set(ylabel='y [mm]')\n",
    "            c1.set_label('global threshold')\n",
    "            axes[2].set(ylabel='y [mm]')\n",
    "            c2.set_label('threshold [mV]')\n",
    "\n",
    "            ax2 = axes[0].secondary_xaxis('top', functions=(lambda x: x, lambda x: x))\n",
    "            ax2.set(xlabel='x [mm]')\n",
    "            plt.tight_layout()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot trigger rates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "rate_cache = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "09b3912cdfcc4b259a78cd4f4229e0c0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(SelectMultiple(description='File', options=('datalog_2020_12_01_08_39_46_CET_.h5', 'data…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@widgets.interact\n",
    "def display(filenames=widgets.SelectMultiple(options=list(reversed(sorted(files))), rows=10, \n",
    "                                             description=\"File\")\n",
    "           ):   \n",
    "    plt.close('all')\n",
    "    fig1 = None\n",
    "    for filename in filenames:\n",
    "        if not filename in rate_cache:\n",
    "            rate_cache[filename] = dict()\n",
    "            print('opening',filename,'...')\n",
    "            f = h5py.File(os.path.join(datapath,filename),'r')\n",
    "            if np.any(f['packets']['packet_type'] == 4):\n",
    "                timestamp_packet_mask = f['packets']['packet_type'] == 4\n",
    "                timestamp_idcs = np.argwhere(timestamp_packet_mask).flatten()\n",
    "                message_groups = np.split(f['packets']['timestamp'], timestamp_idcs)\n",
    "                unixtime = np.array([grp[0] for grp in message_groups for _ in range(0,len(grp))])\n",
    "                unixtimes = np.arange(np.min(unixtime),np.max(unixtime))\n",
    "\n",
    "                packet_type_mask = [f['packets']['packet_type'] == packet_type for packet_type in range(8)]\n",
    "                for packet_type in range(8):\n",
    "                    rate_cache[filename]['packet count {}'.format(packet_type)] = np.histogram(unixtime[packet_type_mask[packet_type]], \n",
    "                                                                                               bins=unixtimes)[0]\n",
    "                rate_cache[filename]['packet count all'] = np.histogram(unixtime, bins=unixtimes)[0]\n",
    "                \n",
    "                parity_error_mask = f['packets'][packet_type_mask[0]]['valid_parity'] == 0\n",
    "                rate_cache[filename]['parity errors'] = np.histogram(unixtime[packet_type_mask[0]][parity_error_mask], bins=unixtimes)[0]\n",
    "                \n",
    "                shared_fifo_mask = [f['packets'][packet_type_mask[0]]['shared_fifo'] == full for full in range(0,4)]\n",
    "                local_fifo_mask = [f['packets'][packet_type_mask[0]]['local_fifo'] == full for full in range(0,4)]\n",
    "                for full in range(0,4):\n",
    "                    rate_cache[filename]['shared fifo {}'.format(full)] = np.histogram(unixtime[packet_type_mask[0]][shared_fifo_mask[full]], \n",
    "                                                                                       bins=unixtimes)[0]\n",
    "                    rate_cache[filename]['local fifo {}'.format(full)] = np.histogram(unixtime[packet_type_mask[0]][local_fifo_mask[full]], \n",
    "                                                                                       bins=unixtimes)[0]\n",
    "                \n",
    "                rate_cache[filename]['time'] = unixtimes\n",
    "                \n",
    "                data_mask = rate_cache[filename]['packet count 0'] > 0\n",
    "                rate_cache[filename]['hit idx'] = [\n",
    "                    np.argwhere(unixtime == unixtimes[:-1][data_mask][i]).flatten()\n",
    "                    for i in range(np.sum(data_mask))\n",
    "                ]\n",
    "            else:\n",
    "                del rate_cache[filename]\n",
    "    \n",
    "    for filename in reversed(sorted(rate_cache)):\n",
    "        if filename in filenames:\n",
    "            plt.close('rates {}'.format(filename))\n",
    "            fig_agg2, axes = plt.subplots(4,1,sharex='col',num=filename,figsize=(6,12))\n",
    "\n",
    "            x = rate_cache[filename]['time'][:-1]\n",
    "            for packet_type in range(8):\n",
    "                y = rate_cache[filename]['packet count {}'.format(packet_type)]\n",
    "                axes[0].plot(x,y,'.-',alpha=0.5,label='packet type = {}'.format(packet_type))\n",
    "            y = rate_cache[filename]['packet count all']\n",
    "            axes[0].plot(x,y,'k-',alpha=0.5,label='all')\n",
    "#             axes[0].set_xlabel('timestamp')\n",
    "            axes[0].set_ylabel('rate [Hz]')\n",
    "            axes[0].set_yscale('log')\n",
    "            axes[0].grid(1)\n",
    "            axes[0].legend(fontsize='xx-small')\n",
    "            \n",
    "            for packet_type in range(8):\n",
    "                y = rate_cache[filename]['packet count {}'.format(packet_type)] / rate_cache[filename]['packet count all']\n",
    "                axes[1].plot(x,y,'.-',alpha=0.5,label='packet type = {}'.format(packet_type))\n",
    "#             axes[1].set_xlabel('timestamp')\n",
    "            axes[1].set_ylabel('fraction')\n",
    "            axes[1].grid(1)\n",
    "            axes[1].set_yscale('log')\n",
    "            axes[1].legend(fontsize='xx-small')\n",
    "            \n",
    "            for full in range(4):\n",
    "                y = rate_cache[filename]['shared fifo {}'.format(full)] / rate_cache[filename]['packet count 0']\n",
    "                axes[2].plot(x,y,'.-',alpha=0.5,label='shared fifo = {}'.format(full))\n",
    "                y = rate_cache[filename]['local fifo {}'.format(full)] / rate_cache[filename]['packet count 0']\n",
    "                axes[2].plot(x,y,'.-',alpha=0.5,label='local fifo = {}'.format(full))\n",
    "#             axes[2].set_xlabel('timestamp')\n",
    "            axes[2].set_ylabel('fraction')\n",
    "            axes[2].grid(1)\n",
    "            axes[2].set_yscale('log')\n",
    "            axes[2].legend(fontsize='xx-small')\n",
    "\n",
    "            y = rate_cache[filename]['parity errors'] / rate_cache[filename]['packet count 0']\n",
    "            axes[3].plot(x,y,'.-',alpha=0.5,label='parity errors')\n",
    "            axes[3].set_xlabel('timestamp')\n",
    "            axes[3].set_ylabel('fraction')\n",
    "            axes[3].grid(1)\n",
    "            axes[3].set_yscale('log')\n",
    "            axes[3].legend(fontsize='xx-small')\n",
    "            \n",
    "            plt.tight_layout()\n",
    "            \n",
    "            options = [(time,i) for i,time in enumerate(rate_cache[filename]['time'][:-1][rate_cache[filename]['packet count 0'] > 0])]\n",
    "            display = None\n",
    "            @widgets.interact\n",
    "            def display(\n",
    "                filename=filename,\n",
    "                timestamp_idxs=widgets.SelectMultiple(\n",
    "                        options=options,\n",
    "                        value=[],\n",
    "                        rows=5,\n",
    "                        description='Hit map for',\n",
    "                        disabled=False\n",
    "                    )\n",
    "                ):\n",
    "                try:\n",
    "                    if len(timestamp_idxs):\n",
    "                        f = h5py.File(os.path.join(datapath,filename),'r')\n",
    "                        idxs = np.concatenate([rate_cache[filename]['hit idx'][timestamp_idx] for timestamp_idx in timestamp_idxs])\n",
    "                        chip_ids = f['packets']['chip_id'][idxs]\n",
    "                        channel_ids = f['packets']['channel_id'][idxs]\n",
    "                        packet_types = f['packets']['packet_type'][idxs]\n",
    "                        pix = np.array([\n",
    "                            chip_pix[chip_id][channel_id] if chip_id in chip_pix else -1\n",
    "                            for chip_id, channel_id in zip(chip_ids[packet_types==0],channel_ids[packet_types==0])\n",
    "                        ])\n",
    "                        x = np.array([geo['pixels'][p][1] for p in pix if p != -1 and p is not None])\n",
    "                        y = np.array([geo['pixels'][p][2] for p in pix if p != -1 and p is not None])\n",
    "\n",
    "                        plt.close('{} xy rate map'.format(filename))\n",
    "                        fig = plt.figure('{} xy rate map'.format(filename))\n",
    "                        plt.hist2d(x, y, weights=[1./len(timestamp_idxs)]*len(y),\n",
    "                                   bins=(np.linspace(-157.407,157.407,71),np.linspace(-157.407,157.407,71)),\n",
    "                                   norm=colors.LogNorm())\n",
    "                        cb = plt.colorbar()\n",
    "                        plt.xlabel('x [mm]')\n",
    "                        plt.ylabel('y [mm]')\n",
    "                        cb.set_label('trigger rate [Hz]')\n",
    "                        plt.tight_layout()\n",
    "                except Exception as e:\n",
    "                    print(e)\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot test pulse summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7698e79586cc4222b7c6d56b0c9183c3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "dac        = [13,3,0,15,14,12]\n",
    "responding = [0.96,0.84,0.21,0.95,0.95,0.95]\n",
    "high_eff   = [0.82,0.58,0.02,0.83,0.81,0.81]\n",
    "eff        = [0.90,0.74,0.06,0.91,0.90,0.90]\n",
    "noise      = [0.03,0.03,0.03,0.03,0.03,0.03]\n",
    "data = np.array(sorted(zip(dac,responding,high_eff,eff,noise)))\n",
    "\n",
    "plt.close('test pulse data')\n",
    "plt.figure('test pulse data')\n",
    "plt.plot(data[:,0],data[:,1],'r.-',label='responding')\n",
    "plt.plot(data[:,0],data[:,2],'b.-',label='>85% efficiency')\n",
    "plt.plot(data[:,0],data[:,3],'k.-',label='overall')\n",
    "plt.plot(data[:,0],data[:,4],'g.-',label='cross talk')\n",
    "plt.legend()\n",
    "plt.xlabel('DAC [1.8ke-]')\n",
    "plt.ylabel('trigger efficiency')\n",
    "plt.ylim(0,1)\n",
    "plt.xlim(0,16)\n",
    "plt.grid()\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "MyEnv",
   "language": "python",
   "name": "myenv"
  },
  "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.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}