示例#1
0
def plot(objVectors, centroidIDs, clusterIDs, generation, run, params):
    """ plots 'objVectors' and emphasizes the solutions indicated by
        'centroidIDs'. In case of 2 objectives, the clusters, given by
        clusterIDs, are plotted by connecting every point with the centroid
        of its cluster as well. The return parameter is an objective of type
        'onClick' which allows to later on ask which objective vector the user
        has picked.
    """
    if (len(objVectors > 0)) and (len(objVectors[0, :]) == 2):
        # plot all points
        h, = plt.plot(objVectors[:, 0], objVectors[:, 1], 'x')
        # plot centroids differently
        plt.plot(objVectors[centroidIDs, 0], objVectors[centroidIDs, 1],
                 'o' + plt.get(h, 'color'))

        s = plt.axis()  # get size of plot for annotations

        # plot the centroids's ids as well
        for i in centroidIDs:
            plt.text(objVectors[i, 0] + (0.1 / (s[1] - s[0])),
                     objVectors[i, 1] + (0.1 / (s[3] - s[2])),
                     i,
                     color=plt.get(h, 'color'))

        # connect all points with the centroids of their cluster
        for i in range(len(objVectors[:, 0])):
            x = [objVectors[i, 0], objVectors[centroidIDs[clusterIDs[i]], 0]]
            y = [objVectors[i, 1], objVectors[centroidIDs[clusterIDs[i]], 1]]
            plt.plot(x, y, ':' + plt.get(h, 'color'), linewidth=0.25)

        beautify2DPlot(generation, run)

        # allow for interactive clicking:
        if params.interaction == 1:
            # 1) add possibility to get objective vector and ids by clicking right:
            #annotes = range(len(objVectors))
            #af = AnnoteFinder.AnnoteFinder(objVectors[:,0],objVectors[:,1], annotes)
            #connect('button_press_event', af)

            # 2) choose best solution by clicking left:
            oc = onClick.onClick(objVectors)
            connect('button_press_event', oc)

            return oc

    else:
        parallelCoordinatesPlot(objVectors, generation, run, params)
        # allow for interactive clicking:
        if params.interaction == 1:
            # 1) add possibility to get objective vector and ids by clicking right:
            annotes = range(len(objVectors))
            af = AnnoteFinder.AnnoteFinder(objVectors[:, 0], objVectors[:, 1],
                                           annotes)
            connect('button_press_event', af)

            # 2) choose best solution by clicking left:
            oc = onClick.onClick(objVectors)
            connect('button_press_event', oc)

            return oc
示例#2
0
def align_axes(axis_name='xyzc', axes=None):
    """Make sure that the given axes are aligned along the given axis_name
    ('x', 'y', 'c', or any combination thereof (e.g. 'xy' which is the
    default)).  If no axis handles are specified, all axes in the current
    figure are used.
    """
    if axes is None:
        axes = plt.findobj(match=plt.Axes)

    for name in axis_name:
        prop = '%clim' % name
        all_lim = []
        all_axes = []
        for ax in axes:
            if ax is None:
                continue
            try:
                all_lim.append(plt.get(ax, prop))
                all_axes.append(ax)
            except AttributeError:
                for childax in plt.get(ax, 'children'):
                    try:
                        all_lim.append(plt.get(childax, prop))
                        all_axes.append(childax)
                    except:
                        pass
        if all_lim:
            all_lim = np.asarray(all_lim)
            aligned_lim = (all_lim[:,0].min(), all_lim[:,1].max())
            plt.setp(all_axes, prop, aligned_lim)
示例#3
0
def align_axes(axis_name='xyzc', axes=None):
    """Make sure that the given axes are aligned along the given axis_name
    ('x', 'y', 'c', or any combination thereof (e.g. 'xy' which is the
    default)).  If no axis handles are specified, all axes in the current
    figure are used.
    """
    if axes is None:
        axes = plt.findobj(match=plt.Axes)

    for name in axis_name:
        prop = '%clim' % name
        all_lim = []
        all_axes = []
        for ax in axes:
            try:
                all_lim.append(plt.get(ax, prop))
                all_axes.append(ax)
            except AttributeError:
                for childax in plt.get(ax, 'children'):
                    try:
                        all_lim.append(plt.get(childax, prop))
                        all_axes.append(childax)
                    except:
                        pass
        if all_lim:
            all_lim = np.asarray(all_lim)
            aligned_lim = (all_lim[:,0].min(), all_lim[:,1].max())
            plt.setp(all_axes, prop, aligned_lim)
示例#4
0
def plot(objVectors, centroidIDs, clusterIDs, generation, run, params):
    """ plots 'objVectors' and emphasizes the solutions indicated by
        'centroidIDs'. In case of 2 objectives, the clusters, given by
        clusterIDs, are plotted by connecting every point with the centroid
        of its cluster as well. The return parameter is an objective of type
        'onClick' which allows to later on ask which objective vector the user
        has picked.
    """
    if (len(objVectors > 0)) and (len(objVectors[0,:]) == 2):
        # plot all points
        h, = plt.plot(objVectors[:,0],objVectors[:,1], 'x')
        # plot centroids differently
        plt.plot(objVectors[centroidIDs,0], objVectors[centroidIDs, 1], 'o' + plt.get(h, 'color'))

        s = plt.axis()  # get size of plot for annotations
        
        # plot the centroids's ids as well
        for i in centroidIDs:
            plt.text(objVectors[i,0] + (0.1/(s[1]-s[0])), objVectors[i,1] + (0.1/(s[3]-s[2])), i, color=plt.get(h, 'color'))
            
        # connect all points with the centroids of their cluster
        for i in range(len(objVectors[:,0])):
            x = [objVectors[i,0], objVectors[centroidIDs[clusterIDs[i]],0]]
            y = [objVectors[i,1], objVectors[centroidIDs[clusterIDs[i]],1]]
            plt.plot(x, y, ':' + plt.get(h, 'color'), linewidth=0.25)
            
        beautify2DPlot(generation, run)
        
        # allow for interactive clicking:
        if params.interaction == 1:
            # 1) add possibility to get objective vector and ids by clicking right:
            #annotes = range(len(objVectors))
            #af = AnnoteFinder.AnnoteFinder(objVectors[:,0],objVectors[:,1], annotes)
            #connect('button_press_event', af)

            # 2) choose best solution by clicking left:
            oc = onClick.onClick(objVectors)
            connect('button_press_event', oc)
            
            return oc
        
        
    else:
        parallelCoordinatesPlot(objVectors, generation, run, params)
        # allow for interactive clicking:
        if params.interaction == 1:
            # 1) add possibility to get objective vector and ids by clicking right:
            annotes = range(len(objVectors))
            af = AnnoteFinder.AnnoteFinder(objVectors[:,0],objVectors[:,1], annotes)
            connect('button_press_event', af)

            # 2) choose best solution by clicking left:
            oc = onClick.onClick(objVectors)
            connect('button_press_event', oc)
            
            return oc
示例#5
0
def main():
    if len(sys.argv) < 2:
        logfilename = 'log.out'  # use default filename
        print('No input filename specified: using %s' % logfilename)
    else:
        logfilename = sys.argv[1]
    if not os.path.exists(logfilename):
        print('%s does not exist!' % logfilename)
        sys.exit()
    else:
        print('Reading file %s' % logfilename)
    if len(sys.argv) < 3:
        pngfilename = None
        print(
            'No output filename specified: will not write output file for plot'
        )
    else:
        pngfilename = sys.argv[2]
        print('Plot will be saved as %s' % pngfilename)
    data = np.genfromtxt(logfilename, usecols=(1, 2))
    t = data[:, 0]
    w = data[:, 1]
    # i = data[:, 3]
    pyplot.figure(0)
    pyplot.plot(t, w)
    ax = pyplot.gca()
    ax.set_xlabel('Time (second)')
    ax.set_ylabel('Power (W)')
    ax2 = ax.twinx()
    clim = pyplot.get(ax, 'ylim')
    ax2.set_ylim(clim[0] * 1000 / 120, clim[1] * 1000 / 120)
    ax2.set_ylabel('Current (mA)')
    # generate a PNG file
    if pngfilename:
        pyplot.savefig(pngfilename + '-power.png')
    # show the plot
    pyplot.show()

    pyplot.figure(1)
    # cumulative plot
    pyplot.plot(t / 60, np.cumsum(w) / 1000)
    ax = pyplot.gca()
    ax.set_xlabel('Time (minutes)')
    ax.set_ylabel('Energy (kJ)')
    ax2 = ax.twinx()
    clim = pyplot.get(ax, 'ylim')
    ax2.set_ylim(clim[0] / 3.6, clim[1] / 3.6)
    ax2.set_ylabel('Energy (Wh)')
    if pngfilename:
        pyplot.savefig(pngfilename + '-energy.png')
    # show the plot
    pyplot.show()
示例#6
0
def plot_iteration_stats(itstats, figNum=None, pretitle=None):

    if (figNum is None): fig = pyplot.figure()
    else: fig = pyplot.figure(figNum)

    pyplot.clf()
    pyplot.hold(True)
    pyplot.plot(itstats, 'k-', linewidth=2)

    yl = pyplot.get(pyplot.gca(), 'ylim')
    dyl = yl[1] - yl[0]

    yoff = yl[1] - 0.1 * dyl
    str = 'min  iterations : %d' % (np.min(itstats[1:]))
    pyplot.text(0.05 * len(itstats), yoff, str, fontsize=10)
    yoff = yoff - dyl / 20
    str = 'mean iterations : %d' % (np.int(np.mean(itstats[1:])))
    pyplot.text(0.05 * len(itstats), yoff, str, fontsize=10)
    yoff = yoff - dyl / 20
    str = 'max  iterations : %d' % (np.max(itstats[1:]))
    pyplot.text(0.05 * len(itstats), yoff, str, fontsize=10)
    pyplot.xlabel('Assimilation Step', fontweight='bold', fontsize=12)
    pyplot.ylabel('# Iterations', fontweight='bold', fontsize=12)
    title = '# Iterations for cost function'
    if (not (pretitle is None)): title = pretitle + ' - ' + title
    pyplot.title(title, fontweight='bold', fontsize=14)
    fig.canvas.set_window_title(title)
    pyplot.hold(False)
    return fig
示例#7
0
def setshowticklabs(h, ticklabs='all'):
    "find the set of plots which get tick-info"
    showticklabs = np.ndarray((len(h)), dtype=bool)
    showticklabs[:] = False  # default to show all
    if ticklabs == 'all':
        showticklabs[:] = True
    else:
        # get the dir to search for extreem plot
        if ticklabs == 'sw': sline = np.array((-1, -1))
        elif ticklabs == 'se': sline = np.array((1, -1))
        elif ticklabs == 'nw': sline = np.array((1, 1))
        elif ticklabs == 'ne': sline = np.array((1, -1))
        # find the most extreem plot
        d = None
        tickpi = None
        for pi, ax in enumerate(h):
            pltpos = plt.get(ax, 'position').get_points().mean(
                0)  # get axis center
            dpi = np.dot(sline, pltpos)
            if d is None or dpi > d:
                d = dpi
                tickpi = pi
        # set to show tick info
        showticklabs[tickpi] = True
    return showticklabs
示例#8
0
def plot_iteration_stats(itstats, figNum=None, pretitle=None):

    if ( figNum is None ): fig = pyplot.figure()
    else: fig = pyplot.figure(figNum)

    pyplot.clf()
    pyplot.hold(True)
    pyplot.plot(itstats,'k-',linewidth=2)

    yl = pyplot.get(pyplot.gca(),'ylim')
    dyl = yl[1] - yl[0]

    yoff = yl[1] - 0.1 * dyl
    str = 'min  iterations : %d' % (np.min(itstats[1:]))
    pyplot.text(0.05*len(itstats),yoff,str,fontsize=10)
    yoff = yoff - dyl / 20
    str = 'mean iterations : %d' % (np.int(np.mean(itstats[1:])))
    pyplot.text(0.05*len(itstats),yoff,str,fontsize=10)
    yoff = yoff - dyl / 20
    str = 'max  iterations : %d' % (np.max(itstats[1:]))
    pyplot.text(0.05*len(itstats),yoff,str,fontsize=10)
    pyplot.xlabel('Assimilation Step',fontweight='bold',fontsize=12)
    pyplot.ylabel('# Iterations',     fontweight='bold',fontsize=12)
    title = '# Iterations for cost function'
    if ( not (pretitle is None) ): title = pretitle + ' - ' + title
    pyplot.title(title,fontweight='bold',fontsize=14)
    fig.canvas.set_window_title(title)
    pyplot.hold(False)
    return fig
示例#9
0
def axis_range(ax):  # gets subplot coordinates on a figure in "normalized"
    # coordinates
    pos = plt.get(ax, 'position')
    bottom_left = pos.p0
    top_right = pos.p1
    xmin, xmax = bottom_left[0], top_right[0]
    ymin, ymax = bottom_left[1], top_right[1]
    return xmin, xmax, ymin, ymax
示例#10
0
def Spy(A, P1, symb, ttl, ax, parts=2, printperm=0):

    m, n = A.shape

    colors = numpy.zeros((parts + 1, 3))

    for cnt in numpy.arange(parts + 1):
        colors[cnt, :] = plotcolors(cnt)

    part_ids = numpy.zeros(m, dtype=numpy.int32)
    part_ids[P1] = 1
    perm = part_ids.argsort()
    A_perm = A[perm, :][:, perm]
    A_perm = A_perm.tocoo()
    part_ids = part_ids[perm]

    nnz = A.nnz
    xlab = 'nnz = %d\n' % nnz
    for i in range(nnz):
        if part_ids[A_perm.row[i]] == part_ids[A_perm.col[i]]:
            A_perm.data[i] = part_ids[A_perm.col[i]]
        else:
            A_perm.data[i] = parts

    plt.hold(True)

    plt.title(ttl, fontsize=14)
    bbox = plt.get(plt.gca(), 'position')
    pos = [bbox.x1, bbox.y1]
    markersize = max(6, min(14, round(6 * min(pos[:]) / max(m + 1, n + 1))))
    sy = symb

    for cnt in numpy.arange(parts + 1):
        ii, = numpy.where(A_perm.data == cnt)
        #print 'part %d has %d entries'%(cnt, len(ii))
        c = colors[cnt, :]
        plt.plot(A_perm.col[ii],
                 A_perm.row[ii],
                 marker=sy,
                 markersize=markersize,
                 color=c,
                 linestyle='.')

    plt.axis('tight')
    plt.xlim(xmin=-2)
    plt.ylim(ymin=-2)
    plt.xlim(xmax=m + 2)
    plt.ylim(ymax=n + 2)
    ax.set_ylim(ax.get_ylim()[::-1])
    ax.set_aspect((m + 1) / (n + 1), adjustable='box')
    plt.hold(False)
    plt.show()
示例#11
0
def plot_abs_error_var(xbev,
                       xaev,
                       label=['x'],
                       N=1,
                       yscale='semilog',
                       figNum=None):

    if ((yscale != 'linear') and (yscale != 'semilog')): yscale = 'semilog'

    if (figNum is None): fig = pyplot.figure()
    else: fig = pyplot.figure(figNum)
    pyplot.clf()
    for k in range(0, N):
        pyplot.subplot(N, 1, k + 1)
        pyplot.hold(True)
        if (yscale == 'linear'):
            pyplot.plot(xbev[k, 2:], 'b-', label='background', linewidth=2)
            pyplot.plot(xaev[k, 2:], 'r-', label='analysis', linewidth=2)
        elif (yscale == 'semilog'):
            pyplot.semilogy(np.abs(xbev[k, 2:]),
                            'b-',
                            label='background',
                            linewidth=2)
            pyplot.semilogy(np.abs(xaev[k, 2:]),
                            'r-',
                            label='analysis',
                            linewidth=2)
        pyplot.ylabel(label[k], fontweight='bold', fontsize=12)
        strb = 'mean background : %5.4f +/- %5.4f' % (np.mean(
            xbev[k, 2:]), np.std(xbev[k, 2:], ddof=1))
        stra = 'mean analysis : %5.4f +/- %5.4f' % (np.mean(
            xaev[k, 2:]), np.std(xaev[k, 2:], ddof=1))
        yl = pyplot.get(pyplot.gca(), 'ylim')
        if (yscale == 'linear'):
            yoffb = 0.9 * yl[1]
            yoffa = 0.8 * yl[1]
        elif (yscale == 'semilog'):
            yoffb = 0.5e1 * yl[0]
            yoffa = 0.2e1 * yl[0]
        pyplot.text(0, yoffb, strb, fontsize=10)
        pyplot.text(0, yoffa, stra, fontsize=10)
        pyplot.hold(False)
        if (k == 0):
            title = 'Ensemble Kalman Filter Error Variance'
            pyplot.title(title, fontweight='bold', fontsize=14)
        if (k == 1):
            pyplot.legend(loc=1)
        if (k == N - 1):
            pyplot.xlabel('Assimilation Step', fontweight='bold', fontsize=12)
    fig.canvas.set_window_title(title)
    return fig
示例#12
0
def plot_ObImpact(dJa, dJe, sOI=None, eOI=None, title=None, xlabel=None, ylabel=None):

    color_adj = 'c'
    color_ens = 'm'
    width     = 0.45

    if ( title  is None ): title   = ''
    if ( xlabel is None ): xlabel  = ''
    if ( ylabel is None ): ylabel  = ''

    if ( (sOI is None)                ): sOI = 0
    if ( (eOI is None) or (eOI == -1) ): eOI = len(dJa)

    index = np.arange(eOI-sOI)
    if   ( len(index) > 1000 ): inc = 1000
    elif ( len(index) > 100  ): inc = 100
    elif ( len(index) > 10   ): inc = 10
    else:                       inc = 1

    fig = pyplot.figure()
    pyplot.hold(True)

    r0 = pyplot.plot(np.zeros(eOI-sOI+1),'k-')
    r1 = pyplot.bar(index,       dJa, width, color=color_adj, edgecolor=color_adj, linewidth=0.0)
    r2 = pyplot.bar(index+width, dJe, width, color=color_ens, edgecolor=color_ens, linewidth=0.0)

    stra = r'mean $\delta J_a$ : %5.4f +/- %5.4f' % (np.mean(dJa), np.std(dJa,ddof=1))
    stre = r'mean $\delta J_e$ : %5.4f +/- %5.4f' % (np.mean(dJe), np.std(dJe,ddof=1))

    locs, labels = pyplot.xticks()
    newlocs   = np.arange(sOI,sOI+len(index)+1,inc) - sOI
    newlabels = np.arange(sOI,sOI+len(index)+1,inc)
    pyplot.xticks(newlocs, newlabels)

    yl = pyplot.get(pyplot.gca(),'ylim')
    dyl = yl[1] - yl[0]
    yoff = yl[0] + 0.1 * dyl
    pyplot.text(5,yoff,stra,fontsize=10,color=color_adj)
    yoff = yl[0] + 0.2 * dyl
    pyplot.text(5,yoff,stre,fontsize=10,color=color_ens)

    pyplot.xlabel(xlabel, fontsize=12)
    pyplot.ylabel(ylabel, fontsize=12)
    pyplot.title(title,   fontsize=14)
    fig.canvas.set_window_title(title)

    pyplot.hold(False)

    return fig
示例#13
0
def plot_log_likelihood_learning_curves(training_curves,
                                        static_lines,
                                        save_dir,
                                        x_lim=None,
                                        y_lim=None,
                                        file_name='train',
                                        title=None,
                                        logx=False,
                                        ax=None):
    """plot log-likelihood training curves

    :param training_curves: list of lists
        each inner list is of the form: [times, log-likelihoods, label, color]
        where times & log-likelihoods are arrays for plotting
    :param static_lines: list of lists
        each inner list is of the form [log-likelihood, label] where
        log-likelihood is a single value that will plotted as a
        horizontal line
    """
    create_fig = False
    if ax is None:
        fig, ax = plt.subplots(1, 1, figsize=(5.5, 5.5))
        create_fig = True

    for triple in training_curves:
        if logx:
            ax.semilogx(triple[0], triple[1], label=triple[2], color=triple[3])
        else:
            ax.plot(triple[0], triple[1], label=triple[2])
        ax.annotate(r"{}".format(round(triple[1][-1], 2)),
                    xy=(triple[1][-1], triple[1][-1] + 1),
                    fontsize=5,
                    color=triple[3])
    for pair in static_lines:
        ax.plot(plt.get(ax, 'xlim'), (pair[0], pair[0]), label=pair[1])

    if title:
        ax.set_title(title)
    ax.set_xlabel('time (seconds)')
    ax.set_ylabel('log likelihood')
    ax.legend(loc='lower right')
    if x_lim:
        ax.set_xlim(x_lim)
    if y_lim:
        ax.set_ylim(y_lim)

    if create_fig:
        save_fig(fig, save_dir,
                 '{}_likelihood_optimisation_curve'.format(file_name))
