Example #1
0
def plot_cv_for_return_levels_current_and_future_and_change():
    low_periods = [2, 5]
    high_periods = [10, 30]


    extreme_types = ['high', 'low']
    extreme_type_to_periods = dict(list(zip(extreme_types, [high_periods, low_periods])))


    i_indices, j_indices = data_select.get_indices_from_file()
    current_cvs = {}
    future_cvs = {}
    for extreme_type in extreme_types:
        current_cvs[extreme_type] = {} #to save return level fields for a given extreme type
        future_cvs[extreme_type] = {}

        for return_period in extreme_type_to_periods[extreme_type]:
            c_rl_fields = np.zeros((len(members.current_ids), len(i_indices)))
            f_rl_fields = np.zeros((len(members.current_ids), len(i_indices)))
            for member_num, the_member in enumerate(members.current_ids):
                pars_current = csfb.get_pars_for_member_and_type(the_member, level_type = extreme_type)
                pars_future = csfb.get_pars_for_member_and_type(members.current2future[the_member], level_type = extreme_type)

                #calculate changes for each pair of members and each position
                npos = len(pars_current)
                for pos, pc, pf in zip(range(npos), pars_current, pars_future):
                    if extreme_type == 'high':
                        c = gevfit.get_high_ret_level_stationary(pc, return_period)
                        f = gevfit.get_high_ret_level_stationary(pf, return_period)
                    else:
                        c = gevfit.get_low_ret_level_stationary(pc, return_period)
                        f = gevfit.get_low_ret_level_stationary(pf, return_period)

                    c_rl_fields[member_num, pos] = c
                    f_rl_fields[member_num, pos] = f

                    pass


            current_cvs[extreme_type][return_period] = np.std( c_rl_fields, axis = 0 ) / np.mean( c_rl_fields, axis = 0 )
            future_cvs[extreme_type][return_period] = np.std( f_rl_fields, axis = 0 ) / np.mean( f_rl_fields, axis = 0 )


    #do plotting
    _plot_map_as_subplots(i_indices, j_indices, current_cvs, title = " Current Climate, CV ")
    plt.savefig('cv_for_return_levels_current.png')
    _plot_map_as_subplots(i_indices, j_indices, future_cvs, title = "Future Climate, CV")
    plt.savefig('cv_for_return_levels_future.png')
    pass
def calculate_forcing_differences(return_period = 10,
                                  prefix = 'gev_params_stationary',
                                  postfix = ''
                                  ):

    level_fields = []


    file = prefix + '_' + members.control_id + postfix
    pars_set = pickle.load(open(file))

    control_field = np.zeros((len(pars_set)))
    for pos, pars in enumerate(pars_set):
        if 'high' in postfix:
            control_field[pos] = gevfit.get_high_ret_level_stationary(pars, return_period)
        else:
            control_field[pos] = gevfit.get_low_ret_level_stationary(pars, return_period)


    for id in members.current_ids:
        file = prefix + '_' + id + postfix
        pars_set = pickle.load(open(file))

        level_field = np.zeros((len(pars_set)))
        for pos, pars in enumerate(pars_set):
            if 'high' in postfix:
                level_field[pos] = gevfit.get_high_ret_level_stationary(pars, return_period)
            else:
                level_field[pos] = gevfit.get_low_ret_level_stationary(pars, return_period)

        level_fields.append(level_field)


    diff = np.zeros((len(pars_set)))
    for level_field in level_fields:
        diff += (level_field - control_field) # / control_field * 100

    print(np.min(diff), np.max(diff))

    print('min(control_field): ', np.min(control_field))
    return diff / float( len(level_fields) )
Example #3
0
def function_for_each_process(args):
    sample_index, sampled_indices, extremes, \
    return_periods, high_flow, positions = args

    print('I work on sample %d' % sample_index)
    
    result = {}
    for the_period in return_periods:
        result[the_period] = []



    for pos in positions:
        pars = gevfit.optimize_stationary_for_period(extremes[sampled_indices, pos],
                                                    high_flow = high_flow)

        #calculate return levels for the current position and sample
        for the_period in return_periods:
            if high_flow:
                ret_level = gevfit.get_high_ret_level_stationary(pars, the_period)
            else:
                ret_level = gevfit.get_low_ret_level_stationary(pars, the_period)
            result[the_period].append(ret_level)
    return result
