def print_latex():

        for i in range(1,7):Respostas[i] = sympy.nsimplify(Respostas[i].evalf(prec), rational = True,tolerance = 0.05)



        # 0- Raizes; 1- Forma Natural da respsota; 2- Resposta Natural;
        # 3- Resposta Particular; 4- Resposta Transitoria; 5- Respsota Forcada
        # 6- Resposta Completa
        # 7-Sinal de entrada x(t)
        ###
        eqDiferencialEntradaLatex = latex(eq)

        ##Perfumaria
        dif = 0.9 -0.77
        xdif = -0.15
        font = {'family' : 'Sans',
                'weight' : 'normal',
                'size'   : 18}

        plt.rc('font', **font)

        ##Obtendo as respostas em Latex
        RespostasEmLatex = [0]*(len(Respostas))
        raizEmLatex = [0]*(len(Respostas[0]))
        str_raizLatex =""
        for i in range(len(Respostas[0])):
                raizEmLatex[i] = '$'+str(latex(Respostas[0][i])) +'$'
        for i in range(len(raizEmLatex)):
                rn = "r"+str(i+1)+" = "
                rn = '$'+str(latex(rn)) +'$'
                str_raizLatex = str_raizLatex+"\t"+rn+raizEmLatex[i]
        ##print len(RespostasEmLatex)
        for i in range(len(Respostas)):
                RespostasEmLatex[i] = '$'+str(latex(Respostas[i])) +'$'
        #print RespostasEmLatex
        xTLatex = '$' + latex(xT) +'$'
        ###Preparando para imprimir
        log_figure = plt.figure("Representacao",facecolor='white')
        ax1 = plt.axes(frameon = False)
        ax1.get_xaxis().tick_bottom()
        ax1.get_xaxis().set_visible(False)
        ax1.axes.get_yaxis().set_visible(False)
        for i in range(0,8,1):
                plt.axhline(0.86-dif*i,xmin = -5,xmax = 5, color = 'black',lw =0.2, linestyle = ':')
        #log_figure.figure("Forma_Representativa:")
        plt.title("Eq dif: 0="+ur'$'+eqDiferencialEntradaLatex+'$', loc = 'left',fontsize = 15)
        plt.text(xdif,0.89,'Forma Natural:'+ur''+RespostasEmLatex[1])
        plt.text(xdif,0.9-dif,'yn(t) = '+ur''+RespostasEmLatex[2])
        plt.text(xdif,0.9-2*dif,'ypar(t) = '+ur''+RespostasEmLatex[3])
        plt.text(xdif,0.9-3*dif,'ytran(t) = '+ur''+RespostasEmLatex[4])
        plt.text(xdif,0.9-4*dif,'yfor(t) = '+ur''+RespostasEmLatex[5])
        plt.text(xdif,0.9-5*dif,'yc(t) = '+ur''+RespostasEmLatex[6])
        plt.text(xdif,0.9-6*dif,'x(t) = '+ur''+xTLatex)
        plt.text(xdif,0.9-7*dif,'Raiz(es): '+ur''+str_raizLatex)

        ##log_figure.set_size_inches(19.2,10.8)
        #log_figure.show()
        plt.show()
        return log_figure
Example #2
0
def disc_norm():
    x = np.linspace(-3,3,100)
    y = st.norm.pdf(x,0,1)
    fig, ax = plt.subplots()
    fig.canvas.draw()
    
    ax.plot(x,y)
    
    fill1_x = np.linspace(-2,-1.5,100)
    fill1_y = st.norm.pdf(fill1_x,0,1)
    fill2_x = np.linspace(-1.5,-1,100)
    fill2_y = st.norm.pdf(fill2_x,0,1)
    ax.fill_between(fill1_x,0,fill1_y,facecolor = 'blue', edgecolor = 'k',alpha = 0.75)
    ax.fill_between(fill2_x,0,fill2_y,facecolor = 'blue', edgecolor = 'k',alpha = 0.75)
    for label in ax.get_yticklabels():
        label.set_visible(False)
    for tick in ax.get_xticklines():
        tick.set_visible(False)
    for tick in ax.get_yticklines():
        tick.set_visible(False)
    
    plt.rc("font", size = 16)
    plt.xticks([-2,-1.5,-1])
    labels = [item.get_text() for item in ax.get_xticklabels()]
    labels[0] = r"$v_k$"
    labels[1] = r"$\varepsilon_k$"
    labels[2] = r"$v_{k+1}$"
    ax.set_xticklabels(labels)
    plt.ylim([0, .45])

    
    plt.savefig('discnorm.pdf')
    plt.clf()
Example #3
0
 def png(self, start_timestamp, end_timestamp):
     self.load(start_timestamp, end_timestamp)
     plt.figure(figsize=(10, 7.52))
     plt.rc("axes", labelsize=12, titlesize=14)
     plt.rc("font", size=10)
     plt.rc("legend", fontsize=7)
     plt.rc("xtick", labelsize=8)
     plt.rc("ytick", labelsize=8)
     plt.axes([0.08, 0.08, 1 - 0.27, 1 - 0.15])
     for plot in self.plots:
         plt.plot(self.timestamps, self.plots[plot], self.series_fmt(plot), label=self.series_label(plot))
     plt.axis("tight")
     plt.gca().xaxis.set_major_formatter(
         matplotlib.ticker.FuncFormatter(lambda x, pos=None: time.strftime("%H:%M\n%b %d", time.localtime(x)))
     )
     plt.gca().yaxis.set_major_formatter(
         matplotlib.ticker.FuncFormatter(lambda x, pos=None: locale.format("%.*f", (0, x), True))
     )
     plt.grid(True)
     plt.legend(loc=(1.003, 0))
     plt.xlabel("Time/Date")
     plt.title(
         self.description()
         + "\n%s to %s"
         % (
             time.strftime("%H:%M %d-%b-%Y", time.localtime(start_timestamp)),
             time.strftime("%H:%M %d-%b-%Y", time.localtime(end_timestamp)),
         )
     )
     output_buffer = StringIO.StringIO()
     plt.savefig(output_buffer, format="png")
     return output_buffer.getvalue()
Example #4
0
def plot(title, dates, lines, labels, count, name, wdir):
    
    N = len(dates)                                                                                  
    start = N - count                                                                               
    date_idx = range(count)                                                                         
                                                                                                    
    def format_date(x, pos=None):                                                                   
        idx = start + int(x)                                                                        
        if idx >= N:                                                                                
            idx = N - 1                                                                             
        return dates[idx].strftime('%m-%d')                                                         
                                                                                                    
    plt.rcParams.update({'font.size': 9})                                                           
    plt.rc('legend', **{'fontsize':8})                                                              
                                                                                                    
    fig = plt.figure()                                                                              
#    ax = fig.add_subplot(111)                                                                      
    ax = fig.add_axes([0.075, 0.125, 0.68, 0.765])                                                  
    handles = []                                                                                    
    for i in range(len(lines)):                                                                     
        handle = ax.plot(date_idx, lines[i][start:], label=labels[i])    
        handles.append(handle)                                                                      
    ax.xaxis.set_major_formatter(ticker.FuncFormatter(format_date))                                 
                                                                                                    
    fig.autofmt_xdate()                                                                             
    fig.set_size_inches(4.25, 2.15)                                                                 
    fig.legend(handles, labels, 'upper right')                                                      
    plt.title(title)                                                                                
    
    filename = wdir + '\\' + name + '.png'                                                                                                              
#    plt.show()                                                                                     
    plt.savefig(filename)
    
    return (name, filename)                                                                     
Example #5
0
def plot(filename):
    import os
    from matplotlib.pyplot import clf, tricontour, tricontourf, \
        gca, savefig, rc, minorticks_on

    if not os.path.exists(filename):
        return -1

    rc('text', usetex=True)
    clf()
    x, y, tri, ux, uy = load_velocity(filename)
    tricontourf(x, y, tri, ux, 16)
    tricontour(x, y, tri, ux, 16, linestyles='-',
               colors='black', linewidths=0.5)
    minorticks_on()
    gca().set_aspect('equal')
    gca().tick_params(direction='out', which='both')
    gca().set_xticklabels([])
    gca().set_yticklabels([])

    name, _ = os.path.splitext(filename)
    name = os.path.basename(name)

    savefig('{0}.png'.format(name), dpi=300, bbox_inches='tight')
    savefig('{0}.pdf'.format(name), bbox_inches='tight')
Example #6
0
def hist(nndist, **kwds):
    if 'output' in kwds:
        import matplotlib
        matplotlib.use('Agg')
    from matplotlib import pyplot as plt

    # handle formatting keywords
    linewidth = kwds.get('linewidth', 3)
    #plt.rc('text', usetex=True)
    plt.rc('font', family='serif')
    n, bins, patches = plt.hist(nndist, normed=True, bins=100)
    width = bins[1] - bins[0]
    ax1 = plt.gca()
    ax2 = plt.twinx()
    ax2.plot(bins[:-1], width*np.cumsum(n), 'r-', linewidth=linewidth)
    ax2.set_ylim(top=1.0)
    tics = ax1.get_yticks(); ax1.set_yticks(tics[1:])
    tics = ax2.get_yticks(); ax2.set_yticks(tics[1:])
    ax1.set_xlabel(r"d ($\mu$m)")
    ax1.set_ylabel(r"PDF")
    ax2.set_ylabel(r"CDF", color='r')
    for tl in ax2.get_yticklabels():
        tl.set_color('r')
    # check scalar descriptors
    median_dist = np.median(nndist)
    ax1.axvline(median_dist, color='gray', linewidth=linewidth)
    # handle keywords
    if 'title' in kwds:
        plt.title(kwds['title'])
    if 'output' in kwds:
        plt.draw()
        plt.savefig(kwds['output'])
    else:
        plt.show()
def plot_all():

    font = {'family': 'serif',
            'weight': 'normal',
            'size': 12,
            }

    plt.rc('font', **font)

    data = DataReader('dyn_spin.txt')
    ts = data['time']

    fig = plt.figure(figsize=(5, 4))

    mx = data['m_x']
    my = data['m_y']
    mz = data['m_z']
    plt.plot(ts, mx, '-', label='mx', color='b')
    plt.plot(ts, my, '-', label='my', color='g')
    plt.plot(ts[::6], mz[::6],'.-', label='mz',  color='r')

    plt.legend(bbox_to_anchor=[0.8, 0.8], shadow=True, frameon=True)
    #plt.xlim([0, 1.01])

    plt.legend()

    plt.xlabel('Time')
    plt.ylabel('m')
    plt.tight_layout()
    fig.savefig('m_ts.pdf')
Example #8
0
def bias_KSB_weight(Args, gal_hlr):
    """Make plots to analyze CG bias with weight function""" 
    mcg_w_ksb, ccg_w_ksb = [],[] 
    weights=np.linspace(0.5,2, 15)
    rt_g=[[0.005,0.005],[0.01,0.01]]
    gtrue=np.array(rt_g)
    for w in weights:
        input_args = Args
        input_args.shear_est='KSB'
        input_args.sig_w = w*gal_hlr
        input_args.rt_g = rt_g
        gcgw,gnocgw=cg.calc_cg(input_args)
        fit_fin   = np.polyfit(gtrue.T[0],gcgw.T-gnocgw.T,1)
        mcg_w_ksb.append(fit_fin[0])
        ccg_w_ksb.append(fit_fin[1])

    k=0
    plt.rc('legend',**{'fontsize':16})
    plt.figure(figsize=[12,8])
    #plt.subplots_adjust(hspace=0.4)
    #plt.subplots_adjust(wspace = 0.4)
    #plt.subplot(221)
    if Args.telescope is 'Euclid':
        plt.plot(weights,-np.array(mcg_w_ksb).T[k],label='KSB',linewidth=2.5)
        plt.ylabel(r'-$\rm m_{CG}$', size=22)
    else:
        plt.plot(weights,np.array(mcg_w_ksb).T[k],label='KSB',linewidth=2.5)
        plt.ylabel(r'$\rm m_{CG}$', size=22)
        
    plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)    
    plt.xlabel(r'weight function size/galaxy size',size=20)    
    plt.title(r'Dependence of $\rm m_{CG}$ '+'on weight function size for {0}'.format(Args.telescope),
              size=22)
    plt.xticks(fontsize = 16)
    plt.yticks(fontsize = 16)