示例#14
0
def add_number(fig, ax, order=1, offset=None):

    # offset = [-175,50] if offset is None else offset
    offset = [-75, 25] if offset is None else offset
    pos = fig.transFigure.transform(plt.get(ax, 'position'))
    x = pos[0, 0] + offset[0]
    y = pos[1, 1] + offset[1]
    ax.text(x=x,
            y=y,
            s='%s)' % chr(96 + order),
            ha='center',
            va='center',
            transform=None,
            weight='bold',
            fontsize=14)
示例#15
0
def Spy(A, P1, symb, ttl, ax, parts=2, printperm=0):

    m, n = A.shape

    colors = numpy.zeros((parts + 1, 3))

    for cnt in numpy.arange(parts + 1):
        colors[cnt, :] = plotcolors(cnt)

    part_ids = numpy.zeros(m, dtype=numpy.int32)
    part_ids[P1] = 1
    perm = part_ids.argsort()
    A_perm = A[perm, :][:, perm]
    A_perm = A_perm.tocoo()
    part_ids = part_ids[perm]

    nnz = A.nnz
    xlab = "nnz = %d\n" % nnz
    for i in range(nnz):
        if part_ids[A_perm.row[i]] == part_ids[A_perm.col[i]]:
            A_perm.data[i] = part_ids[A_perm.col[i]]
        else:
            A_perm.data[i] = parts

    plt.hold(True)

    plt.title(ttl, fontsize=14)
    bbox = plt.get(plt.gca(), "position")
    pos = [bbox.x1, bbox.y1]
    markersize = max(6, min(14, round(6 * min(pos[:]) / max(m + 1, n + 1))))
    sy = symb

    for cnt in numpy.arange(parts + 1):
        ii, = numpy.where(A_perm.data == cnt)
        # print 'part %d has %d entries'%(cnt, len(ii))
        c = colors[cnt, :]
        plt.plot(A_perm.col[ii], A_perm.row[ii], marker=sy, markersize=markersize, color=c, linestyle=".")

    plt.axis("tight")
    plt.xlim(xmin=-2)
    plt.ylim(ymin=-2)
    plt.xlim(xmax=m + 2)
    plt.ylim(ymax=n + 2)
    ax.set_ylim(ax.get_ylim()[::-1])
    ax.set_aspect((m + 1) / (n + 1), adjustable="box")
    plt.hold(False)
    plt.show()
示例#16
0
def plot_rmse(xbrmse=None, xarmse=None, xyrmse=None, yscale='semilog', figNum=None, pretitle=None,
        sStat=100):

    if ( (yscale != 'linear') and (yscale != 'semilog') ): yscale = 'semilog'
    if ( figNum is None ): fig = pyplot.figure()
    else:                  fig = pyplot.figure(figNum)

    pyplot.clf()
    pyplot.hold(True)
    if ( yscale == 'linear' ):
        if ( xbrmse is not None ): pyplot.plot(xbrmse[1:],'b-',label='prior',      linewidth=2, alpha=0.90)
        if ( xarmse is not None ): pyplot.plot(xarmse[:],'r-',label='posterior',  linewidth=2, alpha=0.65)
        if ( xyrmse is not None ): pyplot.plot(xyrmse,     'k-',label='observation',linewidth=2, alpha=0.40)
    elif ( yscale == 'semilog' ):
        if ( xbrmse is not None ): pyplot.semilogy(xbrmse[1: ],'b-',label='prior',      linewidth=2, alpha=0.90)
        if ( xarmse is not None ): pyplot.semilogy(xarmse[:-1],'r-',label='posterior',  linewidth=2, alpha=0.65)
        if ( xyrmse is not None ): pyplot.semilogy(xyrmse,     'k-',label='observation',linewidth=2, alpha=0.40)

    yl = pyplot.get(pyplot.gca(),'ylim')
    pyplot.ylim(0.0, yl[1])
    dyl = yl[1]

    if ( xbrmse is not None ):
        strb = 'mean prior rmse : %5.4f +/- %5.4f' % (np.mean(xbrmse[sStat+1:]),np.std(xbrmse[sStat+1:],ddof=1))
        pyplot.text(0.05*len(xbrmse),yl[1]-0.1*dyl,strb,fontsize=10)
    if ( xarmse is not None ):
        stra = 'mean posterior rmse : %5.4f +/- %5.4f' % (np.mean(xarmse[sStat:-1]),np.std(xarmse[sStat:-1],ddof=1))
        pyplot.text(0.05*len(xarmse),yl[1]-0.15*dyl,stra,fontsize=10)
    if ( xyrmse is not None ):
        stro = 'mean observation rmse : %5.4f +/- %5.4f' % (np.mean(xyrmse[sStat:]), np.std(xyrmse[sStat:],ddof=1))
        pyplot.text(0.05*len(xyrmse),yl[1]-0.2*dyl,stro,fontsize=10)

    pyplot.xlabel('Assimilation Cycle',fontweight='bold',fontsize=12)
    pyplot.ylabel('RMSE',fontweight='bold',fontsize=12)
    title = 'Root Mean Squared Error'
    if ( not (pretitle is None) ): title = pretitle + ' - ' + title
    pyplot.title(title,fontweight='bold',fontsize=14)
    pyplot.legend(loc='lower right',ncol=2)
    pyplot.hold(False)
    fig.canvas.set_window_title(title)
    return fig
def view_scatterplots(df, list_plots):
    '''
    Gets scatterplots of different columns (usually target versus feature of
    interest), with the option to colorcode by other feature.

    Inputs:
        - df: a Pandas Dataframe.
        - list_plots: list of dicts, where each dictionary represents a
            scatterploof to get, which should have for keys:
                - 'xcol': target or other columns of interest)
                - 'ycol': other feature of interests.
                - 'colorcol': feature to colorcode by. optional.

    Output:
        Scatterplot(s)

    '''

    for plt in list_plots:
        xcol = plt['xcol']
        ycol = plt['ycol']
        get_scatterplot(df, xcol, ycol, plt.get('colorcol', None))
示例#18
0
def plot_abs_error_var(xbev, xaev, label=['x'], N=1, yscale='semilog', figNum=None):

    if ( (yscale != 'linear') and (yscale != 'semilog') ): yscale = 'semilog'

    if ( figNum is None ): fig = pyplot.figure()
    else: fig = pyplot.figure(figNum)
    pyplot.clf()
    for k in range(0,N):
        pyplot.subplot(N,1,k+1)
        pyplot.hold(True)
        if ( yscale == 'linear'):
            pyplot.plot(xbev[k,2:],'b-',label='background',linewidth=2)
            pyplot.plot(xaev[k,2:],'r-',label='analysis',linewidth=2)
        elif ( yscale == 'semilog' ):
            pyplot.semilogy(np.abs(xbev[k,2:]),'b-',label='background',linewidth=2)
            pyplot.semilogy(np.abs(xaev[k,2:]),'r-',label='analysis',linewidth=2)
        pyplot.ylabel(label[k],fontweight='bold',fontsize=12)
        strb = 'mean background : %5.4f +/- %5.4f' % (np.mean(xbev[k,2:]), np.std(xbev[k,2:],ddof=1))
        stra = 'mean analysis : %5.4f +/- %5.4f' % (np.mean(xaev[k,2:]), np.std(xaev[k,2:],ddof=1))
        yl = pyplot.get(pyplot.gca(),'ylim')
        if ( yscale == 'linear'):
            yoffb = 0.9 * yl[1]
            yoffa = 0.8 * yl[1]
        elif ( yscale == 'semilog' ):
            yoffb = 0.5e1 * yl[0]
            yoffa = 0.2e1 * yl[0]
        pyplot.text(0,yoffb,strb,fontsize=10)
        pyplot.text(0,yoffa,stra,fontsize=10)
        pyplot.hold(False)
        if ( k == 0 ):
            title = 'Ensemble Kalman Filter Error Variance'
            pyplot.title(title,fontweight='bold',fontsize=14)
        if ( k == 1 ):
            pyplot.legend(loc=1)
        if ( k == N-1 ):
            pyplot.xlabel('Assimilation Step',fontweight='bold',fontsize=12)
    fig.canvas.set_window_title(title)
    return fig
示例#19
0
    def draw_plot(self):
        self.figure.clf()
        self.ax = self.figure.add_subplot(111)
        self.canvas.mpl_connect('pick_event', self.on_pick)
        self.ax.grid(self.grid_cb.isChecked())
	lines = []
	for entry in self.final:
            line, = self.ax.plot(*entry, picker=True)
            lines.append(line)
        self.ax.hold(False)
	self.ax.set_title("Energy Data")
        self.ax.set_xlabel("Time (minutes)")
        self.ax.set_ylabel("Power (w)")
        self.ax2 = self.ax.twinx()
        clim = plt.get(self.ax, 'ylim')
        self.ax2.set_ylim(clim[0]*1000/120, clim[1]*1000/120)
        self.ax2.set_ylabel("Current (mA)")
 
        for i in range(0, len(lines)):
            lines[i].set_label(self.names[i])
        handles, labels = self.ax.get_legend_handles_labels()
        self.ax.legend(handles, labels)
        self.canvas.draw()
示例#20
0
def zvect(zFrom, zTo=None, arg3=None, arg4=None):
    """ZVECT   Plot vectors in complex z-plane from zFrom to zTo

    common usage:  zvect(Z) 
        displays each element of Z as an arrow emanating from the origin.

    usage:   HV = zvect(zFrom, <zTo>, <LTYPE>, <SCALE>)

        zFrom:  is a vector of complex numbers; each one will be
                the starting location of an arrow.
        zTo:  is a vector of complex numbers; each one will be
                the ending point of an arrow starting at zFrom.
        LTYPE: string containing any valid line type (see PLOT)            
        SCALE: controls size of arrowhead (default = 1.0)
                (order of LTYPE and SCALE args doesn't matter)
            HV: output handle from graphics of vector plot

        ** If either zFrom or zTo is a scalar all vectors will
            start or end at that point.

        See also ZCAT.
    """
    zFrom = np.asarray(zFrom)
    zTo = np.asarray(zTo)
    scale = 1.0
    linetype = 'b-'
    if zTo is None:
        zTo = zFrom
        zFrom = 0 * zTo
    elif zTo is not None:
        if type(zTo) == str:
            linetype = zTo
            zTo = zFrom
            zFrom = 0 * zTo
        elif len(zTo) == 0:
            zTo = zFrom
            zFrom = 0 * zTo
        elif len(zTo) == 1:
            zTo = zTo * np.ones(zFrom.shape)
    elif zTo and arg3 is not None:
        if type(arg3) == str:
            linetype = arg3
        else:
            scale = arg3
    else:
        if type(arg3) == str:
            linetype = arg3
            scale = arg4
        else:
            scale = arg3
            linetype = arg4

    jkl = np.where(np.logical_not(np.isnan(zTo - zFrom)))[0]
    if len(jkl) == 0:
        exit('cannot plot NaNs')

    zTo = zTo[jkl]
    zFrom = zFrom[jkl]
    if len(zFrom) == 1:
        zFrom = zFrom * np.ones(zTo.shape)
    elif len(zTo) == 1:
        zTo = zTo * np.ones(zFrom.shape)

    if len(zFrom) != len(zTo):
        exit('ZVECT: zFrom and zTo must be same length.')

    tt = np.r_[zFrom, zTo]
    # zmx = max(abs(tt))
    jkl = np.where(tt == max(tt))[0]
    figsize = max(abs(tt - tt[jkl]))
    arrow = scale * (np.vstack((-1, 0, -1)) + 1j * np.vstack(
        (1 / 4, 0, -1 / 4)))

    dz = zTo - zFrom
    dzm = abs(dz)
    zmax = max(dzm)
    zscale = np.mean(np.r_[zmax, figsize])
    scz = 0.11 + 0.77 * (dzm / zscale - 1)**6
    tt = np.array(np.ones((3, 1)) * zTo + arrow * (scz * dz))

    h = plt.plot(
        np.vstack((zFrom, zTo)).real,
        np.vstack((zFrom, zTo)).imag, linetype, tt.real, tt.imag, linetype)
    num_zzz = len(zFrom)

    for kk in range(num_zzz):
        kolor = plt.get(h[kk], 'color')
        plt.setp(h[kk + num_zzz], 'color', kolor)

    plt.axis('equal')

    plt.show()
    return h
示例#21
0
def plot_rmse(xbrmse=None,
              xarmse=None,
              xyrmse=None,
              yscale='semilog',
              figNum=None,
              pretitle=None,
              sStat=100):

    if ((yscale != 'linear') and (yscale != 'semilog')): yscale = 'semilog'
    if (figNum is None): fig = pyplot.figure()
    else: fig = pyplot.figure(figNum)

    pyplot.clf()
    pyplot.hold(True)
    if (yscale == 'linear'):
        if (xbrmse is not None):
            pyplot.plot(xbrmse[1:],
                        'b-',
                        label='prior',
                        linewidth=2,
                        alpha=0.90)
        if (xarmse is not None):
            pyplot.plot(xarmse[:],
                        'r-',
                        label='posterior',
                        linewidth=2,
                        alpha=0.65)
        if (xyrmse is not None):
            pyplot.plot(xyrmse,
                        'k-',
                        label='observation',
                        linewidth=2,
                        alpha=0.40)
    elif (yscale == 'semilog'):
        if (xbrmse is not None):
            pyplot.semilogy(xbrmse[1:],
                            'b-',
                            label='prior',
                            linewidth=2,
                            alpha=0.90)
        if (xarmse is not None):
            pyplot.semilogy(xarmse[:-1],
                            'r-',
                            label='posterior',
                            linewidth=2,
                            alpha=0.65)
        if (xyrmse is not None):
            pyplot.semilogy(xyrmse,
                            'k-',
                            label='observation',
                            linewidth=2,
                            alpha=0.40)

    yl = pyplot.get(pyplot.gca(), 'ylim')
    pyplot.ylim(0.0, yl[1])
    dyl = yl[1]

    if (xbrmse is not None):
        strb = 'mean prior rmse : %5.4f +/- %5.4f' % (np.mean(
            xbrmse[sStat + 1:]), np.std(xbrmse[sStat + 1:], ddof=1))
        pyplot.text(0.05 * len(xbrmse), yl[1] - 0.1 * dyl, strb, fontsize=10)
    if (xarmse is not None):
        stra = 'mean posterior rmse : %5.4f +/- %5.4f' % (np.mean(
            xarmse[sStat:-1]), np.std(xarmse[sStat:-1], ddof=1))
        pyplot.text(0.05 * len(xarmse), yl[1] - 0.15 * dyl, stra, fontsize=10)
    if (xyrmse is not None):
        stro = 'mean observation rmse : %5.4f +/- %5.4f' % (np.mean(
            xyrmse[sStat:]), np.std(xyrmse[sStat:], ddof=1))
        pyplot.text(0.05 * len(xyrmse), yl[1] - 0.2 * dyl, stro, fontsize=10)

    pyplot.xlabel('Assimilation Cycle', fontweight='bold', fontsize=12)
    pyplot.ylabel('RMSE', fontweight='bold', fontsize=12)
    title = 'Root Mean Squared Error'
    if (not (pretitle is None)): title = pretitle + ' - ' + title
    pyplot.title(title, fontweight='bold', fontsize=14)
    pyplot.legend(loc='lower right', ncol=2)
    pyplot.hold(False)
    fig.canvas.set_window_title(title)
    return fig
