making_probe_map.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Spike sort\n",
    "\n",
    "Notebook within the chronic ephys processing pipeline\n",
    "- 1-preprocess_acoustics\n",
    "- 2-curate_acoustics\n",
    "- **3-sort_spikes**\n",
    "- 4-curate_spikes\n",
    "\n",
    "Use the environment **spikeproc** to run this notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import os\n",
    "import pickle\n",
    "os.environ[\"NPY_MATLAB_PATH\"] = '/mnt/cube/chronic_ephys/code/npy-matlab'\n",
    "os.environ[\"KILOSORT2_PATH\"] = '/mnt/cube/chronic_ephys/code/Kilosort2'\n",
    "os.environ[\"KILOSORT3_PATH\"] = '/mnt/cube/chronic_ephys/code/Kilosort'\n",
    "import spikeinterface.full as si\n",
    "import sys\n",
    "import traceback\n",
    "sys.path.append('/mnt/cube/lo/envs/ceciestunepipe/')\n",
    "from ceciestunepipe.file import bcistructure as et\n",
    "from ceciestunepipe.mods import probe_maps as pm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'batch_size': 60000,\n",
       " 'nblocks': 1,\n",
       " 'Th_universal': 9,\n",
       " 'Th_learned': 8,\n",
       " 'do_CAR': True,\n",
       " 'invert_sign': False,\n",
       " 'nt': 61,\n",
       " 'artifact_threshold': None,\n",
       " 'nskip': 25,\n",
       " 'whitening_range': 32,\n",
       " 'binning_depth': 5,\n",
       " 'sig_interp': 20,\n",
       " 'nt0min': None,\n",
       " 'dmin': None,\n",
       " 'dminx': None,\n",
       " 'min_template_size': 10,\n",
       " 'template_sizes': 5,\n",
       " 'nearest_chans': 10,\n",
       " 'nearest_templates': 100,\n",
       " 'templates_from_data': True,\n",
       " 'n_templates': 6,\n",
       " 'n_pcs': 6,\n",
       " 'Th_single_ch': 6,\n",
       " 'acg_threshold': 0.2,\n",
       " 'ccg_threshold': 0.25,\n",
       " 'cluster_downsampling': 20,\n",
       " 'cluster_pcs': 64,\n",
       " 'duplicate_spike_bins': 15,\n",
       " 'do_correction': True,\n",
       " 'keep_good_only': False,\n",
       " 'save_extra_kwargs': False,\n",
       " 'skip_kilosort_preprocessing': False,\n",
       " 'scaleproc': None}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "si.get_default_sorter_params('kilosort4')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set `dmin` and `dminx`\n",
    "**Setting these appropriately will greatly reduce sort time**\n",
    "- The default value for dmin is the median distance between contacts -- if contacts are irregularly spaced, like in a modular Neuropixels 2.0 setup, will need to specify a value\n",
    "- The default for dminx is 32um (designed for Neuropixels probes)\n",
    "\n",
    "Support documentation [here](https://kilosort.readthedocs.io/en/latest/parameters.html#dmin-and-dminx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# non default spike sorting parameters\n",
    "sort_params_dict_ks3 = {'minFR':0.001, 'minfr_goodchannels':0.001} # kilosort 3\n",
    "sort_params_dict_ks4_npx = {'nblocks':5, 'Th_universal':8, 'Th_learned':7, 'dmin':15, 'dminx':32} # kilosort 4, neuropixels (set dmin and dminx to true pitch)\n",
    "sort_params_dict_ks4_nnx64 = {'nblocks':0, 'nearest_templates':64,\n",
    "                              'Th_universal':8, 'Th_learned':7} # kilosort 4, neuronexus 64 chan\n",
    "\n",
    "# waveform extraction parameters\n",
    "wave_params_dict = {'ms_before':1, 'ms_after':2, 'max_spikes_per_unit':500,\n",
    "                    'sparse':True, 'num_spikes_for_sparsity':100, 'method':'radius',\n",
    "                    'radius_um':40, 'n_components':5, 'mode':'by_channel_local'}\n",
    "\n",
    "# print stuff\n",
    "verbose = True\n",
    "\n",
    "# errors break sorting\n",
    "raise_error = False\n",
    "\n",
    "# restrict sorting to a specific GPU\n",
    "restrict_to_gpu = 1 # 0 1 None\n",
    "\n",
    "# use specific GPU if specified\n",
    "if restrict_to_gpu is not None:\n",
    "    os.environ[\"CUDA_DEVICE_ORDER\"] = \"PCI_BUS_ID\"\n",
    "    os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"{}\".format(restrict_to_gpu)\n",
    "\n",
    "# parallel processing params\n",
    "job_kwargs = dict(n_jobs=28,chunk_duration=\"1s\",progress_bar=False)\n",
    "si.set_global_job_kwargs(**job_kwargs)\n",
    "\n",
    "# force processing of previous failed sorts\n",
    "skip_failed = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "bird_rec_dict = {\n",
    "    'z_p5y10_23':[\n",
    "        {'sess_par_list':['2024-05-16'], # sessions (will process all epochs within)\n",
    "         'probe':{'probe_type':'neuropixels-2.0'}, # probe specs\n",
    "         'sort':'sort_0', # label for this sort instance\n",
    "         'sorter':'kilosort4', # sort method\n",
    "         'sort_params':sort_params_dict_ks4_npx, # non-default sort params\n",
    "         'wave_params':wave_params_dict, # waveform extraction params\n",
    "         'ephys_software':'sglx' # sglx or oe\n",
    "        },\n",
    "    ],\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run sorts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "___________ z_p5y10_23 2024-05-16 1246_g0 ___________\n",
      "prep..\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'stack_shanks' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "File \u001b[0;32m<timed exec>:75\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'stack_shanks' is not defined"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "# store sort summaries\n",
    "sort_summary_all = []\n",
    "\n",
    "# loop through all birds / recordings\n",
    "for this_bird in bird_rec_dict.keys():\n",
    "    # get session configurations\n",
    "    sess_all = bird_rec_dict[this_bird]\n",
    "    \n",
    "    # loop through session configurations\n",
    "    for this_sess_config in sess_all:\n",
    "        \n",
    "        # loop through sessions\n",
    "        for this_sess in this_sess_config['sess_par_list']:\n",
    "            log_dir = os.path.join('/mnt/cube/chronic_ephys/log', this_bird, this_sess)\n",
    "            \n",
    "            # build session parameter dictionary\n",
    "            sess_par = {'bird':this_bird,\n",
    "                        'sess':this_sess,\n",
    "                        'ephys_software':this_sess_config['ephys_software'],\n",
    "                        'sorter':this_sess_config['sorter'],\n",
    "                        'sort':this_sess_config['sort']}\n",
    "            # get epochs\n",
    "            sess_epochs = et.list_ephys_epochs(sess_par)\n",
    "            \n",
    "            for this_epoch in sess_epochs:\n",
    "                \n",
    "                # set output directory\n",
    "                epoch_struct = et.sgl_struct(sess_par,this_epoch,ephys_software=sess_par['ephys_software'])\n",
    "                sess_par['epoch'] = this_epoch\n",
    "                sort_folder = epoch_struct['folders']['derived'] + '/{}/{}/'.format(sess_par['sorter'],sess_par['sort'])\n",
    "                \n",
    "                # get spike sort log\n",
    "                try:\n",
    "                    with open(os.path.join(log_dir, this_epoch+'_spikesort_'+this_sess_config['sort']+'.log'), 'r') as f:\n",
    "                        log_message=f.readline() # read the first line of the log file\n",
    "                    if log_message[:-1] == sess_par['bird']+' '+sess_par['sess']+' sort complete without error':\n",
    "                        print(sess_par['bird'],sess_par['sess'],'already exists -- skipping sort')\n",
    "                        run_proc = False\n",
    "                    elif log_message[:-1] == sess_par['bird']+' '+sess_par['sess']+' sort failed':\n",
    "                        if skip_failed:\n",
    "                            print(sess_par['bird'],sess_par['sess'],'previously failed -- skipping sort')\n",
    "                            run_proc = False\n",
    "                        else:\n",
    "                            run_proc = True\n",
    "                    else: # uninterpretable log file\n",
    "                        run_proc = True\n",
    "                except: # no existing log file\n",
    "                    run_proc = True\n",
    "                \n",
    "                # run sort\n",
    "                if run_proc:\n",
    "#                     try:\n",
    "                    print('___________',this_bird,this_sess,this_epoch,'___________')\n",
    "                    # prepare recording for sorting\n",
    "                    print('prep..')\n",
    "                    if sess_par['ephys_software'] == 'sglx':\n",
    "                        # load recording\n",
    "                        rec_path = epoch_struct['folders']['sglx']\n",
    "                        this_rec = si.read_spikeglx(folder_path=rec_path,stream_name='imec0.ap')\n",
    "                        # save probe map prior to re-ordering for sorting\n",
    "                        probe_df = this_rec.get_probe().to_dataframe()\n",
    "#                         probe_df.to_pickle(os.path.join(epoch_struct['folders']['derived'],'probe_map_df.pickle'))\n",
    "                        # ibl destriping\n",
    "                        this_rec = si.highpass_filter(recording=this_rec)\n",
    "                        this_rec = si.phase_shift(recording=this_rec)\n",
    "                        bad_good_channel_ids = si.detect_bad_channels(recording=this_rec)\n",
    "                        if len(bad_good_channel_ids[0]) > 0:\n",
    "                            this_rec = si.interpolate_bad_channels(recording=this_rec,bad_channel_ids=bad_good_channel_ids[0])\n",
    "                        if this_sess_config['probe']['probe_type'] == 'neuropixels-2.0':\n",
    "                            # highpass by shank\n",
    "                            split_rec = this_rec.split_by(property='group',outputs='list') # split recording by shank\n",
    "                            split_rec = [si.highpass_spatial_filter(recording=r,n_channel_pad=min(r.get_num_channels(),60)) for r in split_rec]\n",
    "                            this_rec_p = si.aggregate_channels(split_rec) # recombine shanks\n",
    "#                                 # stack shanks\n",
    "                            p,_ = stack_shanks(probe_df) # make new Probe object with shanks stacked\n",
    "                            this_rec_p = this_rec.set_probe(p,group_mode='by_probe') # assign new Probe object to probe\n",
    "                        else:\n",
    "                            this_rec_p = si.highpass_spatial_filter(recording=this_rec)\n",
    "#                         elif sess_par['ephys_software'] =='oe':\n",
    "#                             # load recording\n",
    "#                             rec_path = [f.path for f in os.scandir(epoch_struct['folders']['oe']) if f.is_dir()][0]\n",
    "#                             this_rec = si.read_openephys(folder_path=rec_path)\n",
    "#                             # add probe\n",
    "#                             this_probe = pm.make_probes(this_sess_config['probe']['probe_type'],this_sess_config['probe']['probe_model']) # neuronexus, Buzsaki64\n",
    "#                             this_rec_p = this_rec.set_probe(this_probe,group_mode='by_shank')\n",
    "#                         # set sort params\n",
    "#                         this_rec_p = si.concatenate_recordings([this_rec_p])\n",
    "#                         sort_params = si.get_default_sorter_params(this_sess_config['sorter'])\n",
    "#                         for this_param in this_sess_config['sort_params'].keys():\n",
    "#                             sort_params[this_param] = this_sess_config['sort_params'][this_param]\n",
    "#                         # run sort\n",
    "#                         print('sort..')\n",
    "#                         this_sort = si.run_sorter(sorter_name=this_sess_config['sorter'],recording=this_rec_p,output_folder=sort_folder,\n",
    "#                                              remove_existing_folder=True,delete_output_folder=False,delete_container_files=False,\n",
    "#                                              verbose=verbose,raise_error=raise_error,**sort_params)\n",
    "#                         # bandpass recording before waveform extraction\n",
    "#                         print('bandpass..')\n",
    "#                         this_rec_pf = si.bandpass_filter(recording=this_rec_p)\n",
    "#                         # extract waveforms\n",
    "#                         print('waveform..')\n",
    "#                         wave_params = this_sess_config['wave_params']\n",
    "#                         wave = si.extract_waveforms(this_rec_pf,this_sort,folder=os.path.join(sort_folder,'waveforms'),\n",
    "#                                                     ms_before=wave_params['ms_before'],ms_after=wave_params['ms_after'],\n",
    "#                                                     max_spikes_per_unit=wave_params['max_spikes_per_unit'],\n",
    "#                                                     sparse=wave_params['sparse'],num_spikes_for_sparsity=wave_params['num_spikes_for_sparsity'],\n",
    "#                                                     method=wave_params['method'],radius_um=wave_params['radius_um'],overwrite=True,**job_kwargs)\n",
    "#                         # compute metrics\n",
    "#                         print('metrics..')\n",
    "#                         loc = si.compute_unit_locations(waveform_extractor=wave)\n",
    "#                         cor = si.compute_correlograms(waveform_or_sorting_extractor=wave)\n",
    "#                         sim = si.compute_template_similarity(waveform_extractor=wave)\n",
    "#                         amp = si.compute_spike_amplitudes(waveform_extractor=wave,**job_kwargs)\n",
    "#                         pca = si.compute_principal_components(waveform_extractor=wave,n_components=wave_params['n_components'],\n",
    "#                                                               mode=wave_params['mode'],**job_kwargs)\n",
    "#                         qms = si.get_quality_metric_list()\n",
    "#                         metric_names = []\n",
    "#                         bad_metrics = []\n",
    "#                         for qm in qms:\n",
    "#                             try:\n",
    "#                                 si.compute_quality_metrics(waveform_extractor=wave,verbose=False,metric_names=[qm],**job_kwargs)\n",
    "#                                 metric_names.append(qm)\n",
    "#                             except:\n",
    "#                                 bad_metrics.append(qm)\n",
    "#                         met = si.compute_quality_metrics(waveform_extractor=wave,verbose=verbose,metric_names=metric_names,**job_kwargs)\n",
    "\n",
    "#                         # mark complete\n",
    "#                         print('COMPLETE!!')\n",
    "\n",
    "#                         # log complete sort\n",
    "#                         if not os.path.exists(log_dir): os.makedirs(log_dir)\n",
    "#                         with open(os.path.join(log_dir, this_epoch+'_spikesort_'+this_sess_config['sort']+'.log'), 'w') as f:\n",
    "#                             f.write(sess_par['bird']+' '+sess_par['sess']+' sort complete without error\\n\\n')\n",
    "#                             f.write('Sort method: '+this_sess_config['sorter']+'\\n\\n')\n",
    "#                             f.write('Sort params: '+str(sort_params)+'\\n\\n')\n",
    "#                             f.write('Computed quality metrics: '+str(metric_names)+'\\n\\n')\n",
    "#                             f.write('Failed quality metrics: '+str(bad_metrics)+'\\n')\n",
    "#                         sort_summary = [this_bird,this_sess,sess_par['ephys_software'],this_epoch,'COMPLETE']\n",
    "                    \n",
    "#                     except Exception as e:\n",
    "#                         # mark exception\n",
    "#                         print(\"An exception occurred:\", e)\n",
    "                        \n",
    "#                         # log failed sort\n",
    "#                         if not os.path.exists(log_dir): os.makedirs(log_dir)\n",
    "#                         with open(os.path.join(log_dir, this_epoch+'_spikesort_'+this_sess_config['sort']+'.log'), 'w') as f:\n",
    "#                             f.write(sess_par['bird']+' '+sess_par['sess']+' sort failed\\n')\n",
    "#                             f.write(traceback.format_exc())\n",
    "#                         sort_summary = [this_bird,this_sess,sess_par['ephys_software'],this_epoch,'FAIL']\n",
    "                else:\n",
    "                    sort_summary = [this_bird,this_sess,sess_par['ephys_software'],this_epoch,'EXISTS']\n",
    "                \n",
    "                # report and store sort summary\n",
    "                print(sort_summary)\n",
    "                sort_summary_all.append(sort_summary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from probeinterface.utils import combine_probes\n",
    "from probeinterface import Probe, get_probe, ProbeGroup\n",
    "import warnings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [],
   "source": [
    "def stack_shanks(probe_df: pd.DataFrame, stack_pitch=100., shank_pitch=250.):\n",
    "    \n",
    "    # get channels\n",
    "    channels = probe_df.index.to_list()\n",
    "\n",
    "    # get contact shape\n",
    "    if len(probe_df['contact_shapes'].unique()) > 1:\n",
    "        warnings.warn('Multiple contact shapes detected. Setting all to {}.'.format(probe_df['contact_shapes'].unique()[0]))\n",
    "    contact_shape = probe_df['contact_shapes'].unique()[0]\n",
    "\n",
    "    # get contact shape params\n",
    "    if contact_shape == 'circle':\n",
    "        if len(probe_df['radius'].unique()) > 1:\n",
    "            warnings.warn('Multiple radii detected. Setting all to {}.'.format(probe_df['radius'].unique()[0]))\n",
    "        contact_shape_params = {'radius': probe_df['radius'].unique()[0]}\n",
    "    elif contact_shape == 'square':\n",
    "        if len(probe_df['width'].unique()) > 1:\n",
    "            warnings.warn('Multiple widths detected. Setting all to {}.'.format(probe_df['width'].unique()[0]))\n",
    "        contact_shape_params = {'width': probe_df['width'].unique()[0]}\n",
    "    elif contact_shape == 'rect':\n",
    "        if len(probe_df['width/height'].unique()) > 1:\n",
    "            warnings.warn('Multiple width/heights detected. Setting all to {}.'.format(probe_df['width/height'].unique()[0]))\n",
    "        contact_shape_params = {'width/height': probe_df['width/height'].unique()[0]}\n",
    "    else:\n",
    "        raise Exception('Contact shape not recognized: {}'.format(contact_shape))\n",
    "    \n",
    "    # get contact pitches\n",
    "    y_pitch = probe_df['y'].sort_values().diff().dropna().loc[lambda n: n > 0].min()\n",
    "    x_pitch = probe_df['x'].sort_values().diff().dropna().loc[lambda n: n > 0].min()\n",
    "    \n",
    "    # first pass to grab individual blocks\n",
    "    sorted_df = probe_df.sort_values(by=['x', 'y'])\n",
    "    current_block = 0\n",
    "    blocks = [current_block]\n",
    "    for i in range(1, len(sorted_df)):\n",
    "        x_diff = sorted_df.iloc[i]['x'] - sorted_df.iloc[i-1]['x']\n",
    "        y_diff = sorted_df.iloc[i]['y'] - sorted_df.iloc[i-1]['y']\n",
    "        if x_diff > x_pitch or (y_diff > y_pitch or y_diff < 0):\n",
    "            current_block += 1\n",
    "        blocks.append(current_block)\n",
    "\n",
    "    sorted_df['block'] = blocks\n",
    "\n",
    "    # stick the blocks together...\n",
    "    grouped_df = sorted_df.copy()\n",
    "    group_mapping = {}\n",
    "    for i in range(len(grouped_df)):\n",
    "        current_block = grouped_df.iloc[i]['block']\n",
    "        y_value = grouped_df.iloc[i]['y']\n",
    "        x_value = grouped_df.iloc[i]['x']\n",
    "\n",
    "        # check for other blocks with matching y-values and x_pitch-separated x-values\n",
    "        for j in range(i+1, len(grouped_df)):\n",
    "            other_block = grouped_df.iloc[j]['block']\n",
    "            other_y_value = grouped_df.iloc[j]['y']\n",
    "            other_x_value = grouped_df.iloc[j]['x']\n",
    "            if other_y_value == y_value and abs(other_x_value - x_value) == x_pitch:\n",
    "                group_mapping[other_block] = current_block\n",
    "\n",
    "    # merge blocks\n",
    "    for old_block, new_block in group_mapping.items():\n",
    "        grouped_df.loc[grouped_df['block'] == old_block, 'block'] = new_block\n",
    "\n",
    "    # make block numbers sequential (just because I want to)\n",
    "    unique_blocks = grouped_df['block'].unique()\n",
    "    block_mapping = {old: new for new, old in enumerate(sorted(unique_blocks))}\n",
    "    grouped_df['block'] = grouped_df['block'].map(block_mapping)\n",
    "    grouped_df = grouped_df.sort_values(by=['block', 'x', 'y'])\n",
    "\n",
    "    # stack blocks vertically\n",
    "    stacked_df = grouped_df.copy()\n",
    "    for i in range(1, max(stacked_df.block.values)+1):\n",
    "        new_y_min = max(stacked_df[stacked_df['block']==i-1].y.values)+stack_pitch\n",
    "        curr_y_min = min(stacked_df[stacked_df['block']==i].y.values)\n",
    "        stacked_df.loc[stacked_df['block'] == i, 'y'] += (new_y_min-curr_y_min)\n",
    "    stacked_df['x'] = stacked_df['x'] % shank_pitch\n",
    "    \n",
    "    # sort by channel\n",
    "    stacked_df.sort_index(inplace=True)\n",
    "\n",
    "    # retrieve positions\n",
    "    shifted_contact_positions = stacked_df[['x','y']].to_numpy()\n",
    "\n",
    "    # create probe\n",
    "    probe = Probe(ndim=2, si_units=\"um\")\n",
    "\n",
    "    probe.set_contacts(\n",
    "        positions=shifted_contact_positions, # [[x,y], [x,y], ...]\n",
    "        shapes=contact_shape,\n",
    "        shape_params=contact_shape_params,\n",
    "        contact_ids=probe_df.contact_ids.to_numpy(dtype=str),\n",
    "    )\n",
    "    \n",
    "    probe.set_device_channel_indices(channels)\n",
    "\n",
    "    return probe, probe_df\n",
    "\n",
    "p,_ = stack_shanks(probe_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Probe - 384ch - 1shanks"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "      <th>contact_shapes</th>\n",
       "      <th>width</th>\n",
       "      <th>shank_ids</th>\n",
       "      <th>contact_ids</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>500.0</td>\n",
       "      <td>720.0</td>\n",
       "      <td>square</td>\n",
       "      <td>12.0</td>\n",
       "      <td>2</td>\n",
       "      <td>s2e96</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>532.0</td>\n",
       "      <td>720.0</td>\n",
       "      <td>square</td>\n",
       "      <td>12.0</td>\n",
       "      <td>2</td>\n",
       "      <td>s2e97</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>500.0</td>\n",
       "      <td>735.0</td>\n",
       "      <td>square</td>\n",
       "      <td>12.0</td>\n",
       "      <td>2</td>\n",
       "      <td>s2e98</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>532.0</td>\n",
       "      <td>735.0</td>\n",
       "      <td>square</td>\n",
       "      <td>12.0</td>\n",
       "      <td>2</td>\n",
       "      <td>s2e99</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>500.0</td>\n",
       "      <td>750.0</td>\n",
       "      <td>square</td>\n",
       "      <td>12.0</td>\n",
       "      <td>2</td>\n",
       "      <td>s2e100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>95</th>\n",
       "      <td>782.0</td>\n",
       "      <td>3945.0</td>\n",
       "      <td>square</td>\n",
       "      <td>12.0</td>\n",
       "      <td>3</td>\n",
       "      <td>s3e527</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>96</th>\n",
       "      <td>250.0</td>\n",
       "      <td>2520.0</td>\n",
       "      <td>square</td>\n",
       "      <td>12.0</td>\n",
       "      <td>1</td>\n",
       "      <td>s1e336</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>97</th>\n",
       "      <td>282.0</td>\n",
       "      <td>2520.0</td>\n",
       "      <td>square</td>\n",
       "      <td>12.0</td>\n",
       "      <td>1</td>\n",
       "      <td>s1e337</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>98</th>\n",
       "      <td>250.0</td>\n",
       "      <td>2535.0</td>\n",
       "      <td>square</td>\n",
       "      <td>12.0</td>\n",
       "      <td>1</td>\n",
       "      <td>s1e338</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>99</th>\n",
       "      <td>282.0</td>\n",
       "      <td>2535.0</td>\n",
       "      <td>square</td>\n",
       "      <td>12.0</td>\n",
       "      <td>1</td>\n",
       "      <td>s1e339</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>100 rows × 6 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "        x       y contact_shapes  width shank_ids contact_ids\n",
       "0   500.0   720.0         square   12.0         2       s2e96\n",
       "1   532.0   720.0         square   12.0         2       s2e97\n",
       "2   500.0   735.0         square   12.0         2       s2e98\n",
       "3   532.0   735.0         square   12.0         2       s2e99\n",
       "4   500.0   750.0         square   12.0         2      s2e100\n",
       "..    ...     ...            ...    ...       ...         ...\n",
       "95  782.0  3945.0         square   12.0         3      s3e527\n",
       "96  250.0  2520.0         square   12.0         1      s1e336\n",
       "97  282.0  2520.0         square   12.0         1      s1e337\n",
       "98  250.0  2535.0         square   12.0         1      s1e338\n",
       "99  282.0  2535.0         square   12.0         1      s1e339\n",
       "\n",
       "[100 rows x 6 columns]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "probe_df.head(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [],
   "source": [
    "from probeinterface.plotting import plot_probe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_probe(this_rec.get_probe());\n",
    "plot_probe(p);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 100x5000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as patches\n",
    "\n",
    "# Plotting x-y pairs with shaded rectangles\n",
    "fig, ax = plt.subplots(figsize=(1, 50))\n",
    "\n",
    "# Define the size of the rectangles\n",
    "rect_width = 0.5\n",
    "rect_height = 10\n",
    "\n",
    "# Plot each x-y pair as a rectangle\n",
    "for _, row in stacked_df.iterrows():\n",
    "    rect = patches.Rectangle((row['x'] - rect_width / 2, row['y'] - rect_height / 2),\n",
    "                             rect_width, rect_height, linewidth=0, edgecolor='r', facecolor='r', alpha=0.25)\n",
    "    ax.add_patch(rect)\n",
    "\n",
    "# Set the limits of the plot\n",
    "ax.set_xlim(stacked_df['x'].min() - rect_width, stacked_df['x'].max() + rect_width)\n",
    "ax.set_ylim(stacked_df['y'].min() - rect_height, stacked_df['y'].max() + rect_height)\n",
    "\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.title('x-y Pairs with Shaded Rectangles')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Block 0:\n",
      "x                  250.0\n",
      "y                  360.0\n",
      "contact_shapes    square\n",
      "width               12.0\n",
      "shank_ids              1\n",
      "contact_ids        s1e48\n",
      "block                  0\n",
      "Name: 144, dtype: object\n",
      "---\n",
      "x                  250.0\n",
      "y                 1065.0\n",
      "contact_shapes    square\n",
      "width               12.0\n",
      "shank_ids              1\n",
      "contact_ids       s1e142\n",
      "block                  0\n",
      "Name: 286, dtype: object\n",
      "\n",
      "\n",
      "Block 1:\n",
      "x                  250.0\n",
      "y                 2520.0\n",
      "contact_shapes    square\n",
      "width               12.0\n",
      "shank_ids              1\n",
      "contact_ids       s1e336\n",
      "block                  1\n",
      "Name: 96, dtype: object\n",
      "---\n",
      "x                  250.0\n",
      "y                 2865.0\n",
      "contact_shapes    square\n",
      "width               12.0\n",
      "shank_ids              1\n",
      "contact_ids       s1e382\n",
      "block                  1\n",
      "Name: 142, dtype: object\n",
      "\n",
      "\n",
      "Block 2:\n",
      "x                  282.0\n",
      "y                  360.0\n",
      "contact_shapes    square\n",
      "width               12.0\n",
      "shank_ids              1\n",
      "contact_ids        s1e49\n",
      "block                  2\n",
      "Name: 145, dtype: object\n",
      "---\n",
      "x                  282.0\n",
      "y                 1065.0\n",
      "contact_shapes    square\n",
      "width               12.0\n",
      "shank_ids              1\n",
      "contact_ids       s1e143\n",
      "block                  2\n",
      "Name: 287, dtype: object\n",
      "\n",
      "\n",
      "Block 3:\n",
      "x                  282.0\n",
      "y                 2520.0\n",
      "contact_shapes    square\n",
      "width               12.0\n",
      "shank_ids              1\n",
      "contact_ids       s1e337\n",
      "block                  3\n",
      "Name: 97, dtype: object\n",
      "---\n",
      "x                  282.0\n",
      "y                 2865.0\n",
      "contact_shapes    square\n",
      "width               12.0\n",
      "shank_ids              1\n",
      "contact_ids       s1e383\n",
      "block                  3\n",
      "Name: 143, dtype: object\n",
      "\n",
      "\n",
      "Block 4:\n",
      "x                  500.0\n",
      "y                  720.0\n",
      "contact_shapes    square\n",
      "width               12.0\n",
      "shank_ids              2\n",
      "contact_ids        s2e96\n",
      "block                  4\n",
      "Name: 0, dtype: object\n",
      "---\n",
      "x                  500.0\n",
      "y                 1065.0\n",
      "contact_shapes    square\n",
      "width               12.0\n",
      "shank_ids              2\n",
      "contact_ids       s2e142\n",
      "block                  4\n",
      "Name: 46, dtype: object\n",
      "\n",
      "\n",
      "Block 5:\n",
      "x                  500.0\n",
      "y                 2520.0\n",
      "contact_shapes    square\n",
      "width               12.0\n",
      "shank_ids              2\n",
      "contact_ids       s2e336\n",
      "block                  5\n",
      "Name: 336, dtype: object\n",
      "---\n",
      "x                  500.0\n",
      "y                 3585.0\n",
      "contact_shapes    square\n",
      "width               12.0\n",
      "shank_ids              2\n",
      "contact_ids       s2e478\n",
      "block                  5\n",
      "Name: 334, dtype: object\n",
      "\n",
      "\n",
      "Block 6:\n",
      "x                  532.0\n",
      "y                  720.0\n",
      "contact_shapes    square\n",
      "width               12.0\n",
      "shank_ids              2\n",
      "contact_ids        s2e97\n",
      "block                  6\n",
      "Name: 1, dtype: object\n",
      "---\n",
      "x                  532.0\n",
      "y                 1065.0\n",
      "contact_shapes    square\n",
      "width               12.0\n",
      "shank_ids              2\n",
      "contact_ids       s2e143\n",
      "block                  6\n",
      "Name: 47, dtype: object\n",
      "\n",
      "\n",
      "Block 7:\n",
      "x                  532.0\n",
      "y                 2520.0\n",
      "contact_shapes    square\n",
      "width               12.0\n",
      "shank_ids              2\n",
      "contact_ids       s2e337\n",
      "block                  7\n",
      "Name: 337, dtype: object\n",
      "---\n",
      "x                  532.0\n",
      "y                 3585.0\n",
      "contact_shapes    square\n",
      "width               12.0\n",
      "shank_ids              2\n",
      "contact_ids       s2e479\n",
      "block                  7\n",
      "Name: 335, dtype: object\n",
      "\n",
      "\n",
      "Block 8:\n",
      "x                  750.0\n",
      "y                 3600.0\n",
      "contact_shapes    square\n",
      "width               12.0\n",
      "shank_ids              3\n",
      "contact_ids       s3e480\n",
      "block                  8\n",
      "Name: 48, dtype: object\n",
      "---\n",
      "x                  750.0\n",
      "y                 3945.0\n",
      "contact_shapes    square\n",
      "width               12.0\n",
      "shank_ids              3\n",
      "contact_ids       s3e526\n",
      "block                  8\n",
      "Name: 94, dtype: object\n",
      "\n",
      "\n",
      "Block 9:\n",
      "x                  782.0\n",
      "y                 3600.0\n",
      "contact_shapes    square\n",
      "width               12.0\n",
      "shank_ids              3\n",
      "contact_ids       s3e481\n",
      "block                  9\n",
      "Name: 49, dtype: object\n",
      "---\n",
      "Last block:\n",
      "x                  782.0\n",
      "y                 3945.0\n",
      "contact_shapes    square\n",
      "width               12.0\n",
      "shank_ids              3\n",
      "contact_ids       s3e527\n",
      "block                  9\n",
      "Name: 95, dtype: object\n"
     ]
    }
   ],
   "source": [
    "print(\"Block 0:\")\n",
    "print(sorted_df.iloc[0])\n",
    "print(\"---\")\n",
    "counter=0\n",
    "for i in range(1, len(sorted_df)):\n",
    "    if sorted_df.iloc[i]['block'] != sorted_df.iloc[i-1]['block']:\n",
    "        counter += 1\n",
    "        print(sorted_df.iloc[i-1])\n",
    "        print(\"\\n\")\n",
    "        \n",
    "        print(f\"Block {counter}:\")\n",
    "        print(sorted_df.iloc[i])\n",
    "        print(\"---\")\n",
    "print(\"Last block:\")\n",
    "print(sorted_df.iloc[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "spikeproc",
   "language": "python",
   "name": "spikeproc"
  },
  "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.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}