Beispiel #1
0
    def __init__(self, fcst, velocity_variable,
                 speed_units='knots', ax=None, fig=None,
                  **kwdargs):
        self.variable = velocity_variable
        self.speed_units = speed_units
        # set the default colormap if needed
        kwdargs['cmap'] = kwdargs.get('cmap', velocity_cmap)

        # convert the bins to knots
        bins = xray.Variable('bins',
                             velocity_variable.speed_bins.copy(),
                             {'units': velocity_variable.units})
        _, self.bins, _ = units.convert_units(bins, speed_units)

        default_norm = plt.cm.colors.BoundaryNorm(self.bins, self.bins.size)
        kwdargs['norm'] = kwdargs.get('norm', default_norm)

        self.variable = velocity_variable
        self.ax, self.fig = utils.axis_figure(ax, fig)

        # add the color bar
        self.cax = self.fig.add_axes([0.92, 0.05, 0.03, 0.9])
        cbar = mpl.colorbar.ColorbarBase(self.cax,
                                         cmap=kwdargs['cmap'],
                                         norm=kwdargs['norm'])
        cbar.set_label("Knots")

        fcst = self.normalize(fcst)
        # use the longitude grid to define the radius of the circles
        sorted_lats = np.sort(fcst['latitude'].values)
        resol = np.median(angles.angle_diff(sorted_lats[1:],
                                            sorted_lats[:-1]))

        # create the map
        self.m = utils.get_basemap(fcst, ax=self.ax,
                                   lon_pad=0.75 * resol,
                                   lat_pad = 0.75 * resol)
        def create_circle(one_loc):
            # determine the circle center
            x, y = self.m(one_loc['longitude'].values,
                          one_loc['latitude'].values)
            speeds = one_lonlat[self.variable.speed_name].values
            dirs = one_lonlat[self.variable.direction_name].values
            orientation = self.variable.direction_orientation
            return DirectionCircle(x, y,
                                   speeds=np.atleast_1d(speeds),
                                   directions=np.atleast_1d(dirs),
                                   orientation=orientation,
                                   radius=0.4 * resol,
                                   ax=self.ax, **kwdargs)

        self.circles = [[create_circle(one_lonlat)
                         for lo, one_lonlat in one_lat.groupby('longitude')]
                        for la, one_lat in fcst.groupby('latitude')]
        self.set_title(fcst)
Beispiel #2
0
def template_temporal_plot(fcst, ax=None, fig=None):
    """
    Adds a human readable time axis to a figure.
    """
    ax, fig = utils.axis_figure(ax, fig)
    # set the x-axis to show time
    str_times = [x.strftime('%m-%d %Hh')
                 for x in pd.to_datetime(fcst['time'].values)]
    ax.xaxis.set_ticks(np.arange(len(str_times)) + 0.5)
    ax.xaxis.set_ticklabels(str_times, rotation=90)
    ax.set_xlabel("Forecast Time (UTC)")
    return ax
Beispiel #3
0
def binned_line_plot(variable, bin_divs, ax=None, **kwdargs):
    """
    Creates a plot showing the binned probability of the data
    in variable.
    """
    ax, _ = utils.axis_figure(axis=ax)
    assert variable.dims == ('time', 'realization')
    n_times, n_real = variable.shape

    bins = bin_matrix(variable.values, bin_divs)
    xs = np.arange(n_times).repeat(n_real).reshape(bins.shape)
    lines = plt.plot(xs + 0.5, bins - 0.5, **kwdargs)
    return lines
Beispiel #4
0
 def __init__(self, x, y, speeds, directions, radius,
              cmap=None, norm=None, ax=None, fig=None,
              arrow_alpha=0.7, circle_alpha=0.6,
              orientation='from'):
     self.axis, self.fig = utils.axis_figure(ax, fig)
     self.x = x
     self.y = y
     self.center = np.array([self.x, self.y]).flatten()
     self.radius = radius
     self.cm = cmap or plt.cm.get_cmap('Blues')
     self.norm = norm or plt.Normalize()
     self.arrow_alpha = arrow_alpha
     self.circle_alpha = circle_alpha
     assert orientation in ['from', 'to']
     self.orientation = orientation
     self.polys = self._build_polys(speeds, directions)
     self.circle = self._build_circle(speeds)
     self.axis.add_patch(self.circle)
     [self.axis.add_patch(poly) for poly in self.polys]
Beispiel #5
0
    def __init__(self, fcsts, velocity_variable, speed_units='knot',
                 max_speed=None, ax=None, fig=None):
        self.variable = velocity_variable
        self.speed_units = speed_units
        self.ax, self.fig = utils.axis_figure(ax, fig)
        self.ax.set_ylabel("Speed (%s)" % speed_units)

        # convert the bins to knots
        bins = xray.Variable('bins',
                             velocity_variable.speed_bins.copy(),
                             {'units': velocity_variable.units})
        _, self.bins, _ = units.convert_units(bins, speed_units)
        # convert the data to knots and radians
        fcsts = self.normalize(fcsts)

        # determine the upper bound on speed so we can place
        # the direction circles.
        all_speeds =fcsts[self.variable.speed_name].values
        max_speed = max_speed or np.max(all_speeds)
        max_bin = np.sum(self.bins <= max_speed) + 2
        self.max_bin = np.minimum(max_bin, self.bins.size)
        self.plot(fcsts)
Beispiel #6
0
def binned_probability_plot(variable, bin_divs, ax=None, **kwdargs):
    """
    Creates a plot showing the binned probability of the data
    in variable.
    """
    ax, _ = utils.axis_figure(axis=ax)
    if variable.dims == ('time', ):
        variable = (xray.concat([variable], 'realization')
                    .transpose('time', 'realization'))
    assert variable.dims == ('time', 'realization')
    n_times, n_real = variable.shape
    # compute the binned probabilities
    probs = bin_probs(variable, bin_divs)
    # default to a blue colormap placed in the background
    kwdargs['cmap'] = kwdargs.get('cmap', plt.cm.get_cmap('Blues'))
    kwdargs['zorder'] = kwdargs.get('zorder', -100)
    # plot the probabilities
    y, x = np.meshgrid(np.arange(bin_divs.size),
                       np.arange(variable['time'].size + 1))
    pm = ax.pcolormesh(x, y, probs.values,
                       norm=plt.Normalize(vmin=0., vmax=1.),
                       **kwdargs)
    return pm