示例#22
0
def ImagePos(source, lens1, lens2):
    temp = Image.new("RGBA", (640, 480), (255, 255, 255))
    if (lens1.pos == lens2.pos):
        return
    else:
        if (lens1.pos > lens2.pos):
            temp = lens1
            lens1 = lens2
            lens2 = temp
        #drawlens(lens1.pos)
        #drawlens(lens2.pos)
        obj_dis1 = lens1.pos
        plt.hold(True)
        '''
        temp = draw_lens.draw_lens_on(temp,lens1)
        plt.imshow(temp);
        temp = draw_lens.draw_lens_on(temp,lens2)
        plt.imshow(temp);
        '''
        if (source.y == 1 and obj_dis1 == lens1.focus):  #point source at focus
            img_dis1 = np.Inf
            obj_dis2 = img_dis1
            img_dis2 = lens2.focus
            plt.plot([0, lens1.pos], [0, -2], 'b', [0, lens1.pos], [0, -1],
                     'b', [0, lens1.pos], [0, 0], 'b', [0, lens1.pos], [0, 1],
                     'b', [0, lens1.pos], [0, 2], 'b')
            plt.plot([lens1.pos, lens2.pos], [-2, -2], 'b',
                     [lens1.pos, lens2.pos], [-1, -1], 'b',
                     [lens1.pos, lens2.pos], [0, 0], 'b',
                     [lens1.pos, lens2.pos], [1, 1], 'b',
                     [lens1.pos, lens2.pos], [2, 2], 'b')
            if (img_dis2 > 0):
                plt.plot([lens2.pos, lens2.pos + img_dis2], [-2, 0], 'b',
                         [lens2.pos, lens2.pos + img_dis2], [-1, 0], 'b',
                         [lens2.pos, lens2.pos + img_dis2], [0, 0], 'b',
                         [lens2.pos, lens2.pos + img_dis2], [1, 0], 'b',
                         [lens2.pos, lens2.pos + img_dis2], [2, 0], 'b')
            else:
                plt.plot([lens2.pos, lens2.pos + img_dis2], [-2, 0], 'b--',
                         [lens2.pos, lens2.pos + img_dis2], [-1, 0], 'b--',
                         [lens2.pos, lens2.pos + img_dis2], [0, 0], 'b--',
                         [lens2.pos, lens2.pos + img_dis2], [1, 0], 'b--',
                         [lens2.pos, lens2.pos + img_dis2], [2, 0], 'b--')
                plt.plot([lens2.pos, lens2.pos - img_dis2], [-2, -4], 'b',
                         [lens2.pos, lens2.pos - img_dis2], [-1, -2], 'b',
                         [lens2.pos, lens2.pos - img_dis2], [0, 0], 'b',
                         [lens2.pos, lens2.pos - img_dis2], [1, 2], 'b',
                         [lens2.pos, lens2.pos - img_dis2], [2, 4], 'b')
            return
        if (source.y == 1):
            img_dis1 = 1.0 * obj_dis1 * lens1.focus / (obj_dis1 - lens1.focus)
            obj_dis2 = lens2.pos - (img_dis1 + lens1.pos)
            img_dis2 = 1.0 * obj_dis2 * lens2.focus / (obj_dis2 - lens2.focus)
        else:
            obj_dis1 = np.Inf
            img_dis1 = lens1.focus
            obj_dis2 = lens2.pos - (img_dis1 + lens1.pos)
            img_dis2 = obj_dis2 * lens2.focus / (obj_dis2 - lens2.focus)
        if (img_dis1 > 0 and obj_dis2 > 0):
            if (source.y == 1):
                plt.plot([0, lens1.pos], [0, -2], 'b', [0, lens1.pos], [0, -1],
                         'b', [0, lens1.pos], [0, 0], 'b', [0, lens1.pos],
                         [0, 1], 'b', [0, lens1.pos], [0, 2], 'b')
            else:
                plt.plot([0, lens1.pos], [-2, -2], 'b', [0, lens1.pos],
                         [-1, -1], 'b', [0, lens1.pos], [0, 0], 'b',
                         [0, lens1.pos], [1, 1], 'b', [0, lens1.pos], [2, 2],
                         'b')
            plt.plot(
                [lens1.pos, lens1.pos + img_dis1, lens2.pos],
                [-2, 0, 2 * (lens2.pos - lens1.pos - img_dis1) / img_dis1],
                'b', [lens1.pos, lens1.pos + img_dis1, lens2.pos],
                [-1, 0, 1 * (lens2.pos - lens1.pos - img_dis1) / img_dis1],
                'b', [lens1.pos, lens1.pos + img_dis1, lens2.pos], [0, 0, 0],
                'b', [lens1.pos, lens1.pos + img_dis1, lens2.pos],
                [1, 0, -1 * (lens2.pos - lens1.pos - img_dis1) / img_dis1],
                'b', [lens1.pos, lens1.pos + img_dis1, lens2.pos],
                [2, 0, -2 * (lens2.pos - lens1.pos - img_dis1) / img_dis1],
                'b')
            if (img_dis2 > 0):
                plt.plot(
                    [lens2.pos + img_dis2, lens2.pos],
                    [0, 2 * (lens2.pos - lens1.pos - img_dis1) / img_dis1],
                    'b', [lens2.pos + img_dis2, lens2.pos],
                    [0, 1 * (lens2.pos - lens1.pos - img_dis1) / img_dis1],
                    'b', [lens2.pos + img_dis2, lens2.pos], [0, 0], 'b',
                    [lens2.pos + img_dis2, lens2.pos],
                    [0, -1 * (lens2.pos - lens1.pos - img_dis1) / img_dis1],
                    'b', [lens2.pos + img_dis2, lens2.pos],
                    [0, -2 * (lens2.pos - lens1.pos - img_dis1) / img_dis1],
                    'b')
            else:
                plt.plot(
                    [lens2.pos, lens2.pos + img_dis2],
                    [-2 * (lens2.pos - lens1.pos - img_dis1) / img_dis1, 0],
                    'b--', [lens2.pos, lens2.pos + img_dis2],
                    [-1 * (lens2.pos - lens1.pos - img_dis1) / img_dis1, 0],
                    'b--', [lens2.pos, lens2.pos + img_dis2],
                    [0 * (lens2.pos - lens1.pos - img_dis1) / img_dis1, 0],
                    'b--', [lens2.pos, lens2.pos + img_dis2],
                    [1 * (lens2.pos - lens1.pos - img_dis1) / img_dis1, 0],
                    'b--', [lens2.pos, lens2.pos + img_dis2],
                    [2 * (lens2.pos - lens1.pos - img_dis1) / img_dis1, 0],
                    'b--')
                plt.plot([lens2.pos, lens2.pos - img_dis2], [
                    -2 * (lens2.pos - lens1.pos - img_dis1) / img_dis1, -4 *
                    (lens2.pos - lens1.pos - img_dis1) / img_dis1
                ], 'b', [lens2.pos, lens2.pos - img_dis2], [
                    -1 * (lens2.pos - lens1.pos - img_dis1) / img_dis1, -2 *
                    (lens2.pos - lens1.pos - img_dis1) / img_dis1
                ], 'b', [lens2.pos, lens2.pos - img_dis2], [0, 0], 'b',
                         [lens2.pos, lens2.pos - img_dis2], [
                             1 * (lens2.pos - lens1.pos - img_dis1) / img_dis1,
                             2 * (lens2.pos - lens1.pos - img_dis1) / img_dis1
                         ], 'b', [lens2.pos, lens2.pos - img_dis2], [
                             2 * (lens2.pos - lens1.pos - img_dis1) / img_dis1,
                             4 * (lens2.pos - lens1.pos - img_dis1) / img_dis1
                         ], 'b')
        elif (img_dis1 > 0 and obj_dis2 < 0):
            plt.plot([0, lens1.pos], [0, -2], 'b', [0, lens1.pos], [0, -1],
                     'b', [0, lens1.pos], [0, 0], 'b', [0, lens1.pos], [0, 1],
                     'b', [0, lens1.pos], [0, 2], 'b')
            plt.plot([lens1.pos, lens2.pos],
                     [-2, 2 * (lens2.pos - lens1.pos - img_dis1) / img_dis1],
                     'b', [lens1.pos, lens2.pos],
                     [-1, 1 * (lens2.pos - lens1.pos - img_dis1) / img_dis1],
                     'b', [lens1.pos, lens2.pos], [0, 0], 'b',
                     [lens1.pos, lens2.pos],
                     [1, -1 * (lens2.pos - lens1.pos - img_dis1) / img_dis1],
                     'b', [lens1.pos, lens2.pos],
                     [2, -2 * (lens2.pos - lens1.pos - img_dis1) / img_dis1],
                     'b')
            plt.plot([lens1.pos + img_dis1, lens2.pos],
                     [0, 2 * (lens2.pos - lens1.pos - img_dis1) / img_dis1],
                     'b--', [lens1.pos + img_dis1, lens2.pos],
                     [0, 1 * (lens2.pos - lens1.pos - img_dis1) / img_dis1],
                     'b--', [lens1.pos + img_dis1, lens2.pos], [0, 0], 'b--',
                     [lens1.pos + img_dis1, lens2.pos],
                     [0, -1 * (lens2.pos - lens1.pos - img_dis1) / img_dis1],
                     'b--', [lens1.pos + img_dis1, lens2.pos],
                     [0, -2 * (lens2.pos - lens1.pos - img_dis1) / img_dis1],
                     'b--')
            if (img_dis2 > 0):
                plt.plot(
                    [lens2.pos + img_dis2, lens2.pos],
                    [0, 2 * (lens2.pos - lens1.pos - img_dis1) / img_dis1],
                    'b', [lens2.pos + img_dis2, lens2.pos],
                    [0, 1 * (lens2.pos - lens1.pos - img_dis1) / img_dis1],
                    'b', [lens2.pos + img_dis2, lens2.pos], [0, 0], 'b',
                    [lens2.pos + img_dis2, lens2.pos],
                    [0, -1 * (lens2.pos - lens1.pos - img_dis1) / img_dis1],
                    'b', [lens2.pos + img_dis2, lens2.pos],
                    [0, -2 * (lens2.pos - lens1.pos - img_dis1) / img_dis1],
                    'b')
            else:
                plt.plot(
                    [lens2.pos, lens2.pos + img_dis2],
                    [-2 * (lens2.pos - lens1.pos - img_dis1) / img_dis1, 0],
                    'b--', [lens2.pos, lens2.pos + img_dis2],
                    [-1 * (lens2.pos - lens1.pos - img_dis1) / img_dis1, 0],
                    'b--', [lens2.pos, lens2.pos + img_dis2],
                    [0 * (lens2.pos - lens1.pos - img_dis1) / img_dis1, 0],
                    'b--', [lens2.pos, lens2.pos + img_dis2],
                    [1 * (lens2.pos - lens1.pos - img_dis1) / img_dis1, 0],
                    'b--', [lens2.pos, lens2.pos + img_dis2],
                    [2 * (lens2.pos - lens1.pos - img_dis1) / img_dis1, 0],
                    'b--')
                plt.plot([lens2.pos, lens2.pos - img_dis2], [
                    -2 * (lens2.pos - lens1.pos - img_dis1) / img_dis1, -4 *
                    (lens2.pos - lens1.pos - img_dis1) / img_dis1
                ], 'b', [lens2.pos, lens2.pos - img_dis2], [
                    -1 * (lens2.pos - lens1.pos - img_dis1) / img_dis1, -2 *
                    (lens2.pos - lens1.pos - img_dis1) / img_dis1
                ], 'b', [lens2.pos, lens2.pos - img_dis2], [0, 0], 'b',
                         [lens2.pos, lens2.pos - img_dis2], [
                             1 * (lens2.pos - lens1.pos - img_dis1) / img_dis1,
                             2 * (lens2.pos - lens1.pos - img_dis1) / img_dis1
                         ], 'b', [lens2.pos, lens2.pos - img_dis2], [
                             2 * (lens2.pos - lens1.pos - img_dis1) / img_dis1,
                             4 * (lens2.pos - lens1.pos - img_dis1) / img_dis1
                         ], 'b')
        elif (img_dis1 < 0):
            if (source.y == 1):
                plt.plot([0, lens1.pos], [
                    0, 2.0 * (-img_dis1) / (lens2.pos - lens1.pos - img_dis1)
                ], 'b', [0, lens1.pos], [
                    0, 1.0 * (-img_dis1) / (lens2.pos - lens1.pos - img_dis1)
                ], 'b', [0, lens1.pos], [0, 0], 'b', [0, lens1.pos], [
                    0, -1.0 * (-img_dis1) / (lens2.pos - lens1.pos - img_dis1)
                ], 'b', [0, lens1.pos], [
                    0, -2.0 * (-img_dis1) / (lens2.pos - lens1.pos - img_dis1)
                ], 'b')
            else:
                plt.plot([0, lens1.pos], [
                    2.0 * (-img_dis1) / (lens2.pos - lens1.pos - img_dis1),
                    2.0 * (-img_dis1) / (lens2.pos - lens1.pos - img_dis1)
                ], 'b', [0, lens1.pos], [
                    1.0 * (-img_dis1) / (lens2.pos - lens1.pos - img_dis1),
                    1.0 * (-img_dis1) / (lens2.pos - lens1.pos - img_dis1)
                ], 'b', [0, lens1.pos], [0, 0], 'b', [0, lens1.pos], [
                    -1.0 * (-img_dis1) / (lens2.pos - lens1.pos - img_dis1),
                    -1.0 * (-img_dis1) / (lens2.pos - lens1.pos - img_dis1)
                ], 'b', [0, lens1.pos], [
                    -2.0 * (-img_dis1) / (lens2.pos - lens1.pos - img_dis1),
                    -2.0 * (-img_dis1) / (lens2.pos - lens1.pos - img_dis1)
                ], 'b')
            plt.plot(
                [lens1.pos + img_dis1, lens1.pos],
                [0, 2.0 * (-img_dis1) / (lens2.pos - lens1.pos - img_dis1)],
                'b--', [lens1.pos + img_dis1, lens1.pos],
                [0, 1.0 * (-img_dis1) / (lens2.pos - lens1.pos - img_dis1)],
                'b--', [lens1.pos + img_dis1, lens1.pos], [0, 0], 'b--',
                [lens1.pos + img_dis1, lens1.pos],
                [0, -1.0 * (-img_dis1) / (lens2.pos - lens1.pos - img_dis1)],
                'b--', [lens1.pos + img_dis1, lens1.pos],
                [0, -2.0 * (-img_dis1) / (lens2.pos - lens1.pos - img_dis1)],
                'b--')
            plt.plot(
                [lens2.pos, lens1.pos],
                [2, 2.0 * (-img_dis1) / (lens2.pos - lens1.pos - img_dis1)],
                'b', [lens2.pos, lens1.pos],
                [1, 1.0 * (-img_dis1) / (lens2.pos - lens1.pos - img_dis1)],
                'b', [lens2.pos, lens1.pos], [0, 0], 'b',
                [lens2.pos, lens1.pos],
                [-1, -1.0 * (-img_dis1) / (lens2.pos - lens1.pos - img_dis1)],
                'b', [lens2.pos, lens1.pos],
                [-2, -2.0 * (-img_dis1) / (lens2.pos - lens1.pos - img_dis1)],
                'b')
            if (img_dis2 > 0):
                plt.plot([lens2.pos + img_dis2, lens2.pos], [0, 2], 'b',
                         [lens2.pos + img_dis2, lens2.pos], [0, 1], 'b',
                         [lens2.pos + img_dis2, lens2.pos], [0, 0], 'b',
                         [lens2.pos + img_dis2, lens2.pos], [0, -1], 'b',
                         [lens2.pos + img_dis2, lens2.pos], [0, -2], 'b')
            else:
                plt.plot([lens2.pos, lens2.pos + img_dis2], [-2, 0], 'b--',
                         [lens2.pos, lens2.pos + img_dis2], [-1, 0], 'b--',
                         [lens2.pos, lens2.pos + img_dis2], [0, 0], 'b--',
                         [lens2.pos, lens2.pos + img_dis2], [1, 0], 'b--',
                         [lens2.pos, lens2.pos + img_dis2], [2, 0], 'b--')
                plt.plot([lens2.pos, lens2.pos - img_dis2], [-2, -4], 'b',
                         [lens2.pos, lens2.pos - img_dis2], [-1, -2], 'b',
                         [lens2.pos, lens2.pos - img_dis2], [0, 0], 'b',
                         [lens2.pos, lens2.pos - img_dis2], [1, 2], 'b',
                         [lens2.pos, lens2.pos - img_dis2], [2, 4], 'b')
        x_axis = plt.get(plt.gca(), "xlim")
        plt.savefig("lens.jpg", )
        temp = Image.open("lens.jpg")
        draw_lens_on(temp, lens1, x_axis)
        draw_lens_on(temp, lens2, x_axis)
        temp.save('./lens/static/lens/pos.jpg')
示例#23
0
    m_ls = la.solve(G, t)
else:
    m_ls = la.lstsq(G, t)[0]

# Plot the least-squares solution and confidence intervals
covm_ls = (noise**2) * la.inv(np.dot(G.T, G))
conf95 = 1.96 * np.sqrt(np.diag(covm_ls))
conf95 = conf95.reshape(N, 1)

dz = dobs[1] - dobs[0]
dobs2 = dobs + dz / 2

fig1, ax1 = plt.subplots(1, 1)
ax1.plot(dobs2, m_ls * 1000, '-', drawstyle='steps')
dum = ax1.plot(dobs2, (m_ls + conf95) * 1000, '--', drawstyle='steps')
color = plt.get(dum[0], 'color')
ax1.plot(dobs2, (m_ls - conf95) * 1000, '--', color=color, drawstyle='steps')
ax1.set_xlabel('Depth [m]')
ax1.set_ylabel('Slowness [s/km]')
fig1.savefig('c4fmL2.pdf')
plt.close()

# --- Apply first-order Tikhonov regularization ---

L1 = roughmat(N, 1, full=True)
U1, V1, X1, LAM1, MU1 = gsvd(G, L1)

# Apply the L curve criteria to the first-order regularization problem

rho1, eta1, reg_params1 = lcurve_gsvd(U1, X1, LAM1, MU1, t, G, L1, 1200)
示例#24
0
plt.imshow(Z, origin='lower', extent=extent, cmap=cmap, norm=norm)
v = plt.axis()
plt.contour(Z, levels, colors='k', origin='lower', extent=extent)
plt.axis(v)
plt.title("Image, origin 'lower'")

plt.subplot(2, 2, 4)

# We will use the interpolation "nearest" here to show the actual
# image pixels.
# Note that the contour lines don't extend to the edge of the box.
# This is intentional. The Z values are defined at the center of each
# image pixel (each color block on the following subplot), so the
# domain that is contoured does not extend beyond these pixel centers.
im = plt.imshow(Z,
                interpolation='nearest',
                extent=extent,
                cmap=cmap,
                norm=norm)
v = plt.axis()
plt.contour(Z, levels, colors='k', origin='image', extent=extent)
plt.axis(v)
ylim = plt.get(plt.gca(), 'ylim')
plt.setp(plt.gca(), ylim=ylim[::-1])
plt.title("Origin from rc, reversed y-axis")
plt.colorbar(im)

plt.tight_layout()
plt.show()
示例#25
0
def _plotall_plot_page(arrays, props, curr_page=0):
    narrays = len(arrays)
    nsubplots = min(narrays, np.prod(props['subplot']))
    subplots = curr_page * nsubplots + np.arange(nsubplots)

    # Pass 1: plot everything and align axes.
    all_axes = []
    all_image_axes = []
    click_handlers = {}
    for n, x in enumerate(subplots):
        if x < 0 or x >= narrays:
            continue

        kwargs = {}
        if n > 0:
            if 'x' in props['align']:
                kwargs['sharex'] = all_axes[0]
            if 'y' in props['align']:
                kwargs['sharey'] = all_axes[0]
        curr_axes = plt.subplot(*props['subplots'][x], **kwargs)

        data = np.asarray(arrays[x])
        if _plotall_get_prop(props['transpose'], x):
            data = np.transpose(data)

        plotfun = _plotall_get_prop(props['plotfun'], x)
        plotfun(data)

        clickfun = props['clickfun']
        if clickfun:
            click_handlers[curr_axes] = _plotall_get_prop(clickfun, x)

        all_axes.append(curr_axes)
        if data.ndim == 2:
            xlim_max = data.shape[1] - 0.5
        else:
            xlim_max = len(data)
        plt.setp(curr_axes, 'xlim', [-0.5, xlim_max])
        if data.ndim == 2:
            all_image_axes.append(curr_axes)
            plt.setp(curr_axes, 'ylim', [-0.5, data.shape[0]-0.5])

        # Draw colorbars on all subplots (even if they are not images)
        # to keep axis widths consistent.
        if props['colorbar']:
            plt.colorbar()

    if 'x' in props['align']:
        align_axes('x', all_axes)
    for ax in ('y', 'c'):
        if ax in props['align']:
            align_axes(ax, all_image_axes)

    fig = plt.gcf()
    clickfun = functools.partial(_plotall_click_handler,
                                 click_handlers=click_handlers)
    cid = fig.canvas.mpl_connect("button_press_event", clickfun)

    # Pass 2: set specified axis properties.
    for x in subplots:
        if x < 0 or x >= narrays:
            continue
        curr_axes = all_axes[x - subplots[0]]
        plt.axes(curr_axes)

        succeeded = False
        for name, val in props['other'].iteritems():
            val = _plotall_get_prop(val, x)
            if isinstance(val, types.FunctionType):
                val = val()

            try:
                plt.setp(curr_axes, name, val)
                succeeded = True
            except AttributeError:
                for curr_axes_child in plt.get(curr_axes, 'children'):
                    try:
                        plt.setp(curr_axes_child, name, val)
                        succeeded = True
                    except:
                        pass
            if not succeeded:
                print 'Unable to set "%s" property on %s' % (name, curr_axes)
  
        if props['pub']:
            if x <= nsubplots - props['subplot'][1]:
                plt.xlabel('  ')
                #set(curr_axes, 'XTickLabel', ' ')
  
        plt.grid(props['grid'])

    # add_pan_and_zoom_controls_to_figure(properties.figure, all_axes);
    return all_axes
