Beispiel #1
0
def hist_Ne(sel_coinc_ids, coords, data, n):
    global histNe2
    c_index = data.root.coincidences.c_index
    observ = data.root.coincidences.observables
    core_rec = data.root.core_reconstructions.reconstructions
    
    histNe = core_rec.readCoordinates(coords, field='reconstructed_shower_size')
    #histNe = [x for x in histNe if x > 0]  # for showersize smaller than 0 
    
    d = 10**10.2
    
    histNe2 = [x*d for x in histNe]
    #histNe *= 10 ** 10.2
    
      
    pylab.hist(np.log10(histNe2), 100, log=True) # histtype="step"
       
    pylab.xlabel('Showerenergy log(eV)')
    pylab.ylabel('count')
    pylab.title('showersize bij N==%s' %n)
    pylab.ylim(ymin=1)
    pylab.grid(True)
    pylab.show()
    
    return histNe2
Beispiel #2
0
def time_delays_plot(env, **kwargs):

    models = kwargs.pop('models', env.models)
    obj_index = kwargs.pop('obj_index', 0)
    src_index = kwargs.pop('src_index', 0)
    key = kwargs.pop('key', 'accepted')

    d = defaultdict(list)
    for m in models:
        obj,data = m['obj,data'][obj_index]
        t0 = data['arrival times'][src_index][0]
        for i,t in enumerate(data['arrival times'][src_index][1:]):
            d[i].append( float('%0.6f'%convert('arcsec^2 to days', t-t0, obj.dL, obj.z, data['nu'])) )
            t0 = t

    s = product(range(1,1+len(d)), ['solid', 'dashed', 'dashdot', 'dotted'])
    for k,v in d.iteritems():
        #print 'td plot', k, len(v)
        #print v
        lw,ls = s.next()
        pl.hist(v, bins=25, histtype='step', color='k', ls=ls, lw=lw, label='%s - %s' % (str(k+1),str(k+2)), **kwargs)

    #pl.xlim(xmin=0)
    pl.ylim(ymin=0)
    pl.xlim(xmin=pl.xlim()[0] - 0.01*(pl.xlim()[1] - pl.xlim()[0]))
    pl.legend()

    pl.xlabel(_time_delays_xlabel)
    pl.ylabel(r'Count')
Beispiel #3
0
def geweke_plot(data, name, format='png', suffix='-diagnostic', path='./', fontmap = None, 
    verbose=1):
    # Generate Geweke (1992) diagnostic plots

    if fontmap is None: fontmap = {1:10, 2:8, 3:6, 4:5, 5:4}

    # Generate new scatter plot
    figure()
    x, y = transpose(data)
    scatter(x.tolist(), y.tolist())

    # Plot options
    xlabel('First iteration', fontsize='x-small')
    ylabel('Z-score for %s' % name, fontsize='x-small')

    # Plot lines at +/- 2 sd from zero
    pyplot((nmin(x), nmax(x)), (2, 2), '--')
    pyplot((nmin(x), nmax(x)), (-2, -2), '--')

    # Set plot bound
    ylim(min(-2.5, nmin(y)), max(2.5, nmax(y)))
    xlim(0, nmax(x))

    # Save to file
    if not os.path.exists(path):
        os.mkdir(path)
    if not path.endswith('/'):
        path += '/'
    savefig("%s%s%s.%s" % (path, name, suffix, format))
Beispiel #4
0
	def plot_frontier(self,frontier_only=False,plot_samples=True) :
		""" Plot the frontier"""
		frontier = self.frontier
		frontier_energy = self.frontier_energy
		feat1,feat2 = self.feats	
	
		pl.figure()
		if not frontier_only :	
			ll_list1,ll_list2 = zip(*self.all_seq_energy)
			pl.plot(ll_list1,ll_list2,'b*')
		if plot_samples :
			ll_list1,ll_list2 = zip(*self.sample_seq_energy)
			pl.plot(ll_list1,ll_list2,'g*')
					
		pl.plot(*zip(*sorted(frontier_energy)),color='magenta',\
			marker='*',	linestyle='dashed')
		ctr = dict(zip(set(frontier_energy),[0]*
			len(set(frontier_energy))))
		for i,e in enumerate(frontier_energy) : 
			ctr[e] += 1
			pl.text(e[0],e[1]+0.1*ctr[e],str(i),fontsize=10)
			pl.text(e[0]+0.4,e[1]+0.1*ctr[e],frontier[i],fontsize=9)	
		pl.xlabel('Energy:'+feat1)
		pl.ylabel('Energy:'+feat2)
		pl.title('Energy Plot')
		xmin,xmax = pl.xlim()
		ymin,ymax = pl.ylim()
		pl.xlim(xmin,xmax)
		pl.ylim(ymin,ymax)
		pic_dir = '../docs/tex/pics/'
		pl.savefig(pic_dir+self.name+'.pdf')
		pl.savefig(pic_dir+self.name+'.png')
Beispiel #5
0
def param_set_averages_plot(results):
    averages_ocr = [
        a[1] for a in sorted(
            param_set_averages(results, metric='ocr').items(),
            key=lambda x: int(x[0].split('-')[1]))
    ]
    averages_q = [
        a[1] for a in sorted(
            param_set_averages(results, metric='q').items(),
            key=lambda x: int(x[0].split('-')[1]))
    ]
    averages_mse = [
        a[1] for a in sorted(
            param_set_averages(results, metric='mse').items(),
            key=lambda x: int(x[0].split('-')[1]))
    ]
    fig = plt.figure(figsize=(6, 4))
    # plt.tight_layout()
    plt.plot(averages_ocr, label='OCR', linewidth=2.0)
    plt.plot(averages_q, label='Q', linewidth=2.0)
    plt.plot(averages_mse, label='MSE', linewidth=2.0)
    plt.ylim([0, 1])
    plt.xlabel(u'Paslėptų neuronų skaičius')
    plt.ylabel(u'Vidurinė Q įverčio pokyčio reikšmė')
    plt.grid(True)
    plt.tight_layout()
    plt.legend(loc='lower right')
    plt.show()
def simulation1(numTrials, numSteps, loc):
    results = {'UsualDrunk': [], 'ColdDrunk': [], 'EDrunk': [], 'PhotoDrunk': [], 'DDrunk': []}
    drunken_types = {'UsualDrunk': UsualDrunk, 'ColdDrunk': ColdDrunk, 'EDrunk': EDrunk, 'PhotoDrunk': PhotoDrunk,
                     'DDrunk': DDrunk}
    for drunken in drunken_types.keys():
        #Create field
        initial_loc = Location(loc[0], loc[1])
        field = Field()
        print "Simu", drunken
        drunk = Drunk(drunken)
        drunk_man = drunken_types[drunken](drunk)
        field.addDrunk(drunk_man, initial_loc)
        #print drunk_man
        for trial in range(numTrials):
            distance = walkVector(field, drunk_man, numSteps)
            results[drunken].append((round(distance[0], 1), round(distance[1], 1)))
        print drunken, "=", results[drunken]
    for result in results.keys():
        # x, y = zip(*results[result])
        # print "x", x
        # print "y", y
        pylab.plot(*zip(*results[result]), marker='o', color='r', ls='')
        pylab.title(result)
        pylab.xlabel('X coordinateds')
        pylab.ylabel('Y coordinateds')
        pylab.xlim(-100, 100)
        pylab.ylim(-100, 100)
        pylab.figure()
    pylab.show
Beispiel #7
0
def trace(data, name, format='png', datarange=(None, None), suffix='', path='./', rows=1, columns=1, 
    num=1, last=True, fontmap = None, verbose=1):
    """
    Generates trace plot from an array of data.

    :Arguments:
        data: array or list
            Usually a trace from an MCMC sample.

        name: string
            The name of the trace.
            
        datarange: tuple or list
            Preferred y-range of trace (defaults to (None,None)).

        format (optional): string
            Graphic output format (defaults to png).

        suffix (optional): string
            Filename suffix.

        path (optional): string
            Specifies location for saving plots (defaults to local directory).
            
        fontmap (optional): dict
            Font map for plot.

    """

    if fontmap is None: fontmap = {1:10, 2:8, 3:6, 4:5, 5:4}

    # Stand-alone plot or subplot?
    standalone = rows==1 and columns==1 and num==1

    if standalone:
        if verbose>0:
            print_('Plotting', name)
        figure()

    subplot(rows, columns, num)
    pyplot(data.tolist())
    ylim(datarange)

    # Plot options
    title('\n\n   %s trace'%name, x=0., y=1., ha='left', va='top', fontsize='small')

    # Smaller tick labels
    tlabels = gca().get_xticklabels()
    setp(tlabels, 'fontsize', fontmap[rows/2])

    tlabels = gca().get_yticklabels()
    setp(tlabels, 'fontsize', fontmap[rows/2])

    if standalone:
        if not os.path.exists(path):
            os.mkdir(path)
        if not path.endswith('/'):
            path += '/'
        # Save to file
        savefig("%s%s%s.%s" % (path, name, suffix, format))
def plotForce():
    figure(size=3,aspect=0.5)
    subplot(1,2,1)
    from EvalTraj import plotFF
    plotFF(vp=351,t=28,f=900,cm=0.6,foffset=8)
    subplot_annotate()
    
    subplot(1,2,2)
    for i in [1,2,3,4]:
        R=np.squeeze(np.load('Rdpse%d.npy'%i))
        R=stats.nanmedian(R,axis=2)[:,1:,:]
        dps=np.linspace(-1,1,201)[1:]
        plt.plot(dps,R[:,:,2].mean(0));
    plt.legend([0,0.1,0.2,0.3],loc=3) 
    i=2
    R=np.squeeze(np.load('Rdpse%d.npy'%i))
    R=stats.nanmedian(R,axis=2)[:,1:,:]
    mn=np.argmin(R,axis=1)
    y=np.random.randn(mn.shape[0])*0.00002+0.0438
    plt.plot(np.sort(dps[mn[:,2]]),y,'+',mew=1,ms=6,mec=[ 0.39  ,  0.76,  0.64])
    plt.xlabel('Displacement of Force Origin')
    plt.ylabel('Average Net Force Magnitude')
    hh=dps[mn[:,2]]
    err=np.std(hh)/np.sqrt(hh.shape[0])*stats.t.ppf(0.975,hh.shape[0])
    err2=np.std(hh)/np.sqrt(hh.shape[0])*stats.t.ppf(0.75,hh.shape[0])
    m=np.mean(hh)
    print m, m-err,m+err
    np.save('force',[m, m-err,m+err,m-err2,m+err2])
    plt.xlim([-0.5,0.5])
    plt.ylim([0.0435,0.046])
    plt.grid(b=True,axis='x')
    subplot_annotate()
def plot_sphere_x( s, fname ):
  """ put plot of ionization fractions from sphere `s` into fname """

  plt.figure()
  s.Edges.units = 'kpc'
  s.r_c.units = 'kpc'
  xx = s.r_c
  L = s.Edges[-1]

  plt.plot( xx, np.log10( s.xHe1 ),
            color='green', ls='-', label = r'$x_{\rm HeI}$' )
  plt.plot( xx, np.log10( s.xHe2 ),
            color='green', ls='--', label = r'$x_{\rm HeII}$' )
  plt.plot( xx, np.log10( s.xHe3 ),
            color='green', ls=':', label = r'$x_{\rm HeIII}$' )

  plt.plot( xx, np.log10( s.xH1 ),
            color='red', ls='-', label = r'$x_{\rm HI}$' )
  plt.plot( xx, np.log10( s.xH2 ),
            color='red', ls='--', label = r'$x_{\rm HII}$' )

  plt.xlim( -L/20, L+L/20 )
  plt.xlabel( 'r_c [kpc]' )

  plt.ylim( -4.5, 0.2 )
  plt.ylabel( 'log 10 ( x )' )

  plt.grid()
  plt.legend(loc='best', ncol=2)
  plt.tight_layout()
  plt.savefig( 'doc/img/x_' + fname )
def plotB2reg(prefix=''):
    w=loadStanFit(prefix+'revE2B2LHregCa.fit')
    px=np.array(np.linspace(-0.5,0.5,101),ndmin=2)
    a1=np.array(w['ma'][:,4],ndmin=2).T+1
    a0=np.array(w['ma'][:,3],ndmin=2).T
    printCI(w,'ma')
    y=np.concatenate([sap(a0+a1*px,97.5,axis=0),sap(a0+a1*px[:,::-1],2.5,axis=0)])
    x=np.squeeze(np.concatenate([px,px[:,::-1]],axis=1))
    man=np.array([-0.4,-0.2,0,0.2,0.4])
    plt.plot(px[0,:],np.median(a0)+np.median(a1)*px[0,:],'red')
    #plt.plot([-1,1],[0.5,0.5],'grey')
    ax=plt.gca()
    ax.set_aspect(1)
    ax.add_patch(plt.Polygon(np.array([x,y]).T,alpha=0.2,fill=True,fc='red',ec='w'))
    y=np.concatenate([sap(a0+a1*px,75,axis=0),sap(a0+a1*px[:,::-1],25,axis=0)])
    ax.add_patch(plt.Polygon(np.array([x,y]).T,alpha=0.2,fill=True,fc='red',ec='w'))
    mus=[]
    for m in range(len(man)):
        mus.append(loadStanFit(prefix+'revE2B2LHC%d.fit'%m)['ma4']+man[m])
    mus=np.array(mus).T
    errorbar(mus,x=man)
    ax.set_xticks(man)
    plt.xlim([-0.5,0.5])
    plt.ylim([-0.6,0.8])
    plt.xlabel('Pivot Displacement')
    plt.ylabel('Perceived Displacemet')