Example #9
0
def boxplotThem(dataToPlot,title):
    means = [np.mean(item) for item in dataToPlot]
    fig = plt.figure(1, figsize=(9,6))
    ax = fig.add_subplot(111)

    plt.rc('text', usetex=True)
    plt.rc('font', family='serif')
    for i in range(25):
        print('length ',str(i+1))
        for item in dataToPlot[i]:
            ax.scatter(i+1,item)

    ax.plot(list(range(1,26)),means,linewidth=4,color='r')

    ax.set_xticks([1,5,10,15,20,25])
    ax.set_xticklabels([r"$1",r"$5$",r"$10$",r"$15$",r"$20$",r"$25$"],fontsize = 25)

    ax.set_yscale('log')
    ax.set_yticks([0.00000001,0.000001,0.0001,0.01,1])
    ax.xaxis.set_tick_params(width=1.5)
    ax.yaxis.set_tick_params(width=1.5)
    ax.set_yticklabels([r"$10^{-8}$",r"$10^{-6}$",r"$10^{-4}$",r"$10^{-2}$",r"$1$"],fontsize = 25)
    ax.get_yaxis().get_major_formatter().labelOnlyBase = False
    ax.set_ylabel('relative population',fontsize = 30)
    ax.set_xlabel(r'length',fontsize = 30)
    ax.set_xlim(0,26)
    ax.set_ylim(0.00000005)
    plt.suptitle(title,fontsize=25)
    plt.savefig(r.outputDir+'distr.png')
Example #10
0
def setup_colors():
    pyplot.rc('axes', color_cycle=['#ff0000','#00ff00','#0000ff',
        '#ffff00','#ff00ff','#00ffff',
        '#000000','#ff8000','#0080ff',
        '#ff0080','#80ff00','#8000ff',
        '#00ff80','#ff8080','#80ff80',
        '#8080ff'])
Example #11
0
def dim_sensitivity_plot(x, Y, fname, show_legend=True):

    plt.rc('text', usetex=True)
    plt.rc('font', family='serif')

    plt.figure(figsize=(3, 3))
    plt.xlabel('$d$', size=FONTSIZE)
    plt.ylabel('ROC AUC', size=FONTSIZE)

    plt.set_cmap('Set2')

    lines = []
    for i, label in enumerate(KEYS):
        line_data = Y.get(label)

        if line_data is None:
            continue
        
        line, = plt.plot(x, line_data, label=label, marker=MARKERS[i],
                         markersize=0.5 * FONTSIZE, color=COLORS[i])
        lines.append(line)



    if show_legend:
        plt.legend(handles=lines)
        plt.legend(loc='lower right')
    plt.xscale('log', basex=2)
    plt.xticks(x, [str(y) for y in x], size=FONTSIZE)
    plt.yticks(size=FONTSIZE)
    plt.tight_layout()

    plt.savefig(fname)
Example #12
0
def test_tilde_in_tempfilename():
    # Tilde ~ in the tempdir path (e.g. TMPDIR, TMP oder TEMP on windows
    # when the username is very long and windows uses a short name) breaks
    # latex before https://github.com/matplotlib/matplotlib/pull/5928
    import tempfile
    import shutil
    import os
    import os.path

    tempdir = None
    old_tempdir = tempfile.tempdir
    try:
        # change the path for new tempdirs, which is used
        # internally by the ps backend to write a file
        tempdir = tempfile.mkdtemp()
        base_tempdir = os.path.join(tempdir, "short~1")
        os.makedirs(base_tempdir)
        tempfile.tempdir = base_tempdir

        # usetex results in the latex call, which does not like the ~
        plt.rc('text', usetex=True)
        plt.plot([1, 2, 3, 4])
        plt.xlabel(r'\textbf{time} (s)')
        #matplotlib.verbose.set_level("debug")
        output_eps = os.path.join(base_tempdir, 'tex_demo.eps')
        # use the PS backend to write the file...
        plt.savefig(output_eps, format="ps")
    finally:
        tempfile.tempdir = old_tempdir
        if tempdir:
            try:
                shutil.rmtree(tempdir)
            except Exception as e:
                # do not break if this is not removeable...
                print(e)
Example #13
0
def PlotData(Stock,buyselldata):
    plt.rc('axes', grid=True)
    plt.rc('grid', color='0.75', linestyle='-', linewidth=0.5)
    
    textsize = 9
    left, width = 0.1, 0.8
    rect1 = [left, 0.1, width, 0.9]

    fig = plt.figure(facecolor='white')
    axescolor  = '#f6f6f6'  # the axies background color

    ax1 = fig.add_axes(rect1, axisbg=axescolor)  #left, bottom, width, height

    ### plot the relative strength indicator
    prices = Stock.close
   
    fillcolor = 'darkgoldenrod'
    
    plt.plot(Stock.date, prices, color=fillcolor)            
    for i in buyselldata[0]:
        plt.plot(Stock.date[i],prices[i],'bo')
    for i in buyselldata[1]:
        plt.plot(Stock.date[i],prices[i],'rx')
    plt.show()            
            
Example #14
0
def visualize_data(mnist):
    plt.rc("image",cmap="binary")
    plt.subplot(10,10,1)
    for i in range(100):
        plt.subplot(10,10,i)
        idx=np.random.randint(len(mnist.data))
        plt.imshow(mnist.data[idx].reshape(28,28))
Example #15
0
    def plot(self, debug = False):
	"""plot figures for population, nuisance parameters"""
	# first figure out what scheme is used
	self.list_scheme()

	# next get MABR sampling done
	self.MBAR_analysis()

	# load in precomputed P and dP from MBAR analysis
        pops0, pops1   = self.P_dP[:,0], self.P_dP[:,self.K-1]
        dpops0, dpops1 = self.P_dP[:,self.K], self.P_dP[:,2*self.K-1]
	t0 = self.traj[0]
    	t1 = self.traj[self.K-1]

        # Figure Plot SETTINGS
        label_fontsize = 12
        legend_fontsize = 10
        fontfamily={'family':'sans-serif','sans-serif':['Arial']}
        plt.rc('font', **fontfamily)

        # determine number of row and column
        if (len(self.scheme)+1)%2 != 0:
            c,r = 2, (len(self.scheme)+2)/2
    	else:
            c,r = 2, (len(self.scheme)+1)/2
    	plt.figure( figsize=(4*c,5*r) )
    	# Make a subplot in the upper left
    	plt.subplot(r,c,1)
    	plt.errorbar( pops0, pops1, xerr=dpops0, yerr=dpops1, fmt='k.')
    	plt.hold(True)
    	plt.plot([1e-6, 1], [1e-6, 1], color='k', linestyle='-', linewidth=2)
    	plt.xlim(1e-6, 1.)
    	plt.ylim(1e-6, 1.)
    	plt.xlabel('$p_i$ (exp)', fontsize=label_fontsize)
    	plt.ylabel('$p_i$ (sim+exp)', fontsize=label_fontsize)
    	plt.xscale('log')
    	plt.yscale('log')
    	# label key states
    	plt.hold(True)
    	for i in range(len(pops1)):
        	if (i==0) or (pops1[i] > 0.05):
            		plt.text( pops0[i], pops1[i], str(i), color='g' )
    	for k in range(len(self.scheme)):
        	plt.subplot(r,c,k+2)
        	plt.step(t0['allowed_'+self.scheme[k]], t0['sampled_'+self.scheme[k]], 'b-')
        	plt.hold(True)
        	plt.xlim(0,5)
        	plt.step(t1['allowed_'+self.scheme[k]], t1['sampled_'+self.scheme[k]], 'r-')
        	plt.legend(['exp', 'sim+exp'], fontsize=legend_fontsize)
        	if self.scheme[k].find('cs') == -1:
            		plt.xlabel("$\%s$"%self.scheme[k], fontsize=label_fontsize)
            		plt.ylabel("$P(\%s)$"%self.scheme[k], fontsize=label_fontsize)
            		plt.yticks([])
        	else:
            		plt.xlabel("$\sigma_{%s}$"%self.scheme[k][6:],fontsize=label_fontsize)
            		plt.ylabel("$P(\sigma_{%s})$"%self.scheme[k][6:],fontsize=label_fontsize)
            		plt.yticks([])

    	plt.tight_layout()
    	plt.savefig(self.picfile)
Example #16
0
def plot_objectivefunctiontraces(results,evaluation,algorithms,filename='Like_trace'):
    import matplotlib.pyplot as plt
    from matplotlib import colors
    cnames=list(colors.cnames)
    font = {'family' : 'calibri',
        'weight' : 'normal',
        'size'   : 20}
    plt.rc('font', **font)   
    fig=plt.figure(figsize=(16,3))
    xticks=[5000,15000]
    
    for i in range(len(results)):
        ax  = plt.subplot(1,len(results),i+1)
        likes=calc_like(results[i],evaluation)  
        ax.plot(likes,'b-')
        ax.set_ylim(0,25)
        ax.set_xlim(0,len(results[0]))
        ax.set_xlabel(algorithms[i])
        ax.xaxis.set_ticks(xticks)
        if i==0:
            ax.set_ylabel('RMSE')
            ax.yaxis.set_ticks([0,10,20])   
        else:
            ax.yaxis.set_ticks([])        
        
    plt.tight_layout()
    fig.savefig(str(filename)+'.png')
Example #17
0
def plotcurve(xax,f1,f2,ct):
	fig, axes = plt.subplots(nrows=4, ncols=1, sharex=True)
	plt.minorticks_on()
	fig.subplots_adjust(hspace = 0.001)
	plt.rc('font', family='serif',serif='Times')
	y_formatter = matplotlib.ticker.ScalarFormatter(useOffset=False)
	
	axes[0].plot(xax,f1[0],'D-',c='k',mec='b',fillstyle='none')
	axes[0].plot(xax,f2[0],'o-',c='g',mec='k',fillstyle='none')
	axes[0].set_ylabel(r'$raw$ $RMS$',fontsize=13)
	axes[0].yaxis.set_major_formatter(y_formatter)
	axes[0].yaxis.set_major_locator(MaxNLocator(prune='both',nbins=5))

	axes[1].plot(xax,f1[1],'D-',c='k',mec='b',fillstyle='none')
	axes[1].plot(xax,f2[1],'o-',c='g',mec='k',fillstyle='none')
	axes[1].set_ylabel(r'$frames$ $RMS$',fontsize=13)
	axes[1].yaxis.set_major_formatter(y_formatter)
	axes[1].yaxis.set_major_locator(MaxNLocator(prune='both',nbins=5))

	axes[2].plot(xax,f1[2],'D-',c='k',mec='b',fillstyle='none')
	axes[2].plot(xax,f2[2],'o-',c='g',mec='k',fillstyle='none')
	axes[2].set_ylabel(r'$\sigma-clipped$',fontsize=13)
	axes[2].yaxis.set_major_formatter(y_formatter)
	axes[2].yaxis.set_major_locator(MaxNLocator(prune='both',nbins=5))

	axes[3].plot(xax,f1[3],'D-',c='k',mec='b',fillstyle='none',label='Hard')
	axes[3].plot(xax,f2[3],'o-',c='g',mec='k',fillstyle='none',label='Soft')
	axes[3].set_ylabel(r'$\sigma$ $clipped$ $RMS$',fontsize=13)
	axes[3].set_xlabel(r'$aperture$ $(pixels)$',fontsize=13)
	axes[3].yaxis.set_major_formatter(y_formatter)
	axes[3].yaxis.set_major_locator(MaxNLocator(prune='both',nbins=5))
	axes[3].legend(numpoints=1)
	plt.savefig('paneltest/'+str(ct)+'updchanges.png',bbox_inches='tight',dpi=200)