示例#26
0
                         xticks=[-2, -1, 0, 1, 2],
                         ylim=[0, 1],
                         xlim=[-2, 2],
                         ylabel='P(choose sum)',
                         yticks=[0, .25, .5, .75, 1],
                         color=plt.cm.jet(cm_inds[si - 1]))
    #setup colorbar
    cmap_singplot = mpl.colors.ListedColormap(plt.cm.jet(cm_inds))
    norm = mpl.colors.BoundaryNorm(boundaries=np.insert(using_flatlo, 0, .5) +
                                   .5,
                                   ncolors=cmap_singplot.N)
    cbar = mpl.colorbar.ColorbarBase(ax[2],
                                     cmap=cmap_singplot,
                                     norm=norm,
                                     ticks=using)
    bbox = plt.get(ax[0], 'position')
    cbpos = plt.get(ax[2], 'position')
    #plt.tight_layout()
    #ax[2].set_position([cbpos.x0,cbpos.y0+.2,cbpos.width*.1,cbpos.height*.5])
    pdf.savefig()

    h, ax = plt.subplots(1, 2, figsize=[2 * width_per_panel, height_per_panel])
    Plotter.scatter(ax[0],
                    xdata=x_arithperf,
                    ydata=x_threshperf,
                    ylim=[.5, 1],
                    xlim=[.5, 1],
                    xlabel='Arithmetic strategy',
                    ylabel='Singleton-Thresholding Strategy',
                    title='Monkey X')
    Plotter.scatter(ax[1],
示例#27
0
def _plotall_plot_page(arrays, props, curr_page=0):
    narrays = len(arrays)
    nsubplots = min(narrays, np.prod(props['subplot']))
    subplots = curr_page * nsubplots + np.arange(nsubplots)

    # Pass 1: plot everything and align axes.
    if props['clf']:
        plt.clf()
    all_axes = []
    all_image_axes = []
    click_handlers = {}
    for n, x in enumerate(subplots):
        if x < 0 or x >= narrays or arrays[x] is None:
            all_axes.append(None)
            continue

        kwargs = {}
        if all_axes:
            if 'x' in props['align']:
                kwargs['sharex'] = all_axes[0]
            if 'y' in props['align']:
                kwargs['sharey'] = all_axes[0]
        curr_axes = plt.subplot(*props['subplots'][x], **kwargs)

        data = np.asarray(arrays[x])
        if _plotall_get_prop(props['transpose'], x):
            data = np.transpose(data)

        plotfun = _plotall_get_prop(props['plotfun'], x)
        plotfun(data)

        clickfun = props['clickfun']
        if clickfun:
            click_handlers[curr_axes] = _plotall_get_prop(clickfun, x)

        all_axes.append(curr_axes)
        if data.ndim == 2:
            xlim_max = data.shape[1] - 0.5
        else:
            xlim_max = len(data)
        plt.setp(curr_axes, 'xlim', [-0.5, xlim_max])
        if data.ndim == 2:
            all_image_axes.append(curr_axes)
            plt.setp(curr_axes, 'ylim', [-0.5, data.shape[0]-0.5])

        # Draw colorbars on all subplots (even if they are not images)
        # to keep axis widths consistent.
        if props['colorbar']:
            plt.colorbar()

    if 'x' in props['align']:
        align_axes('x', all_axes)
    for ax in ('y', 'c'):
        if ax in props['align']:
            align_axes(ax, all_image_axes)

    fig = plt.gcf()
    clickfun = functools.partial(_plotall_click_handler,
                                 click_handlers=click_handlers)
    cid = fig.canvas.mpl_connect("button_press_event", clickfun)

    # Pass 2: set specified axis properties.
    for x in subplots:
        if x < 0 or x >= narrays or arrays[x] is None:
            continue
        curr_axes = all_axes[x]
        if curr_axes is None:
            continue
        plt.axes(curr_axes)

        succeeded = False
        for name, val in props['other'].iteritems():
            val = _plotall_get_prop(val, x)
            if isinstance(val, types.FunctionType):
                val = val()

            try:
                plt.setp(curr_axes, name, val)
                succeeded = True
            except AttributeError:
                for curr_axes_child in plt.get(curr_axes, 'children'):
                    try:
                        plt.setp(curr_axes_child, name, val)
                        succeeded = True
                    except:
                        pass
            if not succeeded:
                print 'Unable to set "%s" property on %s' % (name, curr_axes)
  
        if props['pub']:
            if x <= nsubplots - props['subplot'][1]:
                plt.xlabel('  ')
                #set(curr_axes, 'XTickLabel', ' ')
  
        plt.grid(props['grid'])

    # add_pan_and_zoom_controls_to_figure(properties.figure, all_axes);
    return all_axes
示例#28
0
    fig = plt.figure(facecolor='w')
    ax1 = fig.add_subplot(2, 1, 1)
    ax1.plot(trainDay,
             np.array(data['rewardsEarned'][mouseInd])[sortInd], 'ko')

    ax2 = fig.add_subplot(2, 1, 2)
    ax2.plot(weighDay, data['weight'][mouseInd], 'ko')

    for i, (ax, ylbl) in enumerate(zip((ax1, ax2), ('Rewards', 'Weight (g)'))):
        for j, lbl in zip((handoffReady, rig, ephys),
                          ('handoff\nready', 'on rig', 'ephys')):
            x = trainDay[j] - 0.5
            ax.axvline(x, color='k')
            if i == 0:
                ylim = plt.get(ax, 'ylim')
                ax.text(x,
                        ylim[0] + 1.05 * (ylim[1] - ylim[0]),
                        lbl,
                        horizontalalignment='center',
                        verticalalignment='bottom')
        for side in ('right', 'top'):
            ax.spines[side].set_visible(False)
        ax.tick_params(direction='out', top=False, right=False)
        ax.set_xlim([-1, max(trainDay) + 1])
        if i == 1:
            ax.set_xlabel('Day')
        ax.set_ylabel(ylbl)

params = (rewardsEarned, dprimeEngaged, probEngaged)
labels = ('Rewards Earned', 'd prime', 'prob. engaged')
示例#29
0
def main():

    # name of starting ensDA output diagnostic file, starting index and measure
    [measure, fname, sOI, _] = get_input_arguments()

    # Ensemble sizes to compare
    Ne = [5, 10, 20, 30, 40, 50]

    # some more arguments, currently hard-coded
    save_figures = False         # save plots as eps
    yscale       = 'linear'      # y-axis of RMSE plots (linear/semilog)
    yFix         = None          # fix the y-axis of RMSE plots ( None = automatic )
    fOrient      = 'portrait'    # figure orientation (landscape/portrait)

    if ( not measure ): measure = 'truth'
    if ( sOI == -1 ): sOI = 0

    nf = len(Ne)
    fnames = []
    for i in range(0,nf): fnames.append(fname + '%d.nc4' % Ne[i])
    for i in range(0,nf): print fnames[i]

    if ( len(fnames) <= 15 ):
        fcolor = ["#000000", "#C0C0C0", "#808080", "#800000", "#FF0000",\
                  "#800080", "#FF00FF", "#008000", "#00FF00", "#808000",\
                  "#FFFF00", "#000080", "#0000FF", "#008080", "#00FFFF"]
        # black, silver, gray, maroon, red
        # purple, fuchsia, green, lime, olive
        # yellow, navy, blue, teal, aqua
    else:
        fcolor = get_Ndistinct_colors(len(fnames))

    # read dimensions and necessary attributes from the diagnostic file
    [model, DA, ensDA, _] = read_diag_info(fnames[0])

    if   ( ensDA.update == 1 ): estr = 'EnKF'
    elif ( ensDA.update == 2 ): estr = 'EnSRF'
    elif ( ensDA.update == 3 ): estr = 'EAKF'

    # allocate room for variables
    print 'computing RMSE against %s' % measure
    xbrmse = np.zeros((len(fnames),DA.nassim))
    xarmse = np.zeros((len(fnames),DA.nassim))
    xyrmse = np.zeros((len(fnames),DA.nassim))
    flabel = []
    blabel = []
    mean_prior     = np.zeros(len(fnames))
    mean_posterior = np.zeros(len(fnames))
    std_prior      = np.zeros(len(fnames))
    std_posterior  = np.zeros(len(fnames))
    mean_evratio   = np.zeros(len(fnames))
    std_evratio    = np.zeros(len(fnames))

    for fname in fnames:

        print 'reading ... %s' % fname
        f = fnames.index(fname)

        try:
            nc = Dataset(fname, mode='r', format='NETCDF4')
            flabel.append('Ne = %d' % len(nc.dimensions['ncopy']))
            blabel.append('%d' % len(nc.dimensions['ncopy']))
            nc.close()
        except Exception as Instance:
            print 'Exception occurred during read of ' + fname
            print type(Instance)
            print Instance.args
            print Instance
            sys.exit(1)

        # read the diagnostic file
        xt, Xb, Xa, y, _, _, evratio = read_diag(fname, 0, end_time=DA.nassim)

        # compute ensemble mean
        xbm = np.squeeze(np.mean(Xb, axis=1))
        xam = np.squeeze(np.mean(Xa, axis=1))

        # compute RMSE in prior, posterior and observations
        if ( measure == 'truth' ):
            xbrmse[f,] = np.sqrt( np.sum( (xt - xbm)**2, axis = 1) / model.Ndof )
            xarmse[f,] = np.sqrt( np.sum( (xt - xam)**2, axis = 1) / model.Ndof )
        else:
            xbrmse[f,] = np.sqrt( np.sum( (y - xbm)**2, axis = 1) / model.Ndof )
            xarmse[f,] = np.sqrt( np.sum( (y - xam)**2, axis = 1) / model.Ndof )
        xyrmse[f,] = np.sqrt( np.sum( (xt -  y)**2 ) / model.Ndof )

        # compute mean and std. dev. in the error-variance ratio
        mean_evratio[f] = np.mean(evratio[sOI+1:])
        std_evratio[f]  = np.std(evratio[sOI+1:], ddof=1)

    # start plotting

    #-----------------------------------------------------------
    fig = pyplot.figure()
    pyplot.clf()
    pyplot.hold(True)
    for fname in fnames:
        f = fnames.index(fname)
        q = np.squeeze(xbrmse[f,sOI:])
        if   ( yscale == 'linear'  ): pyplot.plot(    q,'-',color=fcolor[f],label=flabel[f],linewidth=1)
        elif ( yscale == 'semilog' ): pyplot.semilogy(q,'-',color=fcolor[f],label=flabel[f],linewidth=1)

    yl = pyplot.get(pyplot.gca(),'ylim')
    xl = pyplot.get(pyplot.gca(),'xlim')
    if ( yFix is None ): ymax = yl[1]
    else:                ymax = yFix
    pyplot.ylim(0.0, ymax)
    pyplot.xlim(0.0, len(q))

    for fname in fnames:
        f = fnames.index(fname)
        q = np.squeeze(xbrmse[f,sOI:])
        mean_prior[f] = np.mean(q)
        std_prior[f]  = np.std(q,ddof=1)
        str = 'mean rmse : %5.4f +/- %5.4f' % (np.mean(q), np.std(q,ddof=1))
        pyplot.text(25,(1-0.05*(f+1))*ymax,str,color=fcolor[f],fontsize=10)

    pyplot.xlabel('Assimilation Cycle',fontweight='bold',fontsize=12)
    pyplot.ylabel('RMSE',fontweight='bold',fontsize=12)
    pyplot.title('RMSE - Prior',fontweight='bold',fontsize=14)
    pyplot.legend(loc=1)
    pyplot.hold(False)
    if save_figures:
        fig.savefig('%s_ensDA_RMSE_Prior.eps' % (model.Name),dpi=300,orientation=fOrient,format='eps')
    #-----------------------------------------------------------

    #-----------------------------------------------------------
    fig = pyplot.figure()
    pyplot.clf()
    pyplot.hold(True)
    for fname in fnames:
        f = fnames.index(fname)
        q = np.squeeze(xarmse[f,sOI:])
        if   ( yscale == 'linear'  ): pyplot.plot(    q,'-',color=fcolor[f],label=flabel[f],linewidth=1)
        elif ( yscale == 'semilog' ): pyplot.semilogy(q,'-',color=fcolor[f],label=flabel[f],linewidth=1)

    yl = pyplot.get(pyplot.gca(),'ylim')
    xl = pyplot.get(pyplot.gca(),'xlim')
    if ( yFix is None ): ymax = yl[1]
    else:                ymax = yFix
    pyplot.ylim(0.0, ymax)
    pyplot.xlim(0.0, len(q))

    for fname in fnames:
        f = fnames.index(fname)
        q = np.squeeze(xarmse[f,sOI:])
        mean_posterior[f] = np.mean(q)
        std_posterior[f]  = np.std(q,ddof=1)
        str = 'mean rmse : %5.4f +/- %5.4f' % (np.mean(q), np.std(q,ddof=1))
        pyplot.text(25,(1-0.05*(f+1))*ymax,str,color=fcolor[f],fontsize=10)

    pyplot.xlabel('Assimilation Cycle',fontweight='bold',fontsize=12)
    pyplot.ylabel('RMSE',fontweight='bold',fontsize=12)
    pyplot.title('RMSE - Posterior',fontweight='bold',fontsize=14)
    pyplot.legend(loc=1)
    pyplot.hold(False)
    if save_figures:
        fig.savefig('%s_ensDA_RMSE_Posterior.eps' % (model.Name),dpi=300,orientation=fOrient,format='eps')
    #-----------------------------------------------------------

    #-----------------------------------------------------------
    fig = pyplot.figure()
    pyplot.clf()
    pyplot.hold(True)

    index = np.arange(nf) + 0.15
    width = 0.35

    pyplot.bar(index,mean_prior,width,linewidth=0.0,color='0.75',edgecolor='0.75',yerr=std_prior, error_kw=dict(ecolor='black',elinewidth=3,capsize=5))
    pyplot.bar(index+width,mean_posterior,width,linewidth=0.0,color='gray',edgecolor='gray',yerr=std_posterior,error_kw=dict(ecolor='black',elinewidth=3,capsize=5))

    pyplot.xticks(index+width, blabel)

    pyplot.xlabel('Ensemble Size', fontweight='bold',fontsize=12)
    pyplot.ylabel('RMSE',          fontweight='bold',fontsize=12)
    pyplot.title( 'RMSE',          fontweight='bold',fontsize=14)
    pyplot.hold(False)
    if save_figures:
        fig.savefig('%s_ensDA_RMSE.eps' % (model.Name),dpi=300,orientation=fOrient,format='eps')
    #-----------------------------------------------------------

    #-----------------------------------------------------------
    fig = pyplot.figure()
    pyplot.clf()
    pyplot.hold(True)

    index = np.arange(nf) + 0.2
    width = 0.6

    pyplot.bar(index,mean_evratio,width,linewidth=0.0,color='gray',edgecolor='gray',yerr=std_evratio,error_kw=dict(ecolor='black',elinewidth=3,capsize=5))

    pyplot.xticks(index+width/2, blabel)

    pyplot.xlabel('Ensemble Size',          fontweight='bold',fontsize=12)
    pyplot.ylabel('Error - Variance Ratio', fontweight='bold',fontsize=12)
    pyplot.title( 'Error - Variance Ratio', fontweight='bold',fontsize=14)
    pyplot.hold(False)
    if save_figures:
        fig.savefig('%s_ensDA_evratio.eps' % (model.Name),dpi=300,orientation=fOrient,format='eps')
    #-----------------------------------------------------------

    if not save_figures: pyplot.show()
    print '... all done ...'
    sys.exit(0)
示例#30
0
def main():
    ipshell = IPShellEmbed()
    if len(sys.argv) < 2:
        logfilename = 'log.csv'  # use default filename
        print 'No input filename specified: using %s' % logfilename
    else:
        logfilename = sys.argv[1]
    if not os.path.exists(logfilename):
        print '%s does not exist!' % logfilename
        sys.exit()
    else:
        print 'Reading file %s' % logfilename
    if len(sys.argv) < 3:
        pngfilename = None
        print 'No output filename specified: will not write output file for plot'
    else:
        pngfilename = sys.argv[2]
        print 'Plot will be saved as %s' % pngfilename
    data = np.genfromtxt(logfilename,
                         delimiter=',',
                         skip_header=6,
                         usecols=(0, 1, 3, 4, 5, 6, 7, 8, 9))
    t = data[:, 0]
    stamp = data[:, 1]
    lm61temp = data[:, 2]
    #therm1 = data[:,3]
    therm1 = np.ma.masked_where(np.isnan(data[:, 3]), data[:, 3])
    therm2 = data[:, 4]
    temp0 = data[:, 5]
    #temp1 = data[:,6]
    # use masked array rather than nan for bad values
    data[np.where(data[:, 6] > MAXTEMP), 6] = np.nan
    data[np.where(data[:, 7] > MAXTEMP), 7] = np.nan
    data[np.where(data[:, 8] > MAXTEMP), 8] = np.nan
    temp1 = np.ma.masked_where(np.isnan(data[:, 6]), data[:, 6])
    temp2 = np.ma.masked_where(np.isnan(data[:, 7]), data[:, 7])
    temp3 = np.ma.masked_where(np.isnan(data[:, 8]), data[:, 8])

    offset = stamp[1] - t[1] / 1000
    print offset
    maxstamp = t[len(t) - 1] / 1000 + offset + MAXSEC
    print maxstamp
    stamp[stamp < offset] = np.nan
    stamp[stamp > maxstamp] = np.nan
    stamp[abs(stamp - t / 1000 - offset) > MAXSEC] = np.nan
    nancount = np.sum(np.isnan(stamp))
    print '%d bad time stamps to interpolate' % nancount
    # extrapolate - see
    # http://stackoverflow.com/questions/1599754/is-there-easy-way-in-python-to-extrapolate-data-points-to-the-future
    extrapolator = UnivariateSpline(t[np.isfinite(stamp)],
                                    stamp[np.isfinite(stamp)],
                                    k=1)
    utime = extrapolator(t)

    # plot 6 columns
    pyplot.plot(dates.epoch2num(utime), lm61temp, '.', dates.epoch2num(utime),
                therm1, '.', dates.epoch2num(utime), therm2, '.',
                dates.epoch2num(utime), temp1, '.', dates.epoch2num(utime),
                temp2, '.', dates.epoch2num(utime), temp3, '.')
    ax = pyplot.gca()
    ax.legend(('LM61', 'Thermistor 1', 'Thermistor 2', 'digital 1',
               'digital 2', 'digital 3'),
              loc=0)
    ax.set_xlabel('Time')
    ax.set_ylabel(u'Temp (°C)')
    ax2 = ax.twinx()
    clim = pyplot.get(ax, 'ylim')
    ax2.set_ylim(c2f(clim[0]), c2f(clim[1]))
    ax2.set_ylabel(u'Temp (°F)')
    xlocator = dates.AutoDateLocator()
    xformatter = dates.AutoDateFormatter(xlocator)
    pyplot.gca().xaxis.set_major_locator(xlocator)
    pyplot.gca().xaxis.set_major_formatter(dates.DateFormatter('%H:%M'))
    # generate a PNG file
    if pngfilename:
        pyplot.savefig(pngfilename)
    # show the plot
    pyplot.show()
    # open interactive shell
    ipshell()
def main():
    # Import iris data
    iris = datasets.load_iris()
    x = iris.data[:, :2]  # take the first two features.
    y = iris.target  # label

    # Splitting data into train, validation and test set
    # 50% training set, 20% validation set, 30% test set
    x_train, x_tmp, y_train, y_tmp = train_test_split(x,
                                                      y,
                                                      test_size=0.5,
                                                      random_state=42)
    x_validate, x_test, y_validate, y_test = train_test_split(x_tmp,
                                                              y_tmp,
                                                              test_size=0.4,
                                                              random_state=42)

    c = [10**(-3), 10**(-2), 10**(-1), 10**0, 10**1, 10**2, 10**3]
    g = [10**(-9), 10**(-7), 10**(-5), 10**(-3)]
    #c = [10**(-2), 10**(-1), 10**0, 10**1, 10**2, 10**3, 10**4, 10**5, 10**6, 10**7, 10**8, 10**9, 10**10]
    #g = [10**(-9), 10**(-8), 10**(-7), 10**(-6), 10**(-5), 10**(-4), 10**(-3), 10**(-2), 10**(-1), 10**0, 10**1, 10**2, 10**3]
    best_values = [-1, -1,
                   -1]  # respectively best success rate, best C and best gamma
    a = [
    ]  # rows are C values and columns are gamma values, each cell is the accuracy for the corresponding C and gamma

    plt.figure('SVC with rbf-kernel', figsize=(30, 20))
    k = 1
    for i in c:
        values = []
        for j in g:
            clf = svm.SVC(kernel='rbf', C=i, gamma=j)
            clf.fit(x_train, y_train)

            # create a mesh to plot in
            x_min, x_max = x_train[:, 0].min() - 1, x_train[:, 0].max() + 1
            y_min, y_max = x_train[:, 1].min() - 1, x_train[:, 1].max() + 1
            h = (x_max / x_min) / 100
            xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                                 np.arange(y_min, y_max, h))

            z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
            z = z.reshape(xx.shape)

            plt.subplot(len(c), len(g), k)
            title = 'C=' + str(i) + ' and gamma=' + str(j)
            plt.title(title, fontsize=30)
            plt.contourf(xx, yy, z, cmap=plt.get('Paired'), alpha=0.8)
            plt.scatter(x_train[:, 0],
                        x_train[:, 1],
                        c=y_train,
                        cmap=plt.get('Paired'))
            plt.xlim(xx.min(), xx.max())

            print('With C=' + str(i) + ' and gamma=' + str(j))
            full_prediction = clf.predict(x_validate)
            print(
                '[-] Number of mislabeled points out of a total %d points: %d'
                % (len(y_validate), (y_validate != full_prediction).sum()))
            accuracy = (
                100 *
                (len(y_validate) -
                 (y_validate != full_prediction).sum())) / len(y_validate)
            print('[-] With an accuracy of %.3f%s' % (accuracy, '%'))

            if accuracy > best_values[0]:
                best_values = accuracy, i, j

            k += 1
            values.append(accuracy)

        a.append(values)
    plt.show()
    plt.close()

    # 2D heatmap validation accuracy
    plt.title('Validation Accuracy')
    plt.xlabel('gamma')
    plt.ylabel('C')
    plt.imshow(a, cmap='hot', interpolation='nearest')
    plt.show()
    plt.close()

    print('\nBest C=' + str(best_values[1]) + ' and best gamma=' +
          str(best_values[2]))

    # With the best C and gamma evaluating test set
    print('Evaluating test set')
    clf = svm.SVC(kernel='rbf', C=best_values[1], gamma=best_values[2])
    clf.fit(x_train, y_train)

    x_min, x_max = x_train[:, 0].min() - 1, x_train[:, 0].max() + 1
    y_min, y_max = x_train[:, 1].min() - 1, x_train[:, 1].max() + 1
    h = (x_max / x_min) / 100
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                         np.arange(y_min, y_max, h))

    z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
    z = z.reshape(xx.shape)

    title = 'C=' + str(best_values[1]) + ' and gamma=' + str(best_values[2])
    plt.title(title, fontsize=20)
    plt.contourf(xx, yy, z, cmap=plt.get('Paired'), alpha=0.8)
    plt.scatter(x_train[:, 0],
                x_train[:, 1],
                c=y_train,
                cmap=plt.get('Paired'))
    plt.xlim(xx.min(), xx.max())

    full_prediction = clf.predict(x_test)
    print('[-] Number of mislabeled points out of a total %d points: %d' %
          (len(y_test), (y_test != full_prediction).sum()))
    print('[-] With an accuracy of: %.3f%s' %
          ((100 * (len(y_test) -
                   (y_test != full_prediction).sum())) / len(y_test), '%'))

    plt.show()
    plt.close()
