def pure_data_plot(self,connect=False,suffix='',cmap=cm.jet,bg=cm.bone(0.3)):
     #fig=plt.figure()
     ax=plt.axes()
     plt.axhline(y=0,color='grey', zorder=-1)
     plt.axvline(x=0,color='grey', zorder=-2)
     if cmap is None:
         if connect: ax.plot(self.x,self.y, 'b-',lw=2,alpha=0.5)
         ax.scatter(self.x,self.y, marker='o', c='b', s=40)
     else:
         if connect:
             if cmap in [cm.jet,cm.brg]:
                 ax.plot(self.x,self.y, 'c-',lw=2,alpha=0.5,zorder=-1)
             else:
                 ax.plot(self.x,self.y, 'b-',lw=2,alpha=0.5)
         c=[cmap((f-self.f[0])/(self.f[-1]-self.f[0])) for f in self.f]
         #c=self.f
         ax.scatter(self.x, self.y, marker='o', c=c, edgecolors=c, zorder=True, s=40) #, cmap=cmap)
     #plt.axis('equal')
     ax.set_xlim(xmin=-0.2*amax(self.x), xmax=1.2*amax(self.x))
     ax.set_aspect('equal')  #, 'datalim')
     if cmap in [cm.jet,cm.brg]:
         ax.set_axis_bgcolor(bg)
     if self.ZorY == 'Z':
         plt.xlabel(r'resistance $R$ in Ohm'); plt.ylabel(r'reactance $X$ in Ohm')
     if self.ZorY == 'Y':
         plt.xlabel(r'conductance $G$ in Siemens'); plt.ylabel(r'susceptance $B$ in Siemens')
     if self.show: plt.show()
     else: plt.savefig(join(self.sdc.plotpath,'c{}_{}_circle_data'.format(self.sdc.case,self.ZorY)+self.sdc.suffix+self.sdc.outsuffix+suffix+'.png'), dpi=240)
     plt.close()

def plot_stat(rows, cache):
    "Use matplotlib to plot DAS statistics"
    if  not PLOT_ALLOWED:
        raise Exception('Matplotlib is not available on the system')
    if  cache in ['cache', 'merge']: # cachein, cacheout, mergein, mergeout
        name_in  = '%sin' % cache
        name_out = '%sout' % cache
    else: # webip, webq, cliip, cliq
        name_in  = '%sip' % cache
        name_out = '%sq' % cache
    def format_date(date):
        "Format given date"
        val = str(date)
        return '%s-%s-%s' % (val[:4], val[4:6], val[6:8])
    date_range = [r['date'] for r in rows]
    formated_dates = [format_date(str(r['date'])) for r in rows]
    req_in  = [r[name_in] for r in rows]
    req_out = [r[name_out] for r in rows]

    plt.plot(date_range, req_in , 'ro-',
             date_range, req_out, 'gv-',
    )
    plt.grid(True)
    plt.axis([min(date_range), max(date_range), \
                0, max([max(req_in), max(req_out)])])
    plt.xticks(date_range, tuple(formated_dates), rotation=17)
#    plt.xlabel('dates [%s, %s]' % (date_range[0], date_range[-1]))
    plt.ylabel('DAS %s behavior' % cache)
    plt.savefig('das_%s.pdf' % cache, format='pdf', transparent=True)
    plt.close()