def plotB3reg():
    w=loadStanFit('revE2B3BHreg.fit')
    printCI(w,'mmu')
    printCI(w,'mr')
    for b in range(2):
        subplot(1,2,b+1)
        plt.title('')
        px=np.array(np.linspace(-0.5,0.5,101),ndmin=2)
        a0=np.array(w['mmu'][:,b],ndmin=2).T
        a1=np.array(w['mr'][:,b],ndmin=2).T
        y=np.concatenate([sap(a0+a1*px,97.5,axis=0),sap(a0+a1*px[:,::-1],2.5,axis=0)])
        x=np.squeeze(np.concatenate([px,px[:,::-1]],axis=1))
        plt.plot(px[0,:],np.median(a0)+np.median(a1)*px[0,:],'red')
        #plt.plot([-1,1],[0.5,0.5],'grey')
        ax=plt.gca()
        ax.set_aspect(1)
        ax.add_patch(plt.Polygon(np.array([x,y]).T,alpha=0.2,fill=True,fc='red',ec='w'))
        y=np.concatenate([sap(a0+a1*px,75,axis=0),sap(a0+a1*px[:,::-1],25,axis=0)])
        ax.add_patch(plt.Polygon(np.array([x,y]).T,alpha=0.2,fill=True,fc='red',ec='w'))
        man=np.array([-0.4,-0.2,0,0.2,0.4])
        mus=[]
        for m in range(len(man)):
            mus.append(loadStanFit('revE2B3BH%d.fit'%m)['mmu'][:,b])
        mus=np.array(mus).T
        errorbar(mus,x=man)
        ax.set_xticks(man)
        plt.xlim([-0.5,0.5])
        plt.ylim([-0.4,0.8])
        #plt.xlabel('Manipulated Displacement')
        if b==0:
            plt.ylabel('Perceived Displacemet')
            plt.gca().set_yticklabels([])
        subplot_annotate()
    plt.text(-1.1,-0.6,'Pivot Displacement',fontsize=8);
Beispiel #12
0
    def plot_roc(self, roc=None):
        """Plot ROC curves

        .. plot::
            :include-source:
            :width: 80%

            from dreamtools import rocs
            r = rocs.ROC()
            r.scores = [.9,.5,.6,.7,.1,.2,.6,.4,.7,.9, .2]
            r.classes = [1,0,1,0,0,1,1,0,0,1,1]
            r.plot_roc()

        """
        if roc == None:
            roc = self.get_roc()
        from pylab import plot, xlim, ylim ,grid, title, xlabel, ylabel
        x = roc['fpr']
        plot(x, roc['tpr'], '-o')
        plot([0,1], [0,1],'r')
        ylim([0, 1])
        xlim([0, 1])
        grid(True)
        title("ROC curve (AUC=%s)" % self.compute_auc(roc))
        xlabel("FPR")
        ylabel("TPR")
Beispiel #13
0
    def rmsdSpreadSubplot(multiplier=1.0, layout=(-1, -1)):
        rmsd_data   = dict( (e, rad_data[e]['innov'][quant])  for e in rad_data.iterkeys() )
        spread_data = dict( (e, rad_data[e]['spread'][quant]) for e in rad_data.iterkeys() )

        times = temp.getTimes()
        n_t = len(times)

        for exp, exp_name in exp_names.iteritems():
            pylab.plot(sawtooth(times, times)[:(n_t + 1)], rmsd_data[exp][:(n_t + 1)], color=colors[exp], linestyle='-')
            pylab.plot(times[(n_t / 2):], rmsd_data[exp][n_t::2], color=colors[exp], linestyle='-')
 
        for exp, exp_name in exp_names.iteritems():
            pylab.plot(sawtooth(times, times)[:(n_t + 1)], spread_data[exp][:(n_t + 1)], color=colors[exp], linestyle='--')
            pylab.plot(times[(n_t / 2):], spread_data[exp][n_t::2], color=colors[exp], linestyle='--')

        ylim = pylab.ylim()
        pylab.plot(times, -1 * np.ones((len(times),)), color='#999999', linestyle='-', label="RMS Innovation")
        pylab.plot(times, -1 * np.ones((len(times),)), color='#999999', linestyle='--', label="Spread")

        pylab.axhline(y=7, color='k', linestyle=':')
        pylab.axvline(x=14400, color='k', linestyle=':')

        pylab.ylabel("RMS Innovation/Spread (dBZ)", size='large')

        pylab.xlim(times[0], times[-1])
        pylab.ylim(ylim)

        pylab.legend(loc=4)

        pylab.xticks(times[::2], [ "" for t in times[::2] ])
        pylab.yticks(size='x-large')
        return
def correlation_matrix(data, size=8.0):
    """ Calculates and shows the correlation matrix of the pandas data frame
        'data' as a heat map.
        Only the correlations between numerical variables are calculated!
    """
    # calculate the correlation matrix
    corr = data.corr()
    #print corr
    lc = len(corr.columns)
    # set some settings for plottin'
    pl.pcolor(corr, vmin = -1, vmax = 1, edgecolor = "black")
    pl.colorbar()
    pl.xlim([-5,lc])
    pl.ylim([0,lc+5])
    pl.axis('off')
    # anotate the rows and columns with their corresponding variables
    ax = pl.gca()            
    for i in range(0,lc):
        ax.annotate(corr.columns[i], (-0.5, i+0.5), \
            size='large', horizontalalignment='right', verticalalignment='center')
        ax.annotate(corr.columns[i], (i+0.5, lc+0.5),\
            size='large', rotation='vertical',\
            horizontalalignment='center', verticalalignment='right')
    # change the size of the image
    fig = pl.figure(num=1)    
    fig.set_size_inches(size+(size/4), size)     
    
    pl.show()
    def InitializePlot(self, goal_config):
        self.fig = pl.figure()
        lower_limits, upper_limits = self.boundary_limits
        pl.xlim([lower_limits[0], upper_limits[0]])
        pl.ylim([lower_limits[1], upper_limits[1]])
        pl.plot(goal_config[0], goal_config[1], 'gx')

        # Show all obstacles in environment
        for b in self.robot.GetEnv().GetBodies():
            if b.GetName() == self.robot.GetName():
                continue
            bb = b.ComputeAABB()
            pl.plot([bb.pos()[0] - bb.extents()[0],
                     bb.pos()[0] + bb.extents()[0],
                     bb.pos()[0] + bb.extents()[0],
                     bb.pos()[0] - bb.extents()[0],
                     bb.pos()[0] - bb.extents()[0]],
                    [bb.pos()[1] - bb.extents()[1],
                     bb.pos()[1] - bb.extents()[1],
                     bb.pos()[1] + bb.extents()[1],
                     bb.pos()[1] + bb.extents()[1],
                     bb.pos()[1] - bb.extents()[1]], 'r')
                    
                     
        pl.ion()
        pl.show()
Beispiel #16
0
def psfplots():
	tpsf = wise.get_psf_model(1, pixpsf=True)
	
	psfp = tpsf.getPointSourcePatch(0, 0)
	psf = psfp.patch
	
	psf /= psf.sum()
	
	plt.clf()
	plt.imshow(np.log10(np.maximum(1e-5, psf)), interpolation='nearest', origin='lower')
	plt.colorbar()
	ps.savefig()
	
	h,w = psf.shape
	cx,cy = w/2, h/2
	
	X,Y = np.meshgrid(np.arange(w), np.arange(h))
	R = np.sqrt((X - cx)**2 + (Y - cy)**2)
	plt.clf()
	plt.semilogy(R.ravel(), psf.ravel(), 'b.')
	plt.xlabel('Radius (pixels)')
	plt.ylabel('PSF value')
	plt.ylim(1e-8, 1.)
	ps.savefig()
	
	plt.clf()
	plt.loglog(R.ravel(), psf.ravel(), 'b.')
	plt.xlabel('Radius (pixels)')
	plt.ylabel('PSF value')
	plt.ylim(1e-8, 1.)
	ps.savefig()
	
	print('PSF norm:', np.sqrt(np.sum(np.maximum(0, psf)**2)))
	print('PSF max:', psf.max())
Beispiel #17
0
def plotFeatureImportance(featureImportance, title, originalImage=None, lim=0.06, colorate=None):
    """
    originalImage : the index of the original image. If None, ignore
    """
    indices = featureImportanceIndices(len(featureImportance), originalImage)
    pl.figure()
    pl.title(title)
    if colorate is not None:
        nbType = len(colorate)
        X = [[] for i in range(nbType)]
        Y = [[] for i in range(nbType)]
        for j, f in enumerate(featureImportance):
            X[j % nbType].append(j)
            Y[j % nbType].append(f)
        for i in range(nbType):
            pl.bar(X[i], Y[i], align="center", label=colorate[i][0], color=colorate[i][1])
        pl.legend()
    else:
        pl.bar(range(len(featureImportance)), featureImportance, align="center")
    #pl.xticks(pl.arange(len(indices)), indices, rotation=-90)
    pl.xlim([-1, len(indices)])
    pl.ylabel("Feature importance")
    pl.xlabel("Filter indices")
    pl.ylim(0, lim)
    pl.show()
Beispiel #18
0
def drunkTest(numTrials = 1000):
    #stepsTaken = [10, 100, 1000, 10000]
    stepsTaken = 1000
    
    for dClass in (UsualDrunk, ColdDrunk, EDrunk, PhotoDrunk, DDrunk):
        #initialize field
        field = Field()
        origin = Location(0, 0)
        
        # initialize drunk 
        drunk = dClass('Drunk')
        field.addDrunk(drunk, origin)

        x_pos, y_pos = [], [] # initialize to empty
        x, y = 0.0, 0.0
        
        for trial in range(numTrials): # trials 
            x, y = walkVector(field, drunk, stepsTaken)
            x_pos.append(x)
            y_pos.append(y)
            
        #pylab.plot(x_pos, y_pos, 'ro', s=5,
        #           label = dClass.__name__)
        pylab.scatter(x_pos, y_pos,s=5, color='red')
        pylab.title(str(dClass))
        pylab.xlabel('x')
        pylab.grid()
        pylab.xlim(-100, 100)
        pylab.ylim(-100,100)
        pylab.ylabel('y')
        pylab.show()
def run(steps=10):
	for i in range(steps):
	    Q.time_step()
	    #Q.plot_links()
	    py.xlim((0,config['XSIZE']))
	    py.ylim((0,config['YSIZE']))
	    py.draw()
Beispiel #20
0
def makeimg(wav):
	global callpath
	global imgpath

	fs, frames = wavfile.read(os.path.join(callpath, wav))
	
	pylab.ion()

	# generate specgram
	pylab.figure(1)
	
	# generate specgram
	pylab.specgram(
		frames,
		NFFT=256, 
		Fs=22050, 
		detrend=pylab.detrend_none,
		window=numpy.hamming(256),
		noverlap=192,
		cmap=pylab.get_cmap('Greys'))
	
	x_width = len(frames)/fs
	
	pylab.ylim([0,11025])
	pylab.xlim([0,round(x_width,3)-0.006])
	
	img_path = os.path.join(imgpath, wav.replace(".wav",".png"))

	pylab.savefig(img_path)
	
	return img_path
Beispiel #21
0
def whiskerplot(shear,dRA=1.,dDEC=1.,scale=5, combine=1, offset=(0,0) ):
    if combine>1:
        s = (combine*int(shear.shape[0]/combine),
             combine*int(shear.shape[1]/combine))
        shear = shear[0:s[0]:combine, 0:s[1]:combine] \
                + shear[1:s[0]:combine, 0:s[1]:combine] \
                + shear[0:s[0]:combine, 1:s[1]:combine] \
                + shear[1:s[0]:combine, 1:s[1]:combine]
        shear *= 0.25

        dRA *= combine
        dDEC *= combine

    
    theta = shear**0.5
    RA = offset[0] + np.arange(shear.shape[0])*dRA
    DEC = offset[1] + np.arange(shear.shape[1])*dDEC

    pylab.quiver(RA,DEC,
                 theta.real.T,theta.imag.T,
                 pivot = 'middle',
                 headwidth = 0,
                 headlength = 0,
                 headaxislength = 0,
                 scale=scale)
    pylab.xlim(0,shear.shape[0]*dRA)
    pylab.ylim(0,shear.shape[1]*dDEC)
    pylab.xlabel('RA (arcmin)')
    pylab.ylabel('DEC (arcmin)')
Beispiel #22
0
def test_anns(results):
    data = read_metrics(results)
    split = int(len(data) * 0.8)
    num_input = len(data[0]) - 1
    random.shuffle(data)
    test_data = data[split:]

    # Read ANNs
    ann_dir = '/home/tomas/Dropbox/Git/ga_sandbox/projects/denoising/neural/trained_anns'
    trained_anns = []
    for filename in os.listdir(ann_dir):
        if filename.endswith('.net'):
            ann_path = os.path.join(ann_dir, filename)
            ann = libfann.neural_net()
            ann.create_from_file(ann_path)
            trained_anns.append(ann)

    points = []
    for row in test_data:
        actual_output = row[num_input]
        ann_mean_output = np.mean([
            ann.run(row[:num_input])
            for ann in trained_anns
        ])
        points.append([ann_mean_output, actual_output])
        print "actual: " + str(actual_output) + ", predicted: " + str(ann_mean_output)

    points = sorted(points, key=lambda p: p[1])
    fig = plt.figure(figsize=(6, 4))
    plt.plot([p[0] for p in points])
    plt.plot([p[1] for p in points])
    plt.ylim([0, 1.2])
    plt.show()
    def InitializePlot(self, goal_config):  # default
        self.fig = pl.figure()
        pl.xlim([self.lower_limits[0], self.upper_limits[0]])
        pl.ylim([self.lower_limits[1], self.upper_limits[1]])
        pl.plot(goal_config[0], goal_config[1], "gx")

        # Show all obstacles in environment
        for b in self.robot.GetEnv().GetBodies():
            if b.GetName() == self.robot.GetName():
                continue
            bb = b.ComputeAABB()
            pl.plot(
                [
                    bb.pos()[0] - bb.extents()[0],
                    bb.pos()[0] + bb.extents()[0],
                    bb.pos()[0] + bb.extents()[0],
                    bb.pos()[0] - bb.extents()[0],
                    bb.pos()[0] - bb.extents()[0],
                ],
                [
                    bb.pos()[1] - bb.extents()[1],
                    bb.pos()[1] - bb.extents()[1],
                    bb.pos()[1] + bb.extents()[1],
                    bb.pos()[1] + bb.extents()[1],
                    bb.pos()[1] - bb.extents()[1],
                ],
                "r",
            )

        pl.ion()
        pl.show()