Example #18
0
def hw8_plot_NPT_instant_msd():
    T_labels = ['0.50', '1.00', '2.00']
    T = [0.5, 1.0, 2.0]
    N = ['32', '108', '256']
    P = ['1.0', '10.0', '20.0']
    
    pyplot.rc('legend',**{'fontsize':10})
    # Plots NVT energies
    i = 0
    for p in P:
        for n in N:
        
            i += 1
            ax = pyplot.subplot(620 + i)
            
            for t in T_labels:
            
                
                
                row = hw8_get_data(n, 'NPT', t, 1, p)
                
                pyplot.setp(ax.get_xticklabels(), fontsize=8)
                pyplot.setp(ax.get_yticklabels(), fontsize=8)
                
                pyplot.plot(row[:,c_step_number], row[:,c_msd], label = 'T = ' + t, linestyle = '--')
                pyplot.xlabel('Step', fontsize=10)
                pyplot.ylabel('MSD', fontsize=10)
                pyplot.legend(loc="upper right")
                pyplot.title('NPT, P = ' + p +', N = ' + n + ', Density = 0.9', fontsize=10)
    
    pyplot.show()
Example #19
0
def StDistributionPlot(Stdistribution):
    ''' 
        Given a dict cointaning azi and dist for each stations
        it makes a plot of the distribution
    ''' 
        
    fig = plt.figure(figsize=(10,10))
    plt.rc('grid', color='#316931', linewidth=1, linestyle='-')  
    ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], polar=True, axisbg='#d5de9c')
   
    

    for trid, val in Stdistribution.iteritems():
        idsplit = trid.split(".")
        stname = idsplit[1]       
        ax.plot([val['azi']],[val['dist']],'o', ms=15)
        ax.annotate(stname,xytext=(val['azi'], val['dist']),
                    xy = (val['azi'], val['dist']))
    ax.set_rgrids(ax.get_yticks(),  angle=135)
    ticks = [str(tick) + r'$^o$' for tick in ax.get_yticks()]
    print ticks
    ax.set_yticklabels(ticks)          
    ax.set_theta_zero_location("N")
    ax.set_theta_direction(1)
    ax.set_thetagrids([0, 90, 180, 270], labels = 
                       ['N', 'E', 'S', 'W' ]  )
Example #20
0
def make_accuracy_plot():
	from numpy import linspace, mean
	from math import pi
	from matplotlib import pyplot as pl
	pl.rc('text', usetex=True)
	pl.rc('font', family='serif')
	pl.axvline(x=1,color='k')
	pl.xlabel(r'$$\lambda$$',fontsize=16)
	pl.ylabel(r'$$\epsilon$$',fontsize=16)
	print "Testing M=0"
	it_list = list()
	#We test for zero revolutions
	err,it,la,x,T = test_standard(M=100000,gooding=False,
		house=True,tau=False,iter_max=15,eps=1e-5, rnd_seed=4562,N=0)
	it_list.append(mean(it))
	pl.semilogy(la,err,'k.')
	#We test for multiple revolutions
	for rev in range(50):
		print "Testing M=" + str(rev)
		err,it,la,x,T = test_standard(M=10000,gooding=False,
			house=True,tau=False,iter_max=15,eps=1e-8, rnd_seed=4562+rev+1,N=rev+1)
		pl.semilogy(la,err,'k.')
		it_list.append(mean(it))
	pl.figure()
	pl.plot(it_list)
Example #21
0
    def plotSeqsAvesLen(self,categories):
        (autox,autoy,foldx,foldy,regx,regy) = categories
        plt.gcf().subplots_adjust(bottom=0.15)
        plt.gcf().subplots_adjust(left=0.15)
        fig = plt.figure(1, figsize=(9,6))
        ax = fig.add_subplot(111)
        plt.rc('text', usetex=True)
        plt.rc('font', family='serif')

        ax.scatter(regx,regy,color='0.4')
        ax.scatter(foldx,foldy,color='b')
        ax.scatter(autox,autoy,color='r')

        ax.set_yscale('log')
        ax.set_xticks([1,5,10,15,20,25])
        ax.set_xticklabels([r"$1",r"$5$",r"$10$",r"$15$",r"$20$",r"$25$"],fontsize = 25)
        ax.set_yticks([0.000001,0.0001,0.01,1,100])
        ax.set_yticklabels(
           [r"$10^{-6}$",r"$10^{-4}$",r"$10^{-2}$",r"$1$",r"$10^2$"],
           fontsize = 25)
        ax.get_yaxis().get_major_formatter().labelOnlyBase = False
        ax.xaxis.set_tick_params(width=1.5)
        ax.yaxis.set_tick_params(width=1.5)
        ax.set_ylabel('population',fontsize = 30)
        ax.set_xlabel(r'length',fontsize = 30)
        ax.set_xlim(0,26)
        ax.set_ylim(0.000001)
        plt.savefig(os.path.join(
            self.outputDir,'scatter'+str(self.trajectory[2])+'.pdf'))
        plt.savefig(os.path.join(
            self.outputDir,'scatter'+str(self.trajectory[2])+'.png'))
Example #22
0
def make_xi_plot():
	from numpy import linspace
	from matplotlib import pyplot as pl
	pl.rc('text', usetex=True)
	pl.rc('font', family='serif')
	lamdas = [-1,-0.9,-0.7,0,0.7,0.9,1]
	for lam in lamdas:
		plotx(lam,0,linestyle='k',minval=-0.9,maxval=10.0,logplot=True)
		plotx(lam,1,linestyle='k--',logplot=True)
		plotx(lam,2,logplot=True)
		plotx(lam,3,linestyle='k--',logplot=True)
	pl.vlines(x=1,ymin=-2,ymax=-0.076,color='k')
	pl.xlabel(r'$$\xi$$',fontsize=16)
	pl.ylabel(r'$$\tau$$',fontsize=16)
	pl.text(0.0, 0, r'$$M=0$$', bbox=dict(facecolor='white', alpha=1))
	pl.text(0.0, 1.4, r'$$M=1$$', bbox=dict(facecolor='white', alpha=1))
	pl.text(0, 2.48, r'$$M=2$$', bbox=dict(facecolor='white', alpha=1))
	pl.text(1.3, -1.5, r'hyperbolic')
	pl.text(0.3, -1.5, r'elliptic')
	pl.annotate(r'$$\lambda = 1$$', xy=(-0.29, -0.19), xytext=(-1, -1),
            arrowprops=dict(facecolor='black', shrink=0.15, width=1,headwidth=5),
            )
	pl.annotate(r'$$\lambda = -1$$', xy=(0.7, 0.4), xytext=(0.8,0.8),
            arrowprops=dict(facecolor='black', shrink=0.15, width=1,headwidth=5),
            )
	pl.xlim((-2,2))
	pl.ylim((-2,3))
Example #23
0
File: cmap.py Project: syrte/handy
def make_rainbow(a=0.75, b=0.2, name='custom_rainbow', register=False):
    """
    Use a=0.7, b=0.2 for a darker end.

    when 0.5<=a<=1.5, should have b >= (a-0.5)/2 or 0 <= b <= (a-1)/3
    when 0<=a<=0.5, should have b >= (0.5-a)/2 or 0<= b<= -a/3
    to assert the monoique

    To show the parameter dependencies interactively in notebook
    ```
    %matplotlib inline
    from ipywidgets import interact
    def func(a=0.75, b=0.2):
        cmap = gene_rainbow(a=a, b=b)
        show_cmap(cmap)
    interact(func, a=(0, 1, 0.05), b=(0.1, 0.5, 0.05))
    ```
    """
    def gfunc(a, b, c=1):
        def func(x):
            return c * np.exp(-0.5 * (x - a)**2 / b**2)
        return func

    cdict = {"red": gfunc(a, b),
             "green": gfunc(0.5, b),
             "blue": gfunc(1 - a, b)
             }
    cmap = mpl.colors.LinearSegmentedColormap(name, cdict)
    if register:
        plt.register_cmap(cmap=cmap)
        plt.rc('image', cmap=cmap.name)
    return cmap
Example #24
0
def prepare_figure(obj_area):

    # create new figure 
    #fig = Figure()  # old version, does not work for the stream plot 

    ## Turn interactive plotting off
    #plt.ioff()
    fig = plt.figure()   # needs a DISPLAY environment variable (simulated here with mpl.use('Agg'))

    # define size of image 
    nx = obj_area.x_size
    ny = obj_area.y_size
    # canvas figure 
    canvas = FigureCanvas(fig)
    # get dots per inch of the screen
    DPI = fig.get_dpi()
    # print "DPI", DPI
    fig.set_size_inches(nx/float(DPI),ny/float(DPI))
    # set fonts to bold
    plt.rc('font', weight='bold')
    # get axis object 
    ax = fig.add_subplot(111, aspect='equal')
    ## eliminates margins totally 
    fig.subplots_adjust(left=0.0,right=1.0,bottom=0.0,top=1.0, wspace=0, hspace=0)
    # set limits of the axis
    ax.set_xlim(0, nx)
    ax.set_ylim(0, ny)
    # set transparent backgroud 
    fig.patch.set_alpha(0.0)        # transparent outside of diagram  
    ax.set_axis_bgcolor([1,0,0,0])  # transparent color inside diagram 

    return fig, ax 
Example #25
0
def plot(results, total_a, total_b, label_a, label_b, outputFile=None):
    all_rules = sorted(results, key=lambda v: (-len(v['item']), round(abs(v['count_a'] / total_a - v['count_b'] / total_b), 2), round(v['count_a'] / total_a, 2)))

    values_a = [100 * rule['count_a'] / total_a for rule in all_rules]
    values_b = [100 * rule['count_b'] / total_b for rule in all_rules]

    plt.rc('figure', autolayout=True)
    plt.rc('font', size=22)

    fig, ax = plt.subplots(figsize=(24, 18))
    index = range(len(all_rules))
    bar_width = 0.35

    if label_a.startswith('_'):
        label_a = ' ' + label_a
    if label_b.startswith('_'):
        label_b = ' ' + label_b

    bar_a = plt.barh(index, values_a, bar_width, color='b', label=label_a)
    bar_b = plt.barh([i + bar_width for i in index], values_b, bar_width, color='r', label=label_b)

    plt.xlabel('Support')
    plt.ylabel('Rule')
    plt.title('Most interesting deviations')
    plt.yticks([i + bar_width for i in index], [rule_to_str(rule['item']) for rule in all_rules])
    if len(all_rules) > 0:
        plt.legend(handles=[bar_b, bar_a], loc='best')

    if outputFile is not None:
        plt.savefig(outputFile)
    else:
        plt.show()
    plt.close(fig)