Example #4
0
def plot_signal_to_noise_ratio():
    low_periods = [2, 5]
    high_periods = [10, 30]
    plot_utils.apply_plot_params(width_pt=None, font_size=9, aspect_ratio=2.5)

    extreme_types = ['high', 'low']
    extreme_type_to_periods = dict(list(zip(extreme_types, [high_periods, low_periods])))

    i_indices, j_indices = data_select.get_indices_from_file()
    i_subplot = 0

    #plt.subplots_adjust(wspace = 0.1)
    cMap = mpl.cm.get_cmap('jet', 3)
    cMap.set_over(color = '#FF8C00')

    gs = gridspec.GridSpec(3,2)

    for extreme_type in extreme_types:
        for return_period in extreme_type_to_periods[extreme_type]:

            changes = np.zeros((len(members.current_ids), len(i_indices)))
            for member_num, the_member in enumerate(members.current_ids):

                pars_current = csfb.get_pars_for_member_and_type(the_member, level_type = extreme_type)
                pars_future = csfb.get_pars_for_member_and_type(members.current2future[the_member], level_type = extreme_type)

                
                #calculate changes for each pair of members and each position
                npos = len(pars_current)
                for pos, pc, pf in zip(range(npos), pars_current, pars_future):
                    if extreme_type == 'high':
                        c = gevfit.get_high_ret_level_stationary(pc, return_period)
                        f = gevfit.get_high_ret_level_stationary(pf, return_period)
                    else:
                        c = gevfit.get_low_ret_level_stationary(pc, return_period)
                        f = gevfit.get_low_ret_level_stationary(pf, return_period)

                    changes[member_num, pos] = f - c
                    pass

            #calculate mean and stdev of the obtained changes
            the_mean = np.mean(changes, axis = 0)
            the_std = np.std(changes, axis = 0)

            #change if you want signal to noise ratio, currently it is cv (coefficient of variation 1/(signal-to-noise-ratio))
            the_values = the_std / np.abs(the_mean)
            print(the_values.min(), the_values.max())
            #the_values = the_mean
            to_plot = np.ma.masked_all(csfb.xs.shape)

            max_value = 1.5
            for i, j, value, dev in zip(i_indices, j_indices, the_values, the_std):
                to_plot[i, j] = value


            #shaded = np.ma.masked_where(to_plot != 0, shaded)
            #to_plot = np.ma.masked_where(to_plot == 0, to_plot)


            plot_axes = plt.subplot(gs[i_subplot // 2, i_subplot % 2])
            i_subplot += 1
            print('just before plotting')

            
            basin_boundaries.plot_basin_boundaries_from_shape(csfb.basemap, plotter = plt, linewidth = 1.)
            image = csfb.basemap.pcolormesh(csfb.xs, csfb.ys, to_plot, vmin = 0, vmax = max_value, cmap = cMap,
                                            ax = plot_axes)
            csfb.basemap.drawcoastlines(linewidth = 0.2)

            plot_axes.set_title('T = {0}-year'.format(return_period))
            x_min, x_max, y_min, y_max = plot_utils.get_ranges(csfb.xs[i_indices, j_indices], csfb.ys[i_indices, j_indices])
            plot_axes.set_xlim(x_min, x_max)
            plot_axes.set_ylim(y_min, y_max)




            divider = make_axes_locatable(plot_axes)
            cax = divider.append_axes("right", "8%", pad="3%")


            # extend choices are "both", "min", "max" and "neither"
            cb = plt.colorbar(image, extend = 'max',
                              format = "%.1f", drawedges = True, cax = cax)

            cb.set_ticks(LinearLocator(numticks = 4))
            cb.outline.set_visible(False)



    #plt.show()
    plt.tight_layout()
    plt.savefig('cv_for_changes.png')
def plot_results():

    cc = "current"
    fc = "future"
    climate_types = [cc, fc]


    folder_path = 'data/streamflows/hydrosheds_euler9/'
    file_path = os.path.join(folder_path, "aex_discharge_1970_01_01_00_00.nc")
    i_indices, j_indices = data_select.get_indices_from_file(file_path)
    xs = polar_stereographic.xs
    ys = polar_stereographic.ys
    basemap = polar_stereographic.basemap
    
    hi = "high"
    lo = "low"
    extreme_types = [hi, lo]

    base_std_name = "{0}_std_dev_{1}"
    base_par_name = {
        cc : "_".join(["{0}"] + members.current_ids),
        fc : "_".join(["{0}"] + members.future_ids)
    }

    extreme_to_return_periods = {
        hi : get_high_return_periods(),
        lo : get_low_return_periods()
    }


    sig_coefs = [1.96
    #    , 1.645
    ]
    sig_levels = ["95 %"
    #    , "90 %"
    ]
    gs = gridspec.GridSpec(3,2)

    for extreme in extreme_types:
        pars_path_current = base_par_name[cc].format(extreme)
        std_path_current = base_std_name.format(extreme, cc)

        pars_path_future = base_par_name[fc].format(extreme)
        std_path_future = base_std_name.format(extreme, fc)

        pars_current = pickle.load(open(pars_path_current))
        stds_current = pickle.load(open(std_path_current))

        pars_future = pickle.load(open(pars_path_future))
        stds_future = pickle.load(open(std_path_future))

        return_periods = extreme_to_return_periods[extreme]
        #plot_utils.apply_plot_params(font_size=15, width_pt=900, aspect_ratio=2.5)
        #plt.figure()


        delta = 50 if extreme == hi else 100
        for row, ret_period in enumerate( return_periods ):
            #calculate changes in return levels
            func = lambda x: gevfit.get_high_ret_level_stationary(x, ret_period)
            rl_c = list(map(func, pars_current))
            rl_f = list(map(func, pars_future))
            
            rl_c = np.array(rl_c)
            rl_f = np.array(rl_f)

            std_c = stds_current[ret_period]
            std_f = stds_future[ret_period]

            in_odf = (std_c > 0) & (std_f > 0) & (rl_c > 0) & (rl_f >= 0)
            change = np.ma.masked_all(rl_c.shape)
            change[in_odf] = (rl_f[in_odf] - rl_c[in_odf]) / rl_c[in_odf] * 100.0


            min_change = np.min((rl_f - rl_c) / rl_c * 100.0)
            if min_change >= 0:
               low_limit = 0
            elif min_change > -10:
               low_limit = -10
            else:
                low_limit = np.floor(min_change / 10.0) * 10

            print("min change = {0}, low limit = {1}".format(min_change, low_limit))


            for sig_coef, sig_name in zip(sig_coefs, sig_levels):
                significance = np.ma.masked_all(rl_c.shape)
                sig_cond = (sig_coef * (std_c + std_f) < np.abs(rl_f - rl_c)) & in_odf
                significance[~sig_cond] = 0#fill with gray non signifcant areas
                change1 = np.ma.masked_where(~sig_cond, change)
                if extreme == hi:
                    plt.subplot(gs[row, 0])
                else:
                    plt.subplot(gs[row, 1])

                csfb.plot(change1 , i_indices, j_indices, xs, ys,
                        title = 'T = {0}-year'.format( ret_period ),
                        color_map = mycolors.get_red_blue_colormap(ncolors = 10),
                        units = '%',
                        basemap = basemap, minmax = (-delta, delta),
                        colorbar_label_format = '%d',
                        upper_limited = True,
                        colorbar_tick_locator = LinearLocator(numticks = 11),
                        not_significant_mask = significance,
                        show_colorbar = True, impose_lower_limit=low_limit
                        )
                #subplot_count += 1
    plt.tight_layout()
    plt.savefig("rl_of_merged_change.png")

    pass