Beispiel #24
0
def tracks_movie(base, skip=1, frames=500, size=10):
    """
    A movie of each particle as a point
    """
    conf, track, pegs = load(base)

    fig = pl.figure(figsize=(size,size*conf['top']/conf['wall']))
    plot = None

    for t in xrange(1,max(frames, track.shape[1]/skip)):
        tmp = track[:,t*skip,:]
        if not ((tmp[:,0] > 0) & (tmp[:,1] > 0) & (tmp[:,0] < conf['wall']) & (tmp[:,1] < conf['top'])).any():
            continue

        if plot is None:
            plot = pl.plot(tmp[:,0], tmp[:,1], 'k,', alpha=1.0, ms=0.1)[0]
            pl.xticks([])
            pl.yticks([])
            pl.xlim(0,conf['wall'])
            pl.ylim(0,conf['top'])
            pl.tight_layout()
        else:
            plot.set_xdata(tmp[:,0])
            plot.set_ydata(tmp[:,1])
        pl.draw()
        pl.savefig(base+'-movie-%05d.png' % (t-1))
Beispiel #25
0
	def test_seq(self):
		sleep(1)
		
		self.cmd_logger(0)
		self.takeoffpub.publish(Empty())	;print 'takeoff' #takeoff
		sleep(12); print '4'; sleep(1); print '3'; sleep(1); print '2'; sleep(1); print '1'; sleep(1)
		
		self.cmd_logger(0)
		self.twist.linear.z = self.vzcmd
		self.cmd_logger(self.vzcmd)
		self.cmdpub.publish(self.twist)		;print 'vzcmd' #set vzcmd
		sleep(self.vzdur)			#wait for vzdur
		
		self.cmd_logger(self.vzcmd)
		self.clear_twist()
		self.cmd_logger(0)
		self.cmdpub.publish(self.twist)		;print 'clear vz' #clear vz
		sleep(4)
		
		self.cmd_logger(0)
		self.landpub.publish(Empty())		;print 'land' #land
		sleep(1)
		
		if not raw_input('show and save?') == 'n':
			pl.xlabel('time (s)')
			pl.ylim(0,2400)
			pl.plot(self.cmd_log['tm'],self.cmd_log['cmd'], 'b-s')
			pl.plot(self.nd_log['tm'],self.nd_log['vz'], 'g-+')
			pl.plot(self.nd_log['tm'],self.nd_log['al'], 'r-+')
			pl.grid(True)
			pl.show()
def plot_prob_effector(sens, fpr, xmax=1, baserate=0.1):
    """Plots a line graph of P(effector|positive test) against
    the baserate of effectors in the input set to the classifier.
        
    The baserate argument draws an annotation arrow
    indicating P(pos|+ve) at that baserate
    """
    assert 0.1 <= xmax <= 1, "Max x axis value must be in range [0,1]"
    assert 0.01 <= baserate <= 1, "Baserate annotation must be in range [0,1]"
    baserates = pylab.arange(0, 1.05, xmax * 0.005)  
    probs = [p_correct_given_pos(sens, fpr, b) for b in baserates]
    pylab.plot(baserates, probs, 'r')
    pylab.title("P(eff|pos) vs baserate; sens: %.2f, fpr: %.2f" % (sens, fpr))
    pylab.ylabel("P(effector|positive)")
    pylab.xlabel("effector baserate")
    pylab.xlim(0, xmax)
    pylab.ylim(0, 1)
    # Add annotation arrow
    xpos, ypos = (baserate, p_correct_given_pos(sens, fpr, baserate))
    if baserate < xmax:
        if xpos > 0.7 * xmax:
            xtextpos = 0.05 * xmax
        else:
            xtextpos = xpos + (xmax-xpos)/5.
        if ypos > 0.5:
            ytextpos = ypos - 0.05
        else:
            ytextpos = ypos + 0.05
        pylab.annotate('baserate: %.2f, P(pos|+ve): %.3f' % (xpos, ypos), 
                       xy=(xpos, ypos), 
                       xytext=(xtextpos, ytextpos),
                       arrowprops=dict(facecolor='black', shrink=0.05))
    else:
        pylab.text(0.05 * xmax, 0.95, 'baserate: %.2f, P(pos|+ve): %.3f' % \
                   (xpos, ypos))
Beispiel #27
0
def plot_file_color(base, thin=True, start=0, size=14, save=False):
    conf, track, pegs = load(base)

    fig = pl.figure(figsize=(size,size*conf['top']/conf['wall']))

    track = track[start:]
    x = track[:,0];   y = track[:,1]
    t = np.linspace(0,1,x.shape[0])
    points = np.array([x,y]).transpose().reshape(-1,1,2)
    segs = np.concatenate([points[:-1],points[1:]],axis=1)
    lc = LineCollection(segs, linewidths=0.25, cmap=pl.cm.coolwarm)
    lc.set_array(t)
    pl.gca().add_collection(lc)

    #pl.scatter(x, y, c=np.arange(len(x)),linestyle='-',cmap=pl.cm.coolwarm)
    #pl.plot(track[-1000000:,0], track[-1000000:,1], '-', linewidth=0.0125, alpha=0.8)
    for peg in pegs:
        pl.gca().add_artist(pl.Circle(peg, conf['radius'], color='k', alpha=0.3))
    pl.xlim(0, conf['wall'])
    pl.ylim(0, conf['top'])
    pl.xticks([])
    pl.yticks([])
    pl.tight_layout()
    pl.show()
    if save:
        pl.savefig(base+".png", dpi=200)
Beispiel #28
0
def RosenbrockTest():
    nDim = 3
    numOfParticles = 20
    maxIteration = 200
    minX = array([-5.0]*nDim)
    maxX = array([5.0]*nDim)
    maxV = 0.2*(maxX - minX)
    minV = -1.0*maxV
    numOfTrial = 20
    gBest = array([0.0]*maxIteration)
    for i in xrange(numOfTrial):
        p1 = RPSO.PSOProblem(nDim, numOfParticles, maxIteration, minX, maxX, minV, maxV, RPSO.Rosenbrock)
        p1.run()
        gBest = gBest + p1.gBestArray[:maxIteration]
    gBest = gBest / numOfTrial
    pylab.title('$G_{best}$ over 20 trials')
    pylab.xlabel('The $N^{th}$ Iteratioin')
    pylab.ylabel('Average gBest over '+str(numOfTrial)+' runs (logscale)')
    pylab.grid(True)
#    pylab.yscale('log')
    ymin, ymax = -1.5, 2.5
    ystep = 0.5
    pylab.ylim(ymin, ymax)
    yticks = linspace(ymin, ymax, (ymax-ymin)/ystep+1)
    pylab.yticks(tuple(yticks),tuple(map(str,yticks)))
    pylab.plot(range(maxIteration), log10(gBest),'-', label='Global best')
    pylab.legend()
    pylab.show()
def pseudoSystem():

	#The corrolations discovered when answering this question shows the emergent effects of component evolution on CSE.
	#We can further study these correlations by creating an example component system consisting of many components where a a different component has a new version released every day.
	#By looking at users who Upgrade the system at different frequencies over 100 days, we present two graphs, Upgrade frequency to uttd and change.	
	
	
	l = 100
	uttdxy = []
	chxy = []
	for uf in range(1,20):
		uttd = range(uf)*(l*2/uf)
		uttd = uttd[1:l+1]
		uttdxy.append((uf,numpy.mean(uttd)))
		
		sh = [0]*(uf-1) + [uf]
		sh = sh*l
		sh = sh[:l]
		chxy.append((uf,sum(sh)))
		
	pylab.figure(20)
	x,y = zip(*sorted(uttdxy))
	pylab.plot(x,y)
	pylab.scatter(x,y)
	saveFigure("q1bpseudouttd")
	
	pylab.figure(21)
	
	x,y = zip(*sorted(chxy))
	pylab.plot(x,numpy.array(y))
	pylab.scatter(x,numpy.array(y))
	pylab.ylim([0,l+10])
	saveFigure("q1bpseudochange")
Beispiel #30
0
    def plotMean(self, Channel, listPops, colors = [], ylabel = "Fluorescence (a.u.)"):
        """
        missing doc
        """

        if type(listPops) != type([]): listPops = [listPops]

        maxf = 0.
        minf = 1.e10
        maxx = 0.0
        minx = -1.0

        for pop in listPops:
            F = np.array( self.getFluorescence(pop, Channel).mean(axis=1) )
            plot.simplePlot( F, fillcolor=self.colors[pop], label = pop )

            if maxf < F.max().max() : maxf = F.max().max()
            if minf > F.min().min() : minf = F.min().min()

            maxx = max(maxx, F.shape[0])


        # setting labels and axes
        pl.xlabel('Time (h)')
        pl.ylabel(ylabel)
        pl.ylim(0.3*minf, 1.2*maxf)
        pl.xlim(minx, maxx)

        #pl.tight_layout()

        return
Beispiel #31
0
def data_preprocessing_result_box_plot(result_dict,
                                       model_list,
                                       data_preprocessing_list,
                                       metrics_name_list,
                                       data_preprocessing_show_list,
                                       metrics_show_list,
                                       title='',
                                       x_label='',
                                       xlim_range=(0, 15),
                                       ylim_range=(0.2, 0.6),
                                       plot_baseline=True,
                                       baseline_value_tuple=None,
                                       baseline_legend_tuple=None,
                                       baseline_colour_tuple=None):
    box_widths = 0.3
    box_gap = 0.5
    category_gap = 1.5
    position_now = 0
    category_pos_list = []
    fig = figure()
    ax = axes()
    hold(True)

    # Some fake data to plot
    # model_result_dict = result_dict[model_list]
    for data_preprocessing in data_preprocessing_list:
        X = []
        for metric in metrics_name_list:
            model_metric_list = []
            for model in model_list:
                model_metric_list.extend(
                    result_dict[model][data_preprocessing][metric])
            X.append(model_metric_list)
        # first boxplot pair
        position_now += category_gap
        positions_list, position_now = get_positions(metrics_name_list,
                                                     position_now, box_gap)
        category_pos_list.append(np.average(positions_list))
        bp = boxplot(X, positions=positions_list, widths=box_widths, sym='+')
        setBoxColors(bp, metrics_name_list)

    # set axes limits and labels
    xlim(*xlim_range)
    ylim(*ylim_range)
    ax.set_xticklabels(data_preprocessing_show_list)
    ax.set_xticks(category_pos_list)
    ax.set_xlabel(x_label)
    ax.set_title(title)

    # draw temporary red and blue lines and use them to create a legend
    h_list = []
    shape = '-'
    legend_list = [
        'b{}'.format(shape), 'r{}'.format(shape), 'g{}'.format(shape),
        'c{}'.format(shape), 'y{}'.format(shape), 'm{}'.format(shape)
    ]

    for i, _ in enumerate(metrics_show_list):
        h, = plot([1, 1], legend_list[i])
        h_list.append(h)
        # h.set_visible(False)

    # hB, = plot([1, 1], 'b-')
    # hR, = plot([1, 1], 'r-')

    if plot_baseline and baseline_value_tuple:
        for i, baseline_value in enumerate(baseline_value_tuple):
            baseline_plot = plt.plot((0, 99), (baseline_value, baseline_value),
                                     '{}-'.format(baseline_colour_tuple[i]),
                                     dashes=[2, 5])[0]
            h_list.append(baseline_plot)
            metrics_show_list.append('{}'.format(baseline_legend_tuple[i]))

    legend(h_list, metrics_show_list)
    for i, h in enumerate(h_list):
        if i >= len(baseline_legend_tuple):
            pass
        else:
            h.set_visible(False)
    show()
    if this_dx > 0:
        horizontalalignment = 'left'
        x = x + .002
    else:
        horizontalalignment = 'right'
        x = x - .002
    if this_dy > 0:
        verticalalignment = 'bottom'
        y = y + .002
    else:
        verticalalignment = 'top'
        y = y - .002
    pl.text(x,
            y,
            name,
            size=10,
            horizontalalignment=horizontalalignment,
            verticalalignment=verticalalignment,
            bbox=dict(facecolor='w',
                      edgecolor=pl.cm.spectral(label / float(n_labels)),
                      alpha=.6))

pl.xlim(
    embedding[0].min() - .15 * embedding[0].ptp(),
    embedding[0].max() + .10 * embedding[0].ptp(),
)
pl.ylim(embedding[1].min() - .03 * embedding[1].ptp(),
        embedding[1].max() + .03 * embedding[1].ptp())

pl.show()
# INDUCED VOLTAGE FROM IMPEDANCE ----------------------------------------------

imp_list = [resonator]

ind_volt_freq = InducedVoltageFreq(beam, slice_beam, imp_list,
                    RFParams=RF_sct_par, frequency_resolution=5e2,
                    multi_turn_wake=True, mtw_mode='time')

total_ind_volt = TotalInducedVoltage(beam, slice_beam, [ind_volt_freq])

f_rf = RF_sct_par.omega_rf[0,0] / 2.0 / np.pi
plt.figure()
plt.plot(ind_volt_freq.freq*1e-6, np.abs(ind_volt_freq.total_impedance * \
                                         slice_beam.bin_size), lw=2)