def link_level_bars(levels, usages, quantiles, scheme, direction, color, nnames, lnames, admat=None):
    """
    Bar plots of nodes' link usage of links at different levels.
    """
    if not admat:
        admat = np.genfromtxt('./settings/eadmat.txt')
    if color == 'solar':
        cmap = Oranges_cmap
    elif color == 'wind':
        cmap = Blues_cmap
    elif color == 'backup':
        cmap = 'Greys'
    nodes, links = usages.shape
    usageLevels = np.zeros((nodes, levels))
    usageLevelsNorm = np.zeros((nodes, levels))
    for node in range(nodes):
        nl = neighbor_levels(node, levels, admat)
        for lvl in range(levels):
            ll = link_level(nl, lvl, nnames, lnames)
            ll = np.array(ll, dtype='int')
            usageSum = sum(usages[node, ll])
            linkSum = sum(quantiles[ll])
            usageLevels[node, lvl] = usageSum / linkSum
            if lvl == 0:
                usageLevelsNorm[node, lvl] = usageSum
            else:
                usageLevelsNorm[node, lvl] = usageSum / usageLevelsNorm[node, 0]
        usageLevelsNorm[:, 0] = 1

    # plot all nodes
    usages = usageLevels.transpose()
    plt.figure(figsize=(11, 3))
    ax = plt.subplot()
    plt.pcolormesh(usages[:, loadOrder], cmap=cmap)
    plt.colorbar().set_label(label=r'$U_n^{(l)}$', size=11)
    ax.set_yticks(np.linspace(.5, levels - .5, levels))
    ax.set_yticklabels(range(1, levels + 1))
    ax.yaxis.set_tick_params(width=0)
    ax.xaxis.set_tick_params(width=0)
    ax.set_xticks(np.linspace(1, nodes, nodes))
    ax.set_xticklabels(loadNames, rotation=60, ha="right", va="top", fontsize=10)
    plt.ylabel('Link level')
    plt.savefig(figPath + '/levels/' + str(scheme) + '/' + 'total' + '_' + str(direction) + '_' + color + '.pdf', bbox_inches='tight')
    plt.close()

    # plot all nodes normalised to usage of first level
    usages = usageLevelsNorm.transpose()
    plt.figure(figsize=(11, 3))
    ax = plt.subplot()
    plt.pcolormesh(usages[:, loadOrder], cmap=cmap)
    plt.colorbar().set_label(label=r'$U_n^{(l)}$', size=11)
    ax.set_yticks(np.linspace(.5, levels - .5, levels))
    ax.set_yticklabels(range(1, levels + 1))
    ax.yaxis.set_tick_params(width=0)
    ax.xaxis.set_tick_params(width=0)
    ax.set_xticks(np.linspace(1, nodes, nodes))
    ax.set_xticklabels(loadNames, rotation=60, ha="right", va="top", fontsize=10)
    plt.ylabel('Link level')
    plt.savefig(figPath + '/levels/' + str(scheme) + '/' + 'total_norm_cont_' + str(direction) + '_' + color + '.pdf', bbox_inches='tight')
    plt.close()

def serve_css(name, length, keys, values):
    from pylab import plt, mpl
    mpl.rcParams['font.sans-serif'] = ['SimHei']
    mpl.rcParams['axes.unicode_minus'] = False
    from matplotlib.font_manager import FontProperties
    # font = FontProperties(fname="d:\Users\ll.tong\Desktop\msyh.ttf", size=12)
    font = FontProperties(fname="/usr/share/fonts/msyh.ttf", size=11)
    plt.xlabel(u'')
    plt.ylabel(u'出现次数',fontproperties=font)
    plt.title(u'词频统计',fontproperties=font)
    plt.grid()
    keys = keys.decode("utf-8").split(' ')
    values = values.split(' ')
    valuesInt = []
    for value in values:
        valuesInt.append(int(value))

    plt.xticks(range(int(length)), keys)
    plt.plot(range(int(length)), valuesInt)
    plt.xticks(rotation=defaultrotation, fontsize=9,fontproperties=font)
    plt.yticks(fontsize=10,fontproperties=font)
    name = name + str(datetime.now().date()).replace(':', '') + '.png'
    imgUrl = 'static/temp/' + name
    fig = matplotlib.pyplot.gcf()
    fig.set_size_inches(12.2, 2)
    plt.savefig(imgUrl, bbox_inches='tight', figsize=(20,4), dpi=100)
    plt.close()
    tempfile = static_file(name, root='./static/temp/')
    #os.remove(imgUrl)
    return tempfile