示例#32
0

HorizontalSize = 4
VerticalSize   = 4
figMSC=plt.figure(num=2,figsize=(HorizontalSize,VerticalSize), edgecolor='k', facecolor = [1,1,0.92]);
figMSC.clf()

hs = plt.plot(listC0,CI[:,2,:])
plt.grid(True)
plt.hold(True)
MSC0indselect=90
for im in range(LN):
    tt = '$N_d$ = %i' %listNd[im]
    h=plt.plot(listC0[MSC0indselect],CI[MSC0indselect,2,im],'o', 
               label=tt);
    cc = plt.get(hs[im],'color');
    plt.setp(h,color=cc)
    if im==0:
        ha=plt.arrow(listC0[MSC0indselect]+0.01,CI[MSC0indselect,2,im]+0.01,
                  -0.005,-0.005, head_width=0.004)

plt.hold(False)
plt.xlim([0.85, 0.93])
plt.ylim([0.89, 1])
plt.legend(loc='best')

dirfigsave = '/Users/maurice/etudes/ctbto/allJOBs2015/reponsesdevelop/rep2'
tt='%s/MSCthreshold2.pdf' %dirfigsave
figMSC.savefig(tt,format='pdf')

示例#33
0
def main():

    # name of starting hybrid output diagnostic file, starting index and no. of files
    [measure, fname, sOI, _] = get_input_arguments()

    # alpha, beta to compare
    vary_variable = 'alpha'
    beta = [0.0, 0.5, 0.75, 1.00]
    alpha = [0.5, 1.0, 2.0, 2.6]

    # some more arguments, currently hard-coded
    save_figures = False         # save plots as eps
    yscale       = 'linear'      # y-axis of RMSE plots (linear/semilog)
    yFix         = None          # fix the y-axis of RMSE plots ( None = automatic )
    fOrient      = 'portrait'    # figure orientation (landscape/portrait)

    if ( not measure ): measure = 'truth'

    if ( sOI == -1 ): sOI = 0

    fnames = []
    if   ( vary_variable == 'alpha'):
        nf = len(alpha)
        for i in range(0,nf):
            fnames.append( fname + '_beta=%3.2f' % beta[0] + '_alpha=%2.1f' % alpha[i] + '.nc4' )
    elif ( vary_variable == 'beta' ):
        nf = len(beta)
        for i in range(0,nf):
            fnames.append( fname + '_beta=%3.2f' % beta[i] + '_alpha=%2.1f' % alpha[0] + '.nc4' )

    if ( len(fnames) <= 15 ):
        fcolor = ["#000000", "#C0C0C0", "#808080", "#800000", "#FF0000",\
                  "#800080", "#FF00FF", "#008000", "#00FF00", "#808000",\
                  "#FFFF00", "#000080", "#0000FF", "#008080", "#00FFFF"]
        # black, silver, gray, maroon, red
        # purple, fuchsia, green, lime, olive
        # yellow, navy, blue, teal, aqua
    else:
        fcolor = get_Ndistinct_colors(len(fnames))

    # read dimensions and necessary attributes from the diagnostic file
    [model, DA, ensDA, varDA] = read_diag_info(fnames[0])

    if   ( ensDA.update == 1 ): estr = 'EnKF'
    elif ( ensDA.update == 2 ): estr = 'EnSRF'
    elif ( ensDA.update == 3 ): estr = 'EAKF'
    if   ( varDA.update == 1 ): vstr = '3D'
    elif ( varDA.update == 2 ): vstr = '4D'

    # allocate room for variables
    print 'computing RMSE against %s' % measure
    xbrmseE = np.zeros((len(fnames),DA.nassim))
    xarmseE = np.zeros((len(fnames),DA.nassim))
    xbrmseC = np.zeros((len(fnames),DA.nassim))
    xarmseC = np.zeros((len(fnames),DA.nassim))
    xyrmse  = np.zeros((len(fnames),DA.nassim))
    flabel  = []
    blabel  = []
    mean_prior_C     = np.zeros(len(fnames))
    mean_prior_E     = np.zeros(len(fnames))
    mean_posterior_C = np.zeros(len(fnames))
    mean_posterior_E = np.zeros(len(fnames))
    std_prior_C      = np.zeros(len(fnames))
    std_prior_E      = np.zeros(len(fnames))
    std_posterior_C  = np.zeros(len(fnames))
    std_posterior_E  = np.zeros(len(fnames))

    for fname in fnames:

        print 'reading ... %s' % fname
        f = fnames.index(fname)

        try:
            nc = Dataset(fname, mode='r', format='NETCDF4')
            if   ( vary_variable == 'alpha' ):
                flabel.append(r'$\alpha$ = %2.1f' % alpha[f])
                blabel.append('%2.1f' % alpha[f])
            elif ( vary_variable == 'beta' ):
                flabel.append(r'$\beta$ = %3.2f' % nc.hybrid_wght)
                blabel.append('%3.2f' % nc.hybrid_wght)
            nc.close()
        except Exception as Instance:
            print 'Exception occurred during read of ' + fname
            print type(Instance)
            print Instance.args
            print Instance
            sys.exit(1)

        # read the diagnostic file
        xt, Xb, Xa, y, _, _, xbc, xac, _, _ = read_diag(fname, 0, end_time=DA.nassim)

        # compute ensemble mean
        xbm = np.squeeze(np.mean(Xb, axis=1))
        xam = np.squeeze(np.mean(Xa, axis=1))

        # compute RMSE in prior, posterior and observations
        if ( measure == 'truth' ):
            xbrmseE[f,] = np.sqrt( np.sum( (xt - xbm)**2, axis = 1) / model.Ndof )
            xarmseE[f,] = np.sqrt( np.sum( (xt - xam)**2, axis = 1) / model.Ndof )
            xbrmseC[f,] = np.sqrt( np.sum( (xt - xbc)**2, axis = 1) / model.Ndof )
            xarmseC[f,] = np.sqrt( np.sum( (xt - xac)**2, axis = 1) / model.Ndof )
        else:
            xbrmseE[f,] = np.sqrt( np.sum( (y - xbm)**2, axis = 1) / model.Ndof )
            xarmseE[f,] = np.sqrt( np.sum( (y - xam)**2, axis = 1) / model.Ndof )
            xbrmseC[f,] = np.sqrt( np.sum( (y - xbc)**2, axis = 1) / model.Ndof )
            xarmseC[f,] = np.sqrt( np.sum( (y - xac)**2, axis = 1) / model.Ndof )
        xyrmse[f,] = np.sqrt( np.sum( (xt - y)**2 ) / model.Ndof )

    # start plotting

    #-----------------------------------------------------------
    fig = pyplot.figure()
    pyplot.clf()
    pyplot.hold(True)
    for fname in fnames:
        f = fnames.index(fname)
        q = np.squeeze(xbrmseE[f,sOI:])
        if   ( yscale == 'linear'  ): pyplot.plot(    q,'-',color=fcolor[f],label=flabel[f],linewidth=1)
        elif ( yscale == 'semilog' ): pyplot.semilogy(q,'-',color=fcolor[f],label=flabel[f],linewidth=1)

    yl = pyplot.get(pyplot.gca(),'ylim')
    xl = pyplot.get(pyplot.gca(),'xlim')
    if ( yFix is None ): ymax = yl[1]
    else:                ymax = yFix
    pyplot.ylim(0.0, ymax)
    pyplot.xlim(0.0, len(np.squeeze(xbrmseE[f,sOI:])))

    for fname in fnames:
        f = fnames.index(fname)
        q = np.squeeze(xbrmseE[f,sOI:])
        mean_prior_E[f] = np.mean(q)
        std_prior_E[f]  = np.std(q,ddof=1)
        str = 'mean rmse : %5.4f +/- %5.4f' % (np.mean(q), np.std(q,ddof=1))
        pyplot.text(25,(1-0.05*(f+1))*ymax,str,color=fcolor[f],fontsize=10)

    pyplot.xlabel('Assimilation Cycle',fontweight='bold',fontsize=12)
    pyplot.ylabel('RMSE',fontweight='bold',fontsize=12)
    pyplot.title('RMSE - %s Prior' % estr,fontweight='bold',fontsize=14)
    pyplot.legend(loc=1)
    pyplot.hold(False)
    if save_figures:
        fig.savefig('%s_%shybDA_RMSE_%s_Prior.eps' % (model.Name, vstr, estr),dpi=300,orientation=fOrient,format='eps')
    #-----------------------------------------------------------

    #-----------------------------------------------------------
    fig = pyplot.figure()
    pyplot.clf()
    pyplot.hold(True)
    for fname in fnames:
        f = fnames.index(fname)
        q = np.squeeze(xbrmseC[f,sOI:])
        mean_prior_C[f] = np.mean(q)
        std_prior_C[f]  = np.std(q,ddof=1)
        if   ( yscale == 'linear'  ): pyplot.plot(    q,'-',color=fcolor[f],label=flabel[f],linewidth=1)
        elif ( yscale == 'semilog' ): pyplot.semilogy(q,'-',color=fcolor[f],label=flabel[f],linewidth=1)

    yl = pyplot.get(pyplot.gca(),'ylim')
    xl = pyplot.get(pyplot.gca(),'xlim')
    if ( yFix is None ): ymax = yl[1]
    else:                ymax = yFix
    pyplot.ylim(0.0, ymax)
    pyplot.xlim(0.0, len(np.squeeze(xbrmseC[f,sOI:])))

    for fname in fnames:
        f = fnames.index(fname)
        q = np.squeeze(xbrmseC[f,sOI:])
        str = 'mean rmse : %5.4f +/- %5.4f' % (np.mean(q), np.std(q,ddof=1))
        pyplot.text(25,(1-0.05*(f+1))*ymax,str,color=fcolor[f],fontsize=10)

    pyplot.xlabel('Assimilation Cycle',fontweight='bold',fontsize=12)
    pyplot.ylabel('RMSE',fontweight='bold',fontsize=12)
    pyplot.title('RMSE - %sVar Prior' % (vstr), fontweight='bold',fontsize=14)
    pyplot.legend(loc=1)
    pyplot.hold(False)
    if save_figures:
        fig.savefig('%s_%shybDA_RMSE_%sVar_Prior.eps' % (model.Name, vstr, vstr),dpi=300,orientation=fOrient,format='eps')
    #-----------------------------------------------------------

    #-----------------------------------------------------------
    fig = pyplot.figure()
    pyplot.clf()
    pyplot.hold(True)
    for fname in fnames:
        f = fnames.index(fname)
        q = np.squeeze(xarmseE[f,sOI:])
        if   ( yscale == 'linear'  ): pyplot.plot(    q,'-',color=fcolor[f],label=flabel[f],linewidth=1)
        elif ( yscale == 'semilog' ): pyplot.semilogy(q,'-',color=fcolor[f],label=flabel[f],linewidth=1)

    yl = pyplot.get(pyplot.gca(),'ylim')
    xl = pyplot.get(pyplot.gca(),'xlim')
    if ( yFix is None ): ymax = yl[1]
    else:                ymax = yFix
    pyplot.ylim(0.0, ymax)
    pyplot.xlim(0.0, len(np.squeeze(xarmseE[f,sOI:])))

    for fname in fnames:
        f = fnames.index(fname)
        q = np.squeeze(xarmseE[f,sOI:])
        mean_posterior_E[f] = np.mean(q)
        std_posterior_E[f]  = np.std(q,ddof=1)
        str = 'mean rmse : %5.4f +/- %5.4f' % (np.mean(q), np.std(q,ddof=1))
        pyplot.text(25,(1-0.05*(f+1))*ymax,str,color=fcolor[f],fontsize=10)

    pyplot.xlabel('Assimilation Cycle',fontweight='bold',fontsize=12)
    pyplot.ylabel('RMSE',fontweight='bold',fontsize=12)
    pyplot.title('RMSE - %s Posterior' % estr,fontweight='bold',fontsize=14)
    pyplot.legend(loc=1)
    pyplot.hold(False)
    if save_figures:
        fig.savefig('%s_%shybDA_RMSE_%s_Posterior.eps' % (model.Name, vstr, estr),dpi=300,orientation=fOrient,format='eps')
    #-----------------------------------------------------------

    #-----------------------------------------------------------
    fig = pyplot.figure()
    pyplot.clf()
    pyplot.hold(True)
    for fname in fnames:
        f = fnames.index(fname)
        q = np.squeeze(xarmseC[f,sOI:])
        if   ( yscale == 'linear'  ): pyplot.plot(    q,'-',color=fcolor[f],label=flabel[f],linewidth=1)
        elif ( yscale == 'semilog' ): pyplot.semilogy(q,'-',color=fcolor[f],label=flabel[f],linewidth=1)

    yl = pyplot.get(pyplot.gca(),'ylim')
    xl = pyplot.get(pyplot.gca(),'xlim')
    if ( yFix is None ): ymax = yl[1]
    else:                ymax = yFix
    pyplot.ylim(0.0, ymax)
    pyplot.xlim(0.0, len(np.squeeze(xarmseC[f,sOI:])))

    for fname in fnames:
        f = fnames.index(fname)
        q = np.squeeze(xarmseC[f,sOI:])
        mean_posterior_C[f] = np.mean(q)
        std_posterior_C[f]  = np.std(q,ddof=1)
        str = 'mean rmse : %5.4f +/- %5.4f' % (np.mean(q), np.std(q,ddof=1))
        pyplot.text(25,(1-0.05*(f+1))*ymax,str,color=fcolor[f],fontsize=10)

    pyplot.xlabel('Assimilation Cycle',fontweight='bold',fontsize=12)
    pyplot.ylabel('RMSE',fontweight='bold',fontsize=12)
    pyplot.title('RMSE - %sVar Posterior' % (vstr),fontweight='bold',fontsize=14)
    pyplot.legend(loc=1)
    pyplot.hold(False)
    if save_figures:
        fig.savefig('%s_%shybDA_RMSE_%sVar_Posterior.eps' % (model.Name, vstr, vstr),dpi=300,orientation=fOrient,format='eps')
    #-----------------------------------------------------------

    #-----------------------------------------------------------
    fig = pyplot.figure()
    pyplot.clf()
    pyplot.hold(True)

    index = np.arange(nf) + 0.15
    width = 0.35

    pyplot.bar(index,mean_prior_E,width,linewidth=0.0,color='0.75',edgecolor='0.75',yerr=std_prior_E, error_kw=dict(ecolor='black',elinewidth=3,capsize=5))
    pyplot.bar(index+width,mean_posterior_E,width,linewidth=0.0,color='gray',edgecolor='gray',yerr=std_posterior_E,error_kw=dict(ecolor='black',elinewidth=3,capsize=5))

    pyplot.xticks(index+width, blabel)

    pyplot.xlabel(r'$\%s$' % vary_variable,fontweight='bold',fontsize=12)
    pyplot.ylabel('RMSE',                  fontweight='bold',fontsize=12)
    pyplot.title('RMSE - %s' % estr,       fontweight='bold',fontsize=14)
    pyplot.hold(False)
    if save_figures:
        fig.savefig('%s_%shybDA_RMSE_%s.eps' % (model.Name, vstr, estr),dpi=300,orientation=fOrient,format='eps')
    #-----------------------------------------------------------

    #-----------------------------------------------------------
    fig = pyplot.figure()
    pyplot.clf()
    pyplot.hold(True)

    index = np.arange(nf) + 0.15
    width = 0.35

    pyplot.bar(index,mean_prior_C,width,linewidth=0.0,color='0.75',edgecolor='0.75',yerr=std_prior_C, error_kw=dict(ecolor='black',elinewidth=3,capsize=5))
    pyplot.bar(index+width,mean_posterior_C,width,linewidth=0.0,color='gray',edgecolor='gray',yerr=std_posterior_C,error_kw=dict(ecolor='black',elinewidth=3,capsize=5))

    pyplot.xticks(index+width, blabel)

    pyplot.xlabel(r'$\%s$' % vary_variable ,fontweight='bold',fontsize=12)
    pyplot.ylabel('RMSE',                   fontweight='bold',fontsize=12)
    pyplot.title('RMSE - %sVar' % (vstr),   fontweight='bold',fontsize=14)
    pyplot.hold(False)
    if save_figures:
        fig.savefig('%s_%shybDA_RMSE_%sVar.eps' % (model.Name, vstr, vstr),dpi=300,orientation=fOrient,format='eps')
    #-----------------------------------------------------------

    if not save_figures: pyplot.show()
    print '... all done ...'
    sys.exit(0)
def main():
    # Import iris data
    iris = datasets.load_iris()
    x = iris.data[:, :2]  # take the first two features.
    y = iris.target  # label

    # Splitting data into train, validation and test set
    # 50% training set, 20% validation set, 30% test set
    x_train, x_tmp, y_train, y_tmp = train_test_split(x,
                                                      y,
                                                      test_size=0.5,
                                                      random_state=42)
    x_validate, x_test, y_validate, y_test = train_test_split(x_tmp,
                                                              y_tmp,
                                                              test_size=0.4,
                                                              random_state=42)

    c = [10**(-3), 10**(-2), 10**(-1), 10**0, 10**1, 10**2, 10**3]
    best_values = [-1, -1]  # respectively best success rate and best C
    k = 1

    plt.figure('SVC with linear kernel')
    plt.figure(figsize=(30, 20))
    for i in c:
        clf = svm.SVC(kernel='linear', C=i)
        clf.fit(x_train, y_train)

        # create a mesh to plot in
        x_min, x_max = x_train[:, 0].min() - 1, x_train[:, 0].max() + 1
        y_min, y_max = x_train[:, 1].min() - 1, x_train[:, 1].max() + 1
        h = (x_max / x_min) / 100
        xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                             np.arange(y_min, y_max, h))

        z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
        z = z.reshape(xx.shape)

        plt.subplot(3, 3, k)
        title = 'C=' + str(i)
        plt.title(title, fontsize=30)
        plt.contourf(xx, yy, z, cmap=plt.get('Paired'), alpha=0.8)
        plt.scatter(x_train[:, 0],
                    x_train[:, 1],
                    c=y_train,
                    cmap=plt.get('Paired'))
        plt.xlim(xx.min(), xx.max())

        print('With C=' + str(i))
        accuracy = clf.score(x_validate, y_validate)
        print('[-] Accuracy of ' + str(accuracy * 100) + '%')
        """
        full_prediction = clf.predict(x_validate)
        print('[-] Number of mislabeled points out of a total %d points: %d'
              % (len(y_validate), (y_validate != full_prediction).sum()))
        accuracy = (100 * (len(y_validate) - (y_validate != full_prediction).sum())) / len(y_validate)
        print('[-] With an accuracy of %.3f%s'
              % (accuracy, '%'))
        """

        if accuracy > best_values[0]:
            best_values = accuracy, i

        k += 1

    plt.show()
    plt.close()

    print('\nBest values of C=' + str(best_values[1]))

    # With the best C evaluating test set
    print('Evaluating test set')
    clf = svm.SVC(kernel='linear', C=best_values[1])
    clf.fit(x_train, y_train)

    x_min, x_max = x_train[:, 0].min() - 1, x_train[:, 0].max() + 1
    y_min, y_max = x_train[:, 1].min() - 1, x_train[:, 1].max() + 1
    h = (x_max / x_min) / 100
    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                         np.arange(y_min, y_max, h))

    z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
    z = z.reshape(xx.shape)

    title = 'C=' + str(best_values[1])
    plt.title(title, fontsize=30)
    plt.contourf(xx, yy, z, cmap=plt.get('Paired'), alpha=0.8)
    plt.scatter(x_train[:, 0],
                x_train[:, 1],
                c=y_train,
                cmap=plt.get('Paired'))
    plt.xlim(xx.min(), xx.max())

    accuracy = clf.score(x_test, y_test)
    print('[-] Accuracy of ' + str(accuracy * 100) + '%')
    """""
    full_prediction = clf.predict(x_test)
    print('[-] Number of mislabeled points out of a total %d points: %d'
          % (len(y_test), (y_test != full_prediction).sum()))
    print('[-] With an accuracy of %.3f%s'
          % ((100 * (len(y_test) - (y_test != full_prediction).sum())) / len(y_test), '%'))
    """

    plt.show()
    plt.close()