plt.plot([f_rf*1e-6]*2, plt.ylim(), 'k', lw=2)
plt.plot([f_rf*1e-6 + fs*1e-6]*2, plt.ylim(), 'k--', lw=2)
plt.plot([f_rf*1e-6 - fs*1e-6]*2, plt.ylim(), 'k--', lw=2)
plt.xlim(1.74,1.76)
plt.legend(('Impedance','RF frequency','Synchrotron sidebands'), loc=0, 
           fontsize='medium')
plt.xlabel('Frequency [MHz]')
plt.ylabel(r'Impedance [$\Omega$]')
plt.savefig(this_directory + '../output_files/EX_18_fig/impedance.png')
plt.close()


# BEAM GENERATION -------------------------------------------------------------

matched_from_distribution_function(beam, full_tracker,
                                  distribution_type=distribution_type,
Beispiel #34
0
)
# pl.errorbar(MockCat[:,0] + 0.001, MockCat[:,1], MockCat[:,5], label='Monopole,   predicted errors', fmt='', color='k')
# pl.errorbar(MockCat[:,0] - 0.001, MockCat[:,2], MockCat[:,6], label='Quadrupole, predicted errors', fmt='', color='r')

pl.loglog(MockCat[:, 0],
          MockCat[:, 5],
          'k-',
          label='predicted monopole   error')
pl.loglog(MockCat[:, 0],
          MockCat[:, 6],
          'r-',
          label='predicted quadrupole error')

pl.loglog(kvals, np.sqrt(MonoVar), 'g-', label='monopole error from mocks')
pl.loglog(kvals, np.sqrt(QuadVar), 'b-', label='quadrupole error from mocks')

pl.xscale('log')
pl.yscale('log', nonposy='clip')

pl.xlabel(r'$k [h Mpc^{-1}]$')
# pl.ylabel(r'P(k) e$^{-9k^2/2}$')

pl.xlim(10.**-2., 0.4)
pl.ylim(10.**0., 10.**5.)

pl.legend(loc=1)

pl.savefig(
    '/disk1/mjw/HOD_MockRun/Plots/Windowfunc/31JulyOnwards/quadrupoleError.pdf'
)
Beispiel #35
0
def main():
    option_parser, opts, args =\
       parse_command_line_parameters(**script_info)

    input_fp = opts.input_fp
    output_dir = opts.output_dir
    
    if opts.num_fraction_for_core_steps < 2:
        option_parser.error("Must perform at least two steps. Increase --num_fraction_for_core_steps.")
    fractions_for_core = linspace(opts.min_fraction_for_core,
                                  opts.max_fraction_for_core,
                                  opts.num_fraction_for_core_steps)

    otu_md = opts.otu_md
    valid_states = opts.valid_states
    mapping_fp = opts.mapping_fp
    
    create_dir(output_dir)

    if valid_states and opts.mapping_fp:
        sample_ids = sample_ids_from_metadata_description(open(mapping_fp,'U'),
                                                          valid_states)
        if len(sample_ids) < 1:
            option_parser.error(\
             "--valid_states pattern didn't match any entries in mapping file: \"%s\"" %\
             valid_states)
    else:
        # get core across all samples if user doesn't specify a subset of the 
        # samples to work with
        sample_ids = None
    
    input_table = parse_biom_table(open(input_fp,'U'))
    
    otu_counts = []
    summary_figure_fp = join(output_dir,'core_otu_size.pdf')
    for fraction_for_core in fractions_for_core:
        # build a string representation of the fraction as that gets used 
        # several times
        fraction_for_core_str = "%1.0f" % (fraction_for_core * 100.)
        
        # prep output files
        output_fp = join(output_dir,'core_otus_%s.txt' % fraction_for_core_str)
        output_table_fp = join(output_dir,'core_table_%s.biom' % fraction_for_core_str)
        output_f = open(output_fp,'w')
    
        try:
            core_table = filter_table_to_core(input_table,
                                              sample_ids,
                                              fraction_for_core)
        except TableException:
            output_f.write("# No OTUs present in %s %% of samples." % fraction_for_core_str)
            output_f.close()
            continue
    
        # write some header information to file
        if sample_ids == None:
            output_f.write("# Core OTUs across %s %% of samples.\n" % fraction_for_core_str)
        else:
            output_f.write(\
             "# Core OTUs across %s %% of samples matching the sample metadata pattern \"%s\":\n# %s\n" %\
              (fraction_for_core_str, valid_states,' '.join(sample_ids)))
    
        # write the otu id and corresponding metadata for all core otus
        otu_count = 0
        for value, id_, md in core_table.iterObservations():
            output_f.write('%s\t%s\n' % (id_,md[otu_md]))
            otu_count += 1
        output_f.close()
    
        # write the core biom table
        output_table_f = open(output_table_fp,'w')
        output_table_f.write(format_biom_table(core_table))
        output_table_f.close()
        
        # append the otu count to the list of counts
        otu_counts.append(otu_count)
    
    
    plot(fractions_for_core, otu_counts)
    xlim(min(fractions_for_core),max(fractions_for_core))
    ylim(0,max(otu_counts)+1)
    xlabel("Fraction of samples that OTU must be observed in to be considered 'core'")
    ylabel("Number of OTUs")
    savefig(summary_figure_fp)
Beispiel #36
0
#Question 2

a_2 = np.fft.rfft(a1)

#fast fourier transform function for amplitude
a2 = np.abs(a_2) * 1 / N
T = 1 / 4000

#frequency
f = np.linspace(0, N, len(a2))

#plotting frequency vs. amplitude
plt.bar(f, a2)
xlim(0, 100)
ylim(0, 1.0)
xlabel("Frequency [Hz]")
ylabel("Amplitude")
plt.show()  #plot 2

#Question 3

print("Lengths: time =", len(t), " time-domain function =", len(a1), " FFT =",
      len(a2))
print("Sample rate =", T, " Frequency =", 1 / T)
print("Lengths: f =", N, " abs(f) =", len(a2))
print("Lengths: f(N/2) =", N / 2, " abs(fft(N/2)) =", N / 2, "\n\n")

#filtering f = 40 Hz out of bar graph
for i in range(0, 26):
    print(i)
Beispiel #37
0
def model_result_box_plot(result_dict,
                          model_list,
                          data_preprocessing_list,
                          metrics_name_list,
                          title='',
                          x_label='',
                          xlim_range=(0, 15),
                          ylim_range=(0.2, 0.6),
                          metrics_print_list='',
                          plot_baseline=False,
                          baseline_value_tuple=None,
                          baseline_legend_tuple=None,
                          baseline_colour_tuple=None):
    box_widths = 0.3
    box_gap = 0.5
    category_gap = 1.5
    position_now = 0
    category_pos_list = []
    fig = figure()
    ax = axes()
    hold(True)

    # Some fake data to plot
    for model in model_list:
        X = []
        model_result_dict = result_dict[model]
        for metric in metrics_name_list:
            metric_value_list = []
            for data_preprocessing in data_preprocessing_list:
                value_list = model_result_dict[data_preprocessing][metric]
                metric_value_list.extend(value_list)
            X.append(metric_value_list)

        # print the highest result
        for i, metrics_list in enumerate(X):
            if metrics_list:
                metric = metrics_name_list[i]
                if metric == 'rmse_list':
                    max_value = sorted(metrics_list)[0]
                else:
                    max_value = sorted(metrics_list, reverse=True)[0]

                print("{}-best {}: {}".format(model, metric, max_value))
        #

        # first boxplot pair
        position_now += category_gap
        positions_list, position_now = get_positions(metrics_name_list,
                                                     position_now, box_gap)
        category_pos_list.append(np.average(positions_list))
        bp = boxplot(X, positions=positions_list, widths=box_widths, sym='+')
        setBoxColors(bp, metrics_name_list)

    # set axes limits and labels
    xlim(*xlim_range)
    ylim(*ylim_range)
    ax.set_xticklabels(x_label)
    ax.set_xticks(category_pos_list)
    #ax.set_xlabel(x_label)
    ax.set_title(title)

    # draw temporary red and blue lines and use them to create a legend
    h_list = []
    shape = '-'
    legend_list = [
        'b{}'.format(shape), 'r{}'.format(shape), 'g{}'.format(shape),
        'c{}'.format(shape), 'y{}'.format(shape), 'm{}'.format(shape)
    ]

    if not metrics_print_list:
        metrics_print_list = metrics_name_list

    for i, _ in enumerate(metrics_print_list):
        h = plot([1, 1], legend_list[i])[0]
        h_list.append(h)
        #h.set_visible(False)
    # hB, = plot([1, 1], 'b-')
    # hR, = plot([1, 1], 'r-')
    if plot_baseline and baseline_value_tuple:
        for i, baseline_value in enumerate(baseline_value_tuple):
            baseline_plot = plt.plot((0, 99), (baseline_value, baseline_value),
                                     '{}-'.format(baseline_colour_tuple[i]),
                                     dashes=[2, 5])[0]
            h_list.append(baseline_plot)
            metrics_print_list.append('{}'.format(baseline_legend_tuple[i]))

        #legend(baseline_plot, 'baseline'

    legend(h_list, metrics_print_list)
    for i, h in enumerate(h_list):
        if i >= len(baseline_legend_tuple):
            pass
        else:
            h.set_visible(False)
    # hB.set_visible(False)
    # hR.set_visible(False)

    else:
        print("Check plot baseline and baseline_value_tuple")

    show()
Beispiel #38
0
t = data4['t']
yr = np.array((np.mod(t, 365)), dtype=int)
day4 = (t - yr) * 365

plt.close('all')
width = 3.5
height = width / 2.5
fig = plt.figure(num=1, figsize=(width, height), facecolor='w', edgecolor='k')
fig.set_size_inches(width, height, forward=True)
ax = fig.add_axes([0.2, 0.3, 0.75, 0.6])
p4 = ax.plot(day4, (data4['L'] - L) / 1e3, '-', color='slateblue', linewidth=2)
p3 = ax.plot(day3, (data3['L'] - L) / 1e3, '--', color='gray', linewidth=2)
p2 = ax.plot(day2, (data2['L'] - L) / 1e3, '-.', linewidth=2, color='crimson')
plt.xlabel('Time (day)')
plt.ylabel(r'$\Delta L$ (km)')
plt.ylim([-2, 1])
plt.ylim([-0.5, 0.5])
plt.xlim([0.0, 0.2 * 365])
plt.text(0.13 * 365,
         0.3,
         u'-5\u00B0C',
         color=p2[0].get_color(),
         fontsize=10,
         fontweight='bold')
plt.text((0.05 + 0.11) * 365,
         0.1,
         u'-15\u00B0C',
         color=p3[0].get_color(),
         fontsize=10,
         fontweight='bold')
