Example #1
0
def draw_ground_truth_skcsd_3D(ax1, gtruth, skcsd, data,
                                gvmin, gvmax, t_plot):
    ax1[2].set_title('Ground truth at t = %1.1f ms' %t_plot)
    ax1[3].set_title('CSD at t = %1.1f ms' %t_plot)
    for i in [2, 3]:
        ax1[i].set_ylabel('x (um)')
        ax1[i].set_xlabel('y (um)')
        draw_morpho(ax1[i], morphology, extent, data.ele_pos)
   
    pl.make_map_plot(ax1[2],
                     gtruth.sum(axis=(2, 3)), 
                     extent=extent,
                     cmap='seismic_r',
                     vmax=gvmax,
                     vmin=gvmin,
                     alpha=0.5,
                     circles=True)
    pl.make_map_plot(ax1[3],
                     skcsd.sum(axis=(2, 3)),
                     extent=extent,
                     cmap='seismic_r',
                     vmax=gvmax,
                     vmin=gvmin, alpha=0.5)
Example #2
0
                         ele_pos,
                         n_src,
                         tolerance=tolerance,
                         xmin=-1000e-6,
                         xmax=1000e-6,
                         ymin=-1000e-6,
                         ymax=1000e-6)
 cell_itself.distribute_srcs_3D_morph()
 ground_truth_3D = cell_itself.transform_to_3D(ground_truth,
                                               what="morpho")
 ground_truth_t0 = ground_truth_3D[:, :, :, t0].sum(axis=2)
 vmax, vmin = pl.get_min_max(ground_truth_t0)
 morpho, extent = cell_itself.draw_cell2D(axis=2)
 lambd = l/(2*(2*np.pi)**3*R**2*n_src)
 fig, ax = plt.subplots(3, 3, figsize=(8, 20))
 pl.make_map_plot(ax[0, 0], morpho, extent=extent)
 pl.make_map_plot(ax[0, 0], ground_truth_t0, extent=extent, title="Ground truth", vmin=vmin, vmax=vmax, alpha=.75)
 vmax, vmin = pl.get_min_max(ground_truth_t0)
 
 for i, di in enumerate(data_dir):
     data = utils.LoadData(di)
     ele_pos = data.ele_pos/scale_factor
     data.LFP = data.LFP/scale_factor_LFP
     morphology = data.morphology
     morphology[:, 2:6] = morphology[:, 2:6]/scale_factor
     ker = sKCSD(ele_pos,
                 data.LFP,
                 morphology,
                 n_src_init=n_src,
                 src_type='gauss',
                 lambd=lambd,
Example #3
0
    skcsd_seg = cell_itself.transform_to_segments(skcsd)
    skcsd_snapshot = est_skcsd[:, :, :, t0 - tt:t0 + tt].sum(axis=(2, 3))
    gt_snapshot = ground_truth_3D[:, :, :, t0 - tt:t0 + tt].sum(axis=(2, 3))

    axfig22.imshow(skcsd_seg,
                   origin="lower",
                   interpolation="none",
                   vmin=gvmin,
                   vmax=gvmax,
                   cmap=plt.cm.bwr_r)

    cax = pl.make_map_plot(ax4,
                           gt_snapshot,
                           vmin=vmin,
                           vmax=vmax,
                           extent=extent,
                           cmap=cmap,
                           alpha=.95,
                           ele_pos=ele_pos,
                           morphology=morpho)

    ax2.set_yticklabels([])
    ax3.set_yticklabels([])
    ax2.set_xticklabels([])
    ax3.set_xticklabels([])

    cax2 = pl.make_map_plot(ax5,
                            skcsd_snapshot,
                            vmin=vmin,
                            vmax=vmax,
                            extent=extent,
Example #4
0
               zmax=zmax,
               gdx=gdx,
               gdy=gdy,
               gdz=gdz)
 if not len(ground_truth_grid):
     ground_truth_grid = k.cell.transform_to_3D(ground_truth,
                                                what="morpho")
     ground_truth_t1 = ground_truth_grid[:, :, :, t1].sum(axis=1).T
     ground_truth_t2 = ground_truth_grid[:, :, :, t2].sum(axis=1).T
     est_skcsd = k.values(estimate='CSD')
     est_skcsd_t1 = est_skcsd[:, :, :, t1].sum(axis=1).T
     est_skcsd_t2 = est_skcsd[:, :, :, t2].sum(axis=1).T
     est_kcsd = kcsd.values(estimate='CSD')
     est_kcsd_pot = kcsd.values(estimate='POT')
 if i == 0:
     cax = pl.make_map_plot(ax[1, 2], ground_truth_t1)
     cax = pl.make_map_plot(ax[2, 2], ground_truth_t2)
     cax = pl.make_map_plot(ax[1, 3], est_skcsd_t1)
     cax = pl.make_map_plot(ax[2, 3], est_skcsd_t2)
 else:
     cax = pl.make_map_plot(ax[0, 0], est_kcsd_pot[:, :, :,
                                                   t1].sum(axis=1))
     cax = pl.make_map_plot(ax[0, 1], est_kcsd[:, :, :, t1].sum(axis=1))
     cax = pl.make_map_plot(ax[0, 2], ground_truth_t1)
     cax = pl.make_map_plot(ax[0, 3], est_skcsd_t1)
     cax = pl.make_map_plot(ax[1, 0], est_kcsd_pot[:, :, :,
                                                   t1].sum(axis=1))
     cax = pl.make_map_plot(ax[1, 1], est_kcsd[:, :, :, t1].sum(axis=1))
     cax = pl.make_map_plot(ax[2, 0],
                            est_kcsd_pot[:, :, :, t2].sum(axis=1),
                            extent=[-200, 200, -200, 600])
Example #5
0
 t1 = int(42/dt)
 t2 = int(5/dt)
 atstart = t2
 atstop = int(t2 + 10/dt)
 simulation_paths = []
 data_paths = []
 skcsd_grid = []
 skcsd_random = []
 fig, ax = plt.subplots(1, 3)
 fname = fname_base + '.png'
 fig_name = sKCSD_utils.make_fig_names(fname)
 vmax, vmin = pl.get_min_max(ground_truth[:, atstart:atstop])
 pl.make_map_plot(ax[0],
         ground_truth[:, atstart:atstop],
         yticklabels=[x for x in range(0, 86, 15)],
         fig=fig,
         title="Ground truth",
         ylabel='#segment',
         sinksource=True)
 for i, datd in enumerate(data_dir):
     data = utils.LoadData(datd)
     ele_pos = data.ele_pos/scaling_factor
     data.LFP = data.LFP/scaling_factor_LFP
     morphology = data.morphology
     morphology[:, 2:6] = morphology[:, 2:6]/scaling_factor
     k = sKCSD(ele_pos,
              data.LFP,
              morphology,
              n_src_init=n_src,
              src_type='gauss',
              lambd=lambd,
Example #6
0
            data_dir.append(c.return_paths_skCSD_python())
        else:
            new_dir = os.path.join('simulation', fname)
            data_dir.append(new_dir)

    seglen = np.loadtxt(os.path.join(data_dir[0], 'seglength'))
    ground_truth = np.loadtxt(os.path.join(data_dir[0], 'membcurr'))
    ground_truth = ground_truth / seglen[:, None] * 1e-3
    gvmax, gvmin = pl.get_min_max(ground_truth)
    fname = fname_base + '.png'
    fig_name = sKCSD_utils.make_fig_names(fname)
    data_paths = []
    fig, ax = plt.subplots(4, 1)
    xticklabels = list(np.linspace(0, 800, 5))
    yticklabels = list(np.linspace(0, 52, 5))
    pl.make_map_plot(ax[0], ground_truth, alpha=1., vmin=gvmin, vmax=gvmax)
    for i, datd in enumerate(data_dir):
        l = 0
        data = utils.LoadData(datd)
        ele_pos = data.ele_pos / scaling_factor
        data.LFP = data.LFP / scaling_factor_LFP
        morphology = data.morphology
        morphology[:, 2:6] = morphology[:, 2:6] / scaling_factor
        k = sKCSD(ele_pos,
                  data.LFP,
                  morphology,
                  n_src_init=n_src,
                  src_type='gauss',
                  lambd=lambd,
                  R_init=R,
                  exact=True,
Example #7
0
         data_dir.append(c.return_paths_skCSD_python())
     else:
         new_dir = os.path.join('simulation', fname)
         data_dir.append(new_dir)
         
 seglen = np.loadtxt(os.path.join(data_dir[0], 'seglength'))
 ground_truth = np.loadtxt(os.path.join(data_dir[0], 'membcurr'))
 ground_truth = ground_truth/seglen[:, None]*1e-3
 gvmax, gvmin = pl.get_min_max(ground_truth)
 fname = fname_base + '.png'
 fig_name = sKCSD_utils.make_fig_names(fname)
 data_paths = []
 fig, ax = plt.subplots(4, 1)
 xticklabels = list(np.linspace(0, 800, 5))
 yticklabels = list(np.linspace(0, 52, 5))
 pl.make_map_plot(ax[0], ground_truth, alpha=1., vmin=gvmin, vmax=gvmax)
 for i, datd in enumerate(data_dir):
     l = 0
     data = utils.LoadData(datd)
     ele_pos = data.ele_pos/scaling_factor
     data.LFP = data.LFP/scaling_factor_LFP
     morphology = data.morphology
     morphology[:, 2:6] = morphology[:, 2:6]/scaling_factor
     k = sKCSD(ele_pos,
               data.LFP,
               morphology,
               n_src_init=n_src,
               src_type='gauss',
               lambd=lambd,
               R_init=R,
               exact=True)
Example #8
0
    cell_itself = sKCSDcell(morphology,
                            ele_pos,
                            n_src,
                            tolerance=tolerance,
                            xmin=-1000e-6,
                            xmax=1000e-6,
                            ymin=-1000e-6,
                            ymax=1000e-6)
    ground_truth_3D = cell_itself.transform_to_3D(ground_truth, what="morpho")
    ground_truth_t0 = ground_truth_3D[:, :, :, t0].sum(axis=2)
    vmax, vmin = pl.get_min_max(ground_truth_t0)
    morpho, extent = cell_itself.draw_cell2D(axis=2)
    extent = [extent[-2], extent[-1], extent[0], extent[1]]
    lambd = l / (2 * (2 * np.pi)**3 * R**2 * n_src)
    fig, ax = plt.subplots(3, 3, figsize=(8, 20))
    pl.make_map_plot(ax[0, 0], morpho, extent=extent, circles=False)
    pl.make_map_plot(ax[0, 0],
                     ground_truth_t0,
                     extent=extent,
                     title="Ground truth",
                     vmin=vmin,
                     vmax=vmax,
                     alpha=.75)
    vmax, vmin = pl.get_min_max(ground_truth_t0)

    for i, di in enumerate(data_dir):
        data = utils.LoadData(di)
        ele_pos = data.ele_pos / scale_factor
        data.LFP = data.LFP / scale_factor_LFP
        morphology = data.morphology
        morphology[:, 2:6] = morphology[:, 2:6] / scale_factor
Example #9
0
                         R_init=R,
                         skmonaco_available=False)
             est_skcsd = ker.values(estimate='CSD',
                                    transformation='segments')
             outs[i, j, k] = sKCSD_utils.L1_error(ground_truth, est_skcsd)
             print(outs[i, j, k])
 fig, ax = plt.subplots(1, 4, sharey=True)
 vmax = outs.max()
 vmin = outs.min()
 for i, ax_i in enumerate(ax):
     title = "M = %d" % n_srcs[i]
     if not i:
         pl.make_map_plot(ax_i,
                          outs[i],
                          yticklabels=y_ticklabels,
                          xticklabels=x_ticklabels,
                          vmin=vmin,
                          vmax=vmax,
                          title=title,
                          cmap='gray')
     elif i < 3:
         pl.make_map_plot(ax_i,
                          outs[i],
                          xticklabels=x_ticklabels,
                          vmin=vmin,
                          vmax=vmax,
                          title=title,
                          cmap='gray')
     else:
         pl.make_map_plot(ax_i,
                          outs[i],
                          xticklabels=x_ticklabels,
Example #10
0
            cell_object = sKCSDcell(morphology, ele_pos, n_src)
            est_skcsd = cell_itself[i].transform_to_3D(skcsd)


        est_skcsd_t1 = est_skcsd[:, :, :, t1].sum(axis=1)
        est_skcsd_t2 = est_skcsd[:, :, :, t2].sum(axis=1)
        
        if i == 0:  # wrong plane
            for j in [1, 2]:
                for k in [2, 3]:
                    ax[j, k].imshow(morpho, extent=extent, origin='lower', aspect="auto", alpha=1.)
                    for z in ele_pos:
                        pos_x, pos_y = z[2], z[0]
                        ax[j, k].text(pos_x, pos_y, '*',
                                      ha="center", va="center", color="k", fontsize=3)
            cax = pl.make_map_plot(ax[1, 2], ground_truth_t1, extent=extent, alpha=.95, vmin=vmin, vmax=vmax)
            cax = pl.make_map_plot(ax[2, 2], ground_truth_t2, extent=extent, alpha=.95, vmin=vmin, vmax=vmax)
            cax = pl.make_map_plot(ax[1, 3], est_skcsd_t1, extent=extent, vmin=vmin, vmax=vmax)
            cax = pl.make_map_plot(ax[2, 3], est_skcsd_t2, extent=extent, vmin=vmin, vmax=vmax)  # ok
            for j in [1, 2]:
                for k in [0, 1]:
                    ax[j, k].imshow(morpho_kcsd, extent=extent_kcsd, origin='lower', aspect="auto", alpha=1)
                    for z in ele_pos:
                        pos_x, pos_y = z[2], z[1]
                        ax[j, k].text(pos_x, pos_y, '*',
                                      ha="center", va="center", color="k", fontsize=3)
           
            ax[1, 0].imshow(est_kcsd_pot[:, :, :, t1].sum(axis=0),
                            cmap=plt.cm.viridis,
                            extent=extent_kcsd,
                            origin='lower',
Example #11
0
            skcsd, pot, cell_obj = utils.load_sim(path)
            est_skcsd = cell_itself[i].transform_to_3D(skcsd)


        est_skcsd_t1 = est_skcsd[:, :, :, t1].sum(axis=1)
        est_skcsd_t2 = est_skcsd[:, :, :, t2].sum(axis=1)
        
        if i == 0:  # wrong plane
            for j in [1, 2]:
                for k in [2, 3]:
                    ax[j, k].imshow(morpho, extent=extent, origin='lower', aspect="auto", alpha=0.95)
                    for z in ele_pos:
                        pos_x, pos_y = 1e6*z[2], 1e6*z[0]
                        ax[j, k].text(pos_x, pos_y, '*',
                                      ha="center", va="center", color="k", fontsize=3)
            cax = pl.make_map_plot(ax[1, 2], ground_truth_t1, extent=extent, alpha=.95, vmin=vmin, vmax=vmax)
            cax = pl.make_map_plot(ax[2, 2], ground_truth_t2, extent=extent, alpha=.95, vmin=vmin, vmax=vmax)
            cax = pl.make_map_plot(ax[1, 3], est_skcsd_t1, extent=extent, vmin=vmin, vmax=vmax)
            cax = pl.make_map_plot(ax[2, 3], est_skcsd_t2, extent=extent, vmin=vmin, vmax=vmax)  # ok
            
            for j in [1, 2]:
                for k in [0, 1]:
                    ax[j, k].imshow(morpho_kcsd, extent=extent_kcsd, origin='lower', aspect="auto", alpha=0.95)
                    for z in ele_pos:
                        pos_x, pos_y = 1e6*z[2], 1e6*z[1]
                        ax[j, k].text(pos_x, pos_y, '*',
                                      ha="center", va="center", color="k", fontsize=3)
            ax[1, 0].imshow(est_kcsd_pot[:, :, :, t1].sum(axis=0),
                            cmap=plt.cm.viridis,
                            extent=extent_kcsd,
                            origin='lower',
Example #12
0
    skcsd_seg = cell_itself.transform_to_segments(skcsd)
    skcsd_snapshot = est_skcsd[:, :, :, t0-tt:t0+tt].sum(axis=(2, 3))
    gt_snapshot = ground_truth_3D[:, :, :, t0-tt:t0+tt].sum(axis=(2, 3))
                      
    axfig22.imshow(skcsd_seg,
                   origin="lower",
                   interpolation="none",
                   vmin=gvmin,
                   vmax=gvmax,
                   cmap=plt.cm.bwr_r )
    
    cax = pl.make_map_plot(ax4,
                           gt_snapshot,
                           vmin=vmin,
                           vmax=vmax,
                           extent=extent,
                           cmap=cmap,
                           alpha=.95,
                           ele_pos=ele_pos,
                           morphology=morpho)
            
    ax2.set_yticklabels([])
    ax3.set_yticklabels([])
    ax2.set_xticklabels([])
    ax3.set_xticklabels([])

    
    
  
    cax2 = pl.make_map_plot(ax5,
                            skcsd_snapshot,
Example #13
0
 t1 = int(42/dt)
 t2 = int(5/dt)
 atstart = t2
 atstop = int(t2 + 10/dt)
 simulation_paths = []
 data_paths = []
 skcsd_grid = []
 skcsd_random = []
 fig, ax = plt.subplots(1, 3)
 fname = fname_base + '.png'
 fig_name = sKCSD_utils.make_fig_names(fname)
 vmax, vmin = pl.get_min_max(ground_truth[:, atstart:atstop])
 pl.make_map_plot(ax[0],
         ground_truth[:, atstart:atstop],
         yticklabels=[x for x in range(0, 86, 15)],
         fig=fig,
         title="Ground truth",
         ylabel='#segment',
         sinksource=True)
 for i, datd in enumerate(data_dir):
     data = utils.LoadData(datd)
     ele_pos = data.ele_pos/scaling_factor
     data.LFP = data.LFP/scaling_factor_LFP
     morphology = data.morphology
     morphology[:, 2:6] = morphology[:, 2:6]/scaling_factor
     k = sKCSD(ele_pos,
               data.LFP,
               morphology,
               n_src_init=n_src,
               src_type='gauss',
               lambd=lambd,
Example #14
0
             est_skcsd = ker.values(estimate='CSD',
                                    transformation='segments')
       
             outs[i, j, k] = sKCSD_utils.L1_error(ground_truth,
                                                  est_skcsd)
             print(outs[i, j, k], est_skcsd.min(), est_skcsd.max(), ground_truth.min(), ground_truth.max(), n_src, l, R)
 fig, ax = plt.subplots(1, 4, sharey=True)
 vmax = outs.max()
 vmin = outs.min()
 for i, ax_i in enumerate(ax):
     title = "M = %d" % n_srcs[i]
     if not i:
         pl.make_map_plot(ax_i,
                 outs[i],
                 yticklabels=y_ticklabels,
                 xticklabels=x_ticklabels,
                 vmin=vmin,
                 vmax=vmax,
                 title=title,
                 cmap='gray')
     elif i < 3:
         pl.make_map_plot(ax_i,
                 outs[i],
                 xticklabels=x_ticklabels,
                 vmin=vmin,
                 vmax=vmax,
                 title=title,
                 cmap='gray')
     else:
         pl.make_map_plot(ax_i,
                 outs[i],
                 xticklabels=x_ticklabels,
Example #15
0
                     n_src,
                     tolerance=2e-6,
                     xmin=-120e-6,
                     xmax=120e-6,
                     zmin=-50e-6,
                     zmax=550e-6)
    ground_truth_grid = cell.transform_to_3D(ground_truth, what="morpho")
    vmax, vmin = pl.get_min_max(ground_truth_grid[:, :, :, t1].sum(axis=1))
    gdt1 = ground_truth_grid[:, :, :, t1].sum(axis=1)
    morpho, extent = cell.draw_cell2D(axis=1)
    extent = [extent[-2], extent[-1], extent[0], extent[1]]
    new_ele_pos = np.array([ele_pos[:, 2], ele_pos[:, 0]]).T
    pl.make_map_plot(ax[0, 0],
                     gdt1,
                     vmin=vmin,
                     vmax=vmax,
                     extent=extent,
                     alpha=.9,
                     morphology=morpho,
                     ele_pos=new_ele_pos)
    snrs = []
    L1 = []

    for i, nl in enumerate(noise_levels):
        if nl:
            noise = numpy.random.normal(scale=std / nl, size=shape)
            snr = np.round((new_LFP.var()**.5 / noise.var()**.5))

        else:
            noise = 0
            snr = 0
Example #16
0
    shape = data.LFP.shape
    cell =  sKCSDcell(morphology, ele_pos, n_src,
                      tolerance=2e-6,
                      xmin=-120e-6, xmax=120e-6,
                      zmin=-50e-6, zmax=550e-6)
    cell.distribute_srcs_3D_morph()
    ground_truth_grid = cell.transform_to_3D(ground_truth, what="morpho")
    vmax, vmin = pl.get_min_max(ground_truth_grid[:, :, :, t1].sum(axis=1))
    gdt1 = ground_truth_grid[:,:,:,t1].sum(axis=1)
    morpho, extent = cell.draw_cell2D(axis=1)

   
    pl.make_map_plot(ax[0, 0],
                     gdt1,
                     vmin=vmin,
                     vmax=vmax,
                     extent=extent,
                     alpha=.9,
                     morphology=morpho,
                     ele_pos=ele_pos)
    snrs = []
    L1 = []  
    for i, nl in enumerate(noise_levels):
        if nl:
            noise = numpy.random.normal(scale=std/nl, size=shape)
            snr = np.round((new_LFP.var()**.5/noise.var()**.5))
            
        else:
            noise = 0
            snr = 0
            
        snrs.append(snr)
Example #17
0
            data_dir.append(c.return_paths_skCSD_python())
        else:
            new_dir = os.path.join('simulation', fname)
            data_dir.append(new_dir)

    seglen = np.loadtxt(os.path.join(data_dir[0], 'seglength'))
    ground_truth = np.loadtxt(os.path.join(data_dir[0], 'membcurr'))
    ground_truth = ground_truth / seglen[:, None] * 1e-3
    gvmin, gvmax = pl.get_min_max(ground_truth)
    fname = fname_base + '.png'
    fig_name = sKCSD_utils.make_fig_names(fname)
    data_paths = []
    fig, ax = plt.subplots(4, 1)
    xticklabels = list(np.linspace(0, 800, 5))
    yticklabels = list(np.linspace(0, 52, 5))
    pl.make_map_plot(ax[0], ground_truth)
    for i, datd in enumerate(data_dir):
        l = 0
        data = utils.LoadData(datd)
        ele_pos = data.ele_pos / scaling_factor
        data.LFP = data.LFP / scaling_factor_LFP
        morphology = data.morphology
        morphology[:, 2:6] = morphology[:, 2:6] / scaling_factor
        sKCSD.skmonaco_available = False
        k = sKCSD(ele_pos,
                  data.LFP,
                  morphology,
                  n_src_init=n_src,
                  src_type='gauss',
                  lambd=lambd,
                  R_init=R,
Example #18
0
                        R_init=R,
                        dist_table_density=50,
                        skmonaco_available=False)
            if not i and not j:
                ground_truth_3D = ker.cell.transform_to_3D(ground_truth,
                                                           what="morpho")
                vmax, vmin = pl.get_min_max(ground_truth_3D)
            ker_dir = data_dir + '_R_%f_lambda_%f' % (R, lambd)
            morpho, extent = ker.cell.draw_cell2D(axis=2)
            est_skcsd = ker.values()
            fig, ax = plt.subplots(1, 2)
            if sys.version_info < (3, 0):
                path = os.path.join(ker_dir, "preprocessed_data/Python_2")
            else:
                path = os.path.join(ker_dir, "preprocessed_data/Python_3")
            if not os.path.exists(path):
                print("Creating", path)
                os.makedirs(path)
            utils.save_sim(path, ker)
            pl.make_map_plot(ax[1], morpho, extent=extent)
            pl.make_map_plot(ax[1],
                             est_skcsd[:, :, :, t0].sum(axis=(2)),
                             extent=extent,
                             vmin=vmin,
                             vmax=vmax)
            pl.make_map_plot(ax[0], morpho, extent=extent)
            pl.make_map_plot(ax[0],
                             ground_truth_3D[:, :, :, t0].sum(axis=(2)),
                             extent=extent)
    plt.show()
Example #19
0
                         extent=extent,
                         origin='lower',
                         aspect="auto",
                         alpha=0.95)
         for z in ele_pos:
             pos_x, pos_y = 1e6 * z[2], 1e6 * z[0]
             ax[j, k].text(pos_x,
                           pos_y,
                           '*',
                           ha="center",
                           va="center",
                           color="k",
                           fontsize=3)
 cax = pl.make_map_plot(ax[1, 2],
                        ground_truth_t1,
                        extent=extent,
                        alpha=.95,
                        vmin=vmin,
                        vmax=vmax)
 cax = pl.make_map_plot(ax[2, 2],
                        ground_truth_t2,
                        extent=extent,
                        alpha=.95,
                        vmin=vmin,
                        vmax=vmax)
 cax = pl.make_map_plot(ax[1, 3],
                        est_skcsd_t1,
                        extent=extent,
                        vmin=vmin,
                        vmax=vmax)
 cax = pl.make_map_plot(ax[2, 3],
                        est_skcsd_t2,