def printEnrichment(controlVsTestTupleList, proteinGroupsDataFrame, go_to_SGDID,sgdidList):
    f, axarr = plt.subplots(4, 2)
    f.subplots_adjust(hspace = 0.75)
    i = 0
    j = 0
    font ={'family':'normal', 'weight':'bold', 'size':8}
    plt.rc('font', **font)

    for (control, test) in controlVsTestTupleList:
        e1, n1 = calculate_enrichment(test, proteinGroupsDataFrame, go_to_SGDID,sgdidList)
        e0, n0 = calculate_enrichment(control, proteinGroupsDataFrame, go_to_SGDID,sgdidList)
        e0list, e1list, egoidlist, emaxlist = checkGoLengths(e0, e1)
        n0list, n1list, ngoidlist, nmaxlist = checkGoLengths(n0, n1)
        maxlist = [emaxlist[0], emaxlist[1], nmaxlist[0], nmaxlist[1]]
        axarr[i, j].plot(e0list, e1list, 'b.')
        axarr[i, j].plot(n0list, n1list, 'r.')
        axarr[i, j].set_title(control +'vs'+ test, fontsize=8)
        axarr[i, j].set_xlabel('control')
        axarr[i, j].set_ylabel('test') 
        axarr[i, j].set_xlim([0, max(maxlist)])
        axarr[i, j].set_ylim([0, max(maxlist)])
        """index = 0
        #to add all go ids to plot
        for xy in zip(e0list, e1list):                                               
            axarr[i, j].annotate('%s' % egoidlist[index], xy=xy, textcoords='data')
        index+=1"""
        if j == 1:
            i+=1
            j=0
        else:
            j+=1
    plt.show()
Example #27
0
def plot_bars(groups, group_labels, legends, ylabel, yscale=None):
  N = len(group_labels)

  ind = np.arange(N)  # the x locations for the groups
  width = 0.1       # the width of the bars

  plt.rc('xtick', labelsize=12) 
  plt.rc('ytick', labelsize=12) 
  fig = plt.figure(figsize=(14,7), dpi=300)
  ax = fig.add_subplot(111)

  colors = ['b', 'r', 'y', 'g', 'm']

  rects = []
  i = 0
  for group in groups:
    rects.append(ax.bar(ind + ((i + 3) * 1.0 * width), group, width, bottom=10**-3, color=colors[i]))
    i += 1
  
  ax.set_xticks(ind+0.5+width)
  ax.set_xticklabels( group_labels )

  box = ax.get_position()
  ax.set_position([box.x0, box.y0, box.width * 0.95, box.height])
  ax.legend(rects, legends, loc='center left', bbox_to_anchor=(1, 0.5), prop={'size':14})

  if yscale != None:
    plt.yscale(yscale)

  plt.ylabel(ylabel, fontsize=14)
  return plt
Example #28
0
def make_x_plot():
	from numpy import linspace
	from matplotlib import pyplot as pl
	pl.rc('text', usetex=True)
	pl.rc('font', family='serif')
	lamdas = [-1,-0.9,-0.7,0,0.7,0.9,1]
	for lam in lamdas:
		plotx(lam,0)
		plotx(lam,1,linestyle='k--')
		plotx(lam,2)
		plotx(lam,3,linestyle='k--')
	pl.axvline(x=1,color='k')
	pl.xlabel(r'$$x$$',fontsize=16)
	pl.ylabel(r'$$T$$',fontsize=16)
	pl.text(0.0, 1.5, r'$$M=0$$', bbox=dict(facecolor='white', alpha=1))
	pl.text(0.0, 4.7, r'$$M=1$$', bbox=dict(facecolor='white', alpha=1))
	pl.text(0.0, 8.0, r'$$M=2$$', bbox=dict(facecolor='white', alpha=1))
	pl.text(0.5, 4, r'hyperbolic')
	pl.text(1.2, 4, r'elliptic')
	pl.annotate(r'$$\lambda = 1$$', xy=(-0.25, 1.1), xytext=(-0.8, 0.2),
            arrowprops=dict(facecolor='black', shrink=0.15, width=1,headwidth=5),
            )
	pl.annotate(r'$$\lambda = -1$$', xy=(0.5, 2.0), xytext=(0.7, 3.0),
            arrowprops=dict(facecolor='black', shrink=0.15, width=1,headwidth=5),
            )
def features_pca_classified(fscaled, labels_true, labels_predict, axes=None,
                            algorithm="pca"):
    if algorithm == 'pca':
        pc = PCA(n_components=2)
        fscaled_trans = pc.fit(fscaled).transform(fscaled)
    elif algorithm == "tsne":
        fscaled_trans = TSNE(n_components=2).fit_transform(fscaled)
    else:
        raise AlgorithmUnrecognizedException("Not recognizing method of "+
                                             "dimensionality reduction.")

    sns.set_style("whitegrid")
    plt.rc("font", size=24, family="serif", serif="Computer Sans")
    plt.rc("axes", titlesize=20, labelsize=20)
    plt.rc("text", usetex=True)
    plt.rc('xtick', labelsize=20)
    plt.rc('ytick', labelsize=20)

    # make a Figure object
    if axes is None:
        fig, axes = plt.subplots(1,2,figsize=(16,6), sharey=True)

    ax1, ax2 = axes[0], axes[1]

    ax1 = plotting.scatter(fscaled_trans, labels_true, ax=ax1)

    # second panel: physical labels:

    ax2 = plotting.scatter(fscaled_trans, labels_predict, ax=ax2)

    plt.tight_layout()

    return ax1, ax2
Example #30
0
def make_starter_plot():
	from numpy import linspace
	from math import pi
	from matplotlib import pyplot as pl
	pl.rc('text', usetex=True)
	pl.rc('font', family='serif')
	pl.axvline(x=1,color='k')
	pl.xlabel(r'$$x$$',fontsize=16)
	pl.ylabel(r'$$T$$',fontsize=16)
	pl.text(0.5, 4, r'hyperbolic')
	pl.text(1.2, 4, r'elliptic')
	plot_x_curves([-1,-0.85,0.85,1],N=0,logplot=False,maxval=10,minval=-0.9)
	T0s = [pi,pi/2,1.1]
	for T0 in T0s:
		T  =linspace(T0,10*pi)
		pl.plot((T0/T)**(2.0/3.0)-1.0,T,':k')
		T  =linspace(0.1,T0)
		pl.plot((T0/T)**(1.0)-1.0,T,':k')
	pl.plot([],'k-',label="tof curves [-1,-0.85,0.85,1]")
	pl.plot([],'k:',label="initial guesses")
	pl.legend()
	pl.annotate(r'$$\lambda \le -0.85$$', xy=(-0.4, 7.5), xytext=(-0.1, 8),
            arrowprops=dict(facecolor='black', shrink=0.15, width=1,headwidth=5),
            )
	pl.annotate(r'$$\lambda \ge 0.85$$', xy=(-0.33, 2.1), xytext=(-0.9, 1.09),
            arrowprops=dict(facecolor='black', shrink=0.15, width=1,headwidth=5),
            )
# Avoid needing display if plots aren't being shown
import sys

if "--noninteractive" in sys.argv:
    import matplotlib as mpl

    mpl.use("svg")
    import bookutil.latex as latex

import control as ct
import frccontrol as fct
import matplotlib.pyplot as plt
import numpy as np
from numpy import concatenate

plt.rc("text", usetex=True)


def main():
    J = 7.7500e-05
    b = 8.9100e-05
    Kt = 0.0184
    Ke = 0.0211
    R = 0.0916
    L = 5.9000e-05

    # fmt: off
    A = np.array([[-b / J, Kt / J], [-Ke / L, -R / L]])
    B = np.array([[0], [1 / L]])
    C = np.array([[1, 0]])
    D = np.array([[0]])
Example #32
0
    error = np.nan_to_num(error)
    DX, BETA_INI = np.meshgrid(dx_grid, beta_ini_grid)

    plt.figure()
    plt.contourf(
        DX,
        BETA_INI,
    )
    plt.show()
    plt.close()

    return error, dx_grid, beta_ini_grid, dx_grid_test


# Usar latex en texto de figuras y agrandar tamaño de fuente
plt.rc('text', usetex=True)
plt.rcParams.update({'font.size': 15, 'text.latex.unicode': True})
# Obtenemos path para guardar archivos en el mismo directorio donde se ubica el script
script_dir = os.path.dirname(os.path.abspath(__file__))

#################################################################################################
# Corre algoritmo matrix squaring
#
#

# Decide si corre esta parte del algoritmo
run_ms_algorithm = True

# Parámetros físicos del algoritmo
x_max = 5.
nx = 201
_mpl = False

try:
    import matplotlib
    import matplotlib.pyplot as plt
    from matplotlib.widgets import Slider
    matplotlib.rcParams['pdf.fonttype'] = 42
    matplotlib.rcParams['ps.fonttype'] = 42
    plt.style.use('ggplot')
    matplotlib.rcParams['font.size'] = 7
    matplotlib.rcParams['lines.linewidth'] = 0.5
    matplotlib.rcParams['xtick.major.size'] = 1.5
    matplotlib.rcParams['ytick.major.size'] = 1.5
    matplotlib.rcParams['axes.labelpad'] = 1
    plt.rc('grid', linestyle="-", color='#dbdbdb')
    _mpl = True
except ImportError:    # pragma nocover
    pass