plt.text(0.125 * 365,
Beispiel #39
0
    def plot(self, filename=None):
        """
        Plot vrep and derivative together with fit info.

        parameters:
        ===========
        filename:     graphics output file name
        """
        try:
            import pylab as pl
        except:
            raise AssertionError('pylab could not be imported')
        r = np.linspace(0, self.r_cut)
        v = [self(x, der=0) for x in r]
        vp = [self(x, der=1) for x in r]
        rmin = 0.95 * min([d[0] for d in self.deriv])
        rmax = 1.1 * self.r_cut

        fig = pl.figure()
        pl.subplots_adjust(wspace=0.25)

        # Vrep
        pl.subplot(1, 2, 1)
        pl.ylabel(r'$V_{rep}(r)$  (eV)')
        pl.xlabel(r'$r$  ($\AA$)')
        if self.r_dimer != None:
            pl.axvline(x=self.r_dimer, c='r', ls=':')
        pl.axvline(x=self.r_cut, c='r', ls=':')
        pl.plot(r, v)
        pl.ylim(ymin=0, ymax=self(rmin))
        pl.xlim(xmin=rmin, xmax=self.r_cut)

        # Vrep'
        pl.subplot(1, 2, 2)
        pl.ylabel(r'$dV_{rep}(r)/dr$ (eV/$\AA$)')
        pl.xlabel(r'$r$ ($\AA$)')
        pl.plot(r, vp, label=r'$dV_{rep}(r)/dr$')
        for s in self.deriv:
            pl.scatter([s[0]], [s[1]], s=100 * s[2], c=s[3], label=s[4])
        pl.axvline(x=self.r_cut, c='r', ls=':')
        if self.r_dimer != None:
            pl.axvline(x=self.r_dimer, c='r', ls=':')

        ymin = 0
        for point in self.deriv:
            if rmin <= point[0] <= rmax: ymin = min(ymin, point[1])
        ymax = np.abs(ymin) * 0.1
        pl.axhline(0, ls='--', c='k')
        if self.r_dimer != None:
            pl.text(self.r_dimer, ymax, r'$r_{dimer}$')
        pl.text(self.r_cut, ymax, r'$r_{cut}$')
        pl.xlim(xmin=rmin, xmax=rmax)
        pl.ylim(ymin=ymin, ymax=ymax)
        #pl.subtitle('Fitting for %s and %s' % (self.sym1, self.sym2))
        pl.rc('font', size=10)
        pl.rc('legend', fontsize=8)
        pl.legend(loc=4)
        file = '%s_%s_repulsion.pdf' % (self.sym1, self.sym2)
        if filename != None:
            file = filename
        pl.savefig(file)
        pl.clf()
Beispiel #40
0
# Reta tangente no ponto P
tan = f(a) + fprime * (x - a)

# Inclinacao da reta secante
m = (Qy - f(a)) / (Qx - a)

# Reta secante que cruza os pontos P e Q
sec = m * (x - a) + f(a)

# Imprime informacoes
print('Inclinacao da reta secante que une os P(a) e P(b): ', format(m))
print('Inclinacao da reta tangente no ponto P(a): ', format(fprime))

# Plota a funcao, ponto e retas
plot(x, y, 'b', label='y(x)')
plot(x, tan, '--r', label='tan')
plot(x, sec, '--g', label='sec')
plot(a, f(a), 'om', label='P')
plot(Qx, Qy, 'og', label='Q')

# Legenda
legend(loc='upper left')

# Limites dos eixos
xlim(xlim_inf - 0.25, xlim_sup + 0.25)
ylim(ylim_inf, ylim_sup)

# Imprime quadriculado e exibe
grid()
show()
Beispiel #41
0
    def upload(self, fname, gracedb_server=None, testing=True,
               extra_strings=None):
        """Upload this trigger to gracedb

        Parameters
        ----------
        fname: str
            The name to give the xml file associated with this trigger
        gracedb_server: string, optional
            URL to the GraceDB web API service for uploading the event.
            If omitted, the default will be used.
        testing: bool
            Switch to determine if the upload should be sent to gracedb as a
            test trigger (True) or a production trigger (False).
        """
        from ligo.gracedb.rest import GraceDb
        import matplotlib
        matplotlib.use('Agg')
        import pylab

        # first of all, make sure the event is saved on disk
        # as GraceDB operations can fail later
        self.save(fname)

        if self.snr_series is not None:
            if fname.endswith('.xml.gz'):
                snr_series_fname = fname.replace('.xml.gz', '.hdf')
            else:
                snr_series_fname = fname.replace('.xml', '.hdf')
            snr_series_plot_fname = snr_series_fname.replace('.hdf',
                                                             '_snr.png')
            psd_series_plot_fname = snr_series_fname.replace('.hdf',
                                                             '_psd.png')
            pylab.figure()
            for ifo in sorted(self.snr_series):
                curr_snrs = self.snr_series[ifo]
                curr_snrs.save(snr_series_fname, group='%s/snr' % ifo)
                pylab.plot(curr_snrs.sample_times, abs(curr_snrs),
                           c=ifo_color(ifo), label=ifo)
                if ifo in self.ifos:
                    snr = self.coinc_results['foreground/%s/%s' %
                                             (ifo, 'snr')]
                    endt = self.coinc_results['foreground/%s/%s' %
                                              (ifo, 'end_time')]
                    pylab.plot([endt], [snr], c=ifo_color(ifo), marker='x')

            pylab.legend()
            pylab.xlabel('GPS time (s)')
            pylab.ylabel('SNR')
            pylab.savefig(snr_series_plot_fname)
            pylab.close()

            pylab.figure()
            for ifo in sorted(self.snr_series):
                # Undo dynamic range factor
                curr_psd = self.psds[ifo].astype(numpy.float64)
                curr_psd /= pycbc.DYN_RANGE_FAC ** 2.0
                curr_psd.save(snr_series_fname, group='%s/psd' % ifo)
                # Can't plot log(0) so start from point 1
                pylab.loglog(curr_psd.sample_frequencies[1:],
                             curr_psd[1:]**0.5, c=ifo_color(ifo), label=ifo)
            pylab.legend()
            pylab.xlim([10, 1300])
            pylab.ylim([3E-24, 1E-20])
            pylab.xlabel('Frequency (Hz)')
            pylab.ylabel('ASD')
            pylab.savefig(psd_series_plot_fname)

        gid = None
        try:
            # try connecting to GraceDB
            gracedb = GraceDb(gracedb_server) \
                    if gracedb_server is not None else GraceDb()

            # create GraceDB event
            group = 'Test' if testing else 'CBC'
            r = gracedb.createEvent(group, "pycbc", fname, "AllSky").json()
            gid = r["graceid"]
            logging.info("Uploaded event %s", gid)

            if self.is_hardware_injection:
                gracedb.writeLabel(gid, 'INJ')
                logging.info("Tagging event %s as an injection", gid)

            # upload PSDs. Note that the PSDs are already stored in the
            # original event file and we just upload a copy of that same file
            # here. This keeps things as they were in O2 and can be removed
            # after updating the follow-up infrastructure
            psd_fname = 'psd.xml.gz' if fname.endswith('.gz') else 'psd.xml'
            gracedb.writeLog(gid, "PyCBC PSD estimate from the time of event",
                             psd_fname, open(fname, "rb").read(), "psd")
            logging.info("Uploaded PSDs for event %s", gid)

            # add other tags and comments
            gracedb.writeLog(
                    gid, "Using PyCBC code hash %s" % pycbc_version.git_hash)

            extra_strings = [] if extra_strings is None else extra_strings
            for text in extra_strings:
                gracedb.writeLog(gid, text, tag_name=['analyst_comments'])

            # upload SNR series in HDF format and plots
            if self.snr_series is not None:
                gracedb.writeLog(gid, 'SNR timeseries HDF file upload',
                                 filename=snr_series_fname)
                gracedb.writeLog(gid, 'SNR timeseries plot upload',
                                 filename=snr_series_plot_fname,
                                 tag_name=['background'],
                                 displayName=['SNR timeseries'])
                gracedb.writeLog(gid, 'PSD plot upload',
                                 filename=psd_series_plot_fname,
                                 tag_name=['psd'], displayName=['PSDs'])

        except Exception as exc:
            logging.error('Something failed during the upload/annotation of '
                          'event %s on GraceDB. The event may not have been '
                          'uploaded!', fname)
            logging.error(str(exc))

        return gid
mag = {}
mag['g'] = data['decam_g'] - 3.186 * data['ebv']
mag['r'] = data['decam_r'] - 2.140 * data['ebv']
mag['i'] = data['decam_i'] - 1.569 * data['ebv']
mag['z'] = data['decam_z'] - 1.196 * data['ebv']

pylab.figure()
pylab.scatter(mag['g'][cut] - mag['r'][cut],
              mag['r'][cut] - mag['z'][cut],
              c=data['feh50'][cut],
              s=2,
              vmin=-3.5,
              vmax=0.5)
pylab.colorbar(label='[Fe/H]')
pylab.xlim(0.2, 1.1)
pylab.ylim(0.0, 0.6)
pylab.xlabel('g - r (mag)')
pylab.ylabel('r - z (mag)')

d = (1 / data.parallax)
pylab.figure()
pylab.scatter(mag['g'][cut] - mag['r'][cut],
              mag['r'][cut] - mag['z'][cut],
              c=d[cut],
              s=2,
              vmin=0.,
              vmax=15.)
pylab.colorbar(label='distance')
pylab.xlim(0.2, 1.1)
pylab.ylim(0.0, 0.6)
pylab.xlabel('g - r (mag)')
Beispiel #43
0
    if True:
        errs_dn = n.where(errs >= C_l1 - 1e-6, C_l1 - 1e-6, Errs)
        p.errorbar(ells,
                   C_l1, [errs_dn, errs],
                   fmt='.-',
                   label='ch%fcl' % ch,
                   color=color)
    else:
        p.plot(ells, C_l1, '.-', label='ch%fcl' % ch, color=color)
    p.plot(ells, C_l2, '-.', label='ch%ftherm' % ch, color=color)
    #p.plot(ells, .5*errs, 'k-.')
    #p.plot(ells, c_l3, ':', label='ch%ffit' % ch, color=color)
    #p.plot(ells, wgts, 'r-')
print '}'

p.plot(ells,
       10**n.polyval(C_l_sim, n.log10(ells)),
       'k-',
       label='z=9.2_santos2005',
       linewidth=4)
p.plot(ells, C_l_sync(ells, 147.), 'k:', label='sync')
ax = p.gca()
ax.set_xscale('log')
ax.set_yscale('log')
#p.xlim(60,1e3)
p.xlim(1e2, 1e3)
p.ylim(1e-1, 1e11)
p.xlabel(r'$\ell=2\pi u$', fontsize=20)
p.ylabel(r'$\ell(\ell+1)C_\ell/2\pi\ \ (mK^2)$', fontsize=20)
p.show()
Beispiel #44
0
def display_filename(pickle_filename, name=None):
    print "Loading data to display..."
    data = pickle.load(open(pickle_filename, 'rb'))
    coll, xlabel, ylabel = data

    if not name:
        name = pickle_filename.split('/')[3]

    def normalize(val, low, high):
        return (val - low) / (high - low)

    num_features = actual.NUM_FEATURES
    ms = []
    ss = []
    for i in range(num_features):
        ms.append([])
        ss.append([])

    # find ranges of values
    for value in coll:
        (bp, force, i, j, means, stds) = value
        #(bp, force, i, j, sfmm, sfmstd) = value
        for i in range(num_features):
            ms[i].append(means[i])
            ss[i].append(stds[i])
        #ms[0].append(sfmm)
        #ss[0].append(sfmstd)

    print "Generating plots..."
    #m = 0
    ### for schelleng force
    ri = 7
    gi = 0
    bi = 7
    ### for accel?
    #ri = 0
    #gi = 1
    #bi = 7
    power = 0.5
    invert = False
    #invert = True

    if PLOT_PNG_BARE:
        fig = pylab.figure()
        fig.set_size_inches(4, 3)
        ax = pylab.Axes(fig, [
            0.,
            0.,
            1.,
            1.,
        ])
    else:
        fig = pylab.figure()
        pylab.title("%s" % (name))
    fig.set_size_inches(16, 12)
    numx = xlabel.num
    numy = ylabel.num
    img = numpy.zeros((numy, numx, 3), dtype=numpy.float32)

    min_ms_ri = min(ms[ri])
    min_ms_gi = min(ms[gi])
    min_ms_bi = min(ms[bi])
    max_ms_ri = max(ms[ri])
    max_ms_gi = max(ms[gi])
    max_ms_bi = max(ms[bi])

    min_ss_ri = min(ms[ri])
    max_ss_ri = max(ms[ri])
    print "got min/max"
    for value in coll:
        (bp, force, i, j, means, stds) = value
        #(bp, force, i, j, sfmm, sfmstd) = value
        x = bp
        y = force
        #r = normalize(means[ri], min(ms[ri]), max(ms[ri]))
        g = normalize(means[gi], min_ms_gi, max_ms_gi)
        b = normalize(means[bi], min_ms_bi, max_ms_bi)

        r = normalize(stds[ri], min_ss_ri, max_ss_ri)
        if invert:
            r = 1. - r**power
            g = 1. - g**power
            b = 1. - b**power
        else:
            r = r**power
            g = g**power
            b = b**power
        #text = "%.3f\t%.3f\t%.3f\t%.3f\t%.3f" % (x,y,r,g,b)
        #out.write(text + "\n")

        #pylab.plot(x,y, '.', color=(r,g,b), markersize=10)
        #pylab.semilogy(x,y, '.', color=(r,g,b), markersize=10)
        img[i][j][0] = r
        img[i][j][1] = g
        img[i][j][2] = b
    print "start imshow"
    if PLOT_PNG_BARE:
        ax.imshow(
            img,
            #interpolation='bilinear',
            aspect="auto",
            origin="lower",
        )
        ax.set_xlim(0, numx - 1)
        ax.set_ylim(0, numy - 1)
    else:
        pylab.imshow(
            img,
            #interpolation='bilinear',
            aspect="auto",
            origin="lower",
        )
        pylab.xlim(0, numx - 1)
        pylab.ylim(0, numy - 1)
    print "end imshow"
    for m in range(5, 10):
        modal = 1.0 / m
        relpos = 1.0 - (xlabel.high - modal) / (xlabel.high - xlabel.low)
        abspos = relpos * (numx - 1)
        print abspos,
        if xlabel.log:
            abspos = numpy.log(abspos)
        print abspos
        #print m, modal, relpos, abspos
        if PLOT_PNG_BARE:
            pass
            #ax.axvline(abspos, color="yellow")
        else:
            #pylab.axvline(abspos, color="yellow")
            pass

    xlocs = numpy.linspace(0, numx - 1, 11)
    ylocs = numpy.linspace(0, numy - 1, 11)
    if xlabel.log:
        xticks = map(
            lambda d: str("%.3f" % d),
            numpy.exp(
                numpy.linspace(numpy.log(xlabel.low), numpy.log(xlabel.high),
                               len(xlocs))))
    else:
        xticks = map(lambda d: str("%.3f" % d),
                     numpy.linspace(xlabel.low, xlabel.high, len(xlocs)))
    if ylabel.log:
        yticks = map(
            lambda d: str("%.2f" % d),
            numpy.exp(
                numpy.linspace(numpy.log(ylabel.low), numpy.log(ylabel.high),
                               len(ylocs))))
    else:
        yticks = map(lambda d: str("%.2f" % d),
                     numpy.linspace(ylabel.low, ylabel.high, len(ylocs)))
    if True:
        pylab.xticks(xlocs, xticks)
        pylab.xlabel(xlabel.title)

        pylab.yticks(ylocs, yticks)
        pylab.ylabel(ylabel.title)

    if PLOT_STD:
        pylab.figure()
        pylab.title("Standard deviations for %s" % (name))
        pylab.xlim(XB_MIN, XB_MAX)
        power = 0.5
        for value in coll:
            (bp, force, i, j, means, stds) = value
            x = bp
            y = force
            r = normalize(stds[ri], min(ss[ri]), max(ss[ri]))
            g = normalize(stds[gi], min(ss[gi]), max(ss[gi]))
            b = normalize(stds[bi], min(ss[bi]), max(ss[bi]))
            r = r**power
            g = g**power
            b = b**power
            pylab.plot(x, y, '.', color=(r, g, b), markersize=10)
    if PLOT_COMBO:
        pylab.figure()
        pylab.title("Combo for %s" % (name))
        pylab.xlim(XB_MIN, XB_MAX)
        power = 0.5
        ri = 0
        gi = 3
        bi = 3
        for value in coll:
            (bp, force, i, j, means, stds) = value
            x = bp
            y = force
            r = normalize(means[ri], min(ms[ri]), max(ms[ri]))
            g = normalize(stds[gi], min(ss[gi]), max(ss[gi]))
            b = normalize(means[bi], min(ms[bi]), max(ms[bi]))
            r = r**power
            g = g**power
            b = b**power
            pylab.plot(x, y, '.', color=(r, g, b), markersize=10)
    #pylab.axis('off')
    #pylab.yscale('log')
    filename = name + ".png"
    if PLOT_PNG_BARE:
        ax.set_axis_off()
        fig.add_axes(ax)
        #pylab.title('')
        #pylab.savefig(name+".png", bbox_inches='tight', pad_inches=0)
        extent = ax.get_window_extent().transformed(
            fig.dpi_scale_trans.inverted())
        pylab.savefig(filename, bbox_inches=extent)
        print "filename:\tX:", xlabel.title, xlabel.low, xlabel.high
        print "\t\tY:", ylabel.title, ylabel.low, ylabel.high
    else:
        pylab.savefig(filename)
    print "... done"
Beispiel #45
0

pl.subplot(2, 2, 1)
a = pendulums(9.8, 3 * math.pi / 1000)
a.calculation(0.5, 0.2, 0, 1.4, 2 / 3, 3 * math.pi * 2000)
showangle = []
showomega = []
for i in range(10000, len(a.t)):
    if ((2 / 3) * (a.t[i])) % (2 * (math.pi)) < 0.001:
        showangle.append(a.angle[i])
        showomega.append(a.omega[i])
pl.plot(showangle, showomega, '.', label='$2/3t=2\pi n$')
pl.xlabel('Angle ($rad$)')
pl.ylabel('Angular ($rad/s$)')
pl.xlim(-4, 4)
pl.ylim(-2, 2)
pl.legend(loc='best')

pl.subplot(2, 2, 2)
a = pendulums(9.8, 3 * math.pi / 1000)
a.calculation(0.5, 0.2, 0, 1.4, 2 / 3, 3 * math.pi * 2000)
showangle = []
showomega = []
for i in range(10000, len(a.t)):
    if ((2 / 3) * (a.t[i]) - math.pi / 4) % (2 * (math.pi)) < 0.001:
        showangle.append(a.angle[i])
        showomega.append(a.omega[i])
pl.plot(showangle, showomega, '.', label='$2/3t=2\pi n+\pi/4$')
pl.xlabel('Angle ($rad$)')
pl.ylabel('Angular ($rad/s$)')
pl.xlim(-4, 4)
def main(argv=None):
    """script main.

    parses command line options in sys.argv, unless *argv* is given.
    """

    if argv is None:
        argv = sys.argv

    parser = E.OptionParser(
        version=
        "%prog version: $Id: plot_matrix.py 2782 2009-09-10 11:40:29Z andreas $"
    )

    parser.add_option("-c",
                      "--columns",
                      dest="columns",
                      type="string",
                      help="columns to take from table.")

    parser.add_option("-a",
                      "--hardcopy",
                      dest="hardcopy",
                      type="string",
                      help="write hardcopy to file.",
                      metavar="FILE")

    parser.add_option("-f",
                      "--file",
                      dest="input_filename",
                      type="string",
                      help="filename with table data.",
                      metavar="FILE")

    parser.add_option("-p",
                      "--plot",
                      dest="plot",
                      type="string",
                      help="plots to plot.",
                      action="append")

    parser.add_option("-t",
                      "--threshold",
                      dest="threshold",
                      type="float",
                      help="min threshold to use for counting method.")

    parser.add_option("-o",
                      "--colours",
                      dest="colours",
                      type="int",
                      help="column with colour information.")

    parser.add_option("-l",
                      "--plot-labels",
                      dest="labels",
                      type="string",
                      help="column labels for x and y in matched plots.")

    parser.add_option("-e",
                      "--header-names",
                      dest="headers",
                      action="store_true",
                      help="headers are supplied in matrix.")

    parser.add_option("--no-headers",
                      dest="headers",
                      action="store_false",
                      help="headers are not supplied in matrix.")

    parser.add_option("--normalize",
                      dest="normalize",
                      action="store_true",
                      help="normalize matrix.")

    parser.add_option("--palette",
                      dest="palette",
                      type="choice",
                      choices=("rainbow", "gray", "blue-white-red", "autumn",
                               "bone", "cool", "copper", "flag", "gray", "hot",
                               "hsv", "jet", "pink", "prism", "spring",
                               "summer", "winter", "spectral", "RdBu", "RdGy",
                               "BrBG", "BuGn", "Blues", "Greens", "Reds",
                               "Oranges", "Greys"),
                      help="colour palette [default=%Default]")

    parser.add_option("--reverse-palette",
                      dest="reverse_palette",
                      action="store_true",
                      help="reverse the palette [default=%default].")

    parser.add_option("",
                      "--xrange",
                      dest="xrange",
                      type="string",
                      help="xrange.")

    parser.add_option("",
                      "--yrange",
                      dest="yrange",
                      type="string",
                      help="yrange.")

    parser.add_option("",
                      "--zrange",
                      dest="zrange",
                      type="string",
                      help="zrange.")

    parser.add_option("",
                      "--xticks",
                      dest="xticks",
                      type="string",
                      help="xticks.")

    parser.add_option("",
                      "--yticks",
                      dest="yticks",
                      type="string",
                      help="yticks.")

    parser.add_option("--bar-format",
                      dest="bar_format",
                      type="string",
                      help="format for ticks on colourbar.")

    parser.add_option("--title",
                      dest="title",
                      type="string",
                      help="title to use.")

    parser.add_option("--missing-value",
                      dest="missing",
                      type="float",
                      help="value to use for missing data.")

    parser.add_option(
        "--subplots",
        dest="subplots",
        type="string",
        help=
        "split matrix into several subplots. Supply number of rows and columns separated by a comma."
    )

    parser.set_defaults(hardcopy=None,
                        input_filename="-",
                        columns="all",
                        statistics=[],
                        plot=[],
                        threshold=0.0,
                        labels="x,y",
                        colours=None,
                        xrange=None,
                        yrange=None,
                        zrange=None,
                        palette=None,
                        reverse_palette=False,
                        xticks=None,
                        yticks=None,
                        normalize=False,
                        bar_format="%1.1f",
                        headers=True,
                        missing=None,
                        title=None,
                        subplots=None)

    (options, args) = E.start(parser)

    # import matplotlib/pylab. Has to be done here
    # for batch scripts without GUI.
    import matplotlib
    if options.hardcopy:
        matplotlib.use("cairo")
    import pylab

    if len(args) > 0:
        options.input_filename = ",".join(args)

    if options.xticks:
        options.xticks = options.xticks.split(",")
    if options.yticks:
        options.yticks = options.yticks.split(",")

    if options.xrange:
        options.xrange = list(map(float, options.xrange.split(",")))
    if options.yrange:
        options.yrange = list(map(float, options.yrange.split(",")))

    if options.columns != "all":
        options.columns = [int(x) - 1 for x in options.columns.split(",")]

    filenames = options.input_filename.split(",")

    if len(filenames) > 1:
        nsubrows = (len(filenames) / 3) + 1
        nsubcols = 3
    elif options.subplots:
        nsubrows, nsubcols = [int(x) for x in options.subplots.split(",")]
    else:
        nsubrows, nsubcols = 1, 1

    nsubplots = nsubrows * nsubcols

    # Setting up color maps
    if options.palette:
        if options.palette == "gray":
            _gray_data = {
                'red': ((0., 1, 1), (1., 0, 0)),
                'green': ((0., 1, 1), (1., 0, 0)),
                'blue': ((0., 1, 1), (1., 0, 0))
            }

            LUTSIZE = pylab.rcParams['image.lut']
            colors_gray = matplotlib.colors.LinearSegmentedColormap(
                'gray', _gray_data, LUTSIZE)

    plot_id = 0
    for filename in filenames:

        plot_id += 1
        pylab.subplot(nsubrows, nsubcols, plot_id)

        if filename == "-":
            infile = sys.stdin
        else:
            infile = IOTools.open_file(filename, "r")

        matrix, row_headers, col_headers = MatlabTools.readMatrix(
            infile,
            numeric_type=numpy.float32,
            take=options.columns,
            headers=options.headers,
            missing=options.missing)

        if min(matrix.flat) == max(matrix.flat):
            options.stderr.write("matrix is uniform - no plotting done.\n")
            sys.exit(0)

        if options.normalize:
            v = max(matrix.flat)
            matrix = matrix / v

        if options.zrange:
            options.zrange = GetRange(matrix, options.zrange)

        nrows, ncols = matrix.shape

        if options.palette:
            if options.palette == "gray":
                color_scheme = colors_gray
            else:
                if options.reverse_palette:
                    color_scheme = eval("pylab.cm.%s_r" % options.palette)
                else:
                    color_scheme = eval("pylab.cm.%s" % options.palette)
        else:
            color_scheme = None

        if options.zrange:
            vmin, vmax = options.zrange
            matrix[matrix < vmin] = vmin
            matrix[matrix > vmax] = vmax
        else:
            vmin, vmax = None, None

        if options.subplots:

            if nsubcols > 1:
                increment_x = int(float(nrows + 1) / nsubcols)
                increment_y = nrows

                x = 0
                y = 0
                for n in range(nsubplots):
                    pylab.subplot(nsubrows, nsubcols, plot_id)
                    plot_id += 1

                    print(n, "rows=", nsubrows, "cols=", nsubcols, y,
                          y + increment_y, x, x + increment_x)
                    print(matrix[y:y + increment_y, x:x + increment_x].shape)
                    print(matrix.shape)
                    plotMatrix(matrix[y:y + increment_y, x:x + increment_x],
                               color_scheme, row_headers[y:y + increment_y],
                               col_headers[x:x + increment_x], 0, 100, options)

                x += increment_x

            elif nsubrows > 1:
                increment_x = int(float(ncols + 1) / nsubrows)

                x = 0
                for n in range(nsubplots):
                    pylab.subplot(nsubrows, nsubcols, plot_id)
                    plot_id += 1
                    plotMatrix(matrix[0:nrows,
                                      x:x + increment_x], color_scheme,
                               row_headers, col_headers[x:x + increment_x],
                               vmin, vmax, options)

                    x += increment_x
        else:
            plotMatrix(matrix, color_scheme, row_headers, col_headers, vmin,
                       vmax, options)

        if options.xrange:
            pylab.xlim(options.xrange)

        if options.yrange:
            pylab.ylim(options.yrange)

        if options.labels:
            xlabel, ylabel = options.labels.split(",")
            pylab.xlabel(xlabel)
            pylab.ylabel(ylabel)

        if not options.subplots:
            pylab.colorbar(format=options.bar_format)

        if options.title is None or options.title != "":
            pylab.title(filename)

    if options.hardcopy:
        pylab.savefig(os.path.expanduser(options.hardcopy))
    else:
        pylab.show()

    E.stop()
h = .02  # step size in the mesh

clf = svm.SVC(C=1.0, kernel='linear')

# we create an instance of SVM Classifier and fit the data.
clf.fit(X, Y)

# Plot the decision boundary. For that, we will assign a color to each
# point in the mesh [x_min, m_max]x[y_min, y_max].
x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])