def render_confusion(file_name, queue, vmin, vmax, divergent, array_shape):
    from pylab import plt
    import matplotlib.animation as animation
    plt.close()
    fig = plt.figure()

    def update_img((expected, output)):
        plt.cla()
        plt.ylim((vmin, vmin+vmax))
        plt.xlim((vmin, vmin+vmax))
        ax = fig.add_subplot(111)
        plt.plot([vmin, vmin+vmax], [vmin, vmin+vmax])
        ax.grid(True)
        plt.xlabel("expected output")
        plt.ylabel("network output")
        plt.legend()

        expected = expected*vmax + vmin
        output = output*vmax + vmin
        #scat.set_offsets((expected, output))
        scat = ax.scatter(expected, output)
        return scat

    ani = animation.FuncAnimation(fig, update_img, frames=IterableQueue(queue))

    ani.save(file_name, fps=30, extra_args=['-vcodec', 'libvpx', '-threads', '4', '-b:v', '1M'])

 def test_plot_dep_contour(self):
     plot = MapPlotSlab()
     plot.plot_dep_contour(-20, color='red')
     plot.plot_dep_contour(-40, color='blue')
     plot.plot_dep_contour(-60, color='black')
     plt.savefig(join(this_test_path, '~outs/plot_dep_contour.png'))
     plt.close()

    def plot(cls, data, figure_folder, msg="", suffix=""):

        fig, ax = plt.subplots()

        plt.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0.2)

        x = np.arange(len(data[:]))

        ax.plot(x, data[:, 0], c="red", linewidth=2, label="agent 01")
        ax.plot(x, data[:, 1], c="blue", linewidth=2, label="agent 12")
        ax.plot(x, data[:, 2], c="green", linewidth=2, label="agent 20")

        plt.ylim([-0.01, 1.01])

        plt.text(0, -0.23, "PARAMETERS. {}".format(msg))

        ax.legend(fontsize=12, bbox_to_anchor=(1.1, 1.05))  # loc='upper center'
        ax.set_xlabel("$t$")
        ax.set_ylabel("Proportion of agents proceeding to indirect exchange")

        ax.set_title("Money emergence with a basal ganglia model")

        # Save fig
        if not exists(figure_folder):
            mkdir(figure_folder)
        fig_name = "{}/figure_{}.pdf".format(figure_folder, suffix.split(".p")[0])
        plt.savefig(fig_name)
        plt.close()

    def test1(self):
        partition_file = '/home/zy/workspace/viscojapan/tests/share/deformation_partition.h5'
        res_file = '/home/zy/workspace/viscojapan/tests/share/nrough_05_naslip_11.h5'



        plotter = vj.inv.PredictedTimeSeriesPlotter(
            partition_file = partition_file,
            #result_file = res_file,
            )

        site = 'J550'
        cmpt = 'e'
        #plotter.plot_cumu_disp_pred(site, cmpt)
        #plotter.plot_cumu_disp_pred_added(site, cmpt, color='blue')
        # plotter.plot_post_disp_pred_added(site, cmpt)
        #plotter.plot_cumu_obs_linres(site, cmpt)
        #plotter.plot_R_co(site, cmpt)
        # plotter.plot_post_disp_pred(site, cmpt)
        # plotter.plot_post_obs_linres(site, cmpt)
        #plotter.plot_E_cumu_slip(site, cmpt)
        # plotter.plot_E_aslip(site, cmpt)
        #plotter.plot_R_aslip(site, cmpt)
        #plt.show()
        #plt.close()


        #
        plotter.plot_cumu_disp_decomposition(site, cmpt)
        plt.show()
        plt.close()

        plotter.plot_post_disp_decomposition(site, cmpt)
        plt.show()
        plt.close()

    def test_plot_slip(self):
        ep = EpochalIncrSlip(self.file_incr_slip)

        plot = MapPlotFault(self.file_fault)
        plot.plot_slip(ep(0))

        plt.savefig(join(self.outs_dir, 'plot_slip.png'))
        plt.close()

 def plot_data(self):
     for i,dat in enumerate(self.data):
         plt.imshow(dat, cmap=cm.jet, interpolation=None, extent=[11,22,-3,2])
         txt='plot '.format(self.n[i])
         txt+='\nmin {0:.2f} und max {1:.2f}'.format(self.min[i],self.max[i])
         txt+='\navg. min {0:.2f} und avg. max {1:.2f}'.format(mean(self.min),mean(self.max))
         plt.suptitle(txt,x=0.5,y=0.98,ha='center',va='top',fontsize=10)
         plt.savefig(join(self.plotpath,'pic_oo_'+str(self.n[i])+'.png'))
         plt.close()  # wichtig, sonst wird in den selben Plot immer mehr reingepackt

