def plot_surface_difference(surface_difference,
                            filepath,
                            title,
                            cbar_min=None,
                            cbar_max=None,
                            ice_mask=None):
    if cbar_min is None:
        cbar_min = surface_difference.min()
    if cbar_max is None:
        cbar_max = surface_difference.max()
    fig, ax = plt.subplots()
    im_b = ax.imshow(surface_difference,
                     cmap='RdBu_r',
                     norm=MidpointNormalize(midpoint=0.,
                                            vmin=cbar_min,
                                            vmax=cbar_max))
    cbar = fig.colorbar(im_b)
    cbar.set_label('$\Delta$surface  height  (m)')
    ax.set_title(title)
    if ice_mask is not None:
        plot_glacier_contours(ax,
                              ice_mask,
                              linestyles='dashed',
                              linewidths=[0.75])
    plt.savefig(filepath)
    plt.clf()
Exemplo n.º 2
0
def plot_bed_difference(bed_difference,
                        filepath,
                        title,
                        cbar_min=None,
                        cbar_max=None,
                        ice_mask=None,
                        bed_measurements=None):
    if cbar_min is None:
        cbar_min = bed_difference.min()
    if cbar_max is None:
        cbar_max = bed_difference.max()
    fig, ax = plt.subplots()
    im_b = ax.imshow(bed_difference,
                     cmap='RdBu_r',
                     norm=MidpointNormalize(midpoint=0.,
                                            vmin=cbar_min,
                                            vmax=cbar_max))

    cbar = plt.colorbar(im_b)
    cbar.set_label('$\Delta$bed  height  (m)')
    ax.set_title(title)
    if ice_mask is not None:
        plot_glacier_contours(ax,
                              ice_mask,
                              linestyles='dashed',
                              linewidths=[0.75])
    if bed_measurements is not None:
        plot_glacier_contours(ax,
                              ~bed_measurements.mask,
                              colors='k',
                              linestyles='solid',
                              linewidths=[1.])
    plt.savefig(filepath)
    plt.clf()
    cmap_bed_diff = plt.get_cmap('seismic')
    cmap_surf_diff = plt.get_cmap('PuOr_r')
    cmap_list = [
        sns.diverging_palette(240, 0, l=40, s=99, as_cmap=True),
        sns.diverging_palette(240, 60, l=40, s=99, as_cmap=True),
        sns.diverging_palette(240, 120, l=40, s=99, as_cmap=True),
        sns.diverging_palette(240, 180, l=40, s=99, as_cmap=True), None, None,
        sns.diverging_palette(240, 240, l=40, s=99, as_cmap=True)
    ]

    cbar_min = bed_diff.min()
    cbar_max = bed_diff.max()
    cbar_min_max = max(abs(cbar_min), abs(cbar_max))
    norm = MidpointNormalize(midpoint=0.,
                             vmin=-cbar_min_max,
                             vmax=cbar_min_max)
    plotpath = os.path.join(output_dir, 'bed_error',
                            base_plotpath.format('bed_error'))
    plot_bed_difference(bed_diff,
                        plotpath,
                        case,
                        ice_mask=ref_ice_mask,
                        bed_measurements=None,
                        cbar_min=cbar_min,
                        cbar_max=cbar_max,
                        show_cbar=True,
                        norm=norm,
                        cmap=cmap_bed_diff)

    cbar_min = surf_diff.min()
Exemplo n.º 4
0
        if exp_name is not None:

            if exp_name.startswith('bed measurements'):
                ice_mask = np.load(os.path.join(gdir, 'ref_ice_mask.npy'))
                bed_measurements = np.load(os.path.join(idir,
                                                       'bed_measurements.pkl'))

                measurement_noise = bed_measurements - dl.true_bed
                np.ma.set_fill_value(measurement_noise, np.nan)
                cbar_min = measurement_noise.min()
                cbar_max = measurement_noise.max()
                cbar_min = np.floor(cbar_min / 5) * 5
                cbar_max = np.ceil(cbar_max / 5) * 5
                cbar_min_max = max(abs(cbar_min), abs(cbar_max))
                norm = MidpointNormalize(midpoint=0., vmin=-cbar_min_max,
                                         vmax=cbar_min_max,
                                         mask=measurement_noise.mask)
                #my_cmap = sns.diverging_palette(240, 15, l=40, s=99, as_cmap=True)
                my_cmap = plt.get_cmap('PRGn')
                measurement_RMSE = RMSE(bed_measurements, dl.true_bed)
                text = 'measurement RMSE: {:.1f} m'.format(measurement_RMSE)
                plotpath = os.path.join(output_dir,
                                        '{:s}_{:s}_measurement_noise.{:s}'.format(
                                            case.name,
                                            exp_name,
                                            file_extension))
                plot_bed_measurement(measurement_noise, plotpath, case,
                                     ice_mask=ice_mask,
                                     cbar_min=cbar_min, cbar_max=cbar_max,
                                     show_cbar=True, norm=norm, cmap=my_cmap,
                                     text=text, n=int((2 * cbar_min_max) / 10))