# Put the result into a color plot
Z = Z.reshape(xx.shape)
pl.figure(1, figsize=(4, 3))
pl.pcolormesh(xx, yy, Z, cmap=pl.cm.Paired)

# Plot also the training points
pl.scatter(X[:, 0], X[:, 1], c=Y, cmap=pl.cm.Paired)
pl.xlabel('Sepal length')
pl.ylabel('Sepal width')

pl.xlim(xx.min(), xx.max())
pl.ylim(yy.min(), yy.max())
pl.xticks(())
pl.yticks(())

pl.show()
def save_HDF5_to_plot(h5fname, img_path=None, axis_unit=None, map_unit=None, cmap="jet", cmap_range=None,\
  fraction=None, save_into_png=True, discrete=False, verbose=True):#{{{
    r"""
	Function that plots the map with axis + colorbar from an HDF5 file

	Parameters
	----------
	h5fname      : the name of the HDF5 file containing the map
	img_path     : the path in wich the plot img file is to be saved
	axis_unit    : a (length_unit_label, axis_scale_factor) tuple containing :
		 * the label of the u/v axes unit
		 * the scaling factor of the u/v axes unit, or a Unit instance
	map_unit     : a (map_unit_label, map_scale_factor) tuple containing :
		 * the label of the map unit
		 * the scaling factor of the map unit, or a Unit instance
	cmap         : a Colormap object or any default python colormap string
	cmap_range   : a [vmin, vmax] array for map values clipping (linear scale)
	fraction     : fraction of the total map values below the min. map range (in percent)
	save_into_png: whether the plot is saved into an png file or not (default True)
	discrete     : wheter the map values are discrete integer values (default False). for colormap

	"""
    h5f = tables.openFile(h5fname, 'r')
    cam = Camera.from_HDF5(h5f)
    map = h5f.getNode("/map/map").read()
    if cam.log_sensitive and pymses.__revision__ >= '$Revision: 705$':
        map = apply_log_scale(map)
    map_unit_label = None
    if map_unit is not None:
        map_unit_label, map_scale_factor = map_unit
        if isinstance(map_scale_factor, Unit):
            try:
                d = h5f.getNode("/map/unit/dimensions").read()
                v = h5f.getNode("/map/unit/val").read()
            except:
                raise ValueError(
                    "map unit record not found in '%s' HDF5 file" % h5fname)
            mu = Unit(d, v)
            map_scale_factor = mu.express(map_scale_factor)

        if cam.log_sensitive:
            map = map + numpy.log10(map_scale_factor)
        else:
            map = map * map_scale_factor

    nx, ny = map.shape
    map = map.transpose()

    vmin, vmax = get_map_range(map, cam.log_sensitive, cmap_range, fraction)
    colormap, vmin, vmax = get_Colormap(cmap, discrete, (vmin, vmax))
    vrange = [vmin, vmax]
    if cam.log_sensitive:
        vrange = [10.**vmin, 10.**vmax]
    if verbose: print("Colormap range is : [%e, %e]" % (vrange[0], vrange[1]))
    map = numpy.clip(map, vmin, vmax)

    uedges, vedges = cam.get_pixels_coordinates_edges()
    uaxis, vaxis, zaxis = cam.get_camera_axis()
    ulabel = 'u'
    vlabel = 'v'
    ax_dict = {'x': 0, 'y': 1, 'z': 2}
    for axname, axis in list(Camera.special_axes.items()):
        if (numpy.abs(uaxis) == numpy.abs(axis)).all():
            ulabel = axname
            uedges = uedges + cam.center[ax_dict[axname]]
            if (uaxis != axis).any():
                uedges = uedges[::-1]
            break
    for axname, axis in list(Camera.special_axes.items()):
        if (numpy.abs(vaxis) == numpy.abs(axis)).all():
            vlabel = axname
            vedges = vedges + cam.center[ax_dict[axname]]
            if (vaxis != axis).any():
                vedges = vedges[::-1]
            break

    uvaxis_unit_label = 'box size unit'
    if axis_unit is not None:
        uvaxis_unit_label, axis_scale_factor = axis_unit
        if isinstance(axis_scale_factor, Unit):
            try:
                d = h5f.getNode("/map/length_unit/dimensions").read()
                v = h5f.getNode("/map/length_unit/val").read()
            except:
                raise ValueError(
                    "length_unit record not found in '%s' HDF5 file" % h5fname)
            au = Unit(d, v)
            axis_scale_factor = au.express(axis_scale_factor)

        uedges = uedges * axis_scale_factor
        vedges = vedges * axis_scale_factor

    fig = pylab.figure()
    pylab.pcolormesh(uedges, vedges, map, cmap=colormap, vmin=vmin, vmax=vmax)
    pylab.xlabel("%s (%s)" % (ulabel, uvaxis_unit_label))
    pylab.xlim(uedges[0], uedges[-1])
    pylab.ylabel("%s (%s)" % (vlabel, uvaxis_unit_label))
    pylab.ylim(vedges[0], vedges[-1])
    pylab.gca().set_aspect('equal')

    # Pretty user-defined colorbar
    if cam.log_sensitive:
        fo = pylab.matplotlib.ticker.FormatStrFormatter("$10^{%d}$")
        offset = numpy.ceil(vmin) - vmin
        lo = pylab.matplotlib.ticker.IndexLocator(1.0, offset)
        cb = pylab.colorbar(ticks=lo, format=fo)
    else:
        if discrete:
            fo = pylab.matplotlib.ticker.FormatStrFormatter("%d")
            ncol = int(round(vmax - vmin))
            ti = numpy.linspace(vmin + 0.5, vmax - 0.5, ncol)
            cb = pylab.colorbar(format=fo, ticks=ti)
        else:
            cb = pylab.colorbar()

    if map_unit_label is not None:
        cb.set_label(map_unit_label)

    if img_path is None:
        h5f.close()
        return fig
    else:
        if save_into_png:
            fname = "%s.png" % h5f.getNode("/name").read()
            fname = os.path.join(img_path, fname)
            print("Saving plot into '%s'" % fname)
            try:
                pylab.savefig(fname)
            except:
                os.mkdir(img_path)
                pylab.savefig(fname)
            h5f.close()
            return