class PyPlot2(Connector):

    def __init__(self):

        super(PyPlot2, self).__init__()
        self.robots = []
        self.ellipses = []

        if not _mpl:    # pragma nocover
            raise ImportError(
Example #34
0
m.plot(prediction)

fig = fig = px.line(prediction.iloc[2912:], x='ds', y='yhat')
fig.show()

prediction.info()

pred=prediction.iloc[3912:4248,[0,21]]
pred['ds']=pd.to_datetime(pred.ds)
pred.info()

"""#memvisualisasikan perbandingan data real dan hasil prediksi serta membuat rmse dan r2 dr model"""

plt.figure(figsize=(16,8))
plt.rc('xtick', labelsize=16) 
plt.rc('ytick', labelsize=14) 
plt.plot(d_test['y'].values, label='Test')
plt.plot(pred['yhat'].values, label='pred')
plt.legend(loc='best')
plt.show()

from sklearn.metrics import r2_score
r2=r2_score(d_test['y'],  pred['yhat'])
rms1 = np.sqrt(mean_squared_error(d_test['y'], pred['yhat']))
print(r2," , ",rms1)

"""**note:** selain mentune seasonality kita jg dapat mentune change_point perior scale dr model untuk menyesuaikan apakah hasil prediksi/ model akan mengikuti data set 
---

**note:** hati" saat melakukan tune agas model yang dibuat tidak overfit
def test_grid_regression():
    # Regression test for a bug that meant that if the rc parameter
    # axes.grid was set to True, WCSAxes would crash upon initalization.
    plt.rc('axes', grid=True)
    fig = plt.figure(figsize=(3, 3))
    WCSAxes(fig, [0.1, 0.1, 0.8, 0.8])

def parametric_omega(gamma, other_omega):
    if gamma == 0:
        return 0
    if other_omega < gamma:
        return -gamma * lambertw(
            -other_omega * exp(-other_omega / gamma) / gamma, k=-1).real
    return -gamma * lambertw(
        -other_omega * exp(-other_omega / gamma) / gamma).real


if __name__ == "__main__":
    xs = np.linspace(0, 3.0, 500)

    plt.rc('text', usetex=True)
    plt.rc('font', family='serif')
    plt.plot(xs, [(2 - x) / (2 - 1) for x in xs],
             label=r"Possible $\Omega$ values for $K=2$")
    plt.plot(xs, [(3 - x) / (3 - 1) for x in xs],
             label=r"Possible $\Omega$ values for $K=3$")
    plt.plot(xs, [parametric_omega(1.0, x) for x in xs],
             label=r"$\gamma=1.0$",
             linestyle="dashed")
    plt.plot(xs, [parametric_omega(1.0926, x) for x in xs],
             label=r"$\gamma=1.0926$",
             linestyle="dashed")
    plt.xlim([0.0, 3.0])
    plt.ylim([0.0, 2.0])
    plt.xlabel(r"$\omega_{in}$", fontsize=14)
    plt.ylabel(r"$\omega_{out}$", fontsize=14)
Example #37
0
def EventSubsetDisplay(tubes,
                       quantities,
                       PMTFlatMapPositive,
                       tubes_to_plot,
                       title="Charge",
                       cutrange=[-1, -1],
                       padding=10):
    """
    tubes == np.array of PMTs that were hit
    quantities == np.array of PMT quantities (either charge or time)
    title == title to add to display
    cutrange == minimum and maximum values on plot (or set both -1 for default)
    """
    PMTFlatMapPositive_values = [
        PMTFlatMapPositive[tube] for tube in tubes_to_plot
    ]
    subset_x_values = np.array(
        [value[0] for value in PMTFlatMapPositive_values])
    subset_y_values = np.array(
        [value[1] for value in PMTFlatMapPositive_values])

    # set up dimensions for subset preimage with short tank data
    min_subplot_x_value = subset_x_values.min() - padding
    max_subplot_x_value = subset_x_values.max() + padding

    min_subplot_y_value = subset_y_values.min() - padding
    max_subplot_y_value = subset_y_values.max() + padding

    fig, ax = plt.subplots(figsize=[30, 30])
    preimage = np.zeros(preimage_dimensions)

    subset_quantities = []
    for idx, tube in enumerate(tubes):
        if cutrange[0] != cutrange[1]:
            if (cutrange[0] != -1 and quantities[idx] < cutrange[0]) or \
                (cutrange[1] != -1 and quantities[idx] > cutrange[1]):
                continue
        for dx in range(-3, 4):
            for dy in range(-3, 4):
                if abs(dx) == 3 and abs(dy) == 3:
                    continue
                if tube in tubes_to_plot:
                    #print( "idx=", idx, " len(quantities)=",len(quantities), " tube=", tube, " len(PMTFlatMap)=", len(PMTFlatMapPositive))
                    preimage[PMTFlatMapPositive[tube][1] + dx,
                             PMTFlatMapPositive[tube][0] +
                             dy] = quantities[idx]
                    subset_quantities.append(quantities[idx])

    subset_quantities = np.array(subset_quantities)

    imgmin = subset_quantities.min() if cutrange[0] == -1 else cutrange[0]
    imgmax = subset_quantities.max() if cutrange[1] == -1 else cutrange[1]

    subset_image = preimage[min_subplot_y_value:max_subplot_y_value,
                            min_subplot_x_value:max_subplot_x_value]

    im = ax.imshow(subset_image,
                   extent=[
                       min_subplot_x_value, max_subplot_x_value,
                       min_subplot_y_value, max_subplot_y_value
                   ],
                   vmin=imgmin,
                   vmax=imgmax)

    fig.suptitle(title, fontsize=80)

    plt.rc('xtick', labelsize=24)
    plt.rc('ytick', labelsize=24)
    plt.xlabel('Distance CCW on perimeter from x-axis (cm)', fontsize=48)
    plt.ylabel('Y (cm)', fontsize=48)

    plt.set_cmap('gist_heat_r')

    # Create colourbar
    divider = make_axes_locatable(ax)
    cax = divider.append_axes("right", size="5%", pad=0.05)
    cbar = plt.colorbar(im, cax=cax)
    cbar.ax.tick_params(labelsize=24)

    # Fix title height
    plt.tight_layout()
Example #38
0
        help='decides wether something gets printed to screen or not')
    # do the parsing:
    args = parser.parse_args()

    # process input arguments:
    files = args.files
    number_fish = len(files)
    if args.outroot is not None:
        outroot = args.outroot
    else:
        outroot = None

    # latex rendering of text if required:
    if args.latex is not None:
        if args.latex:
            plt.rc('font', **{'family': 'serif', 'serif': ['Computer Modern']})
            plt.rc('text', usetex=True)

    # start the plot:
    fig = plt.figure()

    # cycle over files:
    for file in files:
        # import the data:
        data = np.loadtxt(file)
        # get number of columns:
        n_col = data.shape[1]
        # get the x column:
        if args.x_column is not None:
            x_index = args.x_column
        else:
def plot_figA1(df, fcstnme, gis_path, hshallow_gp, hdeep_gp, hmuni_gp, zwells_gp):    
    
    # Export parameters
    fontsze = 11
    figsize = cm2inch(14, 18)
    plt.rcParams['font.size'] = fontsze
    plt.rc('font',**{'family':'sans-serif', 'sans-serif':['Arial']})
    
#    # Set up labels
    if 'muni' in fcstnme:
        well_no = fcstnme.split('muni')[1]
        title = 'Forecast: Interface elevation ' + r'$\zeta_{\rm muni} $ ' + well_no
    
    elif fcstnme == 'fw_storage':
        df = df / (10**9)
        title = 'Forecast: Freshwater volume'
            
    # Load GIS data using gis_path
    wells_muni = gpd.GeoDataFrame.from_features(records(gis_path + 'wells_muni' + '.shp', ['name_model']))
    coastline = gpd.read_file(gis_path + 'polyg_model' + '.shp')
    
    muni_coordinates = get_coordinates(muni_df) # Get coordinates of municipal wells
    xmuni = [coord[0] for name, coord in muni_coordinates.items()]
    ymuni = [coord[1] for name, coord in muni_coordinates.items()]
    
    # Merge dataframe info and geopandas geometry
    hshallow, hdeep, hmuni, zwells, ztdem, zert, hobs, zobs = merge_df_with_gpd(df, hshallow_gp, hdeep_gp, hmuni_gp, zwells_gp, gis_path)
            
    # Set up figure
    
    fig, axs = plt.subplots(2, 1, figsize=figsize, sharex=True, sharey=True, subplot_kw=dict(aspect='equal')) 
#    fig.suptitle(title, fontsize = fontsze)
    axs = axs.ravel()
    cbar_label = '% decrease in ' + r'$\sigma_{\rm prior}$' + ' when obs. used'
    
    for i in range(2):
        coastline.plot(ax=axs[i], color='gray', alpha=0.4, edgecolor='k') # Plot coastline
        
        ax_divider = make_axes_locatable(axs[i])
        cax = ax_divider.append_axes("right", size="5%", pad="1%")
        
        # If we're plotting data worth for municipal well forecasts
        
        if 'muni' in fcstnme:
            wells_muni[ wells_muni.name_model.str.endswith(fcstnme[1:]) ].plot(ax=axs[i], 
                       marker='o', markersize=40, facecolors='k', label=None) # Plot municipal wells at which forecast made
            
            idx = [idx for idx, well in enumerate(wells_muni.name_model) if fcstnme[1:] in well][0]
            
            axs[i].annotate(wells_muni.name_model[idx], (xmuni[idx], ymuni[idx]), xytext=(0, 5), 
               textcoords='offset points', ha='center', va='bottom', fontsize = fontsze - 1)
        
        # First frame = head observations
        
        if i == 0:
            
            hobs.plot(ax=axs[i], column=fcstnme, marker='o', markersize=30, edgecolors='k', 
                      linewidths=0, cmap=plt.cm.viridis, legend=True, cax=cax, legend_kwds={'label': cbar_label}) # legend=True: tells Geopandas to add the colorbar
            
            # Label observation groups
            
            hshallow.plot(ax=axs[i], marker='p', markersize=50, facecolors='None', 
                          edgecolors='k', linewidths=0.5, label='Shallow wells')
            
            hdeep.plot(ax=axs[i], marker='o', markersize=35, facecolors='None', 
                       edgecolors='white', linewidths=1.2, label='Deep wells')
            
            hmuni.plot(ax=axs[i], marker='o', markersize=35, facecolors='None', 
                       edgecolors='k', linewidths=1.3, label='Municipal wells')
            
            axs[i].set_title('Worth of freshwater head observations (' + r'$\zeta_{\rm muni} $ ' + well_no + ' forecast)' , fontsize = fontsze)
        
        # Second frame = interface observations
        
        elif i == 1:
                   
            zobs.plot(ax=axs[i], column=fcstnme, marker='o', markersize=30, 
                      cmap=plt.cm.viridis, legend=True, cax=cax, legend_kwds={'label': cbar_label}) # markersize=np.abs(zobs.residual)*2
            
            # Label observation groups
            
            zwells.plot(ax=axs[i], marker='o', markersize=35, facecolors='None', 
                        edgecolors='white', linewidths=1.2, label='Deep wells')
            
            ztdem.plot(ax=axs[i], marker='p', markersize=50, facecolors='None', 
                       edgecolors='white', linewidths=0.5, label='TDEM')
            
            zert.plot(ax=axs[i], marker='o', markersize=60, facecolors='None', 
                      edgecolors='gray', linewidths=0.1, label='ERT')
            
            axs[i].set_title('Worth of interface observations (' + r'$\zeta_{\rm muni} $ ' + well_no + ' forecast)' , fontsize = fontsze)
        
        axs[i].legend(loc='upper left', facecolor='gray', framealpha=0.3, fontsize = fontsze)
        
        # Show x and y axis in km instead of m
        
        axs[i].xaxis.set_major_formatter(FuncFormatter(lambda x, pos: ('%.0f')%(x/1e3)))
        axs[i].yaxis.set_major_formatter(FuncFormatter(lambda x, pos: ('%.0f')%(x/1e3)))
        axs[i].set_ylabel('y (km)')
    
    axs[0].set_xlim(300000, 306000)
    axs[0].set_ylim(5267000, 5271000)
    axs[1].set_xlabel('x (km)')
        
    plt.tight_layout(rect=[0, 0, 1, 0.95])
    plt.show()
    plt.savefig('FigA1_' + fcstnme + '.png', dpi = 600)
Example #40
0
import time
import re
import datetime
import pyActigraphy

import sys
sfp = '/home/ngrav/project'
sys.path.append(sfp)
from wearables.scripts import utils as wearutils

import torch

# plotting
import matplotlib.pyplot as plt
import seaborn as sns
plt.rc('font', size=9)
plt.rc('font', family='sans serif')
plt.rcParams['pdf.fonttype'] = 42
plt.rcParams['ps.fonttype'] = 42
plt.rcParams['legend.frameon'] = False
plt.rcParams['axes.grid'] = False
plt.rcParams['legend.markerscale'] = 0.5
plt.rcParams['savefig.dpi'] = 600
sns.set_style("ticks")


class raw2df():
    ''' 
    Description:
      The data was sent with {PID}_GA{y}.mtn names. We need to convert this
        raw data into numpy and pandas. First, we identify all valid files and
def plot_fig8(post_for, df_abs, fcstnme):
    
    # Export parameters
    fontsze = 11
    figsize = cm2inch(9.5, 8)
    plt.rcParams['font.size'] = fontsze
    plt.rc('font',**{'family':'sans-serif', 'sans-serif':['Arial']})
    
    # Prepare dataframe
    df_abs_subset = df_abs[df_abs.index.str.startswith(fcstnme)]
    
    # Replace column names with the following list (for the legend)
    cols = [r'$\sigma_{\rm\ post}$', #          Posterior forecast stdev
            r'If $K$ field' + '\nknown', #      hcond parameter group
            r'If $R$ known', #                  recharge parameter group
            r'If $\alpha_{\rm T}$ known'] #     alpha parameter group
    df_abs_subset.columns = cols
    
    # Sort dataframe in descending order
    df_abs_subset = df_abs_subset.T
    df_abs_subset = df_abs_subset.sort_values(by=fcstnme, ascending=False)
    df_abs_subset = df_abs_subset.T
    
    # Set up a different color for each parameter group
    colors=[]
    for col in df_abs_subset.columns:
        if col == cols[0]: #    posterior forecast stdev
            c = 'k'
        if col == cols[1]: #    hcond parameter group
            c = 'tab:red'
        elif col == cols[2]: #  recharge parameter group
            c = 'tab:blue'
        elif col == cols[3]: #  alpha parameter group
            c = 'tab:green'
        colors.append(c)
    
    # Set up labels
    if 'muni' in fcstnme:
        well_no = fcstnme.split('muni')[1] # Get well number
        unit_stdev = 'm'
        unit_fcst = 'masl'
        Fmt = '%0.0f'
        fcst = post_for.loc[fcstnme, 'Mean']
        title = 'Interface elevation ' + r'$\zeta_{\rm muni}$ ' + well_no + \
            ' (%0.1f '  % (fcst) + unit_fcst + ')'
    
    elif fcstnme == 'fw_storage':
        df_abs_subset = df_abs_subset / (10**9)
        unit_stdev = 'km$^3$'
        unit_fcst = unit_stdev
        Fmt = '%0.1f'
        fcst = post_for.loc[fcstnme, 'Mean']  / (10**9)
        title = 'Freshwater volume ' + r'$V_{\rm f}$ (%0.1f '  % (fcst) + unit_fcst + ')'
    
    # Bar plot
    ax = df_abs_subset.plot(kind = 'bar', figsize = figsize, rot = 45, grid = True, 
                         color = colors, legend = None, width = 15, edgecolor = 'white', linewidth = 5)
    
    # Annotate the first bar differently (base posterior forecast uncertainty)
    for p in ax.patches[0:1]:
        sigma_base = p.get_height()
        ann = df_abs_subset.columns[0]
        ax.annotate(ann, (p.get_x() * 1.005, p.get_height() * 0.980), va='bottom', fontsize = fontsze - 1)
    
    # Annotate the other bars with 1) legend and 2) percent reduction in forecast uncertainty
    for i, p in enumerate(ax.patches[1:]):
        sigma = p.get_height()
        label = 100 * (sigma_base - sigma) / sigma_base # Compute percent reduction in forecast uncertainty
        ann = df_abs_subset.columns[i+1] + '\n' + '- ' + Fmt % (label) + ' %%'
        ax.annotate(ann, (p.get_x() * 1.005, p.get_height() * 0.980),  va='bottom', fontsize = fontsze - 1)
    
    # Figure limits
    ax.set_ylim(0, sigma_base + sigma_base * 0.15)
    
    # Other figure parameters
    ax.set_axisbelow(True)
    x_axis = ax.axes.get_xaxis()
    x_axis.set_visible(False)
    ax.set_ylabel('Standard deviation ' + r'$\sigma$' + ' (' + unit_stdev + ')')
    plt.title(title, loc='left', fontsize = fontsze)
    
    plt.tight_layout()
    plt.show()
    plt.savefig('Fig8_' + fcstnme + '.png', dpi = 600)
def plot_fig5a(pst):
    
    # Export parameters
    fontsze = 11
    figsze = cm2inch(9.5, 9.5)
    plt.rcParams['font.size'] = fontsze
    plt.rc('font',**{'family':'sans-serif', 'sans-serif':['Arial']})
    
    # Load residuals & observations dataframes
    res = pst.res # Residuals
    obs = pst.observation_data # Observations
    
    # Group observations
    grouper = obs.groupby(obs.obgnme).groups
    
    # Drop the observation groups that are not to be plotted
    [grouper.pop(key, None) for key in ['fw_storage', 'hdomest']]
    [grouper.pop(key, None) for key in ['zwells', 'ztdem', 'zert']]
    
    # For each remaining observation group, define legend and marker type, size, color, edgecolor, linewidth
    grouper_lgd = {'hdeep': r'$h_{\rm f\ deep\ wells}$', 'hshallow': r'$h_{\rm f\ shallow\ wells}$','hmuni': r'$h_{\rm f\ pumping\ wells}$'}    
    grouper_mkr = {'hdeep': '^', 'hshallow': 'o','hmuni': 's'}
    grouper_sz = {'hdeep': 120, 'hshallow': 70,'hmuni': 50}
    grouper_clr = {'hdeep': 'red', 'hshallow': 'lime', 'hmuni': 'black'}
    grouper_edgeclr = {'hdeep': 'black', 'hshallow': 'black','hmuni': None}
    grouper_linewdth = {'hdeep': 0.5, 'hshallow': 0.5, 'hmuni': None}
    
    # Start plotting
    fig, ax = plt.subplots(figsize=figsze)
    
    # For each observation group
    for groupname, obsnames in grouper.items():
        
        obs_g = obs.loc[obsnames, :]
        obs_g.loc[:, 'sim'] = res.loc[obsnames, 'modelled']
        obs_g.loc[:,'res'] = obs_g.sim - obs_g.obsval # Define residual = sim - obs
        obs_g = obs_g.loc[obs_g.weight > 0, :] # Exclude observations with weight = 0
        
        ax.scatter([obs_g.obsval], [obs_g.sim], 
                   label=grouper_lgd[groupname], 
                   marker=grouper_mkr[groupname], s=grouper_sz[groupname], 
                   color=grouper_clr[groupname], edgecolors=grouper_edgeclr[groupname],
                   linewidths=grouper_linewdth[groupname])        
    
    # Modify limits of the scatter plot
    Max = 3
    Min = 0
    ax.plot([Min,Max], [Min,Max], 'k--', lw=1.0) # Plot the 1:1 diagonal line
    ax.set_xlim(Min,Max)
    ax.set_ylim(Min,Max)
        
    # Other figure parameters
    ax.axis('square')
    ax.grid()
    ax.set_axisbelow(True)
    
    # Order the legend
    handles, labels = plt.gca().get_legend_handles_labels()
    order = [2,1,0]
    ax.legend([handles[idx] for idx in order], [labels[idx] for idx in order], loc='upper left')
    
    ax.set_xlabel('Observed (m)', labelpad=0.1)
    ax.set_ylabel('Simulated (m)', labelpad=0.1)
    ax.set_title('Freshwater heads ' + r'$h_{\rm f}$', loc='left', fontsize=fontsze)
    
    plt.tight_layout()
    plt.show()
    plt.savefig('Fig5A.png', dpi = 600)
Example #43
0
# first_date = Date_total.iloc[0]
# last_date = Date_total.iloc[-1]

# first_date = first_date[6:]+'-'+first_date[0:2]+'-'+first_date[3:5]
# last_date = last_date[6:]+'-'+last_date[0:2]+'-'+str(int(last_date[3:5])+1)

# date_total = np.arange(first_date, last_date, dtype='datetime64[D]')[:,None]

first_date = '2020-03-06'  #first_date[6:]+'-'+first_date[0:2]+'-'+first_date[3:5]
last_date = '2021-03-11'  #last_date[6:]+'-'+last_date[0:2]+'-'+str(int(last_date[3:5])+1)

date_total = np.arange(first_date, last_date, dtype='datetime64[D]')

# date_total = Date_total
sf = 1e-4
plt.rc('font', size=30)

#%%
#Current Suspectious
fig, ax = plt.subplots()
ax.plot(date_total, S_pred_mean / sf, 'k-', lw=5)
plt.fill_between(date_total, \
                  (S_pred_mean+S_pred_std)/sf, \
                  (S_pred_mean-S_pred_std)/sf, \
                  facecolor=(0.1,0.2,0.5,0.3), interpolate=True)

# ax.set_xlim(0-0.5,180)
# ax.set_ylim(0-0.5,6000+0.5)
ax.xaxis.set_major_locator(mdates.MonthLocator(interval=2))
ax.xaxis.set_major_formatter(mdates.DateFormatter('%m-%y'))
ax.xaxis.set_minor_locator(mdates.DayLocator(interval=7))
def plot_fig9(post_for, df_stdev, fcstnme):
    
    # Export parameters
    fontsze = 11
    plt.rcParams['font.size'] = fontsze
    plt.rc('font',**{'family':'sans-serif', 'sans-serif':['Arial']})
    figsze = cm2inch(19, 6)
    
    # Prepare dataframe
    df_stdev_subset = df_stdev[df_stdev.index.str.startswith(fcstnme)]
    
    # Replace column names with the following list (for the legend)
    cols = ['No data ' + r'($\sigma_{\rm prior}$)', #    Prior forecast stdev (no observations)
            r'+ $h_{\rm shallow}$', #                    h shallow observation group
            r'+ $h_{\rm deep}$', #                       h deep observation group
            r'+ $h_{\rm muni}$', #                       h muni observation group
            r'+ $\zeta_{\rm deep}$', #                   zeta deep well observation group  
            r'+ $\zeta_{\rm TDEM}$', #                   zeta TDEM observation group
            r'+ $\zeta_{\rm ERT}$', #                    zeta ERT observation group
            'All data\n' + r'($\sigma_{\rm post}$)', #   Posterior forecast stdev (all observations)
            '+ All ' + r'$h$', #                         All h observations
            '+ All\n' + r'$\zeta_{\rm geophy}$', #       All geophysical zeta observations
            '+ All ' + r'$\zeta$'] #                     All zeta observations
    df_stdev_subset.columns = cols
    
    # Sort dataframe in descending order
    df_stdev_subset = df_stdev_subset.T
    df_stdev_subset = df_stdev_subset.sort_values(by=fcstnme, ascending=False)
    df_stdev_subset = df_stdev_subset.T
    
    # Set up a different color for each observation group
    colors=[]
    for col in df_stdev_subset.columns:
        if col == cols[0]: # prior forecast stdev
            c = 'tab:orange'
        if col == cols[1]: # hshallow
            c = 'chartreuse'
        elif col == cols[2]: # hdeep
            c = 'red'
        elif col == cols[3]: # hmuni
            c = 'grey'
        elif col == cols[4]: # zdeep
            c = 'aquamarine'
        elif col == cols[5]: # ztdem
            c = 'cornflowerblue'
        elif col == cols[6]: # zert
            c = 'tab:blue'
        elif col == cols[7]: # posterior forecast stdev
            c = 'k'
        elif col == cols[8]: # hobs
            c = 'tab:green'
        elif col == cols[9]: # zgeo
            c = 'tab:purple'
        elif col == cols[10]: # zobs
            c = 'navy'
        colors.append(c)
    
    # Set up labels
    if 'muni' in fcstnme:
        well_no = fcstnme.split('muni')[1]
        unit_stdev = 'm'
        unit_fcst = 'm/sea level'
        fcst = post_for.loc[fcstnme, 'Mean']
        title = 'Interface elevation ' + r'$\zeta_{\rm muni} $ ' + well_no + \
            ' (%0.1f '  % (fcst) + unit_fcst + ')'
    
    elif fcstnme == 'fw_storage':
        df_stdev_subset = df_stdev_subset / (10**9)
        unit_stdev = 'km$^3$'
        unit_fcst = unit_stdev
        fcst = post_for.loc[fcstnme, 'Mean']  / (10**9)
        title = 'Freshwater volume ' + r'$V_{\rm f}$ (%0.1f '  % (fcst) + unit_fcst + ')'
    
    
    # Bar plot
    ax = df_stdev_subset.plot(kind = 'bar', figsize = figsze, rot = 45, grid = True, 
                         color = colors, legend = None, 
                         width = 15, edgecolor = 'white', linewidth = 5) # Cycle through default colors
    
     # Annotate the first bar differently (base prior forecast uncertainty)
    for p in ax.patches[0:1]:
        sigma_base = p.get_height()
        ann = df_stdev_subset.columns[0] #stdev_symbol
        ax.annotate(ann, (p.get_x() * 1.005, p.get_height() * 0.960), va='bottom', fontsize = fontsze - 1)
    
    # Annotate the other bars with 1) legend and 2) percent reduction in prior forecast uncertainty
    for i, p in enumerate(ax.patches[1:]):
        sigma = p.get_height()
        label = 100 * (sigma_base - sigma) / sigma_base
        ann = df_stdev_subset.columns[i+1] + '\n' + '-%0.1f %%' % (label)
        ax.annotate(ann, (p.get_x() * 1.005, p.get_height() * 0.900), va='bottom', fontsize = fontsze - 1)
    
    # Figure limits
    ax.set_ylim(0, sigma_base + sigma_base * 0.1)
    ax.set_axisbelow(True)
    
    # Other figure parameters
    x_axis = ax.axes.get_xaxis()
    x_axis.set_visible(False)
    ax.set_ylabel('Standard deviation ' + r'$\sigma$' + ' (' + unit_stdev + ')')
    plt.title(title, loc='left', fontsize = fontsze)
    
    plt.tight_layout()
    plt.show()
    plt.savefig('Fig9_' + fcstnme + '.png', dpi = 600)
from sklearn.cross_validation import StratifiedKFold
from sklearn.metrics import roc_curve, auc, roc_auc_score
from sklearn.feature_selection import SelectFwe
from scipy import signal
from scipy.fftpack import fft, fftshift
from scipy import interp

params = {'legend.fontsize': 'large',
          'figure.figsize': (5, 3),
          'axes.labelsize': 'x-large',
          'axes.titlesize': 'x-large',
          'xtick.labelsize': 'x-large',
          'ytick.labelsize': 'x-large'}
font = {'weight': 'bold',
        'size': 22}
plt.rc('font', **font)
from sklearn.feature_selection import VarianceThreshold
from sklearn.feature_selection import SelectPercentile, f_classif, GenericUnivariateSelect, SelectKBest, chi2
from sklearn.feature_selection import RFE
import os
import seaborn as sns
import pandas as pd
import csv
from scipy import stats
import brainiak
import brainiak.funcalign.srm
import sys

projectDir='/jukebox/norman/amennen/prettymouth/'
DMNmask='/jukebox/norman/amennen/MNI_things/Yeo_JNeurophysiol11_MNI152/Yeo_Network7mask_reoriented_resampledBOLD.nii.gz'
fmriprep_dir=projectDir + '/derivatives/fmriprep'
def plot_fig7(df_prior, df_post, fcstnme):
    
    # Export parameters
    fontsze = 11
    figsze = cm2inch(9.5,9.5)
    plt.rcParams['font.size'] = fontsze
    plt.rc('font',**{'family':'sans-serif', 'sans-serif':['Arial']})
    
    # Prepare dataframes
    df_prior_subset = df_prior[df_prior.index.str.startswith(fcstnme)]
    df_post_subset = df_post[df_post.index.str.startswith(fcstnme)]
        
    # Set up labels
    if 'zmuni' in fcstnme:
        well_no = fcstnme.split('muni')[1] # Get well number
        clean_nme = r'$\zeta$'
        unit = 'masl'
        Fmt = '%0.0f'
        xlabel = 'Interface elevation ' + r'$\zeta_{\rm muni} $' + well_no + ' (' + unit + ')'
    
    elif fcstnme == 'fw_storage':
        df_prior_subset = df_prior_subset / (10**9) # From m3 to km3
        df_post_subset = df_post_subset / (10**9) #   From m3 to km3
        clean_nme = r'$V_{\rm f}$'
        unit = 'km$^3$'
        Fmt = '%0.1f'
        xlabel = 'Freshwater volume ' + r'$V_{\rm f}$' + ' (' + unit + ')'
    
    # Start plot
    plt.figure(figsize=figsze)
    ax = plt.subplot(1,1,1)
    
    # Plot prior distribution (Gaussian)
    mean = df_prior_subset.Mean[0]
    stdev = df_prior_subset.Stdev[0]
    
    x1, y1 = pyemu.plot_utils.gaussian_distribution(mean, stdev)
    label = 'Prior ' + clean_nme + ': ' + Fmt % (mean) + ' \u00B1 ' + Fmt % (2 * stdev) + ' ' + unit
    ax.plot(x1, y1, linestyle='dashed', color = 'grey', label = label)
    
    # Plot posterior distribution (Gaussian)
    mean = df_post_subset.Mean[0]
    stdev = df_post_subset.Stdev[0]
    
    x2, y2 = pyemu.plot_utils.gaussian_distribution(mean, stdev)
    label = 'Posterior ' + clean_nme + ': ' + Fmt % (mean) + ' \u00B1 ' + Fmt % (2 * stdev) + ' ' + unit
    ax.fill_between(x2, 0, y2, alpha=0.5, color = 'grey', label = label)
    
    
    # Figure limits
    Max = max(y1.max(), y2.max())
    ax.set_ylim(0, Max + Max * 0.3)
    
    # Other figure parameters
    ax.legend(loc = 'upper left')
    ax.set_xlabel(xlabel)
    ax.set_ylabel('Probability density')
    
    plt.tight_layout()
    plt.show()
    plt.savefig('Fig7_' + fcstnme + '.png', dpi = 600)
Example #47
0
def prepare_data(data,bin_tails=False):
    x,y = data

    # Eliminate y offset
    y -= np.mean(y)

    return x,y

T = [0,10,20,30,40,50,60,70,72,75,80]
T_display = [30,60,72,80]
display_count = 0
H_c = np.zeros_like(T)
H_c_err = np.zeros_like(T)

plt.rcParams.update({'font.size': 20})
plt.rc('axes', labelsize=26)
fig, axes = plt.subplots(2,2,sharey="row",sharex="row")
fig.subplots_adjust(hspace=0.35,wspace=0.05)
axes = axes.ravel()

for i,temperature in enumerate(["00","10","20","30","40","50","60","70","72","75","80"]):

    data_x,data_y = prepare_data(np.loadtxt(f"../data/sample_C6_{temperature}.DAT",unpack=True))
    X = np.linspace(0.95*min(data_x),1.05*max(data_x),1000)

    # Split in ascending / descending branch
    xmin, xmax = np.argmin(data_x), np.argmax(data_x)
    complement_mask = np.ones(len(data_x),dtype=bool)
    complement_mask[xmax:xmin] = False

    x_split = [data_x[complement_mask], data_x[xmax:xmin]]
Example #48
0
    def draw_environment(self, sim, interacts, image_file=None, tick=None):

        # --- Plot parameters ---
        plt.clf()
        plt.figure(figsize=(fig_size, fig_size), dpi=25)

        plt.axis('off')

        plt.title('Environment', fontsize=font_size)

        plt.rc('xtick', labelsize=font_size)
        plt.rc('ytick', labelsize=font_size)

        # --- Show resource and danger ---
        res = plt.imshow(self.resource.T, cmap='Greens', alpha=1)
        dng = plt.imshow(self.danger.T, cmap='Reds', alpha=0.4)

        if tick is not None:
            plt.text(3, -5, 'Tick: {}'.format(tick), fontsize=font_size)
        '''
		plt.colorbar(res).set_label('Resource')
		plt.colorbar(dng).set_label('Danger')
		'''

        # --- Show agents ---
        for agent_id, agent in sim.all_agents.items():

            self.draw_agent(agent)

            for other_agent_id, score in agent.acquaint.items():
                try:
                    other_agent = sim.all_agents[other_agent_id]
                    self.draw_relationship(agent, other_agent, score)
                except:
                    pass

        # --- Show current interactions ---
        if len(interacts) > 1:
            for agent_id, oth_agent_id in interacts:
                x1, y1 = sim.all_agents[agent_id].position
                x2, y2 = sim.all_agents[oth_agent_id].position

                plt.plot([x1, x2], [y1, y2],
                         color='cyan',
                         linestyle=':',
                         linewidth=7)

        # --- Show Monolith

        if self.monolith.seen == True:
            pos_x, pos_y = self.monolith.position
            plt.plot(pos_x,
                     pos_y,
                     marker="*",
                     markersize=2 * font_size,
                     color='gold')

        if image_file:
            plt.savefig(image_file)

        plt.close()
# imports
import gemini3d.read
import os
import numpy as np
import matplotlib.pyplot as plt
from plotGDI_tools import padstr

# set some font sizes
SMALL_SIZE = 14
MEDIUM_SIZE = 16
BIGGER_SIZE = 20

plt.rc('font', size=SMALL_SIZE)  # controls default text sizes
plt.rc('axes', titlesize=BIGGER_SIZE)  # fontsize of the axes title
plt.rc('axes', labelsize=MEDIUM_SIZE)  # fontsize of the x and y labels
plt.rc('xtick', labelsize=SMALL_SIZE)  # fontsize of the tick labels
plt.rc('ytick', labelsize=SMALL_SIZE)  # fontsize of the tick labels
plt.rc('legend', fontsize=SMALL_SIZE)  # legend fontsize
plt.rc('figure', titlesize=BIGGER_SIZE)  # fontsize of the figure title

# location of simulation output
home = os.path.expanduser("~")
direc = home + "/simulations/raid/TGI_MR/"
plotdir = direc + "/customplots2/"
if not os.path.isdir(plotdir):
    os.mkdir(plotdir)
parmlbl = "ne"

# config and grid data
print("...Loading config and grid...")
cfg = gemini3d.read.config(direc)
Example #50
0
#程序文件Pex2_47.py
import matplotlib.pyplot as plt
import numpy as np
from scipy.stats import norm
mu0 = [-1, 0]
s0 = [0.5, 1]
x = np.linspace(-7, 7, 100)
plt.rc('font', size=15)
plt.rc('text', usetex=True)
plt.rc('axes', unicode_minus=False)
f, ax = plt.subplots(len(mu0), len(s0), sharex=True, sharey=True)
for i in range(2):
    for j in range(2):
        mu = mu0[i]
        s = s0[j]
        y = norm(mu, s).pdf(x)
        ax[i, j].plot(x, y)
        ax[i,
           j].plot(1,
                   0,
                   label="$\\mu$ = {:3.2f}\n$\\sigma$ = {:3.2f}".format(mu, s))
        ax[i, j].legend(fontsize=12)
ax[1, 1].set_xlabel('$x$')
ax[0, 0].set_ylabel('pdf($x$)')
plt.savefig('figure2_47.png')
plt.show()
Example #51
0
                                             t_c=0.12,
                                             St=0.28,
                                             weighting="A")
        configs[config]["f_{peak}"][j] = f_peak.to(ureg.turn /
                                                   ureg.s).magnitude
        configs[config]["SPL_A"][j] = SPL

    configs[config][
        "f_{peak}"] = configs[config]["f_{peak}"] * ureg.turn / ureg.s

solidity = solidity[1]  #convert back to array from tuple

# Plotting commands
plt.ion()
fig1 = plt.figure(figsize=(12, 12), dpi=80)
plt.rc('axes', axisbelow=True)
plt.show()

style = {}
style["linestyle"] = ["-", "-", "-", "-", "--", "--", "--", "--"]
style["marker"] = ["s", "o", "^", "v", "s", "o", "^", "v"]
style["fillstyle"] = [
    "full", "full", "full", "full", "none", "none", "none", "none"
]
style["markersize"] = 10

#Maximum takeoff weight
plt.subplot(2, 2, 1)
for i, config in enumerate(configs):
    c = configs[config]
    plt.plot(solidity,
Example #52
0
                    print 'NO ' + data_path
                    missing_file = True
                else:
                    ws = np.load(data_path)
                    acc_tmp.append(ws['accu'])
                    ws.close()
        all_mean[i] = np.mean(acc_tmp)
        all_se[i] = np.std(acc_tmp) / math.sqrt(args.nsubjs)

#if missing_file:
#    sys.exit('missing file')

# set font size
font = {'family': 'serif', 'size': 10}

plt.rc('text', usetex=True)
plt.rc('font', **font)

aspectratio = 5
idx = range(len(algo_list))

plt.figure()
error_config = {'ecolor': '0'}
rects = plt.bar(idx,
                all_mean,
                yerr=all_se,
                align='center',
                error_kw=error_config)

plt.xticks(idx, name, rotation='vertical')
plt.ylabel('Accuracy')
Example #53
0
from matplotlib import pyplot as plt
font = {'family': 'LiSu', 'weight': 'bold', 'size': '16'}
plt.rc('font', **font)  # 步骤一(设置字体的更多属性)
plt.rc('axes', unicode_minus=False)  # 步骤二(解决坐标轴负数的负号显示问题)

a = [
    "战狼2", "速度与激情8", "功夫瑜伽", "西游伏妖篇", "变形金刚5:最后的骑士", "摔跤吧!爸爸", "加勒比海盗5:死无对证",
    "金刚:骷髅岛", "极限特工:终极回归", "生化危机6:终章", "乘风破浪", "神偷奶爸3", "智取威虎山", "大闹天竺",
    "金刚狼3:殊死一战", "蜘蛛侠:英雄归来", "悟空传", "银河护卫队2", "情圣", "新木乃伊"
]

b = [
    56.01, 26.94, 17.53, 16.49, 15.45, 12.96, 11.8, 11.61, 11.28, 11.12, 10.49,
    10.3, 8.75, 7.55, 7.32, 6.99, 6.88, 6.86, 6.58, 6.23
]

plt.bar(range(len(a)), b, 0.4)
plt.xticks(range(len(a)), a, rotation=90)
plt.show()
Example #54
0
con_mat = pd.crosstab(y_test, y_pred, rownames=['예측값'], colnames=['관측값'])
print(con_mat)
print((con_mat[0][0] + con_mat[1][1] + con_mat[2][2]) /
      len(y_test))  # 0.9777777777
print(ml.score(x_test, y_test))  # 0.977777777

# 시각화
import numpy as np
import matplotlib.pyplot as plt

from matplotlib.colors import ListedColormap
from matplotlib import font_manager, rc

font_name = font_manager.FontProperties(
    fname="c:/Windows/Fonts/malgun.ttf").get_name()
plt.rc('font', family=font_name)  #그래프에서 한글깨짐 방지용


def plot_decision_region(X,
                         y,
                         classifier,
                         test_idx=None,
                         resolution=0.02,
                         title=''):
    markers = ('s', 'x', 'o', '^', 'v')  # 점표시 모양 5개 정의
    colors = ('r', 'b', 'lightgreen', 'gray', 'cyan')
    cmap = ListedColormap(colors[:len(np.unique(y))])

    #print('cmap : ', cmap.colors[0], cmap.colors[1], cmap.colors[2])

    # decision surface 그리기
# 

#%%
e = np.random.standard_normal(100)
y = np.zeros(100)
y[0] = e[0]

for i in range(1, 100):
    y[i] = y[i-1] + e[i]
    

#%%
%matplotlib inline

import matplotlib.pyplot as plt
plt.rc('figure', figsize=(16,6))

plt.plot(y)

#%%
# ## Problem: Nested Loops
# 
# Begin by loading momentum data used in an earlier lesson. Compute a
# 22-day moving-window standard deviation for each of the columns. Store
# the value at the end of the window.
# 
# When finished, make sure that `std_dev` is a `DataFrame` and 
# plot the annualized percentage standard deviations using:
# 
# ```python
# ann_std_dev = 100 * np.sqrt(252) * std_dev
 count = 0
 for each_product_record in product_records_list:
     cpc_axis.append(float(each_product_record['calc_cpc']))
     stop_date.append(each_product_record['date_stop'])
     ctr_axis.append(float(each_product_record['calc_ctr']))
     print(each_product_record['campaign_name'])
     if each_product_record['purchase_rate'] == '':
         purchase_rate_axis.append(0)
     else:
         purchase_rate_axis.append(float(each_product_record['purchase_rate']))
     if each_product_record['capital_roi'] == '':
         capital_roi.append(0)
     else:
         capital_roi.append(float(each_product_record['capital_roi']))
 # print(item)
 plt.rc('xtick', labelsize=6)
 plt.rc('ytick', labelsize=6)
 plt.figure()
 plt.subplot(221)
 plt.xticks(rotation=45, ha="right")
 plt.plot(stop_date,cpc_axis,'-o')
 plt.title('Cpc')
 plt.grid(True)    
 plt.subplot(222)
 plt.xticks(rotation=45, ha="right")
 plt.plot(stop_date,ctr_axis,'-o')
 plt.title('Ctr')
 plt.grid(True)
 plt.subplot(223)
 plt.xticks(rotation=45, ha="right")
 plt.plot(stop_date,purchase_rate_axis,'-o')
Example #57
0
#! /usr/bin/python

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

plt.rc('axes', titlesize=16)     # fontsize of the axes title
plt.rc('axes', labelsize=16)    # fontsize of the x and y labels
plt.rc('xtick', labelsize=12)    # fontsize of the tick labels
plt.rc('ytick', labelsize=12)    # fontsize of the tick labels
plt.rc('legend', fontsize=12)    # legend fontsize
#plt.rc('figure', titlesize=BIGGER_SIZE)  # fontsize of the figure title


raw_data = {'graph': ['Youtube', 'LJ', 'Pokec', 'R-MATI', 'R-MATII'],
        'c1': [16.1344/16.1344, 90.5813/90.5813, 32.1934/32.1934, 12.6965/12.6965, 50.7354/50.7354],
        'c2': [16.1344/5.5074, 90.5813/48.601, 32.1934/20.7189, 12.6965/10.7273, 50.7354/42.7774],
        'c3': [16.1344/5.2948, 90.5813/47.7471, 32.1934/20.4841, 12.6965/10.6896, 50.7354/42.607],
        'c4': [16.1344/4.7289, 90.5813/45.5692, 32.1934/19.747, 12.6965/10.519, 50.7354/41.9917],
        'c5': [16.1344/3.888, 90.5813/40.9439, 32.1934/17.9292, 12.6965/9.7478, 50.7354/38.9701],
        'c6': [16.1344/1.4022, 90.5813/9.7264, 32.1934/3.8728, 12.6965/2.1245, 50.7354/8.6928],
        'c7': [16.1344/1.4053, 90.5813/9.7447, 32.1934/3.9781, 12.6965/2.1248, 50.7354/8.7066],
        'c8': [16.1344/11.203, 90.5813/116.173, 32.1934/50.658, 12.6965/27.400, 50.7354/109.523],
        'c9': [16.1344/5.4649, 90.5813/51.455, 32.1934/22.1605, 12.6965/11.5924, 50.7354/46.5335]
        }
df = pd.DataFrame(raw_data, columns = ['graph', 'c1', 'c2', 'c3', 'c4', 'c5', 'c6', 'c7', 'c8', 'c9'])
fuck_label=('c1', 'c2', 'c3', 'c4', 'c5', 'c6', 'c7', 'c8', 'c9')
# Setting the positions and width for the bars
pos = list(range(len(df['c1'])))
width = 0.1
ecolor='k'
Example #58
0
#!/usr/bin/env python
# coding: utf-8

# In[9]:

import time
import numpy as np
import matplotlib.pyplot as plt
plt.rc('font', family='Malgun Gothic')


class Matmul:
    def __init__(self, W):
        self.params = [W]
        self.grads = [np.zeros_like(W)]
        self.x = None

    # 순전파
    def forward(self, x):
        W, = self.params
        out = np.dot(x, W)
        self.x = x
        return out

    # 역전파
    def backward(self, dout):
        W, = self.params
        x = self.x
        dx = np.dot(dout, W.T)
        dW = np.dot(x.T, dout)
        self.grads[0][...] = dW  # 깊은 복사
Example #59
0
def latent_viz_pure(args, net, e, sess, data_loader):
    # Create dict of functions to choose next batch
    next_batch_dict = {
        'passive': data_loader.next_batch_pass,
        'medium1': data_loader.next_batch_med1,
        'medium2': data_loader.next_batch_med2,
        'aggressive': data_loader.next_batch_agg
    }

    # Generate samples
    data_loader.batchptr_pass = 0
    data_loader.batchptr_med1 = 0
    data_loader.batchptr_med2 = 0
    data_loader.batchptr_agg = 0
    full_sample_pass = gen_samples(args, net, sess, data_loader.batchptr_pass,
                                   data_loader.n_batches_pass, next_batch_dict,
                                   'passive')
    full_sample_med1 = gen_samples(args, net, sess, data_loader.batchptr_med1,
                                   data_loader.n_batches_med1, next_batch_dict,
                                   'medium1')
    full_sample_med2 = gen_samples(args, net, sess, data_loader.batchptr_med2,
                                   data_loader.n_batches_med2, next_batch_dict,
                                   'medium2')
    full_sample_agg = gen_samples(args, net, sess, data_loader.batchptr_agg,
                                  data_loader.n_batches_agg, next_batch_dict,
                                  'aggressive')

    # Select random subset of values in full set of samples
    ind_pass = random.sample(xrange(len(full_sample_pass)), 2000)
    ind_agg = random.sample(xrange(len(full_sample_agg)), 2000)
    ind_med1 = random.sample(xrange(len(full_sample_med1)), 2000)
    ind_med2 = random.sample(xrange(len(full_sample_med2)), 2000)

    # # Save samples to csv
    # print 'Saving to csv...'
    # np.savetxt('samples_passive.csv', full_sample_pass[ind_pass], delimiter=',')
    # np.savetxt('samples_aggressive.csv', full_sample_agg[ind_agg], delimiter=',')
    # np.savetxt('samples_medium1.csv', full_sample_med1[ind_med1], delimiter=',')
    # np.savetxt('samples_medium2.csv', full_sample_med2[ind_med2], delimiter=',')
    # print 'done'

    # Plot and save results
    print 'saving and exiting.'
    plt.cla()
    plt.rc('text', usetex=True)
    plt.rc('font', family='serif')
    plt.plot(full_sample_pass[ind_pass, 0],
             full_sample_pass[ind_pass, 1],
             'bx',
             label='Passive')
    plt.plot(full_sample_agg[ind_agg, 0],
             full_sample_agg[ind_agg, 1],
             'ro',
             label='Aggressive')
    plt.plot(full_sample_med1[ind_med1, 0],
             full_sample_med1[ind_med1, 1],
             'gp',
             label='Medium 1')
    plt.plot(full_sample_med2[ind_med2, 0],
             full_sample_med2[ind_med2, 1],
             'cd',
             label='Medium 2')

    plt.ylim(-5, 5)
    plt.xlim(-5, 5)
    plt.xlabel(r'$z_1$', fontsize=16)
    plt.ylabel(r'$z_2$', fontsize=16)
    plt.title('Epoch ' + str(e))
    plt.legend(loc='upper right', numpoints=1)
    plt.grid()
    plt.savefig('./images_recurrent/latent_viz_' + str(e) + '.png')
Example #60
0
import matplotlib.pyplot as plt
import numpy as np
import os

# ------------------------------------------------------------------------------#

plt.rc("text", usetex=True)
plt.rc("font", family="serif")
plt.rc("font", size=12)


def plot_single(data, legend, title, col=(0, 1)):

    plt.figure(0)
    plt.plot(data[:, col[0]], data[:, col[1]], label=legend)
    plt.title(title)
    plt.xlabel("arc length")
    plt.ylabel("$p$ difference")
    plt.grid(True)
    plt.legend()


# ------------------------------------------------------------------------------#


def save_single(filename, folder, figure_id=0, extension=".pdf"):

    if not os.path.exists(folder):
        os.makedirs(folder)

    plt.figure(figure_id)