def plot_post(cfs,ifshow=False,loc=2,
              save_fig_path = None, file_type='png'):
    for cf in cfs:
        plot_cf(cf, color='blue')
        plt.legend(loc=loc)
        if ifshow:
            plt.show()
        if save_fig_path is not None:
            plt.savefig(join(save_fig_path, '%s_%s.%s'%(cf.SITE, cf.CMPT, file_type)))
        plt.close()

 def plot_mat(self, mat, fn):
     plt.matshow(asarray(mat.todense()))
     plt.axis('equal')
     sh = mat.shape
     plt.gca().set_yticks(range(0,sh[0]))
     plt.gca().set_xticks(range(0,sh[1]))
     plt.grid('on')
     plt.colorbar()
     plt.savefig(join(self.outs_dir, fn))
     plt.close()

 def test_dip(self):
     xf = arange(0, 425)
     dips = self.fm.get_dip(xf)
     plt.plot(xf,dips)
     plt.grid('on')
     plt.gca().set_xticks(self.fm.Y_PC)
     plt.ylim([0, 30])
     plt.gca().invert_yaxis()
     plt.savefig(join(self.outs_dir, '~y_fc_dips.png'))
     plt.close()

    def test_pcolor_on_fault(self):
        ep = EpochalIncrSlip(self.file_incr_slip)
        fio = FaultFileIO(self.file_fault)

        slip = ep(0).reshape([fio.num_subflt_along_dip,
                              fio.num_subflt_along_strike])

        plot = MapPlotFault(self.file_fault)
        plot.pcolor_on_fault(slip)
        plt.savefig(join(self.outs_dir, 'pcolor_on_fault.png'))
        plt.close()

    def test_share_basemap(self):
        bm = MyBasemap(x_interval = 1)

        p1 = MapPlotSlab(basemap = bm)
        p1.plot_top()
        
        p2 = MapPlotFault(fault_file=join(this_script_dir, 'share/fault.h5'),
                          basemap = bm)
        p2.plot_fault()

        plt.savefig(join(this_script_dir, '~outs/share_basemap.png'))
        plt.close()

    def test_ground2geo(self):
        xp = linspace(0, 700, 25)
        yp = linspace(0, 425, 30)
        xxp, yyp = meshgrid(xp, yp)
       
        LLons, LLats = self.fm.ground2geo(xxp, yyp)

        self.plt_map.basemap.plot(LLons,LLats,color='gray',latlon=True)
        self.plt_map.basemap.plot(ascontiguousarray(LLons.T),
                  ascontiguousarray(LLats.T),
                  color='gray',latlon=True)
        plt.savefig('~test_ground2geo.png')
        plt.close()

    def test1(self):
        partition_file = '/home/zy/workspace/viscojapan/tests/share/deformation_partition.h5'

        plotter = vj.inv.PredictedVelocityTimeSeriesPlotter(
            partition_file = partition_file
            )

        site = 'J550'
        cmpt = 'e'

        plotter.plot_vel_decomposition(site, cmpt)
        plt.show()
        plt.close()

    def test_fault2geo(self):
        xf = linspace(0., 700, 25)
        yf = linspace(0, 425, 30)
        xxf, yyf = meshgrid(xf, yf)
        
        LLons, LLats = self.fm.fault2geo(xxf, yyf)

        self.plt_map.basemap.plot(LLons,LLats,color='gray',latlon=True)
        self.plt_map.basemap.plot(ascontiguousarray(LLons.T),
                  ascontiguousarray(LLats.T),
                  color='gray',latlon=True)
        plt.savefig('~test_fault2geo.png')
        plt.close()

 def plot_smoothed_alpha_comparison(self,rmsval,suffix=''):
     plt.plot(self.f,self.alpha,'ko',label='data set')
     plt.plot(self.f,self.salpha,'c-',lw=2,label='smoothed angle $\phi$')
     plt.xlabel('frequency in Hz')
     plt.ylabel('angle $\phi$ in coordinates of circle')
     plt.legend()
     ylims=plt.axes().get_ylim()
     plt.yticks((arange(9)-4)*0.5*pi, ['$-2\pi$','$-3\pi/2$','$-\pi$','$-\pi/2$','$0$','$\pi/2$','$\pi$','$3\pi/2$','$2\pi$'])
     plt.ylim(ylims)
     plt.title('RMS offset from smooth curve: {:.4f}'.format(rmsval))
     if self.show: plt.show()
     else: plt.savefig(join(self.sdc.plotpath,'salpha','c{}_salpha_on_{}_circle'.format(self.sdc.case,self.ZorY)+self.sdc.suffix+self.sdc.outsuffix+suffix+'.png'), dpi=240)
     plt.close()

    def test1(self):
        file_G = join(self.share_dir,'G0_He50km_VisM6.3E18_Rake83.h5')
        G = vj.inv.ep.EpochGNoRaslip(file_G,
                             mask_sites= ['J550']
        )

        out = G.get_data_at_epoch(0)

        stacked = G.stack([0,60,120])

        plt.matshow(abs(stacked)*100, aspect=5)
        # plt.show()
        plt.close()