Beispiel #49
0
# SOURCE: https://gist.github.com/andrewgiessel/5684769
# good discussion here:  http://stackoverflow.com/questions/4308168/sigmoidal-regression-with-scipy-numpy-python-etc
# curve_fit() example from here: http://permalink.gmane.org/gmane.comp.python.scientific.user/26238
# other sigmoid functions here: http://en.wikipedia.org/wiki/Sigmoid_function

import numpy as np
import pylab
from scipy.optimize import curve_fit


def sigmoid(x, x0, k):
    y = 1 / (1 + np.exp(-k * (x - x0)))
    return y


xdata = np.array([0.0, 1.0, 3.0, 4.3, 7.0, 8.0, 8.5, 10.0, 12.0])
ydata = np.array([0.01, 0.02, 0.04, 0.11, 0.43, 0.7, 0.89, 0.95, 0.99])

popt, pcov = curve_fit(sigmoid, xdata, ydata)
print(popt)

x = np.linspace(-1, 15, 50)
print(x)
y = sigmoid(x, *popt)
print(y)

pylab.plot(xdata, ydata, 'o', label='data')
pylab.plot(x, y, label='fit')
pylab.ylim(0, 1.05)
pylab.legend(loc='best')
pylab.show()
Beispiel #50
0
#labels = ['feed alone 3ft above ground','feed alone 3ft above absorber','feed in cage on ground','feed in cage on absorber','feed in cage upsidedown']
valids = ['C_NC41', 'C_NC41_AB']
labels = ['feed in cage on ground', 'feed in cage on absorber']

fig, ax = p.subplots(nrows=1, ncols=1)
for i, v in enumerate(valids):
    fq, amps = fromcsv(file_base + str(v) + amp_end)
    fq, phs = fromcsv(file_base + str(v) + phs_end)
    #bandwidth = n.where(n.logical_and(fq>.05 ,fq<.25)) #HERA bandwidth
    #bandwidth = n.where(n.logical_and(fq>.1,fq<.2)) #PAPER bandwidth
    bandwidth = n.where(n.logical_and(fq > .05, fq < .5))  #full bandwidth
    dw, d, tau = take_delay(amps[bandwidth], phs[bandwidth], fq[bandwidth])
    #    p.plot(tau, 10*n.log10(n.abs(dw)**2), linewidth=2, label=('%s'%v)+'ft', color=colors[i])
    ax.plot(tau,
            10 * n.log10(n.abs(dw)**2),
            linewidth=2,
            label=labels[i],
            color=colors[i])
p.xlim(-30, 350)
p.ylim(-100, 1)
p.vlines(60, -100, 100, linestyle='--', linewidth=2)
p.hlines(-60, -100, 500, linestyle='--', linewidth=2)
p.xlabel('delay (ns)')
p.ylabel('return loss (dB)')
p.grid(1)
p.legend()

fig.subplots_adjust(left=.08, top=.95, bottom=.10, right=0.92)

p.show()
colors = 'brgkcmbrgkcm'
lines, names = [], []
for fileN, thisStair in enumerate(allIntensities):
    #lines.extend(pylab.plot(thisStair))
    #names = files[fileN]
    pylab.plot(thisStair, label=files[fileN])
#pylab.legend()

#get combined data
combinedInten, combinedResp, combinedN = \
             data.functionFromStaircase(allIntensities, allResponses, 5)
#fit curve - in this case using a Weibull function
fit = data.FitFunction('weibullTAFC',combinedInten, combinedResp, \
guess=[0.2, 0.5])
smoothInt = pylab.arange(min(combinedInten), max(combinedInten), 0.001)
smoothResp = fit.eval(smoothInt)
thresh = fit.inverse(0.8)
print thresh

#plot curve
pylab.subplot(122)
pylab.plot(smoothInt, smoothResp, '-')
pylab.plot([thresh, thresh], [0, 0.8], '--')pylab.plot([0, thresh],\
[0.8,0.8],'--')
pylab.title('threshold = %0.3f' % (thresh))
#plot points
pylab.plot(combinedInten, combinedResp, 'o')
pylab.ylim([0, 1])

pylab.show()
Beispiel #52
0
# top_edge - mean(right-edge)
sensor_1_array = density_hydro[q2_index, q1_index] - np.mean(density_hydro[:,
                                                                           -1])
sensor_2_array = density_ballistic[q2_index, q1_index] - np.mean(
    density_ballistic[:, -1])
sensor_3_array = density_ohmic[q2_index, q1_index] - np.mean(density_ohmic[:,
                                                                           -1])

np.savetxt("R_vs_L_hydro.txt", sensor_1_array)
np.savetxt("R_vs_L_ballistic.txt", sensor_2_array)
np.savetxt("R_vs_L_ohmic.txt", sensor_3_array)

np.savetxt("bottom_edge.txt", x[q1_index, q2_index])

pl.plot(x[q1_index, q2_index], sensor_1_array, label="Hydro")
pl.plot(x[q1_index, q2_index], sensor_2_array, label="Ballistic")
pl.plot(x[q1_index, q2_index], sensor_3_array, label="Ohmic")

pl.axhline(0, color='k', ls='--')

pl.ylim(ymax=150)
#pl.gca().set_aspect('equal')
pl.ylabel(r'$n$')
pl.xlabel(r'x ($\mu$m)')
pl.legend(loc='best')
#pl.suptitle('$\\tau_\mathrm{mc} = \infty$, $\\tau_\mathrm{mr} = \infty$')
#pl.suptitle('$\\tau_\mathrm{mc} = 0.1$, $\\tau_\mathrm{mr} = \infty$')
pl.savefig('images/iv.png')
pl.clf()
import scipy as SP
import pylab as PL
import os
#import cPickle
import scipy.misc
import sys
import pdb
#import pyplot

#from models import *

if __name__ == '__main__':
    X = SP.linspace(-5, 5, 100)

    y_res = 0.5 + 0.5 * SP.exp(-SP.absolute(X))
    y_sus = 0.5 - 0.2 * SP.exp(-SP.absolute(X))
    PL.figure(figsize=[10, 3])
    p0 = PL.plot(X, y_res, linewidth=2)
    p1 = PL.plot(X, y_sus, 'k-', linewidth=2)
    PL.ylim([0, 1])
    PL.yticks([0, 0.25, 0.5, 0.75, 1.0])
    PL.legend([p0, p1], ['res', 'sus'])
    PL.xlabel('Distance')
    PL.ylabel('Frequency, resistant parent')
    #PL.savefig('freq_parent.pdf')
    PL.show()
Beispiel #54
0
    def test2(self):
        """A 1-d example, to test the stray-flux assignment.
        """
        H, W = 1, 100

        fpbb = geom.Box2I(geom.Point2I(0, 0), geom.Point2I(W - 1, H - 1))
        afwimg = afwImage.MaskedImageF(fpbb)
        img = afwimg.getImage().getArray()

        var = afwimg.getVariance().getArray()
        var[:, :] = 1.

        y = 0
        img[y, 1:-1] = 10.

        img[0, 1] = 20.
        img[0, -2] = 20.

        fakepsf_fwhm = 1.
        fakepsf = gaussianPsf(1, 1, fakepsf_fwhm)

        # Run the detection code to get a ~ realistic footprint
        thresh = afwDet.createThreshold(5., 'value', True)
        fpSet = afwDet.FootprintSet(afwimg, thresh, 'DETECTED', 1)
        fps = fpSet.getFootprints()
        self.assertEqual(len(fps), 1)
        fp = fps[0]

        # WORKAROUND: the detection alg produces ONE peak, at (1,0),
        # rather than two.
        self.assertEqual(len(fp.getPeaks()), 1)
        fp.addPeak(W - 2, y, float("NaN"))
        # print 'Added peak; peaks:', len(fp.getPeaks())
        # for pk in fp.getPeaks():
        #    print '  ', pk.getFx(), pk.getFy()

        # Change verbose to False to quiet down the meas_deblender.baseline logger
        deb = deblend(
            fp,
            afwimg,
            fakepsf,
            fakepsf_fwhm,
            verbose=True,
            fitPsfs=False,
        )

        if doPlot:
            XX = np.arange(W + 1).repeat(2)[1:-1]

            plt.clf()
            p1 = plt.plot(XX, img[y, :].repeat(2), 'g-', lw=3, alpha=0.3)

            for i, dpk in enumerate(deb.peaks):
                print(dpk)
                port = dpk.fluxPortion.getImage()
                bb = port.getBBox()
                YY = np.zeros(XX.shape)
                YY[bb.getMinX() * 2:(bb.getMaxX() + 1) *
                   2] = port.getArray()[0, :].repeat(2)
                p2 = plt.plot(XX, YY, 'r-')

                simg = afwImage.ImageF(fpbb)
                dpk.strayFlux.insert(simg)
                p3 = plt.plot(XX, simg.getArray()[y, :].repeat(2), 'b-')

            plt.legend((p1[0], p2[0], p3[0]),
                       ('Parent Flux', 'Child portion', 'Child stray flux'))
            plt.ylim(-2, 22)
            plt.savefig(plotpat % 3)

        strays = []
        for i, dpk in enumerate(deb.deblendedParents[0].peaks):
            simg = afwImage.ImageF(fpbb)
            dpk.strayFlux.insert(simg)
            strays.append(simg.getArray())

        ssum = reduce(np.add, strays)

        starget = np.zeros(W)
        starget[2:-2] = 10.

        self.assertFloatsEqual(ssum, starget)

        X = np.arange(W)
        dx1 = X - 1.
        dx2 = X - (W - 2)
        f1 = (1. / (1. + dx1**2))
        f2 = (1. / (1. + dx2**2))
        strayclip = 0.001
        fsum = f1 + f2
        f1[f1 < strayclip * fsum] = 0.
        f2[f2 < strayclip * fsum] = 0.

        s1 = f1 / (f1 + f2) * 10.
        s2 = f2 / (f1 + f2) * 10.

        s1[:2] = 0.
        s2[-2:] = 0.

        if doPlot:
            p4 = plt.plot(XX, s1.repeat(2), 'm-')
            plt.plot(XX, s2.repeat(2), 'm-')

            plt.legend((p1[0], p2[0], p3[0], p4[0]),
                       ('Parent Flux', 'Child portion', 'Child stray flux',
                        'Expected stray flux'))
            plt.ylim(-2, 22)
            plt.savefig(plotpat % 4)

        # test abs diff
        d = np.max(np.abs(s1 - strays[0]))
        self.assertLess(d, 1e-6)
        d = np.max(np.abs(s2 - strays[1]))
        self.assertLess(d, 1e-6)

        # test relative diff
        self.assertLess(np.max(np.abs(s1 - strays[0]) / np.maximum(1e-3, s1)),
                        1e-6)
        self.assertLess(np.max(np.abs(s2 - strays[1]) / np.maximum(1e-3, s2)),
                        1e-6)
