def get_dates_of_annual_maxima(self, position_index):
        """

        """
        return data_select.get_period_maxima_dates(self._data[:, position_index], self.times,
                start_month = 1, end_month = 12, event_duration = timedelta(days = 1)
        )
def main():
    path = 'data/streamflows/hydrosheds_euler9/aex_discharge_1970_01_01_00_00.nc'

    #path = "data/streamflows/hydrosheds_rk4_changed_partiotioning/aex_discharge_1970_01_01_00_00.nc"
    #path = 'data/streamflows/na/discharge_1990_01_01_00_00_na.nc'
    data = pe_calc.get_station_and_corresponding_model_data(path = path)
    delete_not_continuous(data)



    plot_utils.apply_plot_params(width_pt = None, height_cm=6, font_size = 9)

    high_return_periods = [10, 30]
    high_start_month = 3
    high_end_month = 7
    high_event_duration = timedelta(days = 1)


    low_return_periods = [2, 5]
    low_start_month = 1
    low_end_month = 5
    low_event_duration = timedelta(days = 15)


    #---------------------------high
    high_station_return_levels = {}
    high_model_return_levels = {}

    station_high_dates = []
    model_high_dates = []


    station_minima = []
    station_maxima = []

    model_minima = []
    model_maxima = []

    high_data = []
    labels = []

    point_ids = []

    for station, model_point in data.iteritems():
        if station.id not in selected_station_ids:
            continue


        # @type model_point ModelPoint
        if not model_point.get_timeseries_length():
            continue

        # @type station Station
        if not station.get_timeseries_length():
            continue
        
        high_values_station = data_select.get_period_maxima(station.values, station.dates,
                                      start_date = None, end_date = None,
                                      start_month = high_start_month,
                                      end_month = high_end_month,
                                      event_duration = high_event_duration)
        vals = np.array(high_values_station.values())
        high_data.append(high_values_station.values())
        labels.append("Observed")


        pars_station = gevfit.optimize_stationary_for_period(vals, high_flow = True)


        high_values_model = data_select.get_period_maxima(
                                      model_point.get_values_sorted_by_date(),
                                      model_point.get_sorted_dates(),
                                      start_date = None, end_date = None,
                                      start_month = high_start_month,
                                      end_month = high_end_month,
                                      event_duration = high_event_duration)

        high_data.append(high_values_model.values())
        labels.append("Modelled")
        vals = np.array(high_values_model.values())

        point_ids.append(station.id)
        point_ids.append(station.id)

        pars_model = gevfit.optimize_stationary_for_period(vals, high_flow = True)

        for ret_period in high_return_periods:
            if not high_station_return_levels.has_key(ret_period):
                high_station_return_levels[ret_period] = []
                high_model_return_levels[ret_period] = []
            high_station_return_levels[ret_period].append(gevfit.get_high_ret_level_stationary(pars_station, ret_period))
            high_model_return_levels[ret_period].append(gevfit.get_high_ret_level_stationary(pars_model, ret_period))
            

        #gather dates of the high flow events
        the_station_high_dates = data_select.get_period_maxima_dates(
                                    station.values, station.dates,
                                    start_date = None, end_date = None,
                                    start_month = high_start_month,
                                    end_month = high_end_month,
                                    event_duration = high_event_duration)
        station_high_dates.extend(the_station_high_dates.values())

        the_model_high_dates = data_select.get_period_maxima_dates(
                                    model_point.get_values_sorted_by_date(),
                                    # @type model_point ModelPoint
                                    model_point.get_sorted_dates(),
                                    start_date = None, end_date = None,
                                    start_month = high_start_month,
                                    end_month = high_end_month,
                                    event_duration = high_event_duration)
        model_high_dates.extend(the_model_high_dates.values())



        ##save corresponding maximums for the station and model
        current_station_maxima = []
        current_model_maxima = []
        for year, value in high_values_station.iteritems():
            if high_values_model.has_key(year):
                station_maxima.append(value)
                model_maxima.append(high_values_model[year])

                current_station_maxima.append(value)
                current_model_maxima.append(high_values_model[year])


        #plot scatter for low flow for each station separately
        plot_scatter( current_station_maxima, current_model_maxima, "observed (${\\rm m^3/s}$)",
                    "modelled (${\\rm m^3/s}$)",
                  "high flow values ({0})".format(station.id), different_shapes_and_colors = False)
        plt.savefig('high_values_scatter_{0}.png'.format( station.id ), bbox_inches = 'tight')

        print "%s: n(high_values) = %d;" % (station.id, len( current_station_maxima ))

    ##high flow values
    plot_scatter( station_maxima, model_maxima, "observed (${\\rm m^3/s}$)",
                    "modelled (${\\rm m^3/s}$)",
                    "high flow values", different_shapes_and_colors = False)

    plt.savefig('high_values_scatter.png', bbox_inches = 'tight')

    plot_boxplot([station_maxima, model_maxima],
            title="High flow amplitude",
            labels = ["Observed", "Modelled"], file_name="box_high.png")

    plot_boxplot(high_data, labels=labels, file_name="box_high_all_sep.png", point_ids=point_ids)



    #---------------------------low
    low_station_return_levels = {}
    low_model_return_levels = {}

    station_low_dates = []
    model_low_dates = []

    low_data = []
    for station, model_point in data.iteritems():
        if station.id not in selected_station_ids:
            continue

        #print "retained timeseries lenght of the station %s is %d " % (station.id, station.get_timeseries_length())

        # @type model_point ModelPoint
        if not model_point.get_timeseries_length():
            continue

        # @type station Station
        if not station.get_timeseries_length():
            continue