示例#35
0
def main():
    ipshell = IPShellEmbed()
    if len(sys.argv) < 2:
        logfilename = 'log.csv'         # use default filename
	print 'No input filename specified: using %s' % logfilename
    else:
        logfilename = sys.argv[1]
    if not os.path.exists(logfilename):
        print '%s does not exist!' % logfilename
        sys.exit()
    else:
        print 'Reading file %s' % logfilename
    if len(sys.argv) < 3:
        pngfilename = None
	print 'No output filename specified: will not write output file for plot'
    else:
        pngfilename = sys.argv[2]
        print 'Plot will be saved as %s' % pngfilename
    data = np.genfromtxt(logfilename, delimiter=',', skip_header=6, usecols = (0, 1, 3, 4, 5, 6, 7, 8, 9))
    t = data[:,0]
    stamp = data[:,1]
    lm61temp = data[:,2]
    #therm1 = data[:,3]
    therm1 = np.ma.masked_where(np.isnan(data[:,3]), data[:,3])
    therm2 = data[:,4]
    temp0 = data[:,5]
    #temp1 = data[:,6]
    # use masked array rather than nan for bad values
    data[np.where(data[:,6] > MAXTEMP),6] = np.nan
    data[np.where(data[:,7] > MAXTEMP),7] = np.nan
    data[np.where(data[:,8] > MAXTEMP),8] = np.nan
    temp1 = np.ma.masked_where(np.isnan(data[:,6]), data[:,6])
    temp2 = np.ma.masked_where(np.isnan(data[:,7]), data[:,7])
    temp3 = np.ma.masked_where(np.isnan(data[:,8]), data[:,8])

    offset = stamp[1] - t[1] / 1000
    print offset
    maxstamp = t[len(t)-1] / 1000 + offset + MAXSEC
    print maxstamp
    stamp[stamp<offset] = np.nan
    stamp[stamp>maxstamp] = np.nan
    stamp[abs(stamp-t/1000-offset) > MAXSEC] = np.nan
    nancount = np.sum(np.isnan(stamp))
    print '%d bad time stamps to interpolate' % nancount
    # extrapolate - see
    # http://stackoverflow.com/questions/1599754/is-there-easy-way-in-python-to-extrapolate-data-points-to-the-future
    extrapolator = UnivariateSpline(t[np.isfinite(stamp)],stamp[np.isfinite(stamp)], k=1 )
    utime = extrapolator(t)

    # plot 6 columns
    pyplot.plot(dates.epoch2num(utime),lm61temp,'.',dates.epoch2num(utime),therm1,'.',dates.epoch2num(utime),therm2,'.',dates.epoch2num(utime),temp1,'.',dates.epoch2num(utime),temp2,'.',dates.epoch2num(utime),temp3,'.')
    ax = pyplot.gca()
    ax.legend(('LM61','Thermistor 1','Thermistor 2','digital 1','digital 2','digital 3'),loc=0)
    ax.set_xlabel('Time')
    ax.set_ylabel(u'Temp (°C)')
    ax2 = ax.twinx()
    clim = pyplot.get(ax,'ylim')
    ax2.set_ylim(c2f(clim[0]),c2f(clim[1]))
    ax2.set_ylabel(u'Temp (°F)')
    xlocator = dates.AutoDateLocator()
    xformatter = dates.AutoDateFormatter(xlocator)
    pyplot.gca().xaxis.set_major_locator(xlocator)
    pyplot.gca().xaxis.set_major_formatter(dates.DateFormatter('%H:%M'))
    # generate a PNG file
    if pngfilename:
        pyplot.savefig(pngfilename)
    # show the plot
    pyplot.show()
    # open interactive shell
    ipshell()
print 'TLM perturbation solution      : %7.4f %7.4f %7.4f' %(perttlm[0],perttlm[1],perttlm[2] )
print 'non-linear difference solution : %7.4f %7.4f %7.4f' %(px[-1,0],px[-1,1],px[-1,2])

# predicted and modeled (actual) change in the forecast metric
Jc = xf[0].copy()              # single variable metric - Control
Jp = pxsave[-1,0].copy()       # single variable metric - Perturbation
#Jc = sum(xf).copy()            # sum metric - Control
#Jp = sum(pxsave[-1,:]).copy()  # sum metric - Perturbation
dJp = np.dot(np.transpose(sxi), xp)    # predicted change
dJm = Jp - Jc                          # modeled (actual) change

print
print 'predicted change in metric : %7.4f' % (dJp)
print '  modeled change in metric : %7.4f' % (dJm)

xl = pyplot.get(pyplot.gca(),'xlim')
yl = pyplot.get(pyplot.gca(),'ylim')
pyplot.text(0.9*xl[0],-4,'control trajectory',                 color='red')
pyplot.text(0.9*xl[0],-2,'adjoint sensitivity gradient vector',color='green')
pyplot.text(0.9*xl[0],0, 'perturbed state vector',             color='blue')

pyplot.text(0.9*xl[0],0.9*yl[1],  'predicted change in metric : %7.4f'%(dJp))
pyplot.text(0.9*xl[0],0.9*yl[1]-2,'modeled change in metric   : %7.4f'%(dJm))

# now test as a function of perturbation amplitude
amp_min  = -5.0
amp_max  =  5.0
amp_step =  0.1
dJp = np.zeros((len(np.arange(amp_min,amp_max+amp_step,amp_step)),1))
dJm = dJp.copy()
k = -1
def main(args):
    logfilename = os.path.join(args.logdir,'serial.log')
    oldlogfilename = os.path.join(args.logdir,'serial.log.0')
    current = Weather()
    h = 139                             # elevation in meters
    if args.days > 7:
        print "WARNING: %s days requested; log may contain 7-14 days of data" % args.days

    # copy DATA lines to temporary file, concatenating current and former logfiles
    t = tempfile.TemporaryFile()
    # to have a named file for testing:
    # t = tempfile.NamedTemporaryFile(delete=False)
    logfile = open(oldlogfilename,'r')
    for line in logfile:
        if re.match("(.*)DATA(.*)", line):
            t.write(line)
    logfile.close()
    logfile = open(logfilename,'r')
    for line in logfile:
        if re.match("(.*)DATA(.*)", line):
            t.write(line)
    logfile.close()

    # read from tempfile into numpy array for each parameter
    t.seek(0)
    temptemp = np.asarray(re.findall('(\d+) DATA: T= (.+) degC',t.read()), dtype=np.float64)
    #temptemp[np.where(temptemp<MINTEMP)] = np.nan
    temp = np.ma.masked_less(temptemp, MINTEMP)
    current.temp = temp[len(temp)-1,1]            # most recent temp
    now = int(temp[len(temp)-1,0])                # in Unix seconds
    if args.verbose:
        print "Timezone offset: %s" % timezone
    # store as Python datetime, in local time, naive format with no real tzinfo set
    current.time = dates.num2date(dates.epoch2num(now-timezone)) 
    current.max = np.max(temp[temp[:,0] > (now-86400),1])
    current.min = np.min(temp[temp[:,0] > (now-86400),1])
    if args.verbose:
        print "Temperature records: %s" % len(temp)
    t.seek(0)
    pressure = np.asarray(re.findall('(\d+) DATA: P= (\d+) Pa',t.read()), dtype=np.float64)
    current.pressure = sealevel(pressure[len(pressure)-1,1]/100,h)
    if args.verbose:
        print "Pressure records: %s" % len(pressure)
    t.seek(0)
    humid = np.asarray(re.findall('(\d+) DATA: H= (\d+) %',t.read()), dtype=np.int)
    t.close()
    current.humid = humid[len(humid)-1,1]
    if args.verbose:
        print "Humidity records: %s" % len(humid)
    # set start time to midnight local time, # of days ago specified
    start = (np.floor((now-timezone)/86400.0) - args.days)*86400 + timezone
    if args.verbose:
        print "Current timestamp: %s" % now
    if args.verbose:
        print "Start timestamp: %s" % start
    temp=temp[temp[:,0]>start,:]
    pressure=pressure[pressure[:,0]>start,:]
    humid=humid[humid[:,0]>start,:]
    m=temp[0,0]
    if args.verbose:
        print "First actual timestamp: %s" % m
    current.report()
    save_html(current)
    fig = Figure(figsize=(8,8))
    ax = fig.add_subplot(311)
    ax.plot(dates.epoch2num(temp[:,0]-timezone),temp[:,1])
    ax.set_ylabel(u'Temp (°C)')
    ax2 = ax.twinx()
    clim = pyplot.get(ax,'ylim')
    ax2.set_ylim(c2f(clim[0]),c2f(clim[1]))
    datelabels(ax)
    ax2.set_ylabel(u'Temp (°F)')
    
    ax = fig.add_subplot(312)
    ax.plot(dates.epoch2num(humid[:,0]-timezone),humid[:,1],'-')
    ax.set_ylim(0,100)
    ax.set_ylabel('Humidity (%)')
    ax2 = ax.twinx()
    ax2.set_ylim(0,100)
    datelabels(ax)
    ax2.set_ylabel('Humidity (%)')
    ax = fig.add_subplot(313)
    ax.plot(dates.epoch2num(pressure[:,0]-timezone),sealevel(pressure[:,1],h)/100,'-')
    ax.set_ylabel('Pressure (mbar)')
    ax.set_xlabel('local time (%s)' % TZ)
    ax2 = ax.twinx()
    clim = pyplot.get(ax,'ylim')
    ax2.set_ylim(clim[0]*0.02954,clim[1]*0.02954)
    datelabels(ax)
    ax.xaxis.set_major_locator(
        dates.HourLocator(interval=12)
        )
    ax.xaxis.set_major_formatter(
        dates.DateFormatter('%H:%M')
        )
    ax2.set_ylabel('P (inches Hg)')
    canvas = FigureCanvasAgg(fig)
    canvas.print_figure(os.path.join(args.outdir,'plot.png'), dpi=80)
    canvas.print_figure(os.path.join(args.outdir,'plot.pdf'))

    if args.upload:
        # upload static html file & images
        os.system('sitecopy -u weather')

    if args.show:
        # show the plot
        # doesn't work with FigureCanvasAgg
        #pyplot.show()
        # Linux (or X11 in OS X)
        os.system("display %s" % os.path.join(args.outdir,'plot.png'))
示例#38
0
plt.contour(Z, levels, hold="on", colors="k", origin="upper", extent=extent)
plt.axis(v)
plt.title("Image, origin 'upper'")

plt.subplot(2, 2, 3)

plt.imshow(Z, origin="lower", extent=extent, cmap=cmap, norm=norm)
v = plt.axis()
plt.contour(Z, levels, hold="on", colors="k", origin="lower", extent=extent)
plt.axis(v)
plt.title("Image, origin 'lower'")

plt.subplot(2, 2, 4)

# We will use the interpolation "nearest" here to show the actual
# image pixels.
# Note that the contour lines don't extend to the edge of the box.
# This is intentional. The Z values are defined at the center of each
# image pixel (each color block on the following subplot), so the
# domain that is contoured does not extend beyond these pixel centers.
im = plt.imshow(Z, interpolation="nearest", extent=extent, cmap=cmap, norm=norm)
v = plt.axis()
plt.contour(Z, levels, hold="on", colors="k", origin="image", extent=extent)
plt.axis(v)
ylim = plt.get(plt.gca(), "ylim")
plt.setp(plt.gca(), ylim=ylim[::-1])
plt.title("Image, origin from rc, reversed y-axis")
plt.colorbar(im)

plt.show()
示例#39
0
plt.title("Image, origin 'upper'")

plt.subplot(2, 2, 3)

plt.imshow(Z, origin='lower', extent=extent, cmap=cmap, norm=norm)
v = plt.axis()
plt.contour(Z, levels, hold='on', colors='k',
        origin='lower', extent=extent)
plt.axis(v)
plt.title("Image, origin 'lower'")

plt.subplot(2, 2, 4)

# We will use the interpolation "nearest" here to show the actual
# image pixels.
# Note that the contour lines don't extend to the edge of the box.
# This is intentional. The Z values are defined at the center of each
# image pixel (each color block on the following subplot), so the
# domain that is contoured does not extend beyond these pixel centers.
im = plt.imshow(Z, interpolation='nearest', extent=extent, cmap=cmap, norm=norm)
v = plt.axis()
plt.contour(Z, levels, hold='on', colors='k',
        origin='image', extent=extent)
plt.axis(v)
ylim = plt.get(plt.gca(), 'ylim')
plt.setp(plt.gca(), ylim=ylim[::-1])
plt.title("Image, origin from rc, reversed y-axis")
plt.colorbar(im)

plt.show()
示例#40
0
                             params['response_window'][0])
    i = lickLat <= ylim[1]
    ax.plot(changeTimes[resp][i] / 60,
            lickLat[i],
            'o',
            color=trialColors[lbl],
            label=lbl)
    i = (lickLat > ylim[1]) | (np.isnan(lickLat))
    ax.plot(changeTimes[resp][i] / 60,
            np.zeros(i.sum()) + 0.99 * ylim[1],
            '^',
            color=trialColors[lbl])
for side in ('right', 'top'):
    ax.spines[side].set_visible(False)
ax.tick_params(direction='out', top=False, right=False)
xlim = plt.get(ax, 'xlim')
for i in (0, 1):
    ax.plot(xlim, [params['response_window'][i]] * 2,
            '--',
            color='0.5',
            zorder=0)
ax.set_xlim(xlim)
ax.set_ylim(ylim)
ax.set_xlabel('Time in session (min)')
ax.set_ylabel('Reaction time (s)')
ax.legend()

if params['periodic_flash'] is not None:
    ax = fig.add_subplot(2, 1, 2)
    bins = np.arange(0.125, np.nanmax(timeToChange) + 0.125, 0.25)
    ctBinInd = np.digitize(timeToChange, bins)
示例#41
0
def plot_taylor_axes(axes, cax, option):
    """
    Plot axes for Taylor diagram.

    Plots the x & y axes for a Taylor diagram using the information
    provided in the AXES dictionary returned by the
    GET_TAYLOR_DIAGRAM_AXES function.

    INPUTS:
    axes   : data structure containing axes information for target diagram
    cax    : handle for plot axes
    option : data structure containing option values. (Refer to
             GET_TAYLOR_DIAGRAM_OPTIONS function for more information.)
    option['colcor']       : CORs grid and tick labels color (Default: blue)
    option['colrms']       : RMS grid and tick labels color (Default: green)
    option['colstd']       : STD grid and tick labels color (Default: black)
    option['numberpanels'] : number of panels (quadrants) to use for Taylor
                          diagram
    option['tickrms']      : RMS values to plot gridding circles from
                          observation point
    option['titlecor']     : title for CORRELATION axis
    option['titlerms']     : title for RMS axis
    option['titlestd']     : title fot STD axis

    OUTPUTS:
    ax: returns a list of handles of axis labels

    Author: Peter A. Rochford
    Acorn Science & Innovation
    [email protected]

    Created on Dec 3, 2016

    Author: Peter A. Rochford
        Symplectic, LLC
        www.thesymplectic.com
        [email protected]
    """
    ax = []
    axlabweight = 'bold'
    if option['numberpanels'] == 1:
        # Single panel

        if option['titlestd'] == 'on':
            ttt = plt.ylabel('test', fontsize=14)
            x = -0.15 * axes['rmax']
            y = 0.8 * axes['rmax']
            handle = plt.text(x, y, 'Standard Deviation', rotation=90,
                              color=option['colstd'],
                              fontweight=axlabweight,
                              fontsize=plt.get(ttt, 'fontsize'),
                              horizontalalignment='center')
            ax.append(handle)

        if option['titlecor'] == 'on':
            pos1 = 45
            DA = 15
            lab = 'Correlation Coefficient'
            c = np.fliplr([np.linspace(pos1 - DA, pos1 + DA, len(lab))])[0]
            dd = 1.1 * axes['rmax']
            for ii, ith in enumerate(c):
                handle = plt.text(dd * np.cos(ith * np.pi / 180),
                                  dd * np.sin(ith * np.pi / 180),
                                  lab[ii])
                handle.set(rotation=ith - 90, color=option['colcor'],
                           horizontalalignment='center',
                           verticalalignment='bottom',
                           fontsize=plt.get(ax[0], 'fontsize'),
                           fontweight=axlabweight)
                ax.append(handle)

        if option['titlerms'] == 'on':
            pos1 = option['tickrmsangle'] + (180 - option['tickrmsangle']) / 2
            DA = 15
            pos1 = 160
            lab = 'RMSD'
            c = np.fliplr([np.linspace(pos1 - DA, pos1 + DA, len(lab))])[0]

            # Find optimal placement of label
            itick = -1
            ratio = 1.0
            while (ratio > 0.7):
                itick += 1
                ratio = (option['axismax'] - option['tickrms']
                         [itick]) / option['axismax']
            dd = 0.7 * option['tickrms'][itick] + \
                0.3 * option['tickrms'][itick + 1]

            # Write label in a circular arc
            for ii, ith in enumerate(c):
                xtextpos = axes['dx'] + dd * np.cos(ith * np.pi / 180)
                ytextpos = dd * np.sin(ith * np.pi / 180)
                handle = plt.text(xtextpos, ytextpos, lab[ii])
                handle.set(rotation=ith - 90, color=option['colrms'],
                           horizontalalignment='center',
                           verticalalignment='top',
                           fontsize=plt.get(ax[0], 'fontsize'),
                           fontweight=axlabweight)
                ax.append(handle)

    else:
        # Double panel

        if option['titlestd'] == 'on':
            ttt = plt.ylabel('test', fontsize=14)
            x = 0
            y = -0.15 * axes['rmax']
            handle = plt.text(x, y, 'Standard Deviation', rotation=0,
                              color=option['colstd'],
                              fontweight=axlabweight,
                              fontsize=plt.get(ttt, 'fontsize'),
                              horizontalalignment='center')
            ax.append(handle)

        if option['titlecor'] == 'on':
            pos1 = 90
            DA = 25
            lab = 'Correlation Coefficient'
            c = np.fliplr([np.linspace(pos1 - DA, pos1 + DA, len(lab))])[0]
            dd = 1.1 * axes['rmax']
            for ii, ith in enumerate(c):
                handle = plt.text(dd * np.cos(ith * np.pi / 180),
                                  dd * np.sin(ith * np.pi / 180), lab[ii])
                handle.set(rotation=ith - 90, color=option['colcor'],
                           horizontalalignment='center',
                           verticalalignment='bottom',
                           fontsize=plt.get(ax[0], 'fontsize'),
                           fontweight=axlabweight)
                ax.append(handle)

        if option['titlerms'] == 'on':
            pos1 = 160
            DA = 10
            lab = 'RMSD'
            c = np.fliplr([np.linspace(pos1 - DA, pos1 + DA, len(lab))])[0]
            dd = 1.05 * option['tickrms'][0]
            for ii, ith in enumerate(c):
                xtextpos = axes['dx'] + dd * np.cos(ith * np.pi / 180)
                ytextpos = dd * np.sin(ith * np.pi / 180)
                handle = plt.text(xtextpos, ytextpos, lab[ii])
                handle.set(rotation=ith - 90, color=option['colrms'],
                           horizontalalignment='center',
                           verticalalignment='bottom',
                           fontsize=plt.get(ax[0], 'fontsize'),
                           fontweight=axlabweight)
                ax.append(handle)

    # VARIOUS ADJUSTMENTS TO THE PLOT:
    cax.set_aspect('equal')
    plt.axis('off')
    plt.gcf().patch.set_facecolor('w')

    # set axis limits
    if option['numberpanels'] == 2:
        axislim = [axes['rmax'] * x for x in [-1.15, 1.15, 0, 1.15]]
        plt.axis(axislim)
        plt.plot([-axes['rmax'], axes['rmax']], [0, 0],
                 color=axes['tc'], linewidth=2)
        plt.plot([0, 0], [0, axes['rmax']], color=axes['tc'])
    else:
        axislim = [axes['rmax'] * x for x in [0, 1.15, 0, 1.15]]
        plt.axis(axislim)
        plt.plot([0, axes['rmax']], [0, 0], color=axes['tc'],
                 linewidth=2)
        plt.plot([0, 0], [0, axes['rmax']], color=axes['tc'],
                 linewidth=2)

    return ax