Beispiel #55
0
def MultiBatteryBarChart(report_list,
                         interactive=False,
                         legenddata=(),
                         title=""):
    """Create a bar chart with that places similar conditions together for
  comparison.

  Reports with matching metadata should be grouped together in the list.
  """
    import pylab
    from matplotlib.font_manager import FontProperties
    from matplotlib import colors
    if not interactive:
        pylab.ioff()
    build = report_list[0].metadata.build

    N = len(report_list)

    barwidth = 1.0 / 8.0

    patches = []
    labels = []
    thefig = pylab.gcf()
    thefig.set_size_inches((11, 7))
    thefig.set_dpi(80.0)
    pylab.title("Battery Life (%s) %s" % (build.id, title))
    pylab.subplots_adjust(left=0.07, bottom=0.05, right=0.55, top=0.95)

    group = 0
    last_report = None
    for index, battery_report in enumerate(report_list):
        lifetime = float(battery_report.lifetime.hours)
        blue = aid.IF(battery_report.byvoltage, 0.0, 0.5)
        color = colors.rgb2hex(
            (aid.IF(battery_report.estimated, 1.0,
                    0.0), (index * 0.05) % 1.0, (group * 0.1) % 1.0))
        if last_report and \
            last_report.metadata.CompareData(battery_report.metadata,
            legenddata, missingok=True):
            label = "(%s) - (%.2f h)" % (index + 1, lifetime)
        else:
            label = "(%s) %s (%.2f h)" % (
                index + 1, battery_report.metadata.GetStateString(*legenddata),
                lifetime)
            group += 1
            #pylab.bar(index + group, 0, width=barwidth) # spacer
        patchlist = pylab.bar(index + group,
                              lifetime,
                              width=barwidth,
                              color=color,
                              label=label)
        labels.append(label)
        patches.extend(patchlist)
        last_report = battery_report

    pylab.ylim(0.0, 200.0)
    pylab.xlim(-barwidth, N)
    # label index is origin 1.
    x_range = pylab.arange(N)
    pylab.xticks(x_range + (barwidth / 2.0),
                 map(str, x_range + 1),
                 fontsize=10)
    pylab.ylabel('Time (h)')
    if legenddata:
        font = FontProperties(size=9)
        pylab.figlegend(patches, labels, "upper right", prop=font)

    if interactive:
        pylab.show()
    else:
        fname = "batterylife_group-%s.png" % (
            report_list[0].metadata.timestamp.strftime("%m%d%H%M%S"))
        pylab.savefig(fname, format="png")
        return fname
Beispiel #56
0
    'figure.figsize': fig_size
}
pl.rcParams.update(params)

pl.figure(1)
pl.axes([0.125, 0.15, 0.95 - 0.125, 0.95 - 0.15])
pl.plot(eVV - muVV, dVV, 'b-', label='V 0K')
pl.plot(eVV - muVV300, dVVep300, 'g-', label='V 300K')
pl.plot(eVV - muVV1000, dVVep1000, 'r-', label='V 1000K')
pl.legend()
pl.plot(eVV, dVVep300, 'g--', label=None)
pl.plot(eVV, dVVep1000, 'r--', label=None)
pl.xlabel('$E-\mu(T)$ (eV)')
pl.ylabel('(states/eV/at.)')
pl.xlim((-0.7, 0.7))
pl.ylim((0, 3.0))
pl.grid(True)

pl.figure(2)
pl.axes([0.125, 0.15, 0.95 - 0.125, 0.95 - 0.15])
pl.ylim((0, 3.0))
pl.plot(eVCo - muVCo, dVCo, 'b-', label='V$_{15}$Co$_1$ 0K')
pl.plot(eVCo - muVCo300, dVCoep300, 'g-', label='V$_{15}$Co$_1$ 300K')
pl.plot(eVCo - muVCo1000, dVCoep1000, 'r-', label='V$_{15}$Co$_1$ 1000K')
pl.legend()
pl.plot(eVCo, dVCoep300, 'g--', label=None)
pl.plot(eVCo, dVCoep1000, 'r--', label=None)
pl.xlabel('$E-\mu(T)$ (eV)')
pl.ylabel('(states/eV/at.)')
pl.xlim((-0.7, 0.7))
pl.ylim((0, 3.0))
Beispiel #57
0
           range=((7, 12), (0, 0.4)),
           bins=60)
plt.savefig(
    '/home/ssamurof/massive_black_ii/plots/sanity/2dhist-satellite-bmoffset-barmass.png'
)

exit()

Hc, xc = np.histogram(dr[select & cflag] / 1000,
                      range=(0, 0.4),
                      bins=65,
                      normed=1)
Hs, xs = np.histogram(dr[select & np.invert(cflag)] / 1000,
                      range=(0, 0.4),
                      bins=65,
                      normed=1)

x = (xs[:-1] + xs[1:]) / 2

plt.fill_between(x, Hc, color='purple', alpha=0.2, lw=1.5, label='Centrals')
plt.plot(x, Hs, color='royalblue', lw=1.5, label='Satellites')
plt.legend(loc='upper right', fontsize=18)
plt.xlabel('Baryon - Matter offset $\delta r$ / Mpc $h^{-1}$', fontsize=18)
plt.yticks(visible=False)
plt.subplots_adjust(bottom=0.14)
plt.ylim(ymin=0)

plt.savefig(
    '/home/ssamurof/massive_black_ii/plots/sanity/baryon-matter_offset-subhalos.png'
)
Beispiel #58
0
def MultiBuildBatteryBarChart(report_list,
                              interactive=False,
                              autoscale=False,
                              legenddata=()):
    """Create a bar chart given a list of battery life reports."""
    # same as above.
    import pylab
    from matplotlib.font_manager import FontProperties
    from matplotlib import colors
    if not interactive:
        pylab.ioff()

    N = len(report_list)
    barwidth = 1.0 / N + 0.1

    thefig = pylab.gcf()
    thefig.set_size_inches((11, 6))
    thefig.set_dpi(80.0)
    pylab.subplots_adjust(left=0.07, bottom=0.05, right=0.75, top=0.95)

    max_lifetime = 0.0
    patches = []
    labels = []
    pylab.title("Battery comparison: %s" %
                (report_list[0].metadata.GetStateString(*legenddata)),
                fontsize="small")
    for index, battery_report in enumerate(report_list):
        lifetime = float(battery_report.lifetime.hours)
        max_lifetime = max(lifetime, max_lifetime)
        blue = aid.IF(battery_report.byvoltage, 0.0, 0.5)
        color = colors.rgb2hex(
            aid.IF(battery_report.estimated, ((index * 0.1) % 1.0, 0.5, blue),
                   ((index * 0.1) % 1.0, 1.0, blue)))
        label = "(%s) %s (%.2f h)" % (index + 1,
                                      battery_report.metadata.build.id,
                                      battery_report.lifetime.hours)
        patchlist = pylab.bar(index,
                              lifetime,
                              width=barwidth,
                              color=color,
                              label=label)
        labels.append(label)
        patches.extend(patchlist)
    if autoscale:
        pylab.ylim(0.0, max_lifetime + 20.0)
    else:
        pylab.ylim(0.0, 200.0)
    pylab.xlim(-barwidth, N)
    # labels are position offset by +1.
    pylab.xticks(pylab.arange(N) + (barwidth / 2.0),
                 map(str,
                     pylab.arange(N) + 1),
                 fontsize=10)

    pylab.ylabel('Time (h)')
    if legenddata:
        font = FontProperties(size=9)
        pylab.figlegend(patches, labels, "upper right", prop=font)

    if interactive:
        pylab.show()
    else:
        fname = "batterylife_builds-%s.png" % (
            report_list[0].metadata.timestamp.strftime("%m%d%H%M%S"))
        pylab.savefig(fname, format="png")
        return fname
C, S = np.cos(X), np.sin(X)

# Graficar la función coseno con una línea continua azul de 1 pixel de grosor
pl.plot(X, C, color="blue", linewidth=1.0, linestyle="-")

# Graficar la función seno con una línea continua verde de 1 pixel de grosor
pl.plot(X, S, color="green", linewidth=1.0, linestyle="-")

# Establecer límites del eje x (Divisiones en X)
pl.xlim(-8.0, 8.0)

# Ticks en x(Impresión de intervalos, cantidad de datos mostrados en el eje)
pl.xticks(np.linspace(-8, 8, 17, endpoint=True))

# Establecer límites del eje y (Divisiones en Y)
pl.ylim(-1.0, 1.0)

# Ticks en y (Impresión de intervalos, cantidad de datos mostrados en el eje)
pl.yticks(np.linspace(-1, 1, 5, endpoint=True))

'''Otra opcion de determinar los limites a imprimir
pl.xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi])
pl.yticks([-1, 0, +1]) '''
#AGREGAR LINEAS DE EJES Y QUITAR EL RECUADRO:

ax = pl.gca()
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.spines['bottom'].set_position(('data',0))
ax.yaxis.set_ticks_position('left')
Beispiel #60
0
def extract_plr(t, dr, flash_time, scan_id='1234', which_eye='LEFT'):
    # Extract PLR parameters from provided time series.
    flash_time = flash_time[1]
    t = t - (flash_time - 1)
    flash_time = 1.0

    # Find valid points
    idx = q(t > 0)
    t = t[idx]
    dr = dr[idx] * 1000
    t_start = t.min()
    t -= t_start
    dr = taut_string(dr, 0.01)

    # Fit with cubic splines
    t_mn = 0
    t_mx = 5

    idx = q((t > t_mn) * (t < t_mx))
    t_ = t[idx]
    dr_ = dr[idx]
    f = Fit(t_, 100, basis_type='cubic-spline', reg_coefs=[0, 1e-2, 9e-3])
    r = f.fit(dr_)

    # Grab the latency time.
    try:
        roc = 1 / ((2 + 1 + (r.dy)**2)**(3 / 2) / np.abs(r.d2y))
    except:
        roc = inf

    roc = taut_string(roc, 0.10)
    g = Fit(t_, 100, basis_type='cubic-spline', reg_coefs=[0, 1e-2, 1e-3])
    rc = g.fit(roc)
    roc = rc.y

    peaks = []
    for itr, val in enumerate(roc):
        if (itr < 1) or (itr == len(roc) - 1):
            continue
        if val > roc[itr - 1] and (val > roc[itr + 1]):
            peaks.append(t_[itr])

    # Light flash time.
    closest_index = np.abs(r.x - flash_time)
    flash_idx = np.argmin(closest_index)

    # Starting amplitude.
    starting_amplitude = r.y[flash_idx]

    # Find the peak in the curvature.
    peaks = np.array(peaks)
    peaks -= flash_time
    peaks = peaks[peaks > 0.150]
    peak_time = peaks[0] + flash_time
    med_amplitude = np.median(dr_)
    std_amplitude = dr_.std()
    roc -= mean(roc)
    roc = roc * roc.std() * std_amplitude / 2
    roc += med_amplitude
    latency = peak_time - flash_time
    print('Latency is {:0.3f}'.format(latency))

    # Minimum amplitude.
    idx_min, idx_max, t_min, t_max, v_min, v_max =\
            extrema_in_range(r.x, r.y, t_mn, t_mx-2)
    minimum_amplitude = v_min
    minimum_time = t_min
    delta_amplitude = starting_amplitude - minimum_amplitude
    average_speed = (delta_amplitude) / (minimum_time - flash_time)

    # Find the recovery time.
    recovery_amplitude = 0.75 * delta_amplitude + minimum_amplitude
    idx_after_min = q(t > minimum_time)
    t_after_min = t[idx_after_min]
    amp_after_min = dr[idx_after_min]
    recovery_idx = q(amp_after_min >= recovery_amplitude)[0]
    if recovery_idx:
        recovery_time = t_after_min[recovery_idx] - flash_time
        time_of_recovery = t_after_min[recovery_idx]
    else:
        recovery_time = -1
        time_of_recovery = 5

    package = {}
    package['latency'] = latency
    package['starting_diameter'] = starting_amplitude
    package['minimum_diameter'] = minimum_amplitude
    package['absolute_diameter_change'] = delta_amplitude
    package['relative_diameter_change'] = delta_amplitude / starting_amplitude
    package['average_speed'] = average_speed
    package['recovery_time'] = recovery_time

    plt.ioff()
    plt.close('all')
    plt.plot(r.x, r.y, color='#c62828', linewidth=3)
    plt.plot(t_, roc, color='#305580', linewidth=3, alpha=0.5)
    y_lim = plt.ylim(
        [med_amplitude - 3 * std_amplitude, med_amplitude + 2 * std_amplitude])
    plt.plot([0, 5], [starting_amplitude, starting_amplitude],
             ':',
             color='#2f2f2f')
    plt.plot([0, 5], [minimum_amplitude, minimum_amplitude],
             ':',
             color='#2f2f2f')
    plt.plot([time_of_recovery, time_of_recovery], [0, 20],
             '--',
             color='#c62828')
    plt.plot([flash_time, flash_time], [0, 20], '--', color='#000000')
    plt.plot([peak_time, peak_time], [0, 20], '--', color='#4caf50')
    plt.xlim([t_mn, t_mx])
    plt.xlabel('Time (Seconds)')
    plt.ylabel('Pupil Diameter (mm)')
    location = './plots'
    plt.savefig('{}/{}_{}.png'.format(location, scan_id, which_eye))
    return package