#        print 'station min: %f, max: %f' % (np.min(station.values), np.max(station.values))
#        print 'model min: %f, max: %f' % (
#                                            np.min(model_point.get_values_sorted_by_date()),
#                                            np.max(model_point.get_values_sorted_by_date())
#                                           )

        low_values_station = data_select.get_period_minima(station.values, station.dates,
                                      start_date = None, end_date = None,
                                      start_month = low_start_month,
                                      end_month = low_end_month,
                                      event_duration = low_event_duration)
        
        low_data.append(low_values_station.values())
        vals = np.array(low_values_station.values())
        pars_station = gevfit.optimize_stationary_for_period(vals, high_flow = False)

        low_values_model = data_select.get_period_minima(
                                      model_point.get_values_sorted_by_date(),
                                      model_point.get_sorted_dates(),
                                      start_date = None, end_date = None,
                                      start_month = low_start_month,
                                      end_month = low_end_month,
                                      event_duration = low_event_duration)
        vals = np.array(low_values_model.values())
        low_data.append(low_values_model.values())
        pars_model = gevfit.optimize_stationary_for_period(vals, high_flow = False)

        #gather dates of the low flow events
        the_station_low_dates = data_select.get_period_minima_dates(
                                    station.values, station.dates,
                                    start_date = None, end_date = None,
                                    start_month = low_start_month,
                                    end_month = low_end_month,
                                    event_duration = low_event_duration)
        station_low_dates.extend(the_station_low_dates.values())

        the_model_low_dates = data_select.get_period_minima_dates(
                                    model_point.get_values_sorted_by_date(),
                                    model_point.get_sorted_dates(),
                                    start_date = None, end_date = None,
                                    start_month = low_start_month,
                                    end_month = low_end_month,
                                    event_duration = low_event_duration)
        model_low_dates.extend(the_model_low_dates.values())



        for ret_period in low_return_periods:
            if not low_station_return_levels.has_key(ret_period):
                low_station_return_levels[ret_period] = []
                low_model_return_levels[ret_period] = []
            low_station_return_levels[ret_period].append(gevfit.get_low_ret_level_stationary(pars_station, ret_period))
            low_model_return_levels[ret_period].append(gevfit.get_low_ret_level_stationary(pars_model, ret_period))



        ##save corresponding maxima for the station and model
        current_station_minima = []
        current_model_minima = []
        for year, value in low_values_station.iteritems():
            if low_values_model.has_key(year):
                current_station_minima.append(value)
                current_model_minima.append(low_values_model[year])

                station_minima.append(value)
                model_minima.append(low_values_model[year])


        ##plot temporal dependency
        ts = sorted(low_values_station.keys())
        values_at_ts = []
        for the_t in ts:
            values_at_ts.append(low_values_station[the_t])
        plt.figure()
        plt.plot(ts, values_at_ts)
        plt.ylabel('low flow')
        plt.xlabel('time')
        plt.title(station.id)
        plt.savefig('lows_in_time_%s.png' % station.id)


        #plot scatter for low flow for each station separately
        plot_scatter( current_station_minima, current_model_minima, "observed (${\\rm m^3/s}$)",
                    "modelled (${\\rm m^3/s}$)",
                  "low flow values ({0})".format(station.id), different_shapes_and_colors = False)
        plt.savefig('low_values_scatter_{0}.png'.format( station.id ), bbox_inches = 'tight')

        print "%s: n(low_values) = %d;" % (station.id, len( current_station_minima ))



    #draw return levels
    fig = plt.figure()
    gs = gridspec.GridSpec(1,2)
    ax = fig.add_subplot(gs[0,0])
    plot_scatter(high_station_return_levels,
                 high_model_return_levels,
                 xlabel="Observed return levels",
                 ylabel="Modelled return levels", new_figure=False,
                 title="(a) High flow"

    )
    ax.xaxis.set_major_formatter(FuncFormatter(hide_even_pos_ax_labels))

    fig.add_subplot(gs[0,1])
    plot_scatter(low_station_return_levels,
                 low_model_return_levels,
                 xlabel="Observed return levels",
                 ylabel="Modelled  return levels",
        title="(b) Low flow",
        new_figure=False)


    plt.tight_layout()
    plt.savefig("rl_scatter.png")

    plot_scatter( station_minima, model_minima, "observed", "modelled",
                  "low flow values", different_shapes_and_colors = False)
    plt.savefig('low_values_scatter.png', bbox_inches = 'tight')

    plot_boxplot([station_minima, model_minima],
            title="Low flow amplitude",
            labels = ["Observed", "Modelled"], file_name="box_low.png")

    plot_boxplot(low_data, labels=labels, file_name="box_low_all_sep.png", point_ids= point_ids)

    #plot dates of the high and low flow occurences
    #before uncommenting figure out why the x and y arrays are of different sizes
#    plot_dates_scatter(model_high_dates, station_high_dates, model_low_dates, station_low_dates)
#    plt.savefig('occurences_scatter.png')

  #  plt.show()

    pass