print 'non-linear difference solution : %7.4f %7.4f %7.4f' % (
    px[-1, 0], px[-1, 1], px[-1, 2])

# predicted and modeled (actual) change in the forecast metric
Jc = xf[0].copy()  # single variable metric - Control
Jp = pxsave[-1, 0].copy()  # single variable metric - Perturbation
#Jc = sum(xf).copy()            # sum metric - Control
#Jp = sum(pxsave[-1,:]).copy()  # sum metric - Perturbation
dJp = np.dot(np.transpose(sxi), xp)  # predicted change
dJm = Jp - Jc  # modeled (actual) change

print
print 'predicted change in metric : %7.4f' % (dJp)
print '  modeled change in metric : %7.4f' % (dJm)

xl = pyplot.get(pyplot.gca(), 'xlim')
yl = pyplot.get(pyplot.gca(), 'ylim')
pyplot.text(0.9 * xl[0], -4, 'control trajectory', color='red')
pyplot.text(0.9 * xl[0],
            -2,
            'adjoint sensitivity gradient vector',
            color='green')
pyplot.text(0.9 * xl[0], 0, 'perturbed state vector', color='blue')

pyplot.text(0.9 * xl[0], 0.9 * yl[1],
            'predicted change in metric : %7.4f' % (dJp))
pyplot.text(0.9 * xl[0], 0.9 * yl[1] - 2,
            'modeled change in metric   : %7.4f' % (dJm))

# now test as a function of perturbation amplitude
amp_min = -5.0
示例#43
0
def main():

    # name of starting ensDA output diagnostic file, starting index and measure

    parser = ArgumentParser(description='compare the diag files written by varDA.py',formatter_class=ArgumentDefaultsHelpFormatter)
    parser.add_argument('-f','--filename',help='name of the diag file to read',required=True)
    parser.add_argument('-m','--measure',help='measure to evaluate performance',required=False,choices=['obs','truth'],default='truth')
    parser.add_argument('-b','--begin_index',help='starting index to read',type=int,required=False,default=101)
    parser.add_argument('-e','--end_index',help='ending index to read',type=int,required=False,default=-1)
    parser.add_argument('-s','--save_figure',help='save figures',action='store_true',required=False)
    args = parser.parse_args()

    fname    = args.filename
    measure  = args.measure
    sOI      = args.begin_index
    eOI      = args.end_index
    save_fig = args.save_figure

    # Inflation factors to compare
    #alpha = [1.0, 2.0, 3.0, 3.1, 3.2, 3.4]
    alpha = [0.25, 0.3, 0.35, 0.4, 0.5, 0.6, 0.7, 1.0]
    alpha = [1.0, 2.0, 2.5]

    # some more arguments, currently hard-coded
    save_figures = False         # save plots as eps
    yscale       = 'linear'      # y-axis of RMSE plots (linear/semilog)
    yFix         = 0.18          # fix the y-axis of RMSE plots ( None = automatic )
    fOrient      = 'portrait'    # figure orientation (landscape/portrait)

    if ( not measure ): measure = 'truth'
    if ( sOI == -1 ): sOI = 0

    nf = len(alpha)
    fnames = []
    for i in range(nf): fnames.append( fname + '%3.2f.nc4' % ((alpha[i])) )

    if ( len(fnames) <= 15):
        fcolor = ["#000000", "#C0C0C0", "#808080", "#800000", "#FF0000",\
                  "#800080", "#FF00FF", "#008000", "#00FF00", "#808000",\
                  "#FFFF00", "#000080", "#0000FF", "#008080", "#00FFFF"]
        # black, silver, gray, maroon, red
        # purple, fuchsia, green, lime, olive
        # yellow, navy, blue, teal, aqua
    else:
        fcolor = get_Ndistinct_colors(len(fnames))

    # read general dimensions and necessary attributes from the diagnostic file
    [model, DA, _, gvarDA] = read_diag_info(fnames[0])

    Bc = read_clim_cov(model=model,norm=True)

    if   ( gvarDA.update == 1 ): vstr = '3DVar'
    elif ( gvarDA.update == 2 ): vstr = '4DVar'

    # allocate room for variables
    print 'computing RMSE against %s' % measure
    xbrmse = np.zeros((len(fnames),DA.nassim))
    xarmse = np.zeros((len(fnames),DA.nassim))
    xyrmse = np.zeros((len(fnames),DA.nassim))
    flabel = []
    blabel = []
    mean_prior     = np.zeros(len(fnames))
    mean_posterior = np.zeros(len(fnames))
    std_prior      = np.zeros(len(fnames))
    std_posterior  = np.zeros(len(fnames))
    mean_niters    = np.zeros(len(fnames))
    std_niters     = np.zeros(len(fnames))
    innov          = np.zeros(len(fnames))
    mean_evratio   = np.zeros(len(fnames))
    std_evratio    = np.zeros(len(fnames))

    for fname in fnames:

        print 'reading ... %s' % fname
        f = fnames.index(fname)

        try:
            nc = Dataset(fname, mode='r', format='NETCDF4')
            flabel.append(r'$\alpha = %3.2f$' % alpha[f])
            blabel.append('%3.2f' % alpha[f])
            nc.close()
        except Exception as Instance:
            print 'Exception occurred during read of ' + fname
            print type(Instance)
            print Instance.args
            print Instance
            sys.exit(1)

        # read the varDA for the specific diagnostic file
        [_, _, _, varDA] = read_diag_info(fname)

        # read the diagnostic file
        xt, xb, xa, y, H, R, niters = read_diag(fname, 0, end_time=DA.nassim)
        if ( varDA.update == 2 ): y = y[:,:model.Ndof]

        # compute RMSE in prior, posterior and observations
        if ( measure == 'truth' ):
            xbrmse[f,] = np.sqrt( np.sum( (xt - xb)**2, axis = 1) / model.Ndof )
            xarmse[f,] = np.sqrt( np.sum( (xt - xa)**2, axis = 1) / model.Ndof )
        else:
            xbrmse[f,] = np.sqrt( np.sum( (y - xb)**2, axis = 1) / model.Ndof )
            xarmse[f,] = np.sqrt( np.sum( (y - xa)**2, axis = 1) / model.Ndof )
        xyrmse[f,] = np.sqrt( np.sum( (xt -  y)**2 ) / model.Ndof )

        evratio = niters.copy()
        evratio = np.zeros(len(niters))
        for i in range(DA.nassim):
            innov  = np.sum((y[i,:] - np.dot(np.diag(H[i,:]),xb[  i,:]))**2)
            totvar = np.sum(varDA.inflation.infl_fac*np.diag(Bc) + R[i,:])
            evratio[i] = innov / totvar
        mean_evratio[f] = np.mean(evratio[sOI:])
        std_evratio[f]  = np.std( evratio[sOI:],ddof=1)

        # compute mean and std. dev. in the iteration count
        mean_niters[f] = np.mean(niters[sOI+1:])
        std_niters[f]  = np.std( niters[sOI+1:], ddof=1)

    # start plotting

    #-----------------------------------------------------------
    fig = pyplot.figure()
    pyplot.clf()
    pyplot.hold(True)
    for fname in fnames:
        f = fnames.index(fname)
        q = np.squeeze(xbrmse[f,sOI:])
        if   ( yscale == 'linear'  ): pyplot.plot(    q,'-',color=fcolor[f],label=flabel[f],linewidth=1)
        elif ( yscale == 'semilog' ): pyplot.semilogy(q,'-',color=fcolor[f],label=flabel[f],linewidth=1)

    yl = pyplot.get(pyplot.gca(),'ylim')
    xl = pyplot.get(pyplot.gca(),'xlim')
    if ( yFix is None ): ymax = yl[1]
    else:                ymax = yFix
    pyplot.ylim(0.0, ymax)
    pyplot.xlim(0.0, len(q))

    for fname in fnames:
        f = fnames.index(fname)
        q = np.squeeze(xbrmse[f,sOI:])
        mean_prior[f] = np.mean(q)
        std_prior[f]  = np.std(q,ddof=1)
        str = 'mean rmse : %5.4f +/- %5.4f' % (np.mean(q), np.std(q,ddof=1))
        pyplot.text(25,(1-0.05*(f+1))*ymax,str,color=fcolor[f],fontsize=10)

    pyplot.xlabel('Assimilation Cycle',fontweight='bold',fontsize=12)
    pyplot.ylabel('RMSE',fontweight='bold',fontsize=12)
    pyplot.title('RMSE - Prior',fontweight='bold',fontsize=14)
    pyplot.legend(loc=1)
    pyplot.hold(False)
    if save_figures:
        fig.savefig('%s_varDA_RMSE_Prior.eps' % (model.Name),dpi=300,orientation=fOrient,format='eps')
    #-----------------------------------------------------------

    #-----------------------------------------------------------
    fig = pyplot.figure()
    pyplot.clf()
    pyplot.hold(True)
    for fname in fnames:
        f = fnames.index(fname)
        q = np.squeeze(xarmse[f,sOI:])
        if   ( yscale == 'linear'  ): pyplot.plot(    q,'-',color=fcolor[f],label=flabel[f],linewidth=1)
        elif ( yscale == 'semilog' ): pyplot.semilogy(q,'-',color=fcolor[f],label=flabel[f],linewidth=1)

    yl = pyplot.get(pyplot.gca(),'ylim')
    xl = pyplot.get(pyplot.gca(),'xlim')
    if ( yFix is None ): ymax = yl[1]
    else:                ymax = yFix
    pyplot.ylim(0.0, ymax)
    pyplot.xlim(0.0, len(q))

    for fname in fnames:
        f = fnames.index(fname)
        q = np.squeeze(xarmse[f,sOI:])
        mean_posterior[f] = np.mean(q)
        std_posterior[f]  = np.std(q,ddof=1)
        str = 'mean rmse : %5.4f +/- %5.4f' % (np.mean(q), np.std(q,ddof=1))
        pyplot.text(25,(1-0.05*(f+1))*ymax,str,color=fcolor[f],fontsize=10)

    pyplot.xlabel('Assimilation Cycle',fontweight='bold',fontsize=12)
    pyplot.ylabel('RMSE',fontweight='bold',fontsize=12)
    pyplot.title('RMSE - Posterior',fontweight='bold',fontsize=14)
    pyplot.legend(loc=1)
    pyplot.hold(False)
    if save_figures:
        fig.savefig('%s_varDA_RMSE_Posterior.eps' % (model.Name),dpi=300,orientation=fOrient,format='eps')
    #-----------------------------------------------------------

    #-----------------------------------------------------------
    fig = pyplot.figure()
    pyplot.clf()
    pyplot.hold(True)

    index = np.arange(nf) + 0.15
    width = 0.35

    bottom = 0.0
    pyplot.bar(index,mean_prior-bottom,width,bottom=bottom,linewidth=0.0,color='0.75',edgecolor='0.75',yerr=std_prior, error_kw=dict(ecolor='black',elinewidth=3,capsize=5))
    pyplot.bar(index+width,mean_posterior-bottom,width,bottom=bottom,linewidth=0.0,color='gray',edgecolor='gray',yerr=std_posterior,error_kw=dict(ecolor='black',elinewidth=3,capsize=5))

    pyplot.xticks(index+width, blabel)

    pyplot.xlabel('Inflation Factor', fontweight='bold',fontsize=12)
    pyplot.ylabel('RMSE',             fontweight='bold',fontsize=12)
    pyplot.title( 'RMSE',             fontweight='bold',fontsize=14)
    pyplot.hold(False)
    if save_figures:
        fig.savefig('%s_varDA_RMSE.eps' % (model.Name),dpi=300,orientation=fOrient,format='eps')
    #-----------------------------------------------------------

    #-----------------------------------------------------------
    fig = pyplot.figure()
    pyplot.clf()
    pyplot.hold(True)

    index = np.arange(nf) + 0.2
    width = 0.6

    pyplot.bar(index,mean_niters,width,linewidth=0.0,color='gray',edgecolor='gray',yerr=std_niters,error_kw=dict(ecolor='black',elinewidth=3,capsize=5))

    pyplot.xticks(index+width/2, blabel)

    pyplot.xlabel('Inflation Factor',  fontweight='bold',fontsize=12)
    pyplot.ylabel('No. of Iterations', fontweight='bold',fontsize=12)
    pyplot.title( 'No. of Iterations', fontweight='bold',fontsize=14)
    pyplot.hold(False)
    if save_figures:
        fig.savefig('%s_varDA_niters.eps' % (model.Name),dpi=300,orientation=fOrient,format='eps')
    #-----------------------------------------------------------

    #-----------------------------------------------------------
    fig = pyplot.figure()
    pyplot.clf()
    pyplot.hold(True)

    index = np.arange(nf) + 0.2
    width = 0.6
    pyplot.bar(index,mean_evratio,width,linewidth=0.0,color='gray',edgecolor='gray',yerr=std_evratio,error_kw=dict(ecolor='black',elinewidth=3,capsize=5))

    pyplot.xticks(index+width/2, blabel)

    pyplot.xlabel('Inflation Factor',       fontweight='bold',fontsize=12)
    pyplot.ylabel('Error - Variance Ratio', fontweight='bold',fontsize=12)
    pyplot.title( 'Error - Variance Ratio', fontweight='bold',fontsize=14)
    pyplot.hold(False)
    if save_figures:
        fig.savefig('%s_varDA_evratio.eps' % (model.Name),dpi=300,orientation=fOrient,format='eps')
    #-----------------------------------------------------------


    if not save_figures: pyplot.show()
    print '... all done ...'
    sys.exit(0)
示例#44
0
def plot_simulated_data(ivm, filename=None):

    import matplotlib
    import matplotlib.pyplot as plt
    import matplotlib.gridspec as gridspec
    from matplotlib.collections import LineCollection
    from mpl_toolkits.basemap import Basemap

    if filename is None:
        out_fname = './summary_orbit_simulated_data.png'
    else:
        out_fname = filename

    # make monotonically increasing longitude signal
    diff = ivm['glong'].diff()

    idx, = np.where(diff < 0.)
    for item in idx:
        ivm[item:, 'glong'] += 360.

    f = plt.figure(figsize=(8.5, 7))

    time1 = ivm.data.index[0].strftime('%Y-%h-%d %H:%M:%S')
    if ivm.data.index[0].date() == ivm.data.index[-1].date():
        time2 = ivm.data.index[-1].strftime('%H:%M:%S')
    else:
        time2 = ivm.data.index[-1].strftime('%Y-%h-%d %H:%M:%S')
    # Overall Plot Title
    plt.suptitle(''.join(('SPORT IVM ', time1, ' -- ', time2)), fontsize=18)

    # create grid for plots
    gs = gridspec.GridSpec(5, 2, width_ratios=[12, 1])

    ax = f.add_subplot(gs[0, 0])
    plt.plot(np.log10(ivm['ion_dens']), 'k', label='total')
    plt.plot(np.log10(ivm['ion_dens'] * ivm['frac_dens_o']), 'r', label='O+')
    plt.plot(np.log10(ivm['ion_dens'] * ivm['frac_dens_h']), 'b', label='H+')
    # plt.plot(np.log10(ivm['ion_dens']*ivm['frac_dens_he']), 'g', label='He+')
    plt.legend(loc=(01.01, 0.15))
    ax.set_title('Log Ion Density')
    ax.set_ylabel('Log Density (N/cc)')
    ax.set_ylim([1., 6.])
    ax.axes.get_xaxis().set_visible(False)

    ax2 = f.add_subplot(gs[1, 0], sharex=ax)
    plt.plot(ivm['ion_temp'])
    plt.legend(loc=(1.01, 0.15))
    ax2.set_title('Ion Temperature')
    ax2.set_ylabel('Temp (K)')
    ax2.set_ylim([500., 1500.])
    ax2.axes.get_xaxis().set_visible(False)

    # determine altitudes greater than 770 km
    # idx, = np.where(ivm['alt'] > 770.)

    ax3 = f.add_subplot(gs[2, 0], sharex=ax)
    plt.plot(ivm['sim_wind_sc_x'], color='b', linestyle='--')
    plt.plot(ivm['sim_wind_sc_y'], color='r', linestyle='--')
    plt.plot(ivm['sim_wind_sc_z'], color='g', linestyle='--')
    ax3.set_title('Neutral Winds in S/C X, Y, and Z')
    ax3.set_ylabel('Velocity (m/s)')
    ax3.set_ylim([-200., 200.])
    ax3.axes.get_xaxis().set_visible(False)
    plt.legend(loc=(1.01, 0.15))
    ax3.xaxis.set_major_formatter(matplotlib.dates.DateFormatter('%H:%M'))
    # # xlabels = [label[0:6] for label in xlabels]
    # plt.setp(ax3.xaxis.get_majorticklabels(), rotation=20, ha='right')

    ax4 = f.add_subplot(gs[3, 0], sharex=ax)
    plt.plot(ivm['B_sc_x'] * 1e5, color='b', linestyle='--')
    plt.plot(ivm['B_sc_y'] * 1e5, color='r', linestyle='--')
    plt.plot(ivm['B_sc_z'] * 1e5, color='g', linestyle='--')
    ax4.set_title('Magnetic Field in S/C X, Y, and Z')
    ax4.set_ylabel('Gauss')
    ax4.set_ylim([-3.5, 3.5])
    # ax3.axes.get_xaxis().set_visible(False)
    plt.legend(loc=(1.01, 0.15))
    ax4.xaxis.set_major_formatter(matplotlib.dates.DateFormatter('%H:%M'))
    # # xlabels = [label[0:6] for label in xlabels]
    plt.setp(ax4.xaxis.get_majorticklabels(), rotation=20, ha='right')

    # ivm info
    ax6 = f.add_subplot(gs[4, 0])

    # do world plot if time to be plotted is less than 285 minutes, less than 3 orbits
    time_diff = ivm.data.index[-1] - ivm.data.index[0]
    if time_diff > pds.Timedelta(minutes=285):
        #    # do long time plot
        ivm['glat'].plot(label='glat')  #legend=True, label='mlat')
        ivm['mlt'].plot(label='mlt')  #legend=True, label='mlt')
        plt.title('Satellite Position')
        plt.legend(['mlat', 'mlt'], loc=(1.01, 0.15))
    #    ivm['glong'].plot(secondary_y = True, label='glong')#legend=True, secondary_y = True, label='glong')

    else:

        # make map the same size as the other plots
        s1pos = plt.get(ax, 'position').bounds
        s6pos = plt.get(ax6, 'position').bounds
        ax6.set_position([s1pos[0], s6pos[1] + .008, s1pos[2], s1pos[3]])

        #fix longitude range for plot. Pad longitude so that first sample aligned with
        #ivm measurement sample
        lon0 = ivm[0, 'glong']
        lon1 = ivm[-1, 'glong']
        # print (lon0, lon1)

        # enforce minimal longitude window, keep graphics from being too disturbed
        if (lon1 - lon0) < 90:
            lon0 -= 45.
            lon1 += 45.
        if lon1 > 720:
            lon0 -= 360.
            lon1 -= 360.
            ivm[:, 'glong'] -= 360.
        # print (lon0, lon1)

        m=Basemap(projection='mill', llcrnrlat=-60, urcrnrlat=60., urcrnrlon=lon1.copy(), \
        llcrnrlon=lon0.copy(), resolution='c', ax=ax6, fix_aspect=False)
        # m is an object which manages drawing to the map
        # it also acts as a transformation function for geo coords to plotting coords

        # coastlines
        m.drawcoastlines(ax=ax6)
        # get first longitude meridian to plot
        plon = np.ceil(lon0 / 60.) * 60.
        m.drawmeridians(np.arange(plon, plon + 360. - 22.5, 60),
                        labels=[0, 0, 0, 1],
                        ax=ax6)
        m.drawparallels(np.arange(-20, 20, 20))
        # time midway through ivm to plot terminator locations
        midDate = ivm.data.index[len(ivm.data.index) // 2]

        # plot day/night terminators
        try:
            cs = m.nightshade(midDate)
        except ValueError:
            pass

        x, y = m(ivm['glong'].values, ivm['glat'].values)
        points = np.array([x, y]).T.reshape(-1, 1, 2)
        segments = np.concatenate([points[:-1], points[1:]], axis=1)
        plot_norm = plt.Normalize(300, 500)
        try:
            plot_cmap = plt.get_cmap('viridis')
        except:
            plot_cmap = plt.get_cmap('jet')

        lc = LineCollection(segments,
                            cmap=plot_cmap,
                            norm=plot_norm,
                            linewidths=5.0)
        lc.set_array(ivm['alt'].values)
        sm = plt.cm.ScalarMappable(cmap=plot_cmap, norm=plot_norm)
        sm._A = []

        ax6.add_collection(lc)

        ax6_bar = f.add_subplot(gs[4, 1])
        #plt.colorbar(sm)
        cbar = plt.colorbar(cax=ax6_bar,
                            ax=ax6,
                            mappable=sm,
                            orientation='vertical',
                            ticks=[300., 400., 500.])
        plt.xlabel('Altitude')
        plt.ylabel('km')

    f.tight_layout()
    # buffer for overall title
    f.subplots_adjust(bottom=0.06, top=0.91, right=.91)
    plt.subplots_adjust(hspace=.44)

    plt.savefig(out_fname)

    return
示例#45
0
def displayGeometResults( inputFilePath, prefix ):

    I0Filename = inputFilePath + prefix + "I0-orig.nrrd"
    I1Filename = inputFilePath + prefix + "I1-orig.nrrd"
    I1EstFilename = inputFilePath + prefix + "orig-EstI1.nrrd"
    T1EstFilename = inputFilePath + prefix + "orig-EstT1.nrrd"
    T2EstFilename = inputFilePath + prefix + "orig-EstT2.nrrd"
    map0OutFilename = inputFilePath + prefix + "map0Out.nrrd"
    map1OutFilename = inputFilePath + prefix + "map1Out.nrrd"
    map2OutFilename = inputFilePath + prefix + "map2Out.nrrd"
    map12OutFilename = inputFilePath + prefix + "map12.nrrd"



    I0 = nd.Nrrd(I0Filename)
    I1 = nd.Nrrd(I1Filename)
    I1Est = nd.Nrrd(I1EstFilename)
    T1Est = nd.Nrrd(T1EstFilename)
    T2Est = nd.Nrrd(T2EstFilename)
    map0Out = nd.Nrrd(map0OutFilename)
    map1Out = nd.Nrrd(map1OutFilename)
    map2Out = nd.Nrrd(map2OutFilename)
    map12Out = nd.Nrrd(map12OutFilename)
    print "I0 size ", I0.data.shape

    ysize, xsize = I0.data.shape
    [gridX,gridY]=np.meshgrid(np.arange(1,xsize+1),np.arange(1,ysize+1))

    plt.figure()
    plt.title(prefix + " Geomet Results")
    plt.subplot(235)
    P.imshow(T1Est.data,cmap=cm.gray)
    v = plt.axis()
    plt.axis(v)
    ylim = plt.get(plt.gca(), 'ylim')
    CS = plt.contour(gridX,gridY,map1Out.data[0,:,:], 20, hold='on', colors='red')
    CS = plt.contour(gridX,gridY,map1Out.data[1,:,:], 20, hold='on', colors='red')
    plt.title('Est-T1')

    plt.subplot(236)
    P.imshow(T2Est.data,cmap=cm.gray)
    v = plt.axis()
    plt.axis(v)
    ylim = plt.get(plt.gca(), 'ylim')
    CS = plt.contour(gridX,gridY,map12Out.data[0,:,:], 20, hold='on', colors='red')
    CS = plt.contour(gridX,gridY,map12Out.data[1,:,:], 20, hold='on', colors='red')
    plt.title('Est-T2')

    #plt.figure()
    plt.subplot(234)
    P.imshow(I1Est.data,cmap=cm.gray)
    v = plt.axis()
    plt.axis(v)
    ylim = plt.get(plt.gca(), 'ylim')
    CS = plt.contour(gridX,gridY,map1Out.data[0,:,:], 20, hold='on', colors='red')
    CS = plt.contour(gridX,gridY,map1Out.data[1,:,:], 20, hold='on', colors='red')
    plt.title('Est-I1')

    plt.subplot(231)
    P.imshow(I0.data,cmap=cm.gray)
    v = plt.axis()
    plt.axis(v)
    ylim = plt.get(plt.gca(), 'ylim')
    plt.title('Orig-I0')

    plt.subplot(232)
    P.imshow(I1.data,cmap=cm.gray)
    v = plt.axis()
    plt.axis(v)
    ylim = plt.get(plt.gca(), 'ylim')
    plt.title('Orig-I1')
    outputFileName1 = inputFilePath + prefix + "ALL.png"
    plt.savefig(outputFileName1)
示例#46
0
def plot_taylor_axes(axes, cax, option):
    '''
    Plot axes for Taylor diagram.
    
    Plots the x & y axes for a Taylor diagram using the information 
    provided in the AXES dictionary returned by the 
    GET_TAYLOR_DIAGRAM_AXES function.
    
    INPUTS:
    axes   : data structure containing axes information for target diagram
    cax    : handle for plot axes
    option : data structure containing option values. (Refer to 
             GET_TAYLOR_DIAGRAM_OPTIONS function for more information.)
    option['colcor']       : CORs grid and tick labels color (Default: blue)
    option['colrms']       : RMS grid and tick labels color (Default: green)
    option['colstd']       : STD grid and tick labels color (Default: black)
    option['numberpanels'] : number of panels (quadrants) to use for Taylor
                          diagram
    option['tickrms']      : RMS values to plot gridding circles from 
                          observation point
    option['titlecor']     : title for CORRELATION axis
    option['titlerms']     : title for RMS axis
    option['titlestd']     : title fot STD axis
 
    OUTPUTS:
    ax: returns a list of handles of axis labels
    
    Author: Peter A. Rochford
    Acorn Science & Innovation
    [email protected]

    Created on Dec 3, 2016

    Author: Peter A. Rochford
        Symplectic, LLC
        www.thesymplectic.com
        [email protected]
    '''

    ax = []
    axlabweight = 'bold'
    if option['numberpanels'] == 1:
        # Single panel

        if option['titlestd'] == 'on':
            ttt = plt.ylabel('test', fontsize=16)
            x = -0.15 * axes['rmax']
            y = 0.7 * axes['rmax']
            handle = plt.text(x,
                              y,
                              'Standard Deviation',
                              rotation=90,
                              color=option['colstd'],
                              fontweight=axlabweight,
                              fontsize=plt.get(ttt, 'fontsize'),
                              horizontalalignment='center')
            ax.append(handle)

        if option['titlecor'] == 'on':
            pos1 = 45
            DA = 15
            lab = 'Correlation Coefficient'
            c = np.fliplr([np.linspace(pos1 - DA, pos1 + DA, len(lab))])[0]
            dd = 1.1 * axes['rmax']
            for ii, ith in enumerate(c):
                handle = plt.text(dd * np.cos(ith * np.pi / 180),
                                  dd * np.sin(ith * np.pi / 180), lab[ii])
                handle.set(rotation=ith - 90,
                           color=option['colcor'],
                           horizontalalignment='center',
                           verticalalignment='bottom',
                           fontsize=plt.get(ax[0], 'fontsize'),
                           fontweight=axlabweight)
                ax.append(handle)

        if option['titlerms'] == 'on':
            pos1 = option['tickrmsangle'] + (180 - option['tickrmsangle']) / 2
            DA = 15
            pos1 = 160
            lab = 'RMSD'
            c = np.fliplr([np.linspace(pos1 - DA, pos1 + DA, len(lab))])[0]
            if option['tickrms'][0] > 0:
                dd = 0.7 * option['tickrms'][0] + 0.3 * option['tickrms'][1]
            else:
                dd = 0.7 * option['tickrms'][1] + 0.3 * option['tickrms'][2]
            for ii, ith in enumerate(c):
                xtextpos = axes['dx'] + dd * np.cos(ith * np.pi / 180)
                ytextpos = dd * np.sin(ith * np.pi / 180)
                handle = plt.text(xtextpos, ytextpos, lab[ii])
                handle.set(rotation=ith - 90,
                           color=option['colrms'],
                           horizontalalignment='center',
                           verticalalignment='top',
                           fontsize=plt.get(ax[0], 'fontsize'),
                           fontweight=axlabweight)
                ax.append(handle)

    else:
        # Double panel

        if option['titlestd'] == 'on':
            ttt = plt.ylabel('test', fontsize=14)
            x = 0
            y = -0.15 * axes['rmax']
            handle = plt.text(x,
                              y,
                              'Standard Deviation',
                              rotation=0,
                              color=option['colstd'],
                              fontweight=axlabweight,
                              fontsize=plt.get(ttt, 'fontsize'),
                              horizontalalignment='center')
            ax.append(handle)

        if option['titlecor'] == 'on':
            pos1 = 90
            DA = 25
            lab = 'Correlation Coefficient'
            c = np.fliplr([np.linspace(pos1 - DA, pos1 + DA, len(lab))])[0]
            dd = 1.1 * axes['rmax']
            for ii, ith in enumerate(c):
                handle = plt.text(dd * np.cos(ith * np.pi / 180),
                                  dd * np.sin(ith * np.pi / 180), lab[ii])
                handle.set(rotation=ith - 90,
                           color=option['colcor'],
                           horizontalalignment='center',
                           verticalalignment='bottom',
                           fontsize=plt.get(ax[0], 'fontsize'),
                           fontweight=axlabweight)
                ax.append(handle)

        if option['titlerms'] == 'on':
            pos1 = 160
            DA = 10
            lab = 'RMSD'
            c = np.fliplr([np.linspace(pos1 - DA, pos1 + DA, len(lab))])[0]
            dd = 1.05 * option['tickrms'][0]
            for ii, ith in enumerate(c):
                xtextpos = axes['dx'] + dd * np.cos(ith * np.pi / 180)
                ytextpos = dd * np.sin(ith * np.pi / 180)
                handle = plt.text(xtextpos, ytextpos, lab[ii])
                handle.set(rotation=ith - 90,
                           color=option['colrms'],
                           horizontalalignment='center',
                           verticalalignment='bottom',
                           fontsize=plt.get(ax[0], 'fontsize'),
                           fontweight=axlabweight)
                ax.append(handle)

    # VARIOUS ADJUSTMENTS TO THE PLOT:
    cax.set_aspect('equal')
    plt.axis('off')
    plt.gcf().patch.set_facecolor('w')

    # set axis limits
    if option['numberpanels'] == 2:
        axislim = [axes['rmax'] * x for x in [-1.15, 1.15, 0, 1.15]]
        plt.axis(axislim)
        plt.plot([-axes['rmax'], axes['rmax']], [0, 0],
                 color=axes['tc'],
                 linewidth=2)
        plt.plot([0, 0], [0, axes['rmax']], color=axes['tc'])
    else:
        axislim = [axes['rmax'] * x for x in [0, 1.15, 0, 1.15]]
        plt.axis(axislim)
        plt.plot([0, axes['rmax']], [0, 0], color=axes['tc'], linewidth=2)
        plt.plot([0, 0], [0, axes['rmax']], color=axes['tc'], linewidth=2)

    return ax
示例#47
0
def plot_ObImpact(dJa,
                  dJe,
                  sOI=None,
                  eOI=None,
                  title=None,
                  xlabel=None,
                  ylabel=None):

    color_adj = 'c'
    color_ens = 'm'
    width = 0.45

    if (title is None): title = ''
    if (xlabel is None): xlabel = ''
    if (ylabel is None): ylabel = ''

    if ((sOI is None)): sOI = 0
    if ((eOI is None) or (eOI == -1)): eOI = len(dJa)

    index = np.arange(eOI - sOI)
    if (len(index) > 1000): inc = 1000
    elif (len(index) > 100): inc = 100
    elif (len(index) > 10): inc = 10
    else: inc = 1

    fig = pyplot.figure()
    pyplot.hold(True)

    r0 = pyplot.plot(np.zeros(eOI - sOI + 1), 'k-')
    r1 = pyplot.bar(index,
                    dJa,
                    width,
                    color=color_adj,
                    edgecolor=color_adj,
                    linewidth=0.0)
    r2 = pyplot.bar(index + width,
                    dJe,
                    width,
                    color=color_ens,
                    edgecolor=color_ens,
                    linewidth=0.0)

    stra = r'mean $\delta J_a$ : %5.4f +/- %5.4f' % (np.mean(dJa),
                                                     np.std(dJa, ddof=1))
    stre = r'mean $\delta J_e$ : %5.4f +/- %5.4f' % (np.mean(dJe),
                                                     np.std(dJe, ddof=1))

    locs, labels = pyplot.xticks()
    newlocs = np.arange(sOI, sOI + len(index) + 1, inc) - sOI
    newlabels = np.arange(sOI, sOI + len(index) + 1, inc)
    pyplot.xticks(newlocs, newlabels)

    yl = pyplot.get(pyplot.gca(), 'ylim')
    dyl = yl[1] - yl[0]
    yoff = yl[0] + 0.1 * dyl
    pyplot.text(5, yoff, stra, fontsize=10, color=color_adj)
    yoff = yl[0] + 0.2 * dyl
    pyplot.text(5, yoff, stre, fontsize=10, color=color_ens)

    pyplot.xlabel(xlabel, fontsize=12)
    pyplot.ylabel(ylabel, fontsize=12)
    pyplot.title(title, fontsize=14)
    fig.canvas.set_window_title(title)

    pyplot.hold(False)

    return fig
示例#48
0
def plot_taylor_axes(axes, cax, option):
    """
    Plot axes for Taylor diagram.

    Plots the x & y axes for a Taylor diagram using the information
    provided in the AXES dictionary returned by the
    GET_TAYLOR_DIAGRAM_AXES function.

    INPUTS:
    axes   : data structure containing axes information for target diagram
    cax    : handle for plot axes
    option : data structure containing option values. (Refer to
             GET_TAYLOR_DIAGRAM_OPTIONS function for more information.)
    option['colcor']       : CORs grid and tick labels color (Default: blue)
    option['colrms']       : RMS grid and tick labels color (Default: green)
    option['colstd']       : STD grid and tick labels color (Default: black)
    option['numberpanels'] : number of panels (quadrants) to use for Taylor
                          diagram
    option['tickrms']      : RMS values to plot gridding circles from
                          observation point
    option['titlecor']     : title for CORRELATION axis
    option['titlerms']     : title for RMS axis
    option['titlestd']     : title fot STD axis

    OUTPUTS:
    ax: returns a list of handles of axis labels

    Author: Peter A. Rochford
    Acorn Science & Innovation
    [email protected]

    Created on Dec 3, 2016

    Author: Peter A. Rochford
        Symplectic, LLC
        www.thesymplectic.com
        [email protected]
    """
    ax = []
    axlabweight = "bold"
    if option["numberpanels"] == 1:
        # Single panel

        if option["titlestd"] == "on":
            ttt = plt.ylabel("test", fontsize=14)
            x = -0.15 * axes["rmax"]
            y = 0.8 * axes["rmax"]
            handle = plt.text(
                x,
                y,
                "Standard Deviation",
                rotation=90,
                color=option["colstd"],
                fontweight=axlabweight,
                fontsize=plt.get(ttt, "fontsize"),
                horizontalalignment="center",
            )
            ax.append(handle)

        if option["titlecor"] == "on":
            pos1 = 45
            DA = 15
            lab = "Correlation Coefficient"
            c = np.fliplr([np.linspace(pos1 - DA, pos1 + DA, len(lab))])[0]
            dd = 1.1 * axes["rmax"]
            for ii, ith in enumerate(c):
                handle = plt.text(
                    dd * np.cos(ith * np.pi / 180),
                    dd * np.sin(ith * np.pi / 180),
                    lab[ii],
                )
                handle.set(
                    rotation=ith - 90,
                    color=option["colcor"],
                    horizontalalignment="center",
                    verticalalignment="bottom",
                    fontsize=plt.get(ax[0], "fontsize"),
                    fontweight=axlabweight,
                )
                ax.append(handle)

        if option["titlerms"] == "on":
            pos1 = option["tickrmsangle"] + (180 - option["tickrmsangle"]) / 2
            DA = 15
            pos1 = 160
            lab = "RMSD"
            c = np.fliplr([np.linspace(pos1 - DA, pos1 + DA, len(lab))])[0]

            # Find optimal placement of label
            itick = -1
            ratio = 1.0
            while ratio > 0.7:
                itick += 1
                ratio = (option["axismax"] -
                         option["tickrms"][itick]) / option["axismax"]
            dd = 0.7 * option["tickrms"][itick] + 0.3 * option["tickrms"][itick
                                                                          + 1]

            # Write label in a circular arc
            for ii, ith in enumerate(c):
                xtextpos = axes["dx"] + dd * np.cos(ith * np.pi / 180)
                ytextpos = dd * np.sin(ith * np.pi / 180)
                handle = plt.text(xtextpos, ytextpos, lab[ii])
                handle.set(
                    rotation=ith - 90,
                    color=option["colrms"],
                    horizontalalignment="center",
                    verticalalignment="top",
                    fontsize=plt.get(ax[0], "fontsize"),
                    fontweight=axlabweight,
                )
                ax.append(handle)

    else:
        # Double panel

        if option["titlestd"] == "on":
            ttt = plt.ylabel("test", fontsize=14)
            x = 0
            y = -0.15 * axes["rmax"]
            handle = plt.text(
                x,
                y,
                "Standard Deviation",
                rotation=0,
                color=option["colstd"],
                fontweight=axlabweight,
                fontsize=plt.get(ttt, "fontsize"),
                horizontalalignment="center",
            )
            ax.append(handle)

        if option["titlecor"] == "on":
            pos1 = 90
            DA = 25
            lab = "Correlation Coefficient"
            c = np.fliplr([np.linspace(pos1 - DA, pos1 + DA, len(lab))])[0]
            dd = 1.1 * axes["rmax"]
            for ii, ith in enumerate(c):
                handle = plt.text(
                    dd * np.cos(ith * np.pi / 180),
                    dd * np.sin(ith * np.pi / 180),
                    lab[ii],
                )
                handle.set(
                    rotation=ith - 90,
                    color=option["colcor"],
                    horizontalalignment="center",
                    verticalalignment="bottom",
                    fontsize=plt.get(ax[0], "fontsize"),
                    fontweight=axlabweight,
                )
                ax.append(handle)

        if option["titlerms"] == "on":
            pos1 = 160
            DA = 10
            lab = "RMSD"
            c = np.fliplr([np.linspace(pos1 - DA, pos1 + DA, len(lab))])[0]
            dd = 1.05 * option["tickrms"][0]
            for ii, ith in enumerate(c):
                xtextpos = axes["dx"] + dd * np.cos(ith * np.pi / 180)
                ytextpos = dd * np.sin(ith * np.pi / 180)
                handle = plt.text(xtextpos, ytextpos, lab[ii])
                handle.set(
                    rotation=ith - 90,
                    color=option["colrms"],
                    horizontalalignment="center",
                    verticalalignment="bottom",
                    fontsize=plt.get(ax[0], "fontsize"),
                    fontweight=axlabweight,
                )
                ax.append(handle)

    # VARIOUS ADJUSTMENTS TO THE PLOT:
    cax.set_aspect("equal")
    plt.axis("off")
    plt.gcf().patch.set_facecolor("w")

    # set axis limits
    if option["numberpanels"] == 2:
        axislim = [axes["rmax"] * x for x in [-1.15, 1.15, 0, 1.15]]
        plt.axis(axislim)
        plt.plot([-axes["rmax"], axes["rmax"]], [0, 0],
                 color=axes["tc"],
                 linewidth=2)
        plt.plot([0, 0], [0, axes["rmax"]], color=axes["tc"])
    else:
        axislim = [axes["rmax"] * x for x in [0, 1.15, 0, 1.15]]
        plt.axis(axislim)
        plt.plot([0, axes["rmax"]], [0, 0], color=axes["tc"], linewidth=2)
        plt.plot([0, 0], [0, axes["rmax"]], color=axes["tc"], linewidth